The 33,000-Token Bill You Pay Before Typing a Word

You type one line into your coding agent: “fix this bug.” Simple enough. But before those three words even reach the model, more than 33,000 tokens have already been quietly metered and billed. That is the quiet argument spreading through developer circles right now: the invisible startup cost of AI coding tools.

Let me be honest up front. This is not the kind of viral controversy that blew up on Hacker News in the last month. It is more like a chronic ache that heavy users keep prodding at. So instead of a live play-by-play of community reactions, let’s pull apart the structure and figure out why this actually matters.

33,000 Tokens Before It Reads Your Question

Start with the core fact. A coding agent does not send your prompt to the model alone. It bolts an enormous “briefing document” onto the front of it: a system prompt, tool definitions, safety rules, file-editing format instructions, and a pile of context.

For Claude Code, that briefing is reportedly around 33,000 tokens. Translation: type “hi” and the model has already read the equivalent of a short novella of background before it ever gets to your “hi.”

Why so heavy? The answer is boring but honest. The more tools an agent has, and the smarter they are, the longer the manual gets. Reading files, writing them, searching, running a terminal, spawning sub-agents, loading skills — every single capability needs its own “here’s when and how to use this” explanation. Richness of features becomes weight in tokens. There is no free lunch.

The Minimalist Counterpunch: “We Do It in 7,000”

Here is where the other side speaks up. Minimalist-leaning tools like OpenCode make a blunt claim: you can keep a system prompt at roughly 7,000 tokens and still get the job done.

On the numbers alone, that is more than a 4x gap. Why does the gap matter? Three angles.

First, money. Tokens are cost. Stack 33,000 tokens onto every request, and for a heavy user firing off hundreds of turns a day, that is a bill you cannot wave away. Caching softens a lot of it, sure. But the moment the cache breaks, the full cost comes right back.

Second, the context budget. A model’s context window is finite. Lay down 30,000 tokens of overhead from the start, and you have that much less room for the thing you actually care about: your codebase. The bigger the project, the more brutal that turf war gets.

Third, focus. This one is the sleeper. Longer prompts can dilute the model’s attention. Pile on instructions and some of them get dropped on the floor. The minimalist argument is that the less you tell the model, the more sharply it moves.

But Does Minimalism Actually Win?

Don’t pick a side yet. Heavy exists for a reason.

Claude Code spends 33,000 tokens not out of sloppiness but because it does a lot for you automatically. Those detailed tool definitions are guardrails that stop the agent from flailing. How to edit a file, when to ask for confirmation, how to screen a dangerous command — all of it is baked-in experience so you don’t have to spell it out every single turn.

Minimalist tools are light, but sometimes you pay for that lightness yourself. The model misses context and does something dumb, or you end up typing far more instructions by hand. The tokens you saved in the system prompt get vomited right back up mid-conversation.

So this is really a question of prepaid versus postpaid. The heavy agent pays the cost up front. The light agent spreads that cost across the conversation. Which one comes out ahead depends entirely on the kind of work you do.

The Real Problem Is That It’s Invisible

The part I find most interesting is not the numbers. It’s that this cost is invisible.

Most users have no idea whether their agent’s startup overhead is 33,000 or 7,000. There is barely a way to find out. The bill shows a lumped-together token total; it never tells you how much got burned before your question even arrived. That is a textbook information asymmetry.

Which means the real value of this argument is not deciding who is lighter. It’s that users have started peering into the hidden cost structure of their own tools. We are entering an era where you don’t just scan the feature list — you ask, “how much does this thing burn before it does anything?”

Next time you pick a coding agent, try asking that question once. How much is this tool spending before it reads a word from me? And is that weight actually earning its keep? For your workflow, I’m genuinely curious which side wins — prepaid or postpaid.