July 13, 2026Johan Huynh5 min read

Claude Code's context window: what it is and how to manage it

A full context window is not a wall you hit at the end. It fills quietly the whole time, and the fix is knowing what is in it and how to take things out.

The kitstarter robot beside a container filling with tokens, standing in for the Claude Code context window

The context window is Claude Code's short-term working memory: everything the model can hold at once, measured in tokens. The standard window is about 200,000 tokens, and it is shared across your instructions, the files it reads, its own replies, and every tool definition. When it fills up, quality drops, a slide known as context drift.

Is a bigger window better?

Not automatically. The standard window holds about 200,000 tokens, and some setups offer a 1,000,000-token window. It is tempting to reach for the bigger one, but more context is not free: every token you keep loaded is reprocessed on each turn, which makes responses slower and burns through your usage quota faster. The window still has to hold your instructions, the files Claude Code reads, its own replies, and every tool definition, all at once. The goal is not the biggest window. It is the leanest one that still holds what the task needs.

What fills the context window

Three culprits, in rough order of how often they are the real cause:

Large file readsone big log or generated file can eat 90,000+ tokens in a single read. Point at what you need with @path/to/file so Claude Code loads the relevant slice instead of the whole thing.
A long conversationhours of back-and-forth pile up until there is no room left. /compact compresses the history into a summary, /clear resets it while keeping your project loaded.
Unused MCP serversevery connected server loads its tool definitions into the window even when it is idle. Turning off the ones this task does not need hands that space straight back.
The window is a fixed size. These three usually eat it, and each has its own way back out.

How to manage it

  1. Run /context. It prints a live breakdown of what is using the window right now, so you fix the real culprit instead of guessing.
  2. Run /compact when history piles up. It compresses the conversation into a summary and lets you keep going, clearing room without losing the thread.
  3. Run /clear between unrelated tasks. This wipes the conversation entirely while keeping your project and CLAUDE.md loaded. Fresh window, same project.
  4. Load files with @path/to/file. Pull in only the part you need instead of pasting a whole file or scanning the entire repo.
  5. Disable MCP servers you are not using. Each connected server costs window space just by being available. Trim to the ones this task actually needs.
  6. Keep CLAUDE.md lean. The durable lever. Every token in your memory file is a token unavailable to the work, and it is reloaded on every single turn.
The kitstarter robot handing over a single labeled file instead of a toppling stack of loose pages
Load the whole repo into memory, or hand Claude Code just the file the task needs.

Keep it lean by default

The people who never hit context drift are not lucky. They keep the window clean on purpose: /clear between tasks, /compact before a big one, only the MCP servers they need, files referenced instead of pasted, and a CLAUDE.md that stays short. The payoff is bigger than avoiding one error. A lean window is faster and burns less of your quota, because Claude Code is not reprocessing a bloated context on every turn.

That habit, keeping the window small and deliberate, is what kitstarter builds in. The kit ships a **PreCompact hook** that compacts automatically before the window breaks, context-hygiene rules that stop it filling in the first place, and a lean CLAUDE.md template so your baseline starts small. Context bloat is not just a full window. It is the same thing that makes a long session slow and forgetful.

Common questions

How big is Claude Code's context window? The standard context window is about 200,000 tokens, roughly 150,000 words. Some configurations offer a larger 1,000,000-token window, but bigger is not always better: more context means slower responses and faster quota burn, so a lean window usually beats a large one you keep full.

How do I check my context window usage? Run /context inside Claude Code. It prints a live breakdown of what is filling the window right now, your instructions, file reads, conversation history, and tool definitions, so you can see the real culprit and clear the right thing.

What is the difference between /compact and /clear? /compact compresses your conversation history into a short summary and lets you keep going, so you keep the thread but free up room. /clear wipes the conversation entirely while keeping your project and CLAUDE.md loaded. Use /compact mid-task, /clear between unrelated tasks.

Why does keeping CLAUDE.md short matter? CLAUDE.md is loaded into the context window on every single turn, so every token in it is a token unavailable to the actual work. A short, high-signal CLAUDE.md leaves more room for code and keeps responses fast. This is why kitstarter ships a lean CLAUDE.md template by default.

Keep the context lean by default

kitstarter builds the habits and hooks that stop context bloat before it breaks, for Claude Code, Codex, and Antigravity.

Get the kit · $20 $29Read the docs