Picture this: you open an AI coding assistant and type the two characters “OK” to confirm. Just those two characters — yet before it ever “sees” them, it has already quietly burned roughly 33,000 tokens of compute quota in the background. A functionally similar tool, in the same situation, uses only about 7,000.
This isn’t a metaphor, and it isn’t an estimate. It’s a measured result from the Systima team, who slipped a logging proxy in front of Anthropic’s API and recorded every raw request. They published the full experimental method and the raw numbers on their blog, and the post quickly climbed Hacker News with over 400 upvotes and 200-plus comments.
Let’s walk through three things behind that number in plain terms: what these AI coding tools actually do before they “see your words,” why subagents are the real token black hole, and what role the pay-per-token business model plays in all of it.
What is a token, and why does it burn like gasoline?
Before the specific numbers, one key concept. A token is the smallest unit by which an AI measures text — not “one character,” but roughly 0.75 of an English word, or one to two Chinese characters. With a metered AI service, every token processed generates a line item on the bill.
AI coding tools differ from ordinary chatbot conversations. When you chat with Claude on the web, what it receives is essentially your question. But a coding tool has to stuff in a lot of extra “prep work” on top of your prompt — telling the model who it is, which tools it can call, what the project’s rules are, where the working directory is, the OS environment, and so on.
This extra content is called “harness overhead.” The catch is that the size of this overhead varies wildly.
33,000 vs 7,000: the bill for replying “OK”
Systima’s experiment was straightforward: take two coding tools — Anthropic’s official Claude Code and the open-source OpenCode — and have each perform the same trivial task: reply “OK”.
Before Claude Code ever saw those two characters, it sent about 33,000 tokens to the API. The breakdown: roughly 6,500 tokens of system prompt (telling the model “who you are and how to behave”), about 24,000 tokens defining 27 tools (read file, write file, run command, manage subagents, scheduled tasks…), and around 2,000 tokens of injected reminder blocks (task state, available skills list, current environment info).
OpenCode used only about 7,000 tokens: roughly 2,000 for the system prompt and about 4,800 for 10 tool definitions. No extra reminder blocks; the structure is lean.
One easily overlooked detail: those 33,000 tokens aren’t spent once and done. In a coding tool’s working model, every turn of the conversation — every round trip to the model — re-sends all that harness content. So if your task takes 10 back-and-forth turns, the scaffolding alone costs 330,000 tokens, before you count any of your actual code or dialogue.
Caching should save money — but Claude Code fumbles it
AI providers usually offer a “prompt caching” mechanism: if most of a request is unchanged across successive calls, it can be read from cache at a much lower price instead of being recomputed. This is a key lever for controlling cost.
But Systima found a critical difference: OpenCode’s request prefix is byte-for-byte identical every time, meaning it only needs to write the cache once and then pays a tenth of the price on every subsequent read. Claude Code, within the same task’s consecutive requests, repeatedly rewrote tens of thousands of cached tokens — writing to cache 54x more often than OpenCode for the same task.
Writing to cache is far more expensive than reading from it. In other words, a big part of why users see their bills climb is that the tool isn’t using caching efficiently.
The real production bill: from 33K to 85K
Those 33,000 figures above are the “naked” state — no project config, no plugins, no extra tools. What does a real production environment look like?
Systima ran a “stacking” experiment. They first tested in an empty project, then progressively added the configuration of a real development scenario:
Step one: drop in a 72KB project instructions file (AGENTS.md or CLAUDE.md, which tells the AI your coding conventions). This single step added about 20,000 tokens per request.
Step two: wire in five lightweight MCP servers (letting the AI read/write email, manage tasks, query databases, and so on). Another roughly 5,000 to 7,000 tokens.
All told, in a realistic dev environment, Claude Code has already burned 75,000 to 85,000 tokens before it reads your prompt. OpenCode also balloons under similar stacking, but because its starting point is so low, the absolute numbers stay manageable.
Subagents: the real token black hole
If harness overhead is “high fuel consumption,” subagents are “a leaking gas tank.”
Subagents are a key Claude Code feature: when a task is complex, the main agent can dispatch several “clones” to work in parallel, each independently reading code, analyzing problems, and returning results. Sounds efficient — but the cost is staggering.
Systima ran the same task both ways: executing directly cost 121,000 tokens; switching to two parallel subagents sent consumption soaring to 513,000 tokens — 4.2x the original.
Why such a gap? Because each subagent is an independent working unit. It has its own system prompt (leaner than the main agent’s), its own toolset, and has to re-read the project files to understand context. After a subagent finishes, its entire conversation transcript gets “swallowed” by the main agent as reference material. It’s like sending two people to research something, and each one comes back not just with the answer but with a whole box of every raw document they flipped through.
One HN user reported an even more extreme experience: “I gave Claude Code a fairly large task, and it immediately spun up 7 subagents. Before my budget ran out, not one of them had finished. Five hours later I tried again — same result.” The same task, run sequentially by the main agent, worked perfectly fine.
Anthropic’s business-model bind
At this point a natural question arises: is this a design flaw, or a consequence of the business model?
Anthropic’s API is billed per token. Claude Code, as an official tool, earns Anthropic more revenue the more tokens it consumes. That doesn’t necessarily mean it’s “deliberately designed” that way — more likely it’s a structural incentive: when your revenue depends on how many tokens users burn, you don’t have the same strong motivation to slim down the harness that an open-source community does.
The reason OpenCode can hit the 7,000-token “floor” is largely that it’s an open-source project — maximizing API revenue was never a design goal. Claude Code’s 27 tools, multi-layer reminder blocks, and full subagent bootstrapping machinery each have a legitimate “more capable” rationale. But stack all that “more capable” together, and the user’s bill becomes a side effect.
But Claude Code wins sometimes too
To be fair, Systima’s tests also found a scenario that favors Claude Code.
On a multi-step task (write code, run tests, fix based on errors, test again), Claude Code’s total consumption was actually lower than OpenCode’s. The reason: Claude Code bundles multiple tool calls into a single request, whereas OpenCode does one tool call per request round trip. Although Claude Code’s per-request base is heavier, OpenCode, lacking bundling, paid the base overhead nine times over and ended up with the larger total.
This reveals a subtle truth: a tool’s token efficiency isn’t just about how light its base is, but about how it organizes the workflow. A heavy base that bundles vs. a light base that re-runs — which wins depends on the task.
What this means for ordinary users
If you don’t write code, you might think this is “a programmer’s problem.” In reality, as AI tools move from “chatting” to “doing work,” this metered billing model touches every user.
When you change one line in Cursor, or ask Claude Code to fix a bug, a similar story plays out behind every action: huge volumes of system instructions are being re-sent, subagents spin up and die in the background, caches get rewritten again and again — and the bill quietly accumulates inside those invisible motions.
Systima’s experiment dragged numbers that were hidden inside a black box out into the sunlight. As users, simply knowing these numbers exist is itself a form of informational empowerment.
Or more bluntly: next time you look at an API bill, you’ll know that probably only a small fraction of it is what you actually used.
Reference links:
- Systima: Claude Code vs OpenCode Token Overhead
- HN discussion (item?id=48883275)