Spend Your Tokens Like They Cost Money

A year ago, an article arguing that you should spend fewer tokens would have read as eccentric. The whole industry was leaning the other way: use more, loop harder, leave the agent grinding overnight. A few companies put it on a leaderboard. Then the invoices landed.

The reversal has been quick, and a little undignified. One company reportedly spent on the order of half a billion dollars on Claude in a single month after nobody capped usage ^[R1]. Uber's CTO blew through the company's 2026 Claude Code budget by April, and companies including Uber, Microsoft, Meta, and Salesforce began rationing access ^[R2]. Amazon built an internal AI-usage leaderboard, watched people generate busywork for the agent purely to climb it, and shut it down ^[R2]. Salesforce shipped an entire counter-metric, Agentic Work Units, to make the argument that what the tokens do matters more than how many you feed in ^[R1].

What's ending is tokenmaxxing. My favourite description of it belongs to Appian's Matt Calkins, who likened it to the Soviet habit of grading chandeliers by weight, which is how you get chandeliers heavy enough to bring the ceiling down ^[R1]. That's the whole argument in one image. The goal was never to spend the most. It is not, now, to spend the least. It's to get more work out of the budget you actually have.

What broke

Tokenmaxxing was Goodhart's Law with a corporate card: the instant consumption became the metric, it stopped measuring anything worth knowing.

You can burn a fortune in tokens and not shift a single number a customer would ever notice.

The leaderboard part is the one that gets to me. Ranking engineers by token spend takes the one bit of this job that's meant to be judgement (deciding what to build and what to leave alone) and replaces it with a slalom around a vanity number. It's the lines-of-code contest from 2011, now with a four-figure monthly invoice attached.

The finance side is catching up faster than the culture. There's a FinOps Foundation effort underway to define "tokenomics" properly (cost-per-intelligence, tokens-per-watt) precisely because token spend turned out to be more opaque than anything the same teams managed through the cloud years ^[R3]. Goldman Sachs Research reckons global token usage grows something like twenty-fourfold by 2030 ^[R4]. If that's even roughly right, "buy more" stops being a plan.

The labs are tightening from their side too

This part is mechanical, not a mood. OpenAI and Anthropic keep shipping firmer quotas alongside each more capable model, and there are good reasons for it. Reasoning models spend tokens thinking before they say a word. Agentic harnesses run unattended for hours. Frontier inference is expensive to serve. The age of effectively unmetered access to the best model is closing, and reading your weekly limit as a scarce resource is just reading the pricing page.

Where the tokens actually go

Before optimising anything, find the leaks. In a coding session the heaviest drains are rarely the ones you're looking at:

• Input tokens: the system prompt, your CLAUDE.md, every file you've loaded, and the whole conversation so far, re-sent on every single turn.
• Output tokens: the priciest per unit, and padded with the model's reflexive preamble ("Let me explain what I'm about to do").
• Reasoning tokens: invisible in the transcript, loud on the invoice. A reasoning model can spend more here than on the answer.
• Tool output: the one people miss. A grep across a big repo, a cat of a 500-line file, a failing test with its full stack trace: it all lands in context and just sits there.

That last one is where most of my own waste used to hide.

There's a fifth drain that's really an architecture problem in disguise. Point an agent at a sprawling, tightly-coupled codebase and it has to read half of it just to work out where it is. Every file it opens is rent on the context window. A small service with clean seams is cheap to reason about; a big ball of mud is expensive before you've asked it to do a thing. Token efficiency starts upstream of prompting, in how the code is shaped.

Plan before you vibe

The biggest token sink isn't on that list at all. It's rework. Vibe your way into a dead end and the back-out costs more than any log file ever will, so spend the tokens on thinking first.

In practice that means saying what you're actually building, and where it's heading, before you sweat the next task, and sorting need-to-have from nice-to-have while it's still cheap to change your mind. Spec-Kit and BMAD both formalise this: they make you write the spec, then the plan, then the task list, so the build phase stays narrow ^{[R5] [R6]}. A few hundred tokens of constraint up front is the best trade in the whole stack.

Manage your context

Don't run your entire week through one immortal session. An agent that's just swallowed a giant log file gets noticeably worse at the task in front of it, harness filtering or not. I keep several terminals open and split work by task, and I /compact hard or simply start fresh. A clean context usually beats whatever history I'd be clinging to.

Where the harness allows it, let the agent farm self-contained subtasks out to subagents. The subagent burns its tokens in a sandbox and hands back only the answer.

The machinery this paragraph leans on (subagents, /compact, context management) is treated in full here:

Reach for the tooling, with eyes open

A small, fast-moving set of tools now cuts consumption without changing how you work. The order I'd add them in: measure first with ccusage for a week, then introduce one at a time.

• A model router that sends each turn to the cheapest model that can handle it.
• RTK (Rust Token Killer): a Rust CLI that hooks your shell commands through PreToolUse and compresses the output before it reaches the model. It claims about 89% of CLI noise removed across 2,900-odd real commands; a cargo test run loses over 90%, git status around 80% ^[R7]. You type the same commands and the context just stops filling with scrollback.
• Caveman: a skill that strips the model's filler so it answers in shorthand ("New object ref each render. Inline object prop = re-render. Wrap in useMemo."), for roughly 65% off output tokens ^[R8].

Caveman is the one to handle with care. It shrinks what the model says, not how it thinks, so reasoning tokens are untouched. But a terser model infers more, and more inference means more chances to infer wrong. I use that style for quick lookups and reviews; anything going near production, I pay for full sentences. The project points to a March 2026 paper claiming forced brevity can actually raise accuracy on some benchmarks ^[R8]. Maybe. I'd want to see that hold across more than a handful of tasks before I built a workflow on it.

Keep your hands on the work

This is the habit the leaderboard era trained people out of. You don't have to hand the agent every edit, and you shouldn't. Doing some of the changes yourself keeps you fluent in your own codebase, and it costs nothing.

Same with the plumbing, though I'll happily let a model write the commit message, which is one thing they're reliably good at. And run your own tests. The output is noisy, yes, but reading a failure yourself, tracing it back to the cause and the seam it exposes, gets you a far sharper prompt than "tests are red, fix them." You pick up the codebase on the way. A bit of your attention bought in exchange for a lot of the agent's flailing is almost always a trade worth making.

Why staying close to the work, and what that does to the role, matters now:

Route by difficulty

You don't need a frontier model to rename a variable. Cheap, fast models (Sonnet, Codex, Qwen and friends) carry most of the day. Spend the expensive intelligence in the two places it earns its rate: planning and architecture up front, where one good decomposition spares you a thousand bad downstream turns, and review at the end, where a frontier model is worth every cent hunting the edge cases your cheap builder waved through. Keep one escape hatch open: when a small model is visibly stuck in a loop, hand the whole mess to a big one, take the unblock, and drop back down.

If you live in GitHub Copilot, its "auto" routing does a rough version of this for a discount, and quietly trains Microsoft's router on your choices as it goes. Whether that trade appeals to you is your call.

The point is outcomes

It would be easy to take all of this and stand up the opposite cult: a token-savings leaderboard, a sprint to the smallest bill. That's the same Goodhart trap with the sign flipped. The goal is work that ships and matters; a leaner footprint just buys you more room to get there: longer sessions that stay coherent, bigger problems cleared in one pass, and the standing to ask the only question that was ever the point: did the work land, and did it move something real?

So spend your tokens like they cost money, because they do. Then go ahead and spend them, on the work that earns the invoice.

_{Spend Your Tokens Like They Cost Money · June 2026 · An opinion piece. Token-savings figures are vendor-reported, measured on each tool's own command set. Full source records are in the References section above.}