Blog / · 5 min read
AI credits won. The magic flat-rate coding plan is dead.
GitHub Copilot moves to credit-based billing, coding agents keep proving expensive, and developers now need to learn how to manage AI spend.
For two years, we pretended.
Twenty dollars a month, and behind that: autocomplete, chat, agents, review, test generation, sometimes a premium model chewing through an entire codebase. All of it filed under the same mental label: “my AI subscription”.
June 2026 makes the fiction harder to maintain. GitHub Copilot is moving toward AI credits. Premium models have multipliers. Copilot reviews consume credits too. Companies can set budgets per user.
This is not a billing detail.
It is the end of an illusion: a coding agent is not a slightly smarter chatbot. It is a compute-burning machine.
Why flat pricing could not last
Classic autocomplete is relatively cheap. Short request, short response, little context. The model finishes a line, suggests a function, done.
A coding agent does something else:
- reads the repository;
- explores files;
- runs commands;
- gets things wrong;
- rereads;
- fixes;
- regenerates;
- writes a summary;
- sometimes opens a PR.
One user request can trigger twenty internal operations. And the better the agent gets, the longer the tasks people give it.
The product sells an intention: “fix this bug”.
The infrastructure pays for a loop: read, reason, act, verify, repeat.
Those two things do not fit neatly inside a flat subscription.
GitHub is making visible what already existed
Copilot moving to AI credits can annoy people. I get it. Nobody likes opening a tool they thought was unlimited and discovering a meter.
But the move has one useful property: it forces teams to look at the real cost of the workflow.
Copilot Pro and Pro+ keep a monthly credit envelope aligned with the plan price. Premium usage draws from it. Admins can read reports. Enterprises can set budgets by cost center and user.
In other words: AI coding is entering normal enterprise software territory.
Not very sexy. Very real.
CIOs do not only want to know whether an agent codes well. They want to know:
- how much it costs when a team uses it seriously;
- who consumes too much;
- which models are allowed;
- how to avoid a strange Friday afternoon invoice;
- how to explain ROI without waving a tweet around.
Welcome to the adult phase.
The new skill: spending well
Developers now need to learn a skill we barely had before: economically routing work.
Before, the question was: “which model answers best?”
Now the useful question is closer to:
what is the cheapest task setup that gives a reviewable result without increasing risk?
That is not always the strongest model.
For a trivial test, a mid-tier model is enough. For four-year-old architectural debt, pay for the expensive model. For renaming 80 imports, use a script. For reviewing a sensitive PR, maybe use two models: one proposes, one criticizes.
The developer who sends everything to the premium model “because it works better” becomes the colleague who keeps a Kubernetes cluster alive to serve a landing page.
Not evil. Just expensive.
Agents make cost less predictable
The painful part is variance.
A simple-looking request can explode:
- the repository is large;
- tests fail;
- the agent starts reading docs;
- it makes three attempts;
- it launches an automatic review afterward;
- a subagent activates in the background.
The old mental model “one question = one answer” is broken.
We need better budget tooling: cost estimates, hard stops, internal-call summaries, cost per task, cost per PR, cost per agent. Not a marketing dashboard. A real operations ledger.
If an agent burns 8 euros fixing a typo, I want to know why.
What I would change in my workflow
First rule: no long-running agent without an explicit budget. A two-hour migration needs a cap. When it reaches it, the agent stops and explains where it is.
Second rule: mechanical tasks go to deterministic code first. sed, codemods, AST scripts, SQL migrations. AI can write the tool, but it does not always need to execute the transformation freestyle.
Third rule: premium models need a reason. Not bureaucracy. Just a short note in the prompt or ticket: “high risk”, “large context”, “architecture”, “security”, “uncertain debugging”.
Fourth rule: measure outcome, not request count. If an agent consumes a lot but ships a clean PR on a blocking bug, fine. If it consumes little but leaves a confusing diff that takes two hours to review, it was not cheap.
The point
AI credits are frustrating because they break the feeling of abundance. But that abundance was artificial.
The real problem is not that AI becomes usage-priced. It always was somewhere in the stack.
The problem is that our interfaces are still not honest enough about what they trigger.
When I click “review this PR”, I want to know if I am launching a 20-cent skim or a 6-euro multi-agent audit. Both can be useful. They are not the same product.
2026 is the year coding agents stop being sold as magic.
They become a cost line. Paradoxically, that is a good sign: tools that end up in budgets are the ones people actually use.
Sources
Keep reading