Where Tokens Go in Claude Code: 9 Loss Patterns and How to Fix Them in 2026

In one example, /context in a fresh Claude Code session showed 60K tokens occupied out of 200K before the first message. Only claude had been launched in the project repository. Sixty thousand tokens—that’s a third of the budget spent on “preparing” for the conversation.

Two weeks later, I figured out exactly where they went. Below are all 9 patterns that burn your tokens before you even start typing, and how to fix them. The figures come from official Anthropic docs and measurements from real sessions.

Where Do Tokens Go Before the Prompt?#

Here are the 9 patterns in one table, with figures from measurements of real sessions and Anthropic’s official page on cost management.

The exact shares depend on your setup. But the overall picture is right, and each pattern can be fixed individually. I’ll cover three at a time below.

How Does Claude Build Context Before Reading Your Request?#

In one real session with six MCP servers, /context showed this breakdown:

Notice: even if you haven’t written anything, almost half the window is occupied. Less than half is left for free space and the autocompact buffer, and that half has to fit your entire conversation—messages, Claude’s replies, files read, and command output.

The window size depends on the model. According to Anthropic’s model documentation, as of September 2026, Opus 4.7 and newer, Sonnet 5, and Fable models have a 1M-token window on every plan, including Pro. 200K remains for Opus 4.6 and Sonnet 4.6 without extended context, and for sessions where 1M is disabled with the CLAUDE_CODE_DISABLE_1M_CONTEXT=1 variable. A larger window doesn’t solve the problem of bloated context: everything loaded before the first message is sent to the model with each request, and the cost documentation explicitly says that the more context there is, the more tokens are spent. A subscription doesn’t change that—on any plan, each extra token counts against your limit.

Where Does the First Third of Context Go: CLAUDE.md, History, and MCP?#

Pattern 1. CLAUDE.md Before Every Message

The file is loaded before every message you send, not just once per session. A 5,000-token CLAUDE.md occupies that much context on requests containing it, but fresh input, cache writes, and cache reads need separate accounting; repeated content is not necessarily charged at the full uncached rate.

Anthropic says directly in the docs:

In one example, the project’s CLAUDE.md contains 180 lines—everything specialized (how to write workshop instructions, the TG post format, the legal checklist) was moved into Skills and Markdown files inside business/, which Claude reads only when it looks there specifically. That cuts the baseline by 60-70% compared with two months ago.

Pattern 2. Conversation History Is Reread with Every Response

This is the pattern with the worst visibility from the outside, because it’s invisible externally. The model receives the retained conversation context on subsequent requests. Prompt caching can reuse a stable prefix; compaction and clearing can change the retained text. Repeatedly supplied context still occupies the window even when cache pricing reduces its cost.

The solution is /clear between unrelated tasks. My rule: a new chat for every new task. If a task is long and you need the history, use /compact to summarize the past into a short summary and continue from there.

More on this rule in the guide “How Not to Burn Through Your Claude Code Limits in a Day: 8 Rules for Saving Tokens”, with examples from my sessions.

Pattern 3. MCP Servers Register All Their Tools in Context

This was a historic pain point in Claude Code, causing the biggest losses up to 2026. In the session above, six connected MCP servers (Google Docs, Asana, Calendar, Slack, Atlassian, Gmail) occupied 98 700 tokens—49% of the entire window before the conversation started.

Anthropic released the Tool Search feature in December 2025–January 2026, which solves half of this problem.

In Anthropic’s docs, the description now reads:

What to do in production:

1. Update Claude Code to a version with Tool Search (all current versions after December 2025).
2. Open /mcp and disable servers you don’t need in the current session. In the example described, two are connected all the time—Playwright and shadcn. I enable the others for one task and run /mcp disconnect immediately afterward.
3. Replace MCP with CLI where possible. Use gh instead of an MCP server for GitHub. Use the calendar in a browser instead of Google Calendar MCP.

I covered what MCP servers are in principle and how to configure them sensibly in “Claude Code MCP Servers in 2026: 7 Ready-Made Setups and Step-by-Step Installation”.

Part of the CLAUDE.md and Skills problem is not just the size, but the structure. One instruction file (CLAUDE.md) is the core. Additional project knowledge (audience, products, legal documents, day-by-day instructions) lives in the business/ folder—that’s the project knowledge base. Claude reads only what’s needed right now, and context compression already happens at this level. The full breakdown is in a separate guide.

And one more detail that’s often overlooked: cleaning up CLAUDE.md, switching to Skills, and disabling MCP are the first step. After that, the context engineering methodology comes into play—what to put in each prompt, in what order, what to hand off through Plan Mode, and what to handle through /compact. This guide covers one building block.

What Accumulates in a Session, and What Can’t Be Cut?#

Pattern 4. Tool Output Accumulates Throughout the Session

A detail few people mention: when Claude runs bash cat huge-file.log, the ENTIRE output of that command goes into context and stays there until the end of the session or /clear. The same goes for Read on a large file—all 10,000 lines remain there, taking up tokens in every subsequent message (see Pattern 2).

Solutions:

1. Use head, tail, grep instead of reading everything. bash tail -100 deploy.log instead of Read deploy.log. This immediately cuts the output by 10-100 times.
2. Hooks for preprocessing. Put a script in ~/.claude/hooks that filters bash output before Claude sees it. An example from Anthropic docs is a PreToolUse hook that runs npm test 2>&1 | grep -A 5 -E 'FAIL|ERROR' instead of printing the full test output. This compresses it by 50-100 times. Details are in “Claude Code Hooks 2026: Step-by-Step Setup and 7 Ready-Made Examples”.
3. /clear after a large read. If you read a huge file for one specific task and no longer need it, don’t leave it in context “just in case”; start a new chat.

Pattern 5. System Prompt + System Tools = Permanent Baseline

This pattern can’t be changed because there’s almost nothing you can do about it. Claude Code starts with a system prompt (~3 200 tokens) and descriptions of all built-in tools—Read, Edit, Write, Bash, Glob, Grep, WebSearch, WebFetch, TodoWrite (~16 100 tokens). In total, that’s a permanent baseline of 19 300 tokens that you can’t cut.

What to do in practice:

• Awareness. Know that you have a 19K baseline “tax”: with a 200K window, that’s 200K - 19K = 181K for everything else (minus CLAUDE.md, MCP, and the autocompact buffer). There’s more room in a 1M window, but that “tax” still goes with every request.
• Measure repeated processing. The baseline occupies the window and can recur in later requests. It is not a once-per-session token charge; separate input, cache-write, cache-read, and output totals when calculating cost.

Where Are Tokens Lost on Skills, Plugins, and Agent Teams?#

Pattern 6. Skills and Plugins Can Be Registered Twice

This problem appeared with the arrival of plugins in Claude Code (late 2025). When you install a plugin that adds skills, those skills enter the context. If you also have similar user skills installed in ~/.claude/skills/, they load too. And sometimes they duplicate.

Many skills are never invoked during a session, but their descriptions are constantly loaded into context.

What to do:

1. /context shows what’s actually occupied. If you see a Skills section above 3K, clean it up.
2. ls ~/.claude/skills/—check which skills you actually have installed. Remove those you haven’t used in over a month.
3. /plugin remove for plugins you installed “to try” and forgot about.

What the right structure for Skills looks like and how they differ from CLAUDE.md is covered in “Claude Code Skills in 2026: How to Build a Personal Skills Library”.

Pattern 7. Agent Teams Burn 7 Times More in Plan Mode

Agent teams are a feature where Claude Code spins up several parallel model instances, each with its own context. Anthropic says directly in the docs:

That means five team members in Plan Mode equal five parallel sessions, each loading its own system baseline + its own copy of CLAUDE.md + its own MCP tools. Total token consumption grows nonlinearly.

What to do:

1. Use Sonnet or Haiku for team members. Use Opus only for the team lead coordinating them. The per-token rate may be lower, but measure each member’s complete task cost and quality rather than assuming a fixed saving.
2. Small teams. Two or three team members instead of ten.
3. Clean up inactive team members. If the task is done but a team member is still running, it keeps burning tokens in the background.

More on Plan Mode and when it actually helps in “Plan Mode in Claude Code: Step-by-Step Guide and 4 Stages in 2026”.

What Does Claude Charge Tokens for While You’re Not Looking?#

Pattern 8. Extended Thinking Uses Tokens Without Your Involvement

Extended thinking is a mode where Claude “thinks through” the solution in a hidden thinking block before answering. In terms of calculation, these are output tokens, counted like an ordinary response, but you don’t see them in the chat.

Anthropic says in the docs:

That means a single complex request can use 10-30K thinking tokens that “eat into” the budget, while you see only a short summary in the chat.

What to do:

1. /effort low for simple tasks. It reduces the thinking budget to a minimum.
2. MAX_THINKING_TOKENS=8000 in the environment to set a ceiling.
3. /config → disable thinking for very routine tasks where Claude doesn’t need to “think.”

When thinking is actually useful (complex architecture, complex multi-step reasoning), and when it isn’t, is covered in “Sonnet or Opus 4.7 in Claude Code: Choosing a Model and /effort in 2026”.

Pattern 9. Background Summarization While Idle

This is a very small but interesting pattern. Claude Code runs a background process that summarizes previous sessions for the claude --resume command. This process runs even when you’re not typing.

Anthropic explicitly says this in the docs about it:

Four cents per session isn’t a catastrophe. But if you have 10 open sessions a day, that’s already $0.40 in passive spending per day, $12 a month. Close sessions you don’t need right now. A session can be restored with /resume from the index—you don’t have to keep it open.

How to Measure Your Losses: The /context Command and Its Caveats#

First, the command. In Claude Code, open /context (or /usage for the calculation) and you’ll get something like this:

Context window: 200 000 tokens

System prompt:        3 200 (1.6%)
System tools:        16 100 (8.0%)
MCP tools:           12 600 (6.3%)
CLAUDE.md:            4 800 (2.4%)
Memory files:         3 000 (1.5%)
Conversation:        18 400 (9.2%)
Free space:         141 900 (71.0%)

This is a normal permanent baseline after the first cleanup. Great—71% of the window is free.

Known /context Bug: 3x Overstatement for MCP

Until a recent update, /context showed about 3 times the actual MCP loss, because per-tool overhead was counted separately for each tool.

Anthropic fixed this in newer versions. So:

1. If /context shows 50K+ for MCP tools—you may be on an old version of Claude Code. Update it.
2. If MCP is 8-15K—that’s normal, the real cost with Tool Search.
3. If MCP is 30-50K on a new version, you really have many unused servers connected. Go to /mcp and disconnect them.

What Else to Check Besides /context

/usage—shows your plan usage over the past 24 hours or 7 days. On Pro and Max, it shows a breakdown by skills, subagents, plugins, and individual MCP servers. Useful for identifying which skill burns the most.

/cost—for API users. Shows the prorated cost of the current session in dollars. Not for Pro/Max subscribers—they don’t need it.

/usage-credits—on Pro/Max, lets you set a monthly spending limit. Useful if you don’t want a scripted agent team to accidentally max out your credit card.

How to Clean Up Claude Code Context in 15 Minutes#

Open your project in Claude Code and go through the steps:

1. /context—write down the current breakdown. This is your baseline.
2. /clear—if the chat has accumulated history unrelated to the current task. Fresh window.
3. ls -la ~/.claude/skills/—see which skills are installed. Remove those you haven’t used in a month. Command: rm -rf ~/.claude/skills/[skill-name] (or delete the folder through the interface).
4. /plugin list—same for plugins. Remove what you don’t use with /plugin remove <name>.
5. /mcp—check the connected MCP servers. Keep only those needed for the current task. Disconnect the rest with /mcp disconnect <name>.
6. Open CLAUDE.md in an editor. If the file is over 200 lines, move specialized instructions into Skills (~/.claude/skills/[topic]/SKILL.md). Aim for a 100-200-line core + 5-15 topical Skills. The detailed guide is in “How to Configure CLAUDE.md in 2026: Ready-Made Template and 6 Rules”.
7. Check /effort—use /effort low for simple tasks. A high thinking budget is needed only for complex architecture.
8. Final /context measurement. Compare it with step 1.

In the described sessions, occupied context fell from 60–80K to 25–30K after cleanup. That is a change in the snapshot’s footprint, not proof of a fixed reduction in total processed tokens or cost. Compare complete runs of the same task, including cache and output usage, before claiming savings.

When Does Switching to Sonnet or Haiku Help More Than Cleaning Up Context?#

Anthropic writes about models in the docs:

A rough breakdown of input-token prices (as of May 27, 2026):

My setup:

1. Default—Sonnet 4.5. This is /config → default model. It covers 80% of tasks.
2. Manually run /model opus when a task is truly difficult (an architectural choice, diagnosis of a puzzling bug, a new product).
3. Use /model haiku for tests and formatting. Or explicitly set model: haiku in the subagent config.
4. /effort separately from the model. You can use Opus with /effort low—you get a powerful model with minimal thinking, for quick answers to medium-difficulty tasks.

When context cleanup is more worthwhile than switching models:

• Context is over 50% full—clean it first.
• Context is fine, but tasks are complex—use Opus with normal effort.
• Context is fine and tasks are routine—use Haiku.

For a detailed breakdown of models and effort, see “Sonnet or Opus 4.7 in Claude Code: Choosing a Model and /effort in 2026”.

Which Tips Increase Usage Instead of Saving It?#

Anti-pattern 1. “Delete All MCP; They Burn Tokens”

Laziness is the most common mistake. Yes, MCP historically burned up to 49% of context—but after Tool Search this dropped to 8-15%. And MCP provides real tools that you’d otherwise have to build by hand. Deleting all MCP means returning to manual work that will “eat up” more time than the tokens it saves.

The right approach: keep only MCP servers you actually use regularly. I keep Playwright (for testing landing pages) and shadcn (for generating interfaces). Everything else is for one task at a time.

Anti-pattern 2. “Don’t Use CLAUDE.md; Put Everything Directly in the Prompt”

It sounds “logical”: if CLAUDE.md loads with every request, let’s not load it. In practice, without CLAUDE.md you start each message by typing the same instructions by hand, and Claude forgets the context between messages. That means more tokens, not fewer—they’re just coming through another channel.

The right approach: keep CLAUDE.md compact (100-200 lines), with the core in it and specialized material in Skills. Details are in “How to Configure CLAUDE.md in 2026”.

Anti-pattern 3. “Always Work Through Plan Mode”

Plan Mode is an excellent tool for complex tasks where you first need to explore the codebase and propose a plan. But it uses an average of 7x more tokens when working through agent teams (Anthropic docs). On a simple task like “fix a typo in the README,” Plan Mode burns 7 times more than a direct edit.

The right approach: use Plan Mode for complex tasks that take 30 minutes or more. For short tasks, make a direct request without plan mode. When to use each mode is covered in “Plan Mode in Claude Code: Step-by-Step Guide and 4 Stages in 2026”.

More materials are available on Ailoot.