The Company's Bargain: Subsidized Today, Metered Tomorrow

In April 2026, GitHub published a blog post announcing that every Copilot plan would move to usage-based billing. The stated reason deserves to be framed: the flat-rate model was, in GitHub’s own words, “no longer sustainable.”

Think about what that sentence admits. The subscription your engineering org standardized on — the one in the budget, the one in the onboarding docs, the one your developers’ workflows calcified around — was priced below what it cost to serve. Not as a mistake. As a strategy. And the strategy had reached its next phase.

This is part three of a series about the three parties in every AI coding session. Part two was about what the developer trades. This one is about what the company signs — and what history says happens after the honeymoon pricing ends.

The subsidy machine

Start with the plumbing, because it explains everything else. Most AI coding tools don’t run their own frontier models. They buy inference from the labs — Anthropic, OpenAI, Google — and resell it to you wrapped in an editor. Which means their margins are the difference between your subscription and their model bill.

For most of the boom, that difference was negative. One venture analysis estimated Cursor was paying around $650 million a year to Anthropic against roughly $500 million in revenue — a gross margin around minus 30% before a single salary — memorably describing the growth pattern as “scaling yourself into hell.” As one widely-cited analysis of Cursor’s finances put it, the company was spending every subscription dollar on its model provider.

Selling dollars for eighty cents produces spectacular growth — Cursor’s revenue doubled roughly every two months through 2025 — and investors funded the gap on purpose. Below-cost tokens are customer acquisition, exactly the way below-cost rides built Uber. The plan was never to lose money forever. The plan was to become load-bearing first.

Here’s the twist that proves the pattern runs all the way down: the tool vendors are trapped in their own version of it. Cursor’s answer to its Anthropic bill was to train its own coding model, Composer, launched in late 2025 — and reporting through 2026 suggests margins only crept toward positive as more traffic routed to the in-house model instead of the frontier ones users originally signed up for. Your tool vendor negotiating its dependency on its provider by quietly changing what serves your requests: remember that mechanism, because it means the meter isn’t the only lever. A vendor losing money on your subscription has exactly three moves — raise the price, route you to cheaper inference, or sell itself. You’ll notice the first one. The second is designed to be unnoticeable.

So the honest question for any engineering leader isn’t “is this tool worth $19 per seat?” It’s “what happens to my organization when the price finds its true level?” — and its quieter twin, “how would I even know if the quality already had?”

The ratchet, documented

You don’t have to speculate. It’s already happened, at every major vendor, on a timeline tight enough to print.

June 16, 2025 — Cursor. The Pro plan quietly changed from “500 fast requests plus unlimited slower ones” to “$20 of usage at API rates, then metered overage.” Users found out via surprise charges; the CEO publicly apologized, citing rising model costs, and the company issued refunds.

June 18, 2025 — GitHub. Copilot introduced “premium requests”: a monthly allowance for the good models, then $0.04 per request beyond it.

July 28, 2025 — Anthropic. Announced weekly rate limits for Claude subscriptions, stacked on top of the existing five-hour windows — aimed, the company said, at the under-5% of users running Claude Code around the clock.

March 2026 — Windsurf. Swapped bankable credits for strict daily and weekly quotas — its second pricing overhaul in roughly a year — and users revolted: some estimated the effective price increase at around 4x once credits became expiring quotas.

June 1, 2026 — GitHub again. Every Copilot plan moved to usage-based “AI Credits” — announced that April — with the admission quoted above.

What’s driving it isn’t mysterious, and GitHub spelled it out: “a quick chat question and a multi-hour autonomous coding session can cost the user the same amount” under flat pricing, while agentic use “brings significantly higher compute and inference demands.” The industry sold you autocomplete economics, then shipped you autonomous agents that burn a hundred times the compute — on the same plan. The meter isn’t optional for them anymore. Which is exactly the point: the pricing you budgeted around was an artifact of an earlier, cheaper product, and every vendor now needs it gone.

Five vendors’ worth of events, one shape: flat and generous while adoption is the goal, metered and bounded once the workflows have set. None of it is fraud — costs really did rise, agentic sessions really do burn more compute than chat. But notice that every single adjustment moved in the same direction, and every one arrived after the tool had become the default way a few million developers work. Dependency first. Meter second. That’s not a conspiracy; it’s a sequence — the same one that built empires in databases, clouds, and CRMs.

There’s a second kind of ratchet worth pricing in: your vendor itself can change hands over a weekend. In four days of July 2025, Windsurf went from OpenAI acquisition target to Google talent raid to property of a different startup — three owners’ worth of terms, roadmaps, and data policies for its enterprise customers to re-diligence, through no action of their own. Under its new owner, Windsurf’s free tier now trains on user data with no opt-out. The contract you signed is only as stable as the entity that signed it.

The treadmill

Here’s the part that stings even when the pricing behaves: the productivity gains you’re buying mostly aren’t yours to keep.

Adoption is near-universal — Copilot alone sits in roughly 90% of the Fortune 100 — which means AI-assisted velocity is not an edge; it’s the entry fee. When every firm in your market ships faster, the customer’s expectations rise to match and the surplus gets competed away. Economists have a name for who keeps the durable winnings in a gold rush, and it isn’t the diggers. It’s whoever sells shovels on subscription.

Meanwhile the operational ledger has a quieter line item. DORA’s large-scale research found AI adoption associated with worse delivery stability two years running — even in the 2025 report, where throughput finally turned positive, stability stayed negative. The same research shows the gap between the individual and the organization in one contrast: developers using AI report completing about 21% more tasks and merging nearly twice as many pull requests — while the delivery system around them gets less stable. More code moving faster through the same review capacity, more incidents on the other end. The gains are local and visible; the costs are systemic and deferred, which is the most dangerous accounting shape there is.

It also means the number your dashboard celebrates — PRs merged, cycle time down — is precisely the number the vendor’s pitch deck uses, and neither of you is measuring what it did to change-failure rates two quarters out. If AI adoption were a trading strategy, this would be selling volatility: steady visible income, tail risk accumulating quietly off the books.

So the treadmill has three settings, all bad to ignore: you can’t decline the tools (competitive suicide), you can’t keep the gains (competition passes them through), and you inherit new failure modes while doing it. The only strategic variable left is how much dependency you accumulate per unit of speed — and that one you control completely.

The headcount mirage

Every AI tooling pitch eventually reaches the slide about doing more with fewer engineers. Before anyone in your org acts on it, three data points.

First, the code itself. Veracode tested over a hundred models and found 45% of AI-generated code samples contained security vulnerabilities — with newer, bigger models doing no better than older ones. Second, the maintenance curve: GitClear’s analysis of 211 million changed lines shows copy-paste rising past refactoring for the first time on record, and code increasingly revised within two weeks of landing. AI writes more code; someone senior has to catch more of it. Cut the someones and you’ve automated the writing while un-staffing the judgment.

Third, the pipeline. The hiring pullback is already visible in payroll data — entry-level employment in software down sharply since 2022 — and the juniors you don’t hire this year are the seniors you won’t have in five. The org that replaces its on-ramp with a subscription has made its dependency permanent: no internal pipeline of people who can judge the machine’s output, on tools whose price history you just read.

None of this says the tools don’t pay. It says the pitch inverts the real math: AI plus experienced reviewers is a force multiplier; AI minus them is unreviewed liability generation, on a metered plan, at a vendor’s future price.

And notice whose interests the “fewer engineers” framing actually serves. If AI genuinely replaced engineering judgment, the labs selling it would be the first to shrink their own engineering payrolls — instead they’re hiring aggressively and paying more than ever. What the tools replace is typing. What they multiply is the value of the judgment that reviews the output. A company that reads the pitch correctly buys the tools and keeps the reviewers, then wins on both terms; a company that reads it as a headcount coupon spends two years discovering, incident by incident, what the review layer was for.

What to do now

1. Compute your true exposure. Take one month of your org’s real usage and price it at raw API rates instead of subscription rates. The gap between those numbers is the subsidy you’re enjoying — and the correction you should budget for. GitHub just told you the direction.
2. Get data terms in writing, per tier. Enterprise plans carry no-training carve-outs; personal plans mostly don’t. Audit which accounts your code actually flows through — the intern’s personal Cursor login is not covered by your MSA. Part two has the per-vendor details.
3. Keep workflows portable on purpose. Prompts, agent configs, and CI integrations drift into vendor-specific shapes by default. A quarterly hour spent keeping them harness-agnostic is the cheapest insurance in this article.
4. Run an exit drill, annually. Pick a week, point one team at an alternative stack, and measure what breaks. Not because you’re leaving — because the credible ability to leave is the only negotiating leverage that survives the ratchet.
5. Protect the junior pipeline deliberately. If AI absorbs the tasks juniors learned on, design new on-ramps — supervised review of AI output is a real one. The alternative is renting your future senior judgment from the same vendors renting you the code.
6. Watch stability, not just velocity. If your delivery metrics only track throughput, DORA’s findings say you’re measuring the half of the story that flatters the tools.

The bargain, stated plainly: you’re trading a competitive necessity you can’t refuse for a dependency whose price is set by someone else, after you’re committed. You can’t exit the game — but you can decide how much of your organization’s future sits on the other side of somebody’s pricing meeting. The final part of this series is about the door out: open-weight models on hardware nobody can reprice.