'AI Costs More Than an Employee': The Problem Isn't the Price. It's the Lack of a Plan.

The week was full of headlines: Microsoft is cutting internal access to Claude Code for an entire division (Windows, Microsoft 365, Outlook, Teams, Surface) by the end of June. Uber blew through its full 2026 AI budget in four months. The media verdict: "AI has become more expensive than employees."

On one point, I agree. AI costs ramp fast, and when they're not governed, they explode without turning into gains. That much is factual.

But concluding "it's too expensive"? Not buying it.

The counter-example: Spotify

At the very same moment, Spotify ships code to production roughly 4,500 times per day with Claude in the loop. That's about one deployment every 20 seconds, 24/7, when a "normal" company of that size deploys a handful of times per week. (Figure presented by Niklas Gustavsson, Chief Architect at Spotify, on stage at Anthropic.) The difference isn't the tool: since 2022, Spotify had already built the infrastructure and discipline to industrialise its deployments. AI became a multiplier because there was already something worth multiplying.

The real problem: they gamified usage

Here's what actually happened at the companies that "can't afford it anymore."

Instead of a plan, they ran a competition. A Meta employee built an internal leaderboard called "Claudeonomics" to track who burned the most AI. Amazon pushed its teams to "tokenmaxx", meaning to use as many tokens as possible.

They rewarded volume. Not value.

The outcome was written in advance: large-scale waste, runaway costs, and no real benefit on the other side. This isn't an AI pricing problem. It's a consumption governance problem.

Where the costs really come from

The trap is partly structural, and it catches a lot of organisations off guard.

On a subscription plan (typically Pro/Max, in the $20 to $200/month range depending on tier), usage is essentially free at the margin and the cost is predictable. That's the world most people first met AI in.

On the API, you switch to a usage-based model, billed per token. Two things change:

1. Cost becomes proportional to usage, hence to efficiency. The more your teams adopt the tool, the higher the bill climbs. Uber: $500 to $2,000 per engineer per month.
1. Mistakes are expensive. A poorly designed call (overstuffed context, runaway agent loops, the wrong model) can multiply the bill without producing anything better.

A clear sign the issue is systemic: in November, GitHub suspended new Copilot Pro/Pro+ sign-ups because paying customers' "agentic" usage was exceeding the price of their plan. And Goldman Sachs is forecasting a 24x increase in token consumption by 2030.

Migrating from subscriptions to the API without a plan is like switching from an unlimited phone plan to per-second billing without telling anyone.

The overlooked lever: the right model for the right use case

This is the most underestimated variable. Not all models cost the same, and the gap is massive.

The sticker price doesn't tell the whole story. Two amplifiers really blow up the bill:

• Context size: filling 1M tokens on every call means paying for 1M tokens on every call.
• Extended reasoning / "max effort": thinking tokens are billed as output, where Opus runs at $25/M. This is the line item that runs away fastest. (And Opus 4.7's new tokenizer can generate up to 35% more tokens for the same text.)

Concretely, for one given task (illustrative figures: ~100K input, ~20K output):

Up to 37x spread for the same business outcome. Most tasks (classification, extraction, summarisation, routing) run perfectly well on Haiku. Running Opus at max effort on those tasks is sending a Rolls-Royce to pick up the bread.

And beyond Claude?

The logic doesn't depend on the vendor. Claude, GPT, Gemini, DeepSeek: they all bill per token, with price gaps between vendors at least as wide as the gaps within a single vendor's lineup.

Take a concrete example, the kind a procurement leader will recognise. A mid-sized company wants to audit all its supplier contracts over the past three years: about 3,300 contracts, averaging 20 pages each. At ~750 tokens per page, you land at 50 million input tokens, plus ~5 million output tokens for the synthesis, the deviations and the recommendations. A very realistic workload for a contract review programme.

Here's what the same task costs depending on the model picked (order-of-magnitude figures, 2026 public pricing):

That's roughly a 19x spread between the cheapest and the most expensive option for the same raw task.

The right read is not "go with DeepSeek, it's 95% cheaper." If a cheaper model misses 2% of the material commitments, the legal and commercial risk it creates downstream far outweighs the $350 saved upstream. This is exactly the quality/price trade-off a procurement leader runs every day: the unit price isn't what matters, the total cost at comparable quality is. The right question is never "which model is cheapest?", it's "which model is right-sized for this use case, at what total cost?".

And guess what: this is exactly a procurement discipline

Picking the right model for the right use case isn't an engineering skill. It's a buyer's reflex. You'll find every lever from indirect procurement, one for one:

• Right-sizing the need: you don't buy premium for a standard requirement. Haiku when Haiku is enough.
• Demand management: you govern who consumes what, you don't reward volume.
• Total cost of ownership: you look beyond the sticker price at the hidden cost of failed calls, bloated context, and unnecessary effort.
• Category management: a portfolio of models arbitrated by use case, not a single model forced on everyone.

Ungoverned AI gets expensive for the same reason any spend category drifts when nobody owns it: no one arbitrates, everyone over-specifies, and the bill lands three months later.

Uber and Microsoft don't have an AI problem. They have an indirect procurement problem, applied to a new category of spend.

The question to put on the table at your next leadership meeting: who, in our company, decides which model (and which vendor) runs on which use case, and against what cost criterion? If the answer is "nobody" or "each team on its own," you already know where your next bill is going to land. And you already know which function is built to take back control.

Sources

• Microsoft cuts internal Claude Code access: Windows Central, Windows Forum
• Uber burns 2026 AI budget in four months: AI Magazine, Storyboard18
• Spotify, 4,500 deployments per day with Claude (Niklas Gustavsson, Anthropic): Spotify Engineering, Code w/ Claude, Spotify session, Anthropic customer story
• Meta "Claudeonomics" and Amazon "tokenmaxxing": Fortune, The Pragmatic Engineer
• GitHub suspends Copilot Pro/Pro+ sign-ups: GitHub Blog, The Register, InfoWorld
• Goldman Sachs: 24x token consumption by 2030: Goldman Sachs Insights
• Model public pricing: Anthropic, OpenAI, Google AI Studio, DeepSeek