Copilot turned the meter on. The $20 tool was always a fiction.

On June 1, GitHub moved every Copilot plan to usage-based billing. The flat monthly fee is gone. Now your plan comes with a pile of "AI credits" — one credit is one cent — and every request burns through them based on how many tokens it uses. When the pile runs out, you either set a budget to buy more or Copilot stops.

The reaction was loud. One developer told Reddit their bill would jump from $29 to nearly $750 a month; another projected $50 climbing to $3,000. The word people kept reaching for was "joke." And the math behind the panic is real: a single agentic coding session routinely eats $30 to $40 in credits, so a Pro user with $10 of included credits can burn the whole month's budget in one morning's work, before lunch.

I get the anger. But I don't think this is greed, and reading it as greed makes you miss the actual lesson. The meter didn't make Copilot expensive. The meter made the price visible.

The flat fee was a subsidy with an expiry date

Here's the thing nobody wants to hear. When Copilot was twenty or thirty dollars a month "all you can eat," that price was never the cost of the compute. It was a land-grab price — set low to win the market while investor money covered the gap. It worked because, a year ago, you were mostly using autocomplete: small, cheap requests.

Then the product changed under you. GitHub's own explanation is that Copilot "is not the same product it was a year ago" and now "powers far more complex, agentic workflows that consume far more compute." That part is true. An agent that reads your repo, plans, edits ten files, runs tests, and tries again is doing hundreds of times the work of an autocomplete. The flat fee couldn't survive that, and it didn't. Tellingly, GitHub kept plain code completion free and unlimited — it's the cheap part. The meter is only on the agentic part, because that's the part that costs real money.

So the bill didn't appear in June. It was always there. June is just the month you were handed it.

This is the whole token-economics argument, live

I've been saying for a while that the token bill always comes due and that a flat fee on top of a metered cost isn't a stable business. Copilot just became the largest, most public demonstration of both. If even Microsoft — which owns the platform, the IDE, and increasingly the models — can't keep eating the agentic compute bill, that should end the fantasy that you can run AI features on a fixed price while pretending the meter underneath doesn't exist.

It runs whether you look at it or not. The only question is who's absorbing it this quarter, and for how long.

What this means if you're building

If you ship a product with AI inside it, the Copilot story is your story a year early. Some hard rules fall out of it:

• Cost is a design decision, not a line item you discover. Before you wire an agent to a task, ask what one run costs and multiply by your real usage. If you can't answer that, you don't have a feature — you have an open tab at a bar.
• Don't send a frontier model to do a cheap model's job. Most steps in a workflow don't need the most expensive brain in the room. Routing the easy work to a cheap model and saving the expensive one for the hard parts is the difference between a viable margin and a $3,000 surprise.
• Make the meter visible to your users on purpose. The thing that enraged people wasn't only the price; it was the shock. A budget you can see and a cost you understand feels fair. A counter that empties without warning feels like a trap, even when the number is identical.
• Stay swappable. A big chunk of the angry crowd said they'd route around Copilot to cheaper providers. They can do that because the model is a commodity behind an API. Your own product should have the same escape hatch — one seam, any provider.

The uncomfortable mirror

There's a harsh comment floating around the threads: that the people running up huge bills are "vibe-coders with little actual development knowledge" firing off expensive agent runs without thinking. It's mean, but there's a splinter of truth in it for builders. When compute felt free, nobody had to think about what a request cost. Now everybody does — and the people who designed their systems as if tokens were free are the ones getting the scary invoice.

That's the real shift Copilot just forced into the open. The era of treating AI compute as a rounding error is over. It was always going to end; the only surprise was the date on the envelope. Build like the meter is running, because it is — and it always was.