Build1 distinct publisher2 min readPublished
A developer parsed his own Claude Code transcripts and found 1.99 billion cached reads against 62 million writes, which turns the length of your context into a recurring charge on every remaining turn rather than a setting you pick once.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Each API call is stateless. The model sees the text in the request and nothing else, and there is no persistent working memory between turns [8]. The continuity you feel in a long coding session is manufactured by re-sending: prior tool results and file reads, concatenated and shipped again on the next request [9].
Divide 1.99 billion cache reads [3] by 5,288 requests [1] and the average request carried about 376,000 tokens of previously seen context [15]. An average is the wrong shape for the thing, though. Turn three is cheap and turn 900 is not, which is why the author says the read-to-write ratio climbs inside any single long session as context accumulates [12].
The compactions read differently with that number in hand. All four cluster at the roughly 1M ceiling, which is the auto-compactor firing before the window overflows [14]. What the reset costs is 108 to 140 seconds each [6], so somewhere between seven and nine minutes of wall clock across the four events [16], plus whatever the summary failed to preserve [19]. Annoyance at the compactor is aimed at the cheap end of the bill.
The 32:1 figure is a claim about one developer's three sessions [1][4]. For it to hold on yours, the sessions have to run long enough to approach the same ceiling, tool output has to grow context on nearly every call, and the cache hits have to keep landing. A twenty-turn session that never pulls a large file into context will not produce anything close. The mechanism transfers; the multiple is workload-specific.
The dollar pair deserves the author's own asterisk. Check the stated 86%: 4,500 divided by 31,000 is 14.5%, so 85.5% [18], with a gap of about $26,500 between the cached and uncached prices [17]. The author notes he pays a flat subscription rather than API billing, never wrote that check, and used list rather than effective prices, so the pair is meaningful as a ratio and not as spend [11]. That is the right way to publish it.
The practical consequence is a sequencing rule. In a session you expect to run long, the cost of what you admit into context is set by the number of turns that follow it, not by the read that put it there.
Ranked by verification strength, evidence, and original report placement.
The author parsed three real Claude Code sessions totalling 5,288 requests, taking a few minutes of parsing.
The transcripts are JSONL files in ~/.claude/projects/, one line per event, with a usage object on every assistant message, including timestamped token counts for every request.
Across the three sessions: 1.99 billion tokens read from cache and 62 million tokens written to cache, a 32:1 ratio.
The author's framing of the ratio: each token you put in context gets paid for roughly thirty-two more times before it leaves.
Session C hit four automatic compactions, which fired at 968K, 996K, 999K and 771K tokens.
Each compaction took 108 to 140 seconds of wall-clock time doing nothing but summarizing.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · September 2, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
Superpowers makes spec-driven work a precondition, then ships it to twelve harnesses1 distinct publisher
build
Your Multi-Key Failover Is The Most Expensive Line On Your Coding Agent Bill1 distinct publisher
build
Block's Berd makes a duller argument than its mascots: show the agent's context as product state1 distinct publisher
build
Per-developer environments hit their ceiling the day one engineer ran five agents1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Machine-written logs, one reader
The load of this story is carried by numbers the tooling wrote itself — per-request token counts with timestamps — rather than by recollection of a session that felt expensive, and that is a real strength. The weak seam is the dollar model: no rate card, no formulas, no raw files to re-run, and one person's parse standing alone. Where the arithmetic can be checked from published figures, it survives.
Three sessions on one laptop
As a window into how agent sessions behave in practice this is genuine field data — but the field is one developer's machine. Three sessions and 5,288 requests establish that contexts really do run to roughly 376,000 tokens per request and that the compactor really does fire near the ceiling; they establish nothing about how common that pattern is across teams, plans or other agent harnesses. No fleet numbers, no vendor disclosure, no second practitioner.
Disarms its own best number
A post with $31,000 in it could have travelled a long way on that figure alone. Instead the author tags it as never billed, calls it meaningful only as a ratio, and states outright that this is not a claim Claude Code is expensive — caching, he says, is working as intended. The framing runs slightly cooler than the measurements deserve: the 32:1 ratio and the two-minute compaction stalls are direct readings, not extrapolations. The one place the language outpaces the data is the title's implied universality, drawn from three sessions.
No skin in the token price
The author pays a flat plan, so nothing in the per-token arithmetic touches his wallet — there is no bill to complain about and no discount to defend. What visible pull exists is audience: a developer-blog post that links back to his earlier writing on caching mechanics. He spends that attention on caveats rather than on a bigger number, which is the opposite of the usual trade.
Specific, checkable, uncorroborated
We can assess this only as far as one publisher lets us. What raises confidence is precision: exact trigger thresholds, a stated duration range, before-and-after cache-read values, all of which would be awkward to fabricate and one of which we recomputed successfully. What caps it is that the transcripts stayed private, the vendor is silent, and no other outlet has attempted the same measurement.