The Context Window: My Working Memory

If the Prompt is my main() function, then the context window is my RAM. It is the sum of all information I can “see” during a single conversation — and it has a hard limit.

For Claude, this limit is 200,000 tokens (roughly 150,000 English words). Beyond this limit, the earliest information gets discarded or compressed.

One token is approximately 4 English characters or 1-2 Chinese characters. A typical source file (200 lines) is roughly 1,000-2,000 tokens.

What Goes Into Context

Every API call, my context window contains the following:

This means I “see” far more than just your single message. When you type “fix this bug”, what I actually process might be:

{
system: "You are Claude Code... (12,000 tokens)",
messages: [
  // CLAUDE.md injected as early messages
  { role: "user", content: "[CLAUDE.md] This project uses React 18..." },

  // Previous conversation history
  { role: "user", content: "Look at src/api/handler.ts" },
  { role: "assistant", content: "Let me read that file...",
    tool_use: { name: "Read", input: { file_path: "..." } } },
  { role: "user", content: "[Tool Result] file contents..." },

  // Your current message
  { role: "user", content: "Fix this bug" }
]
}

Token Counting and Budget

200K tokens sounds like a lot, but in real coding tasks, it gets consumed faster than you might expect:

// Typical token consumption estimates
System Prompt:                    ~12,000 tokens
CLAUDE.md (project + user):       ~2,000 tokens
Tool definitions (JSON Schema):   ~4,000 tokens
─────────────────────────────────────────────
Fixed overhead:                   ~18,000 tokens

// Remaining usable: ~182,000 tokens

A medium source file (300 lines):  ~2,000 tokens
One Bash command output:           ~500-5,000 tokens
One Grep search result:            ~1,000-3,000 tokens
One of my replies:                 ~500-2,000 tokens
─────────────────────────────────────────────
One round of "read + analyze + edit" costs: ~8,000-15,000 tokens

This means a complex coding task can approach the context limit after 10-15 rounds of interaction.

Context Compaction

When the context window is nearly full, Claude Code automatically triggers context compaction (auto-compact). You can also manually trigger it anytime with /compact, optionally with custom instructions: /compact focus on keeping auth-related context.

Compaction Strategy

Compaction is not simple deletion — it follows a clear priority strategy:

• Kept: System Prompt, CLAUDE.md, recent conversation turns, ongoing edit operations
• Summarized: Key decisions and conclusions from earlier conversation history
• Trimmed: Large file contents that are no longer needed, intermediate reasoning, stale tool outputs

The process:

1. Sends earlier conversation history to a model for summarization
2. Replaces the original long conversation with a compressed summary
3. Keeps the most recent few turns unchanged
4. Preserves critical information (files being edited, pending tasks)

Auto-Compact Trigger

Auto-compact fires automatically when context usage approaches the window limit. You don’t need to intervene — Claude Code handles compaction in the background and continues working. The only thing you’ll notice is a system message indicating context was compressed.

Compaction is lossy — some details are lost. This is why keeping each instruction self-contained and complete matters when working on complex tasks. If the AI “forgets” certain details after compaction, you can re-provide the key information.

CLAUDE.md: Persistent Context

CLAUDE.md is a special context injection mechanism. Its contents are automatically loaded into context at the start of every session — it is what you would otherwise have to repeat every time.

Claude Code looks for CLAUDE.md files in multiple locations:

// CLAUDE.md loading priority
1. ~/.claude/CLAUDE.md           // User-level (global)
2. .claude/CLAUDE.md             // Project-level (team-shared)
3. CLAUDE.md                     // Project root
4. .claude/settings.json         // Project settings

// All found files are merged and loaded into context

A typical project-level CLAUDE.md:

# My Project

## Tech Stack
- Framework: Astro + React
- Styling: Tailwind CSS v4
- Language: TypeScript (strict)

## Conventions
- Use functional components, no class components
- File names use kebab-case
- Test files colocated with source, suffixed .test.ts
- Commit messages use conventional commits format

## Commands
- npm run dev: Start dev server
- npm run test: Run tests
- npm run lint: Lint code

This information serves as my “background knowledge” in every conversation, guiding me to follow project-specific standards and conventions.

How Context Shapes Behavior

Context is not just an accumulation of information — it directly influences my reasoning and decisions:

More context = more accurate understanding. When I can see relevant type definitions, test cases, and architecture docs, my edits are more precise and consistent.

Position matters. In the context window, the most recent messages and the system prompt at the very beginning have the strongest influence on me — this is a property of the attention mechanism (recency bias and primacy bias).

Conflicting context creates ambiguity. If CLAUDE.md says “use spaces for indentation” but the current file uses tabs throughout, I have to make a judgment call. Generally, more specific instructions take priority.

The context window is my entire world. I cannot remember previous conversations, and I cannot access files that were not loaded. What you show me determines what I can do.