AI coding tools are delivering real productivity — and in the process, generating real bills. The engineering community is starting to work out that model selection is a cost architecture decision, not a default.
1. Spotify Found That 90% of Their Claude Code Tokens Were Going to Work Claude Didn't Need to Do #
Most of what an AI coding agent does isn't deep reasoning. It's I/O. Reading five files to answer a question about one method. Writing a test that follows the exact same structure as the twenty tests sitting next to it. Updating inline documentation after a meeting. Thousands of tokens gone, nearly zero reasoning — all routed to a frontier model priced for problems that actually require it.
Spotify's engineering team quantified the problem: by switching to two modes — a smaller, cheaper model for routine I/O-heavy tasks and a frontier model for complex reasoning — they cut Claude Code token usage by 90%. Not 20%. Ninety. The dollar numbers behind this are real: a quarter of engineering leaders are already spending $200–$500 per developer per month on tokens. Some are past $2,000. By 2028, AI coding costs are projected to exceed the average developer's salary.
The mechanism is straightforward once you see it. Frontier models are designed to handle hard reasoning problems. They're wildly overqualified for regenerating boilerplate or summarizing a diff. Routing that work to a smaller model — one that handles it just as well at a tenth of the cost — isn't a quality trade-off. It's a quality decision. You're freeing the expensive model for the work it's actually good at.
Why it matters:
For ICs: If your AI tooling budget feels like it's burning fast, look at what you're actually asking the model to do. Most of the token spend is probably on tasks that don't need frontier-level reasoning.
For leaders: Token routing is now an architectural decision, not a billing problem. Your platform team needs to own this the same way they own caching strategy.
For founders: If you're building AI dev tools, cost tiering is a feature — not a sales appendix. The $2,000/dev/month ceiling is a product design constraint you can compete on.
2. GitHub Built a Multi-Model Routing System That Matched Frontier Quality at Lower Cost. It Worked. #
GitHub's internal research team took the routing idea further. Project HydraFusion is a multi-model orchestration system for GitHub Copilot that selectively routes coding workflows across models based on task complexity. In controlled offline evaluations, it matched or exceeded an Opus 5 baseline on coding quality while reducing estimated workflow cost. It's now available as a research preview in Copilot.
The key word is "selective." HydraFusion doesn't route everything to a cheaper model and hope for the best. It classifies the task, matches it to the appropriate model, and reserves frontier-level reasoning for the subset of work where it actually changes the output. The result looks like frontier quality from the outside — because on the hard problems, it is — while running on a significantly cheaper blend.
This represents a meaningful shift in how AI coding infrastructure gets built. The previous assumption was: pick a good model, route everything to it, manage costs by limiting usage. HydraFusion inverts that. It assumes multiple models, each specialized, and treats task routing as the primary engineering problem. That's a more mature architecture — and it's coming from the team that ships the dominant coding assistant.
Why it matters:
For ICs: The coding tool you use tomorrow probably won't tell you which model handled which part of your request. That opacity has cost implications worth understanding.
For leaders: Multi-model orchestration is heading toward becoming standard infrastructure. Evaluate your AI toolchain vendors on routing sophistication, not just raw model quality scores.
For founders: HydraFusion is GitHub competing on infrastructure depth. If you're building in the coding assistant space, you need a routing story — or you're getting outcompeted on cost by default.
3. A Robotics Engineer Let an AI Debug His Code for Thirty Minutes. He Still Had to Do It Himself. #
The routing problem isn't only financial. It's also about matching the right capability to the right task — and right now, the tooling gap between software and hardware engineering is wide.
Clayton Ramsey, an engineer writing code for robots, ran an honest experiment: could an LLM handle the visual debugging loop that normally requires running software and inspecting results on screen? The model has vision capabilities. Debugging requires pattern recognition. The ingredients look right on paper.
In practice, it failed. Not because the model was unintelligent, but because the tools available to the model for interacting with visualization software were inadequate. What Ramsey could verify in five seconds with his own eyes took thirty minutes for the agent to attempt — badly. He eventually abandoned the approach and did the debugging himself, faster and more engaged with the actual problem.
This is the routing problem with different stakes. The issue isn't tokens; Ramsey spent time, not money. The issue is that "AI can theoretically do this" and "AI has the tooling to actually do this" are not the same claim. Visual feedback loops, physical environments, and real-time system behavior sit in a different category from text manipulation — and the infrastructure to close that gap doesn't exist yet. Knowing the difference is the skill.
Why it matters:
For ICs: Know the difference between tasks where AI is genuinely productive and tasks where you're waiting for the model to produce confident-sounding wrong answers. The 30-minute failure mode is real and invisible until it happens to you.
For leaders: Audit where your teams are using AI and where it's actually helping. "We use AI for everything" is not a productivity strategy — it's a way to generate invisible friction at scale.
For founders: The tooling gap for physical and embedded engineering is enormous. Closing it isn't a model problem — it's a tool-infrastructure problem. That's a tractable business.
The Verdict: Real or Hype? #
Token routing as a cost discipline → Real. The 90% reduction is not a best-case projection — it's a shipped result from a team that ran the experiment.
Multi-model orchestration for quality parity → Real but early. HydraFusion works in evaluation; production at scale across diverse codebases is the next test.
AI for visual and physical debugging → Hype. The capability exists in theory; the tooling infrastructure to deploy it does not.