How Are Software Companies Cutting AI Costs Without Slowing Down Development?

In April 2026, Uber’s CTO told reporters that the company had burned through its entire annual AI coding budget in four months. Not because the tools didn’t work — engineers liked them. The problem was that nobody had modeled what would happen when 5,000 developers started running AI agents that read, re-read, and reasoned over large codebases dozens of times a day. Microsoft ran into a similar wall around the same time. These aren’t edge cases. A 2025 survey of 372 enterprises found that only 15% of companies could forecast their AI costs within 10% of what they actually spent. Most missed by 11% to 25%, and nearly a quarter missed by more than half.

At the same time, the pressure to move faster with AI hasn’t gone anywhere. Boards want to see the productivity gains they’ve been promised. So software companies are stuck between two forces pulling in opposite directions — ship faster, spend less — and the ones handling it well aren’t doing anything mysterious. They’re just being deliberate about a few specific decisions. Here’s what that actually looks like in practice.

Why AI Development Costs Get Out of Hand So Quickly

To understand the fix, it helps to understand why the bill grows the way it does. When a developer uses a simple chatbot, they ask one question and get one answer. AI coding agents don’t work that way. An agent reads relevant files, forms a plan, writes some code, checks whether it worked, and loops back if it didn’t — and at every single step, it resends the entire accumulated context as part of the request. The model doesn’t remember the previous step. It has to be told everything again, every time. That’s why a single coding task can push anywhere from 400,000 to 2 million cumulative tokens through the API, even though the actual output might be a few hundred lines of code.

Code itself is also more expensive to process than plain English — roughly 1.5 to 2.5 times more tokens for the same amount of content, because of how code gets broken into tokens. And output tokens (what the model generates) typically cost three to five times more than input tokens (what you send it), because generating text requires far more computation than reading it.

Put those two things together and you get numbers like this: Anthropic’s own enterprise data shows Claude Code costs an average of $13 per developer per active day, or roughly $150 to $250 per developer per month. That sounds manageable until you look at the spread — heavy users of agentic coding tools regularly hit $500 to $2,000 per developer per month. Multiply that across a few thousand engineers, and you understand exactly how Uber’s budget disappeared in sixteen weeks.

The Speed Gains Are Real, But Smaller Than the Hype Suggests

Before diving into cost strategies, it’s worth pausing on something that changes how companies should think about this whole balancing act: AI’s actual effect on development speed is messier than most marketing suggests, and that matters for cost decisions.

METR, a research group that runs controlled studies on AI’s real-world impact, found in mid-2025 that experienced developers were actually 19% slower when using AI tools on their own established codebases — even though those same developers believed, after the fact, that AI had made them 20% faster. By early 2026, METR’s follow-up work suggested the picture had improved to something closer to an 18% speedup, though the researchers themselves noted the data was noisy and the true number could range widely.

A separate 2026 study from developer-intelligence platform DX looked at 121,000 developers and found that while 93% of them were using AI regularly, actual pull-request throughput across their organizations rose only about 10% — nowhere near the 2x or 3x figures often quoted by tool vendors. McKinsey’s research tells a more nuanced version of the same story: AI saves close to 46% of the time on routine, repetitive tasks, but under 10% on genuinely complex work. And a large-scale analysis by Opsera found that while AI cut time-to-pull-request by up to 58%, those same AI-written pull requests then sat in code review 4.6 times longer, and carried security vulnerabilities at nearly triple the rate of human-written code.

None of this means AI isn’t useful — it clearly speeds up the right kind of work. But it explains why companies that just throw AI at everything and hope for the best often end up with a bigger bill and a similar delivery timeline. The gains are concentrated in specific, well-scoped tasks, and the cost strategies that work best are the ones built around that reality rather than around the assumption that AI makes everything faster by default.

Strategy 1: Route Tasks to the Right Model, Not the Biggest One

This is the single most effective lever companies are pulling in 2026, and the logic is simple: not every coding task needs your most powerful, most expensive AI model. Writing a unit test, formatting a function, classifying a bug report, or generating boilerplate code doesn’t require the same reasoning depth as architecting a new system or debugging a subtle race condition.

A “model router” checks how complex a task is and sends it to the cheapest model that can handle it well, saving the expensive frontier models for the work that genuinely needs them. The price difference between tiers is large enough that this alone can reshape a company’s entire AI budget:

Companies that have implemented this kind of tiered routing report cost reductions between 40% and 85%, depending on how much of their workload is routine versus complex. Even a moderate shift — routing 60% to 70% of tasks to a cheaper model instead of a frontier one — tends to cut the input-token bill by roughly two-thirds, without a noticeable drop in output quality, as long as the routing logic is tuned properly and checked regularly against real results.

Strategy 2: Stop Paying for the Same Context Twice

Here’s a detail most engineering teams don’t realize until someone points it out: if your AI coding tool sends the same system instructions, the same file context, or the same project background with every single request, you’re paying full price to process that information again and again, even when nothing in it has changed.

Prompt caching solves this. Major providers now let you cache a chunk of context and reuse it across requests at a steep discount — Anthropic charges roughly 90% less for cached reads, and OpenAI charges about half price. For teams running agentic workflows with long, repeated system prompts, this single setting can meaningfully cut the bill without touching the model or the workflow at all.

The other half of this is context management — being deliberate about what gets sent to the model in the first place. Pasting an entire file when only ten lines matter, keeping stale conversation history alive across many turns, or letting an agent re-read the whole codebase on every step all add up fast. Some coding tools now handle this automatically by trimming and managing context behind the scenes, which is worth checking for when comparing tools, since it can be the difference between a predictable bill and a surprising one.

Strategy 3: Set Budgets and Watch Spend in Real Time — Not After the Invoice

One pattern shows up again and again in the companies that overspent badly: they had no owner for AI costs and no alert system until the bill was already large. A 2026 survey of 700 engineering leaders found that more than half of organizations still have no clear owner for AI spending. That’s the gap causing most of the pain, not the technology itself.

Companies handling this well treat AI spend the way they treat cloud infrastructure spend — with the same discipline, not less. That typically includes a token budget for each team or workflow, automatic alerts when usage jumps well above someone’s normal pattern, and hard shutoff limits on agentic workflows that could otherwise run unattended and rack up charges without anyone noticing. Zapier, for example, flags any employee whose AI usage runs five times higher than their peers, then checks whether that usage is genuinely productive or simply wasteful, rather than assuming either by default.

The goal isn’t to restrict developers from using AI. It’s to catch the runaway cases — a poorly configured agent looping endlessly, or a workflow accidentally sending far more context than it needs — before they turn into a five- or six-figure surprise at the end of the month.

Strategy 4: Match Your Pricing Plan to How Your Team Actually Works

AI coding tools are priced in a few fundamentally different ways, and picking the wrong one for your team’s usage pattern is its own hidden cost. Flat per-seat subscriptions (commonly $20 to $40 per developer per month) are predictable but can throttle heavy users or push them into paying API rates once they hit a usage cap. Pure usage-based billing offers no ceiling and scales with exactly what you use, but it also has no ceiling if something goes wrong. A growing number of providers now offer a hybrid — a modest seat fee plus metered usage on top — which tends to fit most teams best because it keeps light users cheap while still tracking heavy usage transparently.

The practical move here is simple: look at your actual daily usage data for a few weeks before committing to a plan, and revisit that choice every quarter. GitHub Copilot’s move to usage-based “AI Credits” billing in June 2026, and similar shifts from other providers, mean the plan that made sense six months ago may not be the cheapest option anymore.

Strategy 5: Don’t Let Speed Create Costs You’ll Pay for Later

This is the part that’s easy to overlook when the goal is “move faster.” AI-generated code that ships quickly but poorly reviewed doesn’t actually save money — it just moves the cost downstream. Research analyzing over 200 million lines of code found that AI-heavy codebases see roughly four times more code duplication, and the amount of time spent on refactoring dropped from around a quarter of engineering work to under 10%. Separately, AI-generated pull requests have been found to carry security vulnerabilities at close to three times the rate of human-written code.

Companies avoiding this trap treat automated testing, linting, and structured code review as non-negotiable guardrails that run alongside AI-generated code, not as optional extras. Several are also adopting AI-powered code review tools specifically built to catch what a human reviewer might rush past when the volume of AI-generated code is high. The logic is straightforward: a bug caught in review costs a few minutes. The same bug caught in production, after it’s already shipped and possibly caused an incident, costs vastly more — in both time and reputation.

Strategy 6: Measure What the AI Actually Produced, Not Just How Much It Was Used

Given how mixed the productivity data has turned out to be, one of the most important shifts companies are making is simply measuring the right thing. Usage dashboards showing how many prompts were sent or how many seats are active tell you almost nothing about whether AI is actually helping. What matters is output: merged pull requests, defect rates on AI-assisted code, review confidence, and — critically — cost attributed to what actually got shipped, not just tokens consumed.

Some companies now track cost per merged pull request as a core metric, which immediately reveals whether a team’s AI spend is translating into real progress or just generating a lot of activity. This kind of tracking also makes the model-routing and budget decisions above much easier, because you’re no longer guessing — you can see exactly which workflows are worth the spend and which ones need to be reined in.

A Simple Starting Point for Smaller Teams

Not every company has the resources to build a full AI cost-governance program on day one, and that’s fine. The companies that get this right usually started small. A reasonable first step is picking one or two high-volume, repetitive workflows — code review comments or test generation are common choices — and routing just those to a cheaper model while keeping everything else on the current setup. From there, turning on prompt caching wherever the same context repeats is close to a free win, since it requires no change to how developers actually work. Once those two things are in place, adding a basic weekly spend review — even a simple spreadsheet pulling numbers from the provider’s dashboard — catches most runaway costs long before they become a real problem.

The companies that struggled hardest in 2025 and 2026 weren’t the ones that adopted AI too slowly. They were the ones that adopted it without asking, at every step, “is this actually necessary, and are we tracking what it costs?” That single habit — treating AI spend as something to actively manage rather than something to discover later — is really the whole strategy, dressed up in different tools and techniques.