Co-authored with Claude. Final editorial judgment and accountability are Alex's.
Pricing as of June 2026. All figures use Opus 4.6 API rates, warm cache unless noted. Subscription plans (Pro, Max) package the same token spend into usage allocations — the underlying mechanics still apply.
In April we published The Economics of Claude Code — a primer that grew into a three-part series (Session Timing, The Agent Tradeoff, What You Carry), plus a cost-driver reference and a helper install guide. The thesis was that cost is structural — baked into session rhythm, cache mechanics, and interaction habits — and that most teams are losing money to failure modes they can't see because nothing in the product layer shows them.
Since then, the platform moved. Claude Code shipped behavior that made one helper redundant, absorbed another into default harness guidance, and changed the mechanism a third was warning about. The math behind a fourth still stands, but the alarm deserved a softer tone.
This post is the honest scorecard. What held, what retired, what the score actually tells you.
A Brief Recap of the Math
The series built everything on one equation. Cache write costs 1.25x the base input rate. Cache read costs 0.1x. That means a warm-cache message costs roughly 12.5x less than a cold one. The cache expires after five minutes of inactivity. There is no native warning — the cache just quietly dies, and the next message pays the full re-cache premium on your entire conversation history.
That math hasn't changed. The reference table still holds:
| Operation | Sonnet 4.6 | Opus 4.6 | Haiku 4.5 |
|---|---|---|---|
| Base input (no cache) | $3.00/MTok | $5.00/MTok | $1.00/MTok |
| 5-minute cache write | $3.75/MTok | $6.25/MTok | $1.25/MTok |
| Cache read (hit) | $0.30/MTok | $0.50/MTok | $0.10/MTok |
| Output | $15.00/MTok | $25.00/MTok | $5.00/MTok |
The anchor pair to keep in your head: a 100K-token Opus session costs about $0.05 per turn on a cache hit and about $0.63 on a miss. Same gap as April, and the gap is still the story. One correction worth owning in a post about auditing our own work: the original table's Opus column ran 3x too high before we caught it. The ratios — the part the whole argument rests on — were always right. The dollar figures above are the corrected ones.
So the foundation is solid. What changed is the superstructure of workarounds built on top of it.
The Deprecations
Watching Cost: The Workaround Retired
The watching-cost module's /to-file command — run a noisy command, redirect the output to a temp file, keep the dump out of context — solved the problem Part 3 named: large tool outputs inflating every subsequent turn because they live permanently in the conversation.
Claude Code now does this natively. Oversized tool output auto-persists to files, with a 2KB preview in the conversation. The full dump doesn't enter context unless you pull it in. This is the right solution at the right layer, and the command's entire job is gone.
Retire /to-file if you installed it. The platform caught up.
The module's monitoring hooks outlived the command, and they've moved earlier in the timeline — suggesting a CI run before a heavy test dump lands, or a redirect before a known-verbose command fires. The sensor stays. The manual workaround retires.
The Compact Gamble: Reframed
This one is more nuanced. The original framing was sharp: compaction was a lossy gamble. The system summarized your session, the original context was gone forever, and you had no idea what the summary dropped until something broke downstream. I called it irreversible and warned accordingly.
The mechanism changed. Compaction now produces a structured summary with unsummarized context carried forward. The pre-compact marker our compact-safety hook writes survives as an audit trail. The catastrophic-and-silent data loss scenario no longer describes what actually happens.
The caution still exists — summarization loses information, and "less bad" isn't "free" — but the fear framing doesn't fit the current mechanism. I'm retiring "the compact gamble" as a label. The underlying instinct (don't compact without knowing what you're trading) remains valid, but it belongs in a soft advisory, not a hazard warning.
Subagent Isolation: Absorbed
The subagent-isolation helper was a nudge: when a task involves reading many files, delegate it to a subagent with a narrow brief rather than pulling everything into the main session. Part 2 called this the cheap side of the agent tradeoff.
That insight now lives in standard harness guidance. The 50-file nudge stays as a habit reminder, but the helper existed to establish a habit the harness itself now recommends.
Keep the habit, and keep the nudge if you like the reminder — it still meters your actual session, which the harness doesn't. What retired is the argument. The harness now makes it for you.
Idle Tax: The Math Stands, the Prescription Softens
Idle tax is the one I built first and believed most. The warning fired at session return and said: you've been away, your cache died, your next message costs 12.5x more than it should. Pay attention.
Everything in that warning is still true. The cache still dies after five minutes. The 12.5x multiplier is still the right number. On my machine, the warning fired meaningfully enough times that it changed my behavior.
But the prescription was overcalibrated. The way I wrote it originally implied that returning to an idle session was a near-catastrophe: costs run hot, context is suspect, you should probably start over. What actually happens is one expensive turn — the re-cache — followed by normal session economics. It's a real cost, not a fictional one, but it's not compounding or structural unless you keep doing it.
The durable value of the idle-tax warning is the nudge, not the alarm. Returning to an idle session is a money event you should know about and factor into whether the session is still worth continuing. It is not a five-alarm fire.
The math stands. The anxiety is retired.
The Keepers
Not everything aged into retirement. Two helpers proved out in production in a way the deprecations actually validate — if the platform had caught up with these too, they'd be gone. They're not.
Auto-persist is the state layer. On my machine: 3,458 state files written since April. Several per day, every day, without deliberate effort, because auto-persist runs as a hook rather than a slash command you have to remember to call. Files accumulate quietly. Sessions become retrievable. Losing work to context collapse becomes optional rather than structural.
Save and resume session is the continuity mechanism — 407 saved sessions since April, several substantive saves per day. A session you can pick up is worth more than a session you lose. That's a deceptively simple observation that most tooling doesn't act on.
Two more keep their jobs for unglamorous reasons: delegation-cost still meters what agent results add to the parent session (Part 2's carrying tax has no native gauge yet), and effort-control still pins the effort level that Opus 4.7 silently resets.
Here's the honest admission that this repo's own Dead Output rules require: the suite's durable value turned out to be session continuity, not cost reduction. The helpers that lasted are the ones that make sessions recoverable. The ones that retired were solving platform gaps the platform eventually filled. Cost awareness was the motivating frame, but what we actually built was memory for a tool that doesn't have it natively.
Say it plainly, because the series doesn't: the cost helpers are a continuity suite that was named wrong.
The New Helper: Idle Autosave
There's one addition since April, and it closes the loop that idle tax opened.
Idle tax warns you at return time. By then, the cache has already died. You get the information after the damage is done. That's useful for calibrating habits over time, but it's not useful in the moment you need it. The warning is retrospective. The cost was prospective.
Idle autosave acts at idle time instead.
The mechanics: a Stop hook arms a detached background watcher after every conversation turn. Each new turn kills the previous watcher and starts a fresh one, so the timer always measures quiet time since the last turn, not since the session started. After four minutes of quiet — deliberately inside the five-minute cache TTL — it extracts the tail of the current transcript (capped at 24,000 characters) and asks headless claude -p --model haiku for a structured handoff: what we were doing, current state, what worked and what failed, the exact next step.
Cost per fired idle event: approximately $0.01. That's the going rate to preserve continuity on a session you didn't know you were about to abandon.
Four engineering details worth knowing if you're deciding whether to install it:
Deterministic fallback. If the headless Claude call fails — network hiccup, rate limit, bad exit — the hook writes a minimal handoff from the raw transcript tail rather than failing silently. You always get something.
Dedupe marker. The hook fingerprints the transcript (modification time plus size) before invoking Claude. If the watcher fires twice on an unchanged transcript, the second invocation sees a matching fingerprint and skips. You don't pay twice for the same content.
Recursion guard. The summarizer Claude process is explicitly excluded from triggering a new Stop hook. Without this, the act of summarizing the session becomes a new turn, which arms a new watcher, which fires four minutes later on the summary session — the summarizer summarizing itself, forever, at a penny a round. The guard is one environment variable check.
Survives /clear. The watcher is a detached shell process. It doesn't know you cleared the conversation. It writes the handoff based on the transcript it already captured. When you return to a fresh session, /resume-session loads the handoff and you're oriented again in three seconds.
The handoff lands in ~/.claude/sessions/*-session.md — exactly where /resume-session loads from, and exactly where idle tax's return warning now links as "most recent handoff note." The loop closes: the warning that fired after the cache died now has a file waiting for it that was written before the cache died.
Walking away from a session is free. The $0.01 buys continuity. The alternative is a cold return, a 12.5x re-cache turn, and the five minutes it takes to reconstruct what you were doing.
The code is GPL-3.0, on GitHub at zivtech/claude-cost-helpers in the idle-autosave/ directory. Install instructions are in the helper guide, alongside the rest of the suite.
The Scorecard
One figure carries the whole audit.
Half the suite is retired or substantially reframed. That's not a failure. That's the right outcome when you build workarounds and the platform catches up with them. Workaround tooling has a half-life. The goal was never to maintain a set of hooks indefinitely; it was to name the problem clearly enough that either the platform fixed it or the habits stuck.
The platform fixed some of them. Good.
The Meta-Lesson
Here's what two months of watching these helpers age out has clarified.
Building tooling on top of a rapidly changing platform is a form of technical debt with an unusual property: the debt retires itself when the platform gets better. A helper that the platform absorbs is a helper that did its job and then became unnecessary. You should want this to happen to your workarounds. The right response when the platform catches up is to retire the crutch cleanly, not to find reasons to keep it running.
The harder discipline is holding your own tools to the evaluation gates you'd demand of someone else's. Before I published this post I went back through the suite and asked the question I'd ask of any code on a client engagement: does this still solve a real problem? Two of them don't. One addresses a problem that changed shape. Saying so clearly is the only thing that makes the keepers credible.
Cost awareness was never about the hooks. The hooks were the medium. The message was: you can't manage what you can't see, and the default tooling doesn't show you the things that compound. That message is still true. Most teams using Claude Code have no visibility into which sessions are burning money and why. No cache-miss count per session. No idle-gap alert. No cost-per-completed-task metric. The billing dashboard tells you the total. It doesn't tell you whether the total was worth it.
The continuity helpers that survived are still worth running because the underlying problem — context collapse, lost session state, the friction of picking up where you left off — is structural, not a platform gap waiting to be filled. Claude Code is stateless by design. The helpers that make it stateful are filling a deliberate gap, not compensating for a temporary one.
The helpers that retired were compensating for temporary gaps. Honor them for that, then let them go.
If you're finding expensive patterns in your own Claude Code usage — sessions that cost more than they should, habits that compounded before you noticed — we'd like to hear about them. The repository is at github.com/zivtech/claude-cost-helpers.
Visuals: idle-autosave timeline at econ-mini-09-idle-autosave.html, helper scorecard at econ-mini-10-harness-absorbed.html — embeddable via iframe, dark-mode aware, color-blind safe.
Code: zivtech/claude-cost-helpers on GitHub. GPL-3.0-or-later licensed.