Flat-rate AI trained us to be wasteful. When “just let the agent run” felt free, we stopped asking whether it was worth running at all.
On June 1, GitHub announced that Copilot is moving off flat-subscription billing to usage-based pricing, metered in a virtual currency they call GitHub AI Credits and billed against the tokens each session burns. The reason they gave is the honest one, and worth quoting: “a quick chat question and a multi-hour autonomous coding session can cost the user the same amount,” and the flat premium-request model that let that happen “is no longer sustainable.” That’s the 2026 story in one line. We moved from a single autocomplete or a chat turn to long-running agent loops that chew through tokens for twenty minutes at a stretch, and somebody finally put a meter on the pipe.
The reflex is to read this as a tax. A thing that was free is now billed, and billed things feel worse than free ones. I think that reflex is exactly backwards. The meter isn’t taking something away. It’s handing back a signal we quietly lost, and the signal is worth more than the penny it costs to see.
We had this argument before, about typing#
A couple weeks ago I wrote that faster to build isn’t cheaper to own. The core of it: writing code used to be slow, and that slowness functioned as a tax on bad ideas. If a feature was going to cost you three days of typing, you thought hard about whether it deserved three days. The friction was doing real work. It killed marginal features before they were born. AI collapsed the build cost to an afternoon and removed the tax, so now you build the good features and all the marginal ones you’d have talked yourself out of.
Metering is that tax coming back. Same job, new units. It used to be priced per hour of your typing, and for a while it was priced at nothing. Now it’s priced per token, in pennies, on a dashboard you can actually read. The mechanism that made you ask “is this worth it?” went missing when build cost hit zero, and a meter is one honest way to put it back.
That’s why I don’t think the billing change is a downgrade. Cost was always an engineering constraint. Latency was legible, memory was legible, and we designed around both without complaint. Compute cost was legible too, right up until a subscription flattened it into a number you paid once a month and never thought about again. Flat-rate didn’t remove the cost. It just hid it, and hidden costs are the ones you overspend.
The math is small enough to do in your head#
Here’s the part that makes the meter useful instead of stressful: the numbers are tiny and you can reason about them.
Credits meter against the tokens a session burns, at each model’s published API rate, so the unit itself isn’t the thing to track. The dollar figure it rolls up to is. A meaningful refactor loop, the kind where you point an agent at a module and let it grind through the edits and the test runs, runs you a dollar, maybe two on a bad day. That’s the whole spend. One agent run, a buck.
Now put it next to what an hour of your time costs, which is a number in the tens of dollars at absolute minimum and usually a large multiple of that. The comparison isn’t close. If a two-dollar agent run saves you forty-five minutes of manual editing, refusing to spend the two dollars is one of the worst trades you can make. You’d be optimizing the cheapest input in the entire system.
So the meter cuts both ways, and here’s where I have to be honest about the failure mode.
The meter can make you timid, and timid is expensive#
The obvious risk of visible cost is that people will spend less. The subtler risk is that they’ll spend less on the wrong things. A meter in front of you every time you invoke the agent is a small, steady nudge toward frugality, and frugality pointed at a two-dollar line item while your own hour costs fifty is penny-wise and dollar-dumb in the most literal sense. You’ll watch someone skip the agent run that would’ve saved an afternoon because the run “costs money” and the afternoon, apparently, doesn’t.
That’s the trap, and it’s the same trap the free tier had, just wearing the opposite coat. Flat-rate made you overspend on marginal work because nothing looked like it cost anything. Metered billing can make you underspend on high-value work because everything does. Neither number was ever the point.
The point is the judgment call between them. The skill was never “spend less.” It’s “know which spend is worth it,” and that’s the exact muscle the own-it-forever post was about, now with a price tag that makes the decision legible instead of invisible. A dollar to let an agent chase a bug that’s been eating your afternoon: obviously yes. A dollar to let it re-run a loop three times because you couldn’t be bothered to write a clear prompt the first time: that’s the spend the meter is supposed to catch, and it’s not the money that stings, it’s the fact that you now have a receipt for your own sloppiness.
What the receipt is actually for#
The value of metered AI isn’t the revenue it protects for GitHub. It’s the feedback loop it hands to you. For two years the cost of a lazy prompt and the cost of a sharp one looked identical from where you sat, which is to say they both looked like zero. The meter separates them. A vague ask that sends the agent wandering for twenty minutes now shows up as a bigger number than a scoped one that lands in three, and seeing those two numbers side by side is how you learn to write the second kind.
I’d go further. The engineers who come out ahead in a metered world are the ones who were already thinking about cost when it was hidden, because good scoping and clear prompts were always cheaper, and now the savings are just visible. The meter doesn’t create the discipline. It reveals who had it.
So no, I’m not mourning the flat rate. It was a nice illusion while it lasted, and illusions about cost are how you end up owning things you never decided to build. The meter starts running, the marginal work gets a price again, and the question you were supposed to be asking all along comes back into focus. Not “can the agent do this,” which is almost always yes. The older, better question: is it worth what it costs to find out.
