On June 1, GitHub flipped Copilot from a flat subscription into a metered utility. Every plan now ships with a fixed bucket of GitHub AI Credits, where one credit equals one cent, and any premium feature you touch beyond code completions draws against that bucket on a per-token basis. The official announcement is on the GitHub blog. The community thread under it is full of developers reporting that their monthly allowance vanished in an afternoon.
This is not really a price hike. The sticker on each plan barely moved. What moved is who pays for what, and how much of the actual usage shows up on the invoice instead of being absorbed by GitHub's margin.
What actually changed
Code completions and Next Edit Suggestions, the original autocomplete features that made Copilot famous, are still unlimited. Everything else now runs against a credit balance.
Per the GitHub plans documentation, every paid tier (Pro, Pro+, Max, Business, Enterprise) ships with a monthly allowance of AI Credits, scaled to the plan. Premium model usage, agentic coding sessions, and multi-step autonomous tasks are billed by tokens consumed: input, output, and cached, priced at each model's listed API rate, then converted into AI Credits.
If you blow through the allowance, you have two options. You can let Copilot pause until the next billing cycle, or you can opt into overage and keep going at one cent per credit. The overage budget is opt-in. The "surprise five-hundred-dollar bill" people are bracing for is something you have to deliberately turn on.
Where the bill actually bites is the agentic mode, which is exactly the part of Copilot GitHub has spent the last year telling everyone is the future. Long-running autonomous sessions that read files, write code, run tests, and try again until something passes can chew through tens of thousands of tokens of frontier-model context in a single task. TechTimes reporting and a gHacks writeup both pull community quotes describing single sessions burning thirty to forty dollars in credits, which is several months of an entry-level Copilot subscription.
Why this is the unbundling moment
Flat-rate pricing was always a cross-subsidy. The developer doing ten quiet autocompletes a day paid the same as the one running multi-step agent sessions for hours. GitHub ate the difference, partly to keep the price simple and partly to keep market share while everyone was figuring out what AI coding even was.
That subsidy is gone. From this point forward, the actual cost of an AI-assisted code change is going to show up on someone's bill. If you bought a custom build, an agency engagement, or a software contract this year, that someone is probably you.
The interesting part is who gets squeezed first. It is not the careful engineer doing focused, scoped work. The careful engineer was already cheap to run. It is the operator who asks an agent to "build me this feature, run the tests, fix whatever breaks" and then wanders off for thirty minutes. Those are the loops that chew through context. Those are the loops the new bill makes visible.
A few weeks ago we wrote that vibe-coding is not the problem; the person holding it is. The same logic applies here. Agentic AI is not the problem. The developer who fires off ten-step autonomous tasks because they cannot decompose the work themselves, however, is now visibly the problem on the invoice.
What this means if you are paying for software
If you are commissioning a custom build, a SaaS feature, or even a maintenance retainer in 2026, the people doing the work are paying for tokens. That cost is either coming out of the developer's margin, which means they have to price for it or eat into their own pay, or it is getting passed through to you. We think it should be in the open. A few practical takeaways:
- Ask your developer how they bill AI usage. Some firms include a flat tooling overhead. Some pass token costs through directly. Both are defensible. Hidden is not.
- Cheap quotes from "AI-first" shops should make you suspicious, not eager. If a shop is materially under-bidding the market and claims they are doing it because "AI does most of the work," ask whether they have actually run the math on AI Credits at their volume. Some of them have not.
- Treat agentic AI like a contractor, not an employee. A contractor who runs the meter for thirty minutes to debug a one-line bug is not a good contractor. The same is true if the contractor is software.
- A senior developer using Copilot deliberately costs less to run than a junior developer using Copilot autonomously. The senior knows when to stop the loop. That cost difference is not theoretical. It shows up in the credit dashboard.
What we do about it on our side
At Pixelworx, our custom software work is done by people who use AI tooling the way a machinist uses a power tool, not the way a teenager uses an air horn. That is not a marketing line. It is the only way the unit economics work now that the meter is running.
Our Experts as a Service bench runs under the same rule. Anyone we put on a project has to be able to defend the design, fix it under pressure, and finish the loop themselves. Engineers who cannot do that without spinning up a forty-thousand-token agent session burn budget that the client did not sign up for.
This is the second time in a few weeks we have had to write about AI tooling shifting underneath everyone's feet. The Microsoft Agent 365 governance story landed at the start of June too, and the right response there was a one-page shadow AI policy, not a panic. This one calls for a similar move: read the docs, set the spend limit, watch the dashboard for a couple of weeks, and decide what you are actually paying for.
If you want help thinking through what to automate with AI without setting fire to your tooling budget, that is a conversation worth having before the first overage notification arrives.
