Something strange is happening to the cost of building with AI. Every headline says prices are collapsing — and they are. Per-token rates have fallen roughly 97% since 2023, and open-weight models now cost a fraction of the frontier ones.

And yet, quietly, the bill keeps going up.

Uber burned through its entire 2026 AI-coding budget by April. Microsoft revoked developers’ Claude Code licenses months after enabling them. Priceline’s contract renewal came back 4–5× more expensive. One engineer reportedly ran up a $40,000 token bill in a single month. Per-developer token consumption rose roughly 18.6× in nine months as tools drifted from “answer a question” to “agent, do the task.”

The rate card didn’t move. The meter did.

The two numbers a solo builder needs to separate

There are two completely different curves hiding inside everyone’s AI spend, and they tell opposite stories.

The price curve is falling. Bigger context windows, cheaper inference, new open-weight challengers every quarter — the cost of one unit of intelligence keeps dropping. If your usage were flat, your bill would shrink every month.

The consumption curve is climbing. Agents don’t answer once; they loop. They reason, retry, call tools, re-read context, and generate far more output than a single chat reply ever did. Token-per-query is up 2–4× versus a year ago, agent loops multiply tokens 3–10×, and reasoning chains stack another 5–10× of output on top.

Fall in price, multiplied by rise in consumption, and the product nets out in the wrong direction for most people who aren’t watching. That’s the whole explanation, and it’s worth sitting with: your AI bill is a consumption problem wearing a pricing costume.

Agents changed the meter

Before agents, a request was a fixed, predictable thing: one prompt in, one answer out. You could price it, budget it, and forget it.

An agent breaks that assumption. The same high-level goal — “fix the failing tests,” “research this topic,” “generate the report” — becomes a loop that runs until it decides it’s done. Every iteration spends input, output, and context tokens. Fail three times and retry, and the meter has clocked three runs where you expected one.

This is the exact curve TechCrunch documented in mid-2026, when “token bill comes due” became a boardroom panic rather than an engineering footnote. A single autonomous agent run can consume what used to be a week of interactive chat. The Jellyfish numbers made the tradeoff explicit: engineers using the most tokens were only about 2× as productive as light users, but burned 10× the tokens to get there.

For a solo builder, there’s no CFO to absorb the surprise. You are the CFO, the engineer, and the one who pays the bill.

Where the money actually goes (and where it doesn’t)

Strip the hype and there are four honest drivers of a rising AI bill, in rough order of how much they silently cost you:

  1. Shipping unused context. Agents and RAG pipelines stuff whole files, entire histories, and full docs into every call whether the task needs them or not. Context tokens are input tokens, billed at full rate, every single call.
  2. Using a frontier model for a task it’s overqualified for. Precision costs roughly 10–100×. A summarization or classification task that a cheap open-weight model does perfectly doesn’t need the flagship.
  3. No caching, no retry discipline. Prompt caching turns repeated prefixes from full-price into a fraction of a cent. Not using it means paying for the same system prompt ten thousand times.
  4. Metering what you ship, not what you use. The bill that surprises people is the one they only saw at the end of the month. Measure at the endpoint, alert at a threshold, and a “surprise” becomes a line item you planned for.

Notice what’s not on the list: the price per token. Because that’s not your problem anymore.

The discipline that brings the meter back

The fix isn’t “spend less on AI.” It’s matching the model to the job and watching the meter, not the rate card.

  • Route to the cheapest capable model. Route the hard reasoning to the strong model and the plain work to the cheap one. This is exactly what the big labs are doing internally — routing Opus calls down to Sonnet or Haiku when the task doesn’t need the top tier. A solo builder gets the same lever for free.
  • Cache aggressively. Put your system prompt, tool schemas, and stable context behind prompt caching and stop re-buying the same tokens.
  • Cap output and cap loops. Set a budget on how many tokens a run may spend and how many iterations an agent may take. An unbounded loop is the single fastest way to a four-figure surprise.
  • Measure shipped-vs-used. The number that matters isn’t “how much did I spend.” It’s “how much of what I spent actually reached a user.” If you can’t see that split, your bill is running you, not the other way around.

None of this is exotic. It’s the same cost-of-goods rigor a solo builder applies to server costs, hosting, and every API they already buy. AI only feels different because the meter is new — and new meters get ignored until the first invoice arrives.

The decade-scale point

The price collapse is real, and it’s a gift: it’s what makes one person able to ship what used to take a team. But the era of “AI is so cheap I don’t have to think about it” is already over — and it ended before most solo builders noticed.

The builders who treat their token spend like the cost of goods it actually is will be the ones still shipping profitably when the conversation has moved from “what can it do” to “what does it cost, and can I see the meter.”

That’s the whole game now. Not watching the rate card. Watching the meter.

The next step is turning that discipline into a budget: setting the number before you write code, and treating a solo build like something that runs on a meter rather than a flat monthly plan.

Sources

  • Rebecca Bellan, “The Token Bill Comes Due: Inside the Industry Scramble to Manage AI’s Runaway Costs,” TechCrunch, June 5, 2026. — Uber’s 2026 AI budget exhausted by April; Microsoft revoking Claude Code licenses; Priceline’s Cursor renewal 4–5× more expensive; one engineer at ~$40,000 in a month; per-developer token consumption +18.6× in nine months; Goldman Sachs projecting 24× global token growth by 2030.
  • Faros AI (2-year study, 20,000 developers) — output rising alongside a rise in bugs and rewrites; the productivity-per-token question unresolved.
  • Jellyfish (Nicholas Arcolano, head of research) — highest-token engineers ~2× as productive as light users but consuming ~10× the tokens; recommends broad moderate adoption over pushing heavy users higher.
  • J.R. Storment (FinOps Foundation executive director) — “3× over our entire 2026 token budget and it’s only April”; the shift from “go fast” to “we need guardrails.”
  • Alexander Embiricos (OpenAI, head of enterprise) — customer conversations moved from “what can it do” to “what visibility, auditability, and token controls do you offer.”
  • ComparEdge AI API index — median input ~$1/1M tokens, output ~$4.4/1M (≈4× input); cheapest open-weight models ~$0.035/1M input vs frontier ~$2.50–3.00/1M input.
  • Redress benchmark — tokens per query up 2–4× vs 2024; agent loops multiply tokens 3–10×; reasoning chains stack 5–10× output.