Trimming CLAUDE.md saves under 4%. Batching your tool calls saves 49%

Search for how to stop Claude Code burning tokens and you get listicles. They are mostly sensible and almost entirely unmeasured, and a few of the most repeated items are wrong.

Here is each common tip with a number attached. Every figure came off a real run on this machine, and each links to the measurement that produced it.

The short version

Advice	Verdict	Worth
Batch your tool calls	Correct, and the biggest lever	saves 49%
Leave MCP tool search on	Correct	20x at 200 tools
Trim your CLAUDE.md	Correct but minor	3.6%
Delegate to subagents to save context	Misleading	costs 1.72x overall
“MCP servers load every tool definition each session”	Wrong by default	3,054, not 60,854
“The 5-minute cache is draining your quota”	Not what 2.1.226 does	writes to the 1-hour tier

Batching tool calls is worth more than everything else combined

Three files read in a single batch cost 121,732 tokens. The same three files read one at a time cost 240,073. That is a 49% saving for a change that costs you nothing.

The reason is that a tool round trip re-sends the entire conversation. Reading a six-byte file costs 58,851 tokens, because the file is not what you are paying for, the round trip is. On a 40KB read the round trip is four times the payload.

It is not Read-specific: three Bash calls cost 117,753 batched against 235,446 sequentially, the same 2x.

This is the tip that matters, and it is usually item seven on a list of ten.

Trimming CLAUDE.md is real, and small

CLAUDE.md costs 106 tokens of fixed overhead plus 0.26 tokens per byte, holding to three decimals from 2KB to 28KB.

So an 8,000-byte CLAUDE.md costs about 2,185 tokens. Against a startup context of roughly 59,000 on this setup, deleting the entire file saves 3.6%. Trimming it to the commonly advised 500 tokens saves less.

Worth doing, and not worth doing first. One un-batched tool call costs more than your whole CLAUDE.md, roughly twenty-five times over.

There is a sharper version of this advice that does work. The same 28,000 bytes costs 7,379 tokens in CLAUDE.md and 4 tokens as a skill body, because a skill body loads only when invoked. That is a 1,845x difference. Do not trim reference material, move it.

And a caution about measuring it yourself: below about 2KB you cannot. A 500-byte file measured +237 tokens on one run and −52 on the next, because session baselines drift by around 290 tokens and the signal is smaller than the noise.

“Every MCP server loads its full tool definitions into context whether you use it or not”

This one is repeated almost verbatim across the guides, and with tool search on, which is the default, it is wrong.

200 MCP tools	Tokens
Default (tool search on)	+3,054
Tool search off	+60,854

Definitions are deferred until needed. That is a 95% reduction, about 15 tokens per tool instead of 304. Measured across 5, 50 and 200 tools, reproduced identically twice, and identical again across two version bumps.

The advice built on that claim, prune your MCP servers before doing anything else, is therefore aimed at a cost most people are not paying. The version that is still true: if you have set ENABLE_TOOL_SEARCH=false, turn it back on. It costs 17,795 tokens with zero MCP servers connected, because Claude Code defers its own built-in tools through the same path.

“Delegate research to subagents to keep your main context clean”

True in the narrow sense and misleading in the way it is used.

Delegating a three-file read to a general-purpose subagent moved the parent context from 126,825 down to about 118,650. That is a real saving of 8,175 tokens, or 6.4%.

It cost about 218,000 tokens in total against 126,825 inline, or 1.72x.

So you spend roughly 91,000 extra tokens to save 8,175 in the parent. That pays back only if the smaller parent context then survives about 11 more round trips. Delegating a small task late in a session is strictly worse than doing it inline. The full measurement is here.

“The five-minute cache is why your quota drains”

Widely blamed, and not what the current version does. Reading the cache tier straight out of reported usage on Claude Code 2.1.226:

cache_creation_input_tokens        43,443
  ephemeral_5m_input_tokens             0
  ephemeral_1h_input_tokens        43,443

100% of cache creation goes to the one-hour tier, none to the five-minute tier. Reproduced across two runs.

What does drain quota is invalidation, not expiry. Any change to your cached prefix rebuilds everything after it: 47,544 tokens re-created, 14.6x the cost, whether the change is a one-character CLAUDE.md edit or adding a single skill. Ten small config tweaks cost ten full rebuilds. Batch your config edits.

I am not making a claim here about how long a cache actually survives. I tried to measure that and got two gaps of the same length producing opposite results, so it stays unpublished until it reproduces.

Update, 2026-08-13: it reproduced, once the measurement was pointed at the right turn. An eight-minute idle gap costs 39 tokens on a subscription against a 17,613-token rebuild with the five-minute TTL forced on. The tier claim above also needs a caveat it did not have: writing to the one-hour tier is not free, it bills at 2x list against 1.25x, and over a three-turn session that premium outweighed the expiry it prevented. The full measurement is here, including why the earlier attempt kept contradicting itself: the first resume always rewrites the cache breakpoint, so the turn I was reading could not respond to a gap at all.

“Long conversations get expensive”

No. A continued turn writes 293 tokens and reads the rest from cache, constant across every turn of a six-turn chain. Context grew 1,465 tokens over those six turns while reported cost rose 2%.

Tool round trips multiply your context. Conversation turns do not. The measurement is here.

What to actually do, in order

1. Batch tool calls. Worth 49%, more than everything below combined.
2. Leave tool search on. Worth 17,795 tokens minimum, more if you run MCP servers.
3. Batch config edits. Each one costs a 47,544-token cache rebuild.
4. Move reference material from CLAUDE.md into skills. 1,845x on the same bytes.
5. Then trim CLAUDE.md if you still care about the remaining few percent.

The ranked version with every figure linked to its run is on the guide page, and you can measure your own project with the same script that produced these numbers.

All figures on Claude Code 2.1.226 unless the linked post states otherwise, headless, usage from --output-format json, every delta paired against a baseline captured in the same batch.