On Thursday, the AI tooling startup Systima published a blog post that did what good engineering blogs do: it measured something everyone suspected but nobody had quantified. The finding — that Anthropic’s Claude Code sends roughly 33,000 tokens of system-prompt overhead before it ever reads your actual prompt, while the open-source OpenCode sends about 7,000 — hit the front page of Hacker News within hours, collecting 470 points and more than 260 comments by the weekend.

The ratio is striking. Nearly five to one. For a simple “say OK” task, Claude Code burned 33,000 tokens before the model even knew what it was being asked to do. OpenCode, running the same model through a different harness, needed 7,000. The post was careful, methodical, and fair. And the internet did what the internet does: it turned the finding into a verdict.

Claude Code is bloated. Anthropic is wasteful. Open-source wins again.

That verdict is satisfying. It is also wrong — not because the numbers are wrong, but because the thing being measured is not the thing people think they’re angry about.

The Overhead Is the Product

Every one of those 33,000 tokens does something. System prompts are not padding; they are instructions, safety guidelines, tool definitions, context windows, formatting rules. They are the scaffolding that turns a raw language model into a coding agent that can read your file tree, execute shell commands, and not accidentally rm -rf your home directory.

OpenCode’s 7,000-token overhead is leaner because OpenCode is leaner. It does less. It assumes less. It protects less. That is not a criticism of OpenCode — it is a description of the tradeoff. The question is not “which overhead is smaller?” but “which overhead buys you the behavior you actually want?”

Anthropic has bet that developers want an agent that is cautious, context-aware, and hard to jailbreak into doing something destructive. That bet costs tokens. Whether it is worth the cost depends on what you are building and how much you trust your own code review process. But treating the token count as a pure efficiency metric is like judging a car by how little fuel it burns while idling in the driveway — it tells you something, but not the thing that matters.

The Real Irritant Is the Meter

What the Systima post actually exposed is not that Claude Code is wasteful. It is that Claude Code’s pricing model forces users to care about waste in the first place.

Anthropic sells Claude Code through subscription plans — $20 per month for Pro, up to $200 for Max 20x — with weekly usage caps that, once exceeded, silently flip the user into pay-per-token mode. A developer who spends the morning chatting with Claude in the browser and then switches to Claude Code in the terminal is eating into the same five-hour session window and the same weekly token pool. The meter is always running, and the user can feel it.

That is the real source of the outrage. Not the tokens themselves, but the fact that someone is counting them and sending you the bill. A engineering manager at a 40-person startup, messaging me on Slack after reviewing her team’s July Anthropic invoice, put it plainly: “I don’t mind paying for output. I mind paying for the model to read its own instruction manual every time I say hello.”

She is not wrong to be annoyed. But the annoyance is a pricing problem, not an engineering problem. If Claude Code were sold as a flat-rate seat license — $100 per developer per month, unlimited usage — nobody would be measuring token overhead on Hacker News. They would be measuring whether the tool made them faster.

What the Market Is Actually Pricing

The token-overhead debate is a symptom of a broader shift that the AI tools market has not fully metabolized. For two years, the industry sold AI on the promise of raw capability: bigger models, longer contexts, more impressive demos. Now the bill is arriving, and the conversation is pivoting to cost — but the pricing models have not pivoted with it.

Anthropic’s subscription-plus-overage model is a hybrid that captures the worst of both worlds. It feels like a flat-rate product until you hit the cap, at which point it feels like a metered utility. Users are left doing mental arithmetic about whether that 33,000-token preamble is worth $0.50 every time they open a terminal. That is not a relationship of trust; it is a relationship of vigilance.

OpenCode, by contrast, is free and open-source. Its overhead is lower, but more importantly, its overhead is invisible to the user’s wallet. The comparison is not apples to apples. It is a paid product with a visible meter versus a free product with no meter at all. Of course the free product looks better on the one dimension where the paid product charges you.

The Systima measurement is genuinely useful. It tells developers something real about the tools they are choosing. But the conclusion the internet drew from it — that Claude Code is bloated and OpenCode is virtuous — mistakes a pricing failure for a technical one. Anthropic’s problem is not that its system prompt is too long. It is that it built a product whose costs are itemized on the receipt before the user has even started working.

Fix the pricing model, and the token count stops being a scandal. It just becomes an implementation detail.

Sources