Claude Code

The Claude Code token overhead hit me like a bill I wasn't expecting. A client — a Series A startup running lean engineering — had adopted Claude Code across their five-person team. Three weeks in, their Anthropic bill had nearly doubled compared to projections. We dug into the usage logs expecting to find runaway context windows, long conversations, maybe some rogue agent loop. What we found instead was something far more mundane and far more infuriating: the tool itself was burning tokens before a single developer had typed a single character of intent.

We're not talking about a few hundred tokens of system prompt boilerplate. We're talking about 33,000 tokens of preamble — instructions, tool definitions, behavioral constraints, and what Anthropic has dressed up as "safety scaffolding" — loaded into every session before your actual work begins. At Claude's current API pricing, that's not a rounding error. Across a team of five doing dozens of sessions a day, it's a material line item that compounds silently, session after session, sprint after sprint.

When I showed the client what was happening, their CTO — a sharp engineer who'd been in the industry fifteen years — just stared at the number. "So we're paying for Anthropic's homework every time we open the tool?" That's exactly what's happening. And now that the developer community has started measuring it against alternatives, the conversation has gotten uncomfortable for Anthropic in ways they apparently weren't prepared for.

The Artificial Intelligence Tax You Didn't Agree To

Let's be precise about what we're talking about. Claude Code, Anthropic's agentic coding tool, injects approximately 33,000 tokens of system-level context into every session. This isn't your conversation history. This isn't your codebase being indexed. This is Anthropic's internal scaffolding — tool descriptions, behavioral guardrails, formatting instructions, capability definitions — all of it billed to you at standard API token rates.

OpenCode, the open-source alternative that's been gaining serious traction, accomplishes the same fundamental job with roughly 7,000 tokens of preamble. Same category of tool. Same agentic coding workflow. 4.7x fewer tokens before you've said a word.

Andrew Kelley, creator of the Zig programming language, called this out directly and without diplomatic softening. The community reaction at Lobste.rs captured what a lot of developers were already thinking: Anthropic's response to the criticism was the kind of corporate smoke-blowing that makes engineers distrust product teams. Kelley's position was straightforward — this is a choice, not a constraint. Anthropic chose to build a tool that consumes 33k tokens of overhead. They could have chosen differently. The Zed editor's creator agreed publicly. These aren't fringe voices; these are people who build developer tooling for a living.

Anthropic's counter-narrative leans on necessity. The argument goes something like this: Claude Code's capabilities require rich tool definitions and context to function reliably. The safety and behavioral consistency that makes the tool trustworthy in agentic settings demands that scaffolding. Strip it down and you get a less capable, less safe tool.

That argument would be more convincing if OpenCode weren't sitting right next to it doing comparable work at 7k tokens.

What the LLM Economics Actually Look Like

Here's where I want to be specific, because vague hand-waving about "costs" doesn't serve anyone.

At Claude Sonnet's current pricing, input tokens run approximately $3 per million. Thirty-three thousand tokens of overhead per session costs roughly $0.10 per session in preamble alone — before you've asked anything. That sounds trivial until you do the math at scale.

A five-person engineering team running ten Claude Code sessions each per workday — not an aggressive estimate for active development — generates 50 sessions daily. That's $5 per day in pure preamble overhead, $25 per week, roughly $1,300 per year, just for Anthropic's scaffolding to load. For a startup watching burn rate, that's not nothing. For a 50-person engineering org, you're looking at $13,000 annually in tokens that did zero work for you.

The counterargument from Anthropic's defenders is that the capability justifies the cost. If the 33k token preamble makes Claude Code meaningfully more capable than a 7k alternative, then the overhead is an investment in output quality. This is a reasonable position — if it's true. The problem is that "meaningfully more capable" is doing a lot of heavy lifting in that sentence, and the burden of proof sits squarely with Anthropic. Right now, developers are running both tools and not consistently finding a 4.7x capability gap that would justify the 4.7x token gap.

The Machine Learning Model Doesn't Require This. The Business Model Might.

This is the part that deserves to be said plainly, because the developer community is dancing around it while Anthropic hopes the conversation moves on.

There is no fundamental machine learning reason why an agentic coding assistant requires 33,000 tokens of system context. Modern LLMs are not fragile systems that collapse without exhaustive behavioral preamble. The models themselves — Claude 3.5 Sonnet, Claude 3 Opus — are capable of coherent, safe, useful behavior with lean prompting. We know this because we can observe it happening with competing tools.

What 33,000 tokens of preamble does accomplish, beyond whatever genuine capability scaffolding exists, is lock in token consumption. Every session starts with a mandatory spend. You cannot opt out. You cannot trim it. You cannot configure it. Anthropic controls the preamble, and Anthropic sets the pricing. The conflict of interest is structural.

I'm not alleging that Anthropic sat in a room and said "let's bloat the preamble to juice revenue." The reality is probably more mundane and more insidious: teams added tool definitions over time, safety reviews added constraints, product managers added behavioral guardrails, and nobody was incentivized to aggressively prune because the cost was borne by customers, not by Anthropic's internal metrics. This is how bloat happens in products where the producer doesn't pay the consumption cost. It's not malice. It's misaligned incentives operating at scale.

But the effect is the same regardless of intent. Developers are paying for overhead they didn't request, can't audit in full, and can't remove.

The AI Integration Community Is Paying Attention

The Hacker News thread asking for flags on AI-generated content — which hit 676 points as of this writing — is superficially about a different topic, but it's part of the same underlying conversation: the developer community is becoming acutely aware of the gap between what AI tooling promises and what it actually delivers, and increasingly skeptical of incentive structures that don't align with user value.

The token overhead debate is a specific, measurable instance of a broader pattern. AI tooling vendors are making architectural choices that happen to maximize their revenue while presenting those choices as technical necessities. When the choices get measured — when someone actually instruments the token counts and publishes the numbers — the gap between narrative and reality becomes visible.

OpenCode's 7k token approach didn't emerge from inferior engineering. It emerged from a different set of priorities: minimize unnecessary overhead, let the model do the work, don't bill users for scaffolding they didn't ask for. That's a product philosophy, not a technical limitation. And it's a philosophy that the open-source community tends to enforce naturally, because the people building the tool are often the people paying to run it.

Where I Land On This

I've built platforms that serve millions of users. I've made architectural decisions under cost pressure and capability pressure simultaneously. I know what it looks like when a technical choice is genuinely constrained versus when it's a choice wearing the costume of a constraint.

The Claude Code token overhead is a choice. It may be a choice made for partially legitimate reasons — some of that scaffolding probably does contribute to reliability in complex agentic workflows. But 33,000 tokens versus 7,000 tokens for comparable functionality is not a technical necessity. It's a product decision that happens to benefit Anthropic's revenue at the direct expense of developer costs.

My strong opinion: Anthropic should publish a full breakdown of what comprises the 33k token preamble and justify each component by its contribution to capability or safety. Not marketing copy — an actual engineering accounting. If the overhead is justified, that documentation will be persuasive. If it isn't, developers deserve to know that too.

In the meantime, teams evaluating AI coding tools need to factor preamble overhead into their total cost of ownership analysis. The headline pricing on a per-token basis is not the full picture when one tool burns 4.7x more tokens before the work starts. For teams at scale, this is the difference between AI tooling that pays for itself and AI tooling that quietly drains budget while looking productive on a dashboard.

OpenCode and tools like it represent a legitimate alternative that deserves serious evaluation — not because they're necessarily better in every dimension, but because competition on token efficiency is healthy and long overdue. The Anthropic documentation on Claude Code is worth reading alongside independent benchmarks, because the official framing and the measured reality are not always the same document.

What Developers Should Do Right Now

If you're running Claude Code in production, instrument your sessions. Count the tokens in the system prompt versus the tokens in your actual work. Understand what fraction of your bill is overhead before you've done anything. That number might surprise you, and you deserve to make resource decisions with accurate data.

If you're evaluating AI coding tools, run OpenCode in parallel for two weeks. Measure output quality against token consumption. Make the comparison empirically, not based on brand trust or marketing positioning.

And if you're an engineering leader presenting AI tooling ROI to a board or a CFO: the per-token price is not your unit cost. Your unit cost includes everything that gets consumed before your prompt lands. Right now, for Claude Code, that's a number your vendor would prefer you not examine too closely.

The developer community is examining it anyway. That's exactly as it should be.