By Alex Urevick-Ackelsberg, Zivtech

The Economics of Claude Code: Where the Money Actually Goes

The full picture: 10 cost drivers, pricing mechanics, benchmarks, and the rhythm of cost-efficient Claude Code work.

The expensive thing is never the prompt you write. It's the context you carry. Every habit in this series is about the same principle: keep the context lean, keep the cache warm, and when a session has served its purpose, let it go.

Claude Code isn't free, and the costs aren't where most people expect. I've spent months tracking usage patterns across two businesses (Zivtech, a dev agency, and Milk Jawn, an ice cream manufacturer), digging into Anthropic's pricing, and figuring out where spend is efficient and where it's waste. Claude (my co-author, and yes, the irony is noted) dug into the cache mechanics. This post covers the economics of the tool itself, not any particular workflow. The underlying mechanics apply to everyone.

Two reasons to care now. First, these models consume real electricity. Wasting tokens isn't just wasting money; it's wasting energy. Second, today's token prices are heavily subsidized. They will not stay this cheap. The habits you build now at subsidized rates are the habits you'll carry when the real prices arrive.

This post gives you: the pricing mechanics, 10 cost drivers with management and monitoring guidance, the rhythm of cost-efficient Claude work, and benchmarks to check whether something is off.

How Claude Code Pricing Actually Works

Claude Code charges per token (chunks of text in and out of the model). You pay for input tokens (everything Claude reads) and output tokens (everything Claude writes back). The critical detail: prompt caching. Claude caches the start of your conversation so it doesn't reprocess it every turn. Cache reads cost 90% less than fresh processing. Cache writes cost 25% more, but pay for themselves on the second message.

The cache has a five-minute TTL. No message for five minutes and the cache expires. The next message reprocesses the entire conversation from scratch: 12.5x more expensive than a warm-cache message. Same tokens, same work, different price. There's no warning. The cache quietly dies.

Reference table:

A 100K-token Opus session costs about $0.15 per turn on a cache hit, about $1.88 per turn on a cache miss. Over a long day, that gap compounds into real money.

The Rhythm of the Work

Most expensive surprises come from drifting into the wrong rhythm without noticing. A session has three modes:

Fast execution. Claude reads files, writes code, runs commands, iterates on errors. Turns are 5 to 30 seconds apart. Cache stays hot. This is the cheapest mode and the highest ratio of useful output per dollar.

Deliberation. Claude asks a question, you think, you answer, Claude reprocesses the full conversation to act. Two or three round trips per decision. Cheap if the gaps are short, but this mode drifts into the expensive one easily.

Wait-and-see. Claude kicks off a long-running task (build, test suite, deep analysis) and waits. Minutes pass. Cache dies. When the result arrives, that single message may be the most expensive in the session because it rehydrates the whole conversation.

Most real work mixes all three. The economic question is whether you notice which mode you're in. The worst shape is repeated wait-and-see cycles with long gaps (each wake-up is a full re-cache). The best shape is dense fast-execution runs with short deliberation checkpoints and long-running work offloaded to infrastructure that doesn't make Claude wait.

Rhythm is invisible to billing reports. If you're going long stretches between messages, the meter is running hotter than you think.

The Cost Drivers

The rest of this post is a working list of the cost drivers in a Claude Code session. For each one I'll note:

• What it is
• Observable / Controllable: whether you can actually see the cost and whether you can actually change it
• How to manage: the levers
• How to monitor: what to watch for
• Joyus AI Internal coverage: whether our internal platform (Joyus AI Internal) is planning to help manage this one, and via which component

"Observable" means the cost leaves a trace you can see (a token count, a billing line, a session log). "Controllable" means you can actually change your behavior or configuration to move the number. Some things are observable but not very controllable (model list prices), some are controllable but not observable (interaction rhythm), and a few are neither. Those last ones are the ones to be most careful about.

1. Front-loaded context (system prompts, CLAUDE.md, project instructions)

What it is. Everything loaded before your first message: Claude's system prompt, tool definitions, CLAUDE.md files (project and parent directories), any --append-system-prompt content. Cached once at a slight write premium, then read cheaply on every turn.

The obvious strategy is "cram everything in." But every front-loaded token gets reread on every turn. A 50,000-token CLAUDE.md means every message, even "yes, do it," reprocesses 50,000 tokens at cache-read rates. Cheap per token, expensive across 40 turns. The alternative is worse: leaving context out forces mid-conversation clarification rounds that also become permanent.

Observable: Yes. Controllable: Yes. How to manage. Front-load what's relevant to most messages; pull in single-task context on demand. Coding standards and workflow preferences belong in the prefix. A specific file you need to edit once does not. Keep project instructions in the low thousands of tokens. If you keep re-explaining something mid-conversation, promote it. If something matters one time in ten, demote it. How to monitor. Count your CLAUDE.md tokens, multiply by a typical turn count (30). That's the cost floor before any work happens. Joyus AI Internal. Partial. Spec 011 captures per-session token totals, making bloated prefixes visible across tenants.

2. Cache lifespan (the five-minute rule)

What it is. The prompt cache expires after about five minutes of inactivity. The first message after that gap reprocesses the entire conversation at full input rate plus a cache-write premium: 12.5x the cost of a warm-cache message.

Observable: Indirectly (elevated input costs in aggregate, no live indicator). Controllable: Yes, tied to your pacing. How to manage. Before stepping away: save session state and start fresh when ready. For long gaps (lunch, meetings, end of day), starting fresh is almost always cheaper than reheating 60 turns of history. How to monitor. Count cache misses per session (turns where cache-read tokens are near zero while base input is high). More than one or two means a gap problem.

Joyus AI Internal. Yes. Spec 011 adds idle-gap detection per mediation message, cacheMissCount and maxIdleGapSeconds on the session record, and a recommendation path for session splitting when both gap length and session size cross thresholds. This is the driver Joyus is most directly built to manage.

3. Context accumulation

What it is. Every file Claude reads, every tool result, every code block it writes becomes permanent until the session ends. Claude rereads the entire conversation on every turn. Turn 5 is cheap. Turn 50 is expensive because it rereads everything that came before.

Reading a 2,000-line file adds roughly 20,000 input tokens to every subsequent turn. Reading it again because you forgot? Two copies.

Observable: Yes (input tokens per turn rise visibly). Controllable: Yes. How to manage. Prefer surgical reads (specific line ranges) over whole files. Don't re-read files already in context. For exploratory work, use a subagent with a narrow brief. Past 30-40 turns or 100K+ tokens, write a handoff note and start fresh. A 5,000-token handoff is cheaper per turn than 200,000 tokens of history. How to monitor. Watch turn-over-turn input token growth. Steep climbs mean something unnecessary is being pulled in.

Joyus AI Internal. Partial. Spec 011 tracks totalInputTokens and totalCacheReadTokens at the session level, making the growth curve legible.

4. Message count and turn churn

What it is. Every round trip rereads the full conversation. Three separate messages ("ok," "sounds good," "yes do it") cost three full context rereads. Batching the same feedback into one message cuts the cost by two-thirds.

Observable: Yes. Controllable: Yes. How to manage. Batch feedback: "Yes, do it. Also change the function name to X and add a test for the edge case" is one turn, not three. Aborting a response mid-generation doesn't refund the context-read cost. Save interruptions for genuine redirects. How to monitor. Watch messages-per-completed-task ratio. Ten messages for a two-message task means churn is burning cache reads on conversation management, not work.

Joyus AI Internal. Partial. Session metrics include messageCount for spotting abnormal churn. Behavioral change is on the human.

5. Agent spawning

What it is. Each subagent gets its own context and cache. The parent's cache keeps ticking down while agents work. Three agents in parallel means four separate caches (parent plus three children), each cold-starting. If agents take more than five minutes, the parent's cache expires too.

Observable: Partially (you see which agents ran, but individual token usage is less visible). Controllable: Yes. How to manage. Give each agent a focused brief. A security reviewer needs the code and the policy, not 30 turns of discussion about button colors. Pick model tier per agent. When agents will run more than a few minutes, keep the parent alive with small tasks or save and let them finish in the background. Parallel critic passes are worth the spend (catching a wrong decision before implementation is cheaper than fixing it after). Parallel implementation on coupled code is usually not worth it (merge cost). How to monitor. Track agent-time to session-time ratio. If agents are out for long stretches while the parent idles, the parent cache is dying repeatedly.

Joyus AI Internal. Partial. Spec 011 tracks cost per session. Agent-level cost attribution is on the roadmap via operation-log sessionId tagging.

6. Model tier (Haiku / Sonnet / Opus)

What it is. Opus is ~5x Sonnet input cost and ~60x Haiku. Think of tiers as billing rates on a consulting team. Haiku is the junior associate: fast, cheap, excellent at file lookups and codebase exploration. Sonnet is the senior developer: implementation, debugging, review, test writing. Most spend belongs here. Opus is the principal architect: deep analysis, security review, plan critique. Worth it when a bad decision compounds into wasted implementation.

Observable: Yes. Controllable: Yes. How to manage. Default to Sonnet. Use Haiku for scans and lookups. Reserve Opus for planning, architecture, and security. If Opus dominates your spend on day-to-day coding, you're paying principal-engineer rates to search for filenames. How to monitor. Break spend by model. Healthy mix: majority Sonnet, meaningful Haiku minority on exploration, smaller Opus slice on strategic calls.

Joyus AI Internal coverage. Yes. Spec 011 captures the model per generation call in operation metadata and includes model-level aggregates in the cost dashboard. Model-based routing is elsewhere in Joyus AI Internal's agent platform; the cost-visibility piece lives here.

7. Clarifying questions and interaction rhythm

What it is. Each time Claude stops to ask a question, the full conversation is reprocessed to generate the question, then again when you answer. Two full context reads, and the only output was a decision Claude might have made on its own. Worse: if the question makes you think for five minutes, the cache dies. Three context reads for one decision.

The cheapest pattern is when Claude has enough context to just execute. The tension: you don't want Claude charging ahead on the wrong approach for 20 turns. A question that prevents wasted work is worth it. A question that a well-written prefix would have prevented is not.

Observable: Indirectly (pacing, not reports). Controllable: Yes, through prompt design and prefix. How to manage. When Claude asks the same kind of question across sessions, update the prefix. "What testing framework?" or "should I follow conventions?" are questions a good prefix answers once, forever. Be explicit about authority: "Fix this and commit" establishes a different rhythm than "take a look and tell me what you'd do." How to monitor. Count deliberation turns versus execution turns. Rising deliberation means the task is genuinely ambiguous or the prefix is underspecified. Joyus AI Internal. Not directly. Rhythm is a prompt-design concern. Cost metrics show that a session has many turns and high per-turn cost, but the fix lives at the workflow layer.

8. Long-running blocking tool calls

What it is. Any tool call that takes more than a few minutes while Claude waits: test suites, builds, multi-file analysis. The cache ages while the tool runs. If the gap exceeds five minutes, that one result triggers a full re-cache. A five-minute test run at turn 50 can be the most expensive message of a session.

Observable: Yes (tool runtime is measurable). Controllable: Yes. How to manage. Move long-running work to infrastructure that doesn't make Claude wait. CI runs the test suite; Claude reads the result artifact. Background processes with file-based handoff beat synchronous waits. Anything approaching the five-minute cache window is a hard architectural boundary. How to monitor. Flag tool calls blocking Claude for more than ~3 minutes. Correlate with cache-miss counts. Joyus AI Internal. Indirectly. Spec 011's idle-gap detection treats a blocking tool call the same as a human absence. The dashboard surfaces the pattern; the fix (async infrastructure) is architectural.

9. Interruptions and aborted responses

What it is. Hitting escape mid-generation, canceling a tool call, switching direction before a response completes. Interruption feels free, but Claude already processed your full context and started generating. You pay for the input read and whatever output was produced before the cancel.

Observable: Partially (interrupted generations appear in usage data if you look). Controllable: Yes. How to manage. Interrupt for real course corrections, not casual "wait, never mind." Frequent interrupts usually mean underspecified prompts. How to monitor. Track interruption rate if your tooling exposes it. More than a handful per day signals prompt-design work needed upstream. Joyus AI Internal. Not directly. Interrupted generations still produce operation log entries.

10. Output length

What it is. Output tokens are priced ~5x higher than input on every tier. Verbose output (restated context, summaries of work visible in diffs) adds cost with little value.

Observable: Yes. Controllable: Partially. The model drifts toward longer responses without explicit guidance. How to manage. Ask for short responses when short is enough. For coding tasks, tell Claude not to restate what the diff shows. Put terseness guidance in the prefix. How to monitor. If a standard bug fix produces a 3,000-token response when 300 would do, the terseness instructions aren't landing.

Joyus AI Internal coverage. Yes. Spec 011 captures outputTokens per operation and in session roll-ups. Verbose outputs are visible in the cost dashboard as a disproportionate output-to-input ratio.

Benchmarking: Is Something Off?

The hard part isn't identifying the drivers; it's knowing whether your numbers are normal. A plan-and-critique pass should cost more than fixing a typo. These aren't hard thresholds. They're the numbers that make me stop and look when they drift.

Cache hit rate (cache reads / total input tokens). Healthy: above 80%. Below 60%: cache-miss problem. Below 40% on any multi-turn session: something structural is wrong.

Cache miss count. Zero or one on a good session. Two or three if you stepped away once. Approaching double digits: wait-and-see rhythm is dominating.

Average idle gap. Under two minutes on active work. Four minutes or longer: flirting with TTL on every gap. Over five minutes average: most turns are starting cold.

Input token growth per turn. Should grow linearly and gently. Doubling every few turns means something unnecessary is being pulled in.

Output token ratio. Output should be a small fraction of input. Above 20% on routine coding: the model is restating work that's visible in artifacts.

Model spend mix. Majority Sonnet, meaningful Haiku minority, smaller Opus slice. If Opus dominates and you're shipping typical CRUD changes, the tier choice is miscalibrated.

Cost per completed task. Pick a representative task type and track it over time. If the cost per "routine feature" trends up without the tasks getting harder, something in the workflow is degrading.

When more than one signal is off, look at how you're working. The issue is almost always one of the ten drivers above.

Where Joyus AI Internal Fits

Most of this is observable if you look hard at the right data. The problem is that most tools don't surface it. Cost is invisible until the bill arrives, and by then the signal about which sessions or drivers caused the spend is lost.

Joyus AI Internal's cache-economics module (spec 011) makes this legible: token and cost data per operation, rolled up per session, with cache-miss and idle-gap flagging surfaced through operator dashboards. The point isn't automatic enforcement. It's making the economics visible enough for informed choices about session splitting, model routing, and workflow design.

Cost visibility is load-bearing. Without it, teams make these mistakes for months before anyone notices.

The Companion Helpers

I built six local helpers (hooks and slash commands in your ~/.claude/ config) to make these cost mechanics visible at the moment they happen. No platform dependency. Just bash and python3.

They cover the six failure modes I kept hitting: cache expiry sneaking up on you, sessions that should have been split, subagent context bloat, lossy compaction with no safety net, tool output silently inflating every future turn, and delegation results piling up in the parent. Each helper warns when the cost is about to spike.

I built them for myself first, then for my team at Zivtech, then for clients and the broader open source community. Free, GPL-3.0-or-later licensed, on GitHub. Pull requests welcome.

The Point

Claude Code is a cab with the meter running. The meter runs whether the cab is moving or parked. If you step out for more than five minutes, getting back in costs 12.5x more than staying in the car.

Most of the drivers above are controllable if you can see them. A few are controllable only indirectly, through workflow design. Rhythm matters more than any single driver. Sessions in fast-execution mode are cheap almost regardless of length. Sessions that drift into wait-and-see cost more than most people expect, even short ones. The biggest improvement most teams can make is noticing which rhythm they're in.

If you're finding expensive patterns in your own usage, we'd like to hear about them.