Uber burned through its entire 2026 AI coding budget in four months. One executive racked up a $1,200 bill in a single two-hour Claude Code session. By spring, 95% of their engineers had adopted AI coding tools, with heavy users hitting $2,000 per month.
Their response? Spending caps at $1,500 per engineer.
But caps are a bandaid. The real problem is architectural.
The Tokenmaxxing Trap
CNBC coined the term "tokenmaxxing" — companies incentivizing developers to use as much AI as possible without worrying about results. Uber even had internal leaderboards ranking engineers by Claude Code usage.
This is the predictable outcome when you give every engineer access to frontier models with no routing logic. Every task — from complex architecture decisions to writing unit tests — gets processed by the most expensive model available.
It's like giving every employee a first-class plane ticket for every trip, including the 30-minute drive to the office.
What Actually Costs Money (And What Doesn't)
After months running ~$10K/month in Claude Code API bills across multiple products, I started tracking which tasks actually benefit from frontier reasoning. The breakdown was surprising:
Tasks that genuinely need frontier models (~15-20%):
- Complex architectural decisions spanning multiple services
- Novel algorithm design with non-obvious edge cases
- Tricky refactors that require understanding implicit dependencies
- Debugging production issues with subtle race conditions
Tasks that run fine on mid-tier models (~60%):
- Standard feature implementation from clear specs
- Code reviews and suggestions
- Refactoring with clear patterns (extract method, rename, reorganize)
- Writing integration tests
Tasks where a fast, cheap model is sufficient (~20%):
- Boilerplate generation
- Unit test scaffolding
- Documentation
- Linting-style fixes and formatting
The ratio was roughly 15/65/20 — meaning 80% of our API spend was going to frontier models for tasks that didn't need them.
Route by Task Type, Not by Preference
The fix isn't picking a cheaper model. It's picking the right model for each step.
Here's the mental model:
Planning/Architecture -> Frontier (Opus, Sol Ultra)
Implementation -> Mid-tier (Sonnet, Sol Standard)
Tests/Docs/Boilerplate -> Fast (Haiku, Luna)
When we implemented this routing — matching the model tier to the coding phase — our monthly bill dropped from ~$10K to ~$3K. Same output quality. Same velocity. 70% cost reduction.
The key insight: the model doesn't know what task it's working on, but the harness does. If your coding agent knows it's generating unit tests, it doesn't need to spin up Opus. If it's planning a complex migration, it absolutely should.
Why Caps Don't Work
Uber's $1,500/month cap addresses the symptom, not the cause. Here's what happens with caps:
Engineers self-ration on the wrong tasks. They'll skip AI assistance on easy tasks (where it's cheapest and most helpful) and save their budget for hard tasks (where the cost is highest).
You lose the 80% productivity gain. Most AI coding value comes from the mundane — scaffolding, boilerplate, test generation. Caps discourage this usage disproportionately.
Caps create political problems. Who gets the higher tier? The senior architect or the junior dev who needs AI more? Every cap becomes a negotiation.
Task-level routing solves all three. Every engineer gets unlimited access. The system just picks the right model for each step.
The Industry Is Figuring This Out
Lindy's CEO recently switched 100% of their traffic from Anthropic to DeepSeek — saving millions. But wholesale model switching is a blunt instrument. You lose quality on the tasks that need it.
The smarter move: route the 80% of tasks that don't need frontier reasoning to cheaper models, and keep frontier for the 20% where it matters.
This is where AI coding tools are heading. The era of "pick one model and use it for everything" is ending. The next generation of tooling will route by task type automatically — no human in the loop deciding "is this a Sol Ultra or Sol Standard task" for every prompt.
Getting Started
If you're running AI coding tools at scale, here's a practical starting point:
- Instrument your usage. Track which task types consume the most tokens.
- Identify your 80%. Most teams find that implementation, tests, and docs account for the bulk of spend.
- Set up tiered routing. Even manual tiers (e.g., different API keys for different task types) cut costs significantly.
- Measure quality, not tokens. The goal isn't fewer tokens — it's the same quality at lower cost.
Uber's $1,200 session wasn't a Claude Code problem. It was a routing problem. And every team running AI coding at scale will hit the same wall — unless the harness gets smarter about matching tasks to models.
I've been building task-level routing tools for AI coding workflows. If this resonates, check my profile for more on the $10K to $3K journey.
Top comments (0)