Practical Guide to Claude Code Context Management: compact, clear, and context Commands Explained

What Is the Context Window?

Context is Claude Code's working memory. Every time you read a file, run a command, or send a message, it takes up space in the context window. Think of the context window as the total amount of space Claude can hold in its memory.

The context window is a core concept in large language model (LLM) architecture, originating from the self-attention mechanism in the Transformer architecture — when generating each token, the model needs to attend to all other tokens within the window simultaneously. Claude series models have a context window of 200K tokens (approximately 150,000 English words or 300,000 Chinese characters). A token is the smallest unit the model uses to process text; one English word typically corresponds to 1-3 tokens, and one Chinese character typically corresponds to 1-2 tokens. The size of the context window directly determines the total amount of information the model can "see" and "remember" — information beyond the window cannot be accessed by the model.

Every time you enter a prompt, Claude reads a file, executes a tool call, or receives tool call results, these are all added to the context window. Since the context window has limited capacity, optimizing this space becomes critically important.

Three Core Commands Explained

/compact: Compress the Context

When you approach the context window limit, the system automatically triggers compaction. Compaction summarizes important details and removes unnecessary tool call results, freeing up significant context space.

Compaction is essentially a summarization technique. When triggered, the system has the model perform a summarizing pass over the current conversation history: retaining key decision points, code change records, and important contextual information, while discarding redundant intermediate processes (such as full file read contents, repetitive error logs, etc.). This is similar to "key point extraction" in human note-taking — you remember the conclusions and critical steps but forget every detail of the derivation process. Compacted context typically frees up 50%-80% of space, but the trade-off is the irreversible loss of details.

It's important to note that compaction may lose some details from previous conversations. You can also manually trigger compaction with the /compact command, which summarizes everything you've done so far. This is particularly useful when you want to free up context space while still retaining a memory of your previous work.

/clear: Completely Clear the Context

If you want to start completely from scratch without retaining any previous working memory, run the /clear command. It removes everything, giving you a completely fresh start. This is ideal when switching to an entirely new task.

/context: View Context Status

Running the /context command shows you the current state of your context. You'll see the overall context size and how much space different categories are consuming. This is extremely helpful for understanding what's eating up your context window.

When to Use compact vs. clear?

Here's a general rule of thumb:

When to use /compact: When you're developing a specific feature and the context window is about to overflow but you still need to continue working. Keeping the context relevant to the current feature is crucial for continuous development. Compaction preserves a summary of key information, allowing you to continue seamlessly.

When to use /clear: When you've completed development of one feature and are ready to start an entirely new one. You don't want previous conversation content to bias or interfere with the creation of the new feature.

Cross-session memory: For information you want Claude to remember across other sessions, write it to the Claude.md file. Claude.md is Claude Code's project-level configuration file, placed in the project root directory. It's automatically read and loaded into the context at the start of each session, serving as "long-term memory." Unlike the "short-term working memory" in the context window, information in Claude.md is persistent and won't be lost due to /clear or /compact. Developers typically record project architecture decisions, coding conventions, common commands, file structure descriptions, and other information in it. This design draws from the software engineering concepts of README and project documentation — solidifying team consensus and project knowledge into documents to avoid re-communicating every time. Note that Claude.md itself also occupies context space, so it should be kept concise, recording only key information that truly needs to persist across sessions.

Advanced Tips for Optimizing Context Usage

Be Specific and Explicit in Your Prompts

Here's a counterintuitive phenomenon: writing shorter prompts actually consumes more context in the long run. If you're not specific enough, Claude has to search around your codebase and do more autonomous thinking, which consumes far more context space than writing one or two clear sentences of explanation.

The principle behind this relates to information retrieval efficiency. When you give a vague instruction like "fix that bug," Claude needs to: first understand which bug you're referring to (possibly requiring reading multiple files), locate the relevant code (possibly requiring searching the entire codebase), and understand the context (possibly requiring reading related test files and documentation). Each exploration step generates tool calls and results, all of which accumulate in the context. In contrast, if you directly say "fix the null pointer exception at line 45 in src/auth/login.ts — when the user doesn't pass an email parameter, it should return a 400 error," Claude can locate and fix it directly, saving a significant amount of exploratory context consumption.

Manage MCP Servers Wisely

MCP servers load all available tools into the context by default. If you have many MCP servers unrelated to your current project, it may be worth disabling them. You can also try using Skills, which work similarly to MCP servers but don't put everything into the context, thus saving space.

MCP (Model Context Protocol) is an open standard introduced by Anthropic for connecting AI models with external data sources and tools. Each MCP server declares all its available tool schemas when connecting (including tool names, parameter descriptions, functionality explanations, etc.), and these schema information occupy context space as part of the system prompt. For example, a database MCP server might declare multiple tools like query, insert, update, and delete, with each tool's schema potentially consuming 200-500 tokens. When you connect multiple MCP servers simultaneously, tool declarations alone can consume thousands of tokens of context space, even if you don't need any of these tools for your current task. Therefore, enabling MCP servers on-demand is an important context optimization strategy.

Leverage Subagents to Save Context Space

Subagents run in parallel with the main agent but have completely independent context windows. For tasks where you only need the answer, not the process — such as "Where is the authentication endpoint?" — you can have a subagent do the work and return only a summary to the main agent. This way you get the answer without polluting the main agent's context window.

The design of subagents is inspired by the concept of child processes in operating systems. The main agent can spawn independent subagents to execute specific tasks, each with its own independent context window that isn't shared with the main agent. After completing a task, the subagent returns only a concise result summary to the main agent. This architecture is similar to the "delegation pattern" in software engineering — the manager doesn't need to know every detail, just the final result. In practice, subagents are particularly well-suited for code searching, documentation lookup, dependency analysis, and other exploratory tasks. The intermediate processes of these tasks (such as traversing multiple files, trying different search keywords) generate significant context consumption, but the ultimately valuable information might be just a few lines. Through subagents, you can isolate these "high-consumption, low-output" exploration processes in independent context spaces.

Summary

Managing context in Claude Code is key to using this tool efficiently:

• Use /compact to summarize long sessions while retaining key memories
• Use /clear to completely reset when starting a new task
• Use /context to monitor context usage at any time
• Maximize context window utilization through specific prompts, wise MCP server management, and effective use of subagents

Mastering these techniques allows you to maximize Claude Code's productivity within its limited memory space. Understanding the essence of context management means understanding how to keep the most important information within the model's field of view within a limited "attention bandwidth."