GitHub Copilot AI Credits: What the June 1 Billing Switch Actually Changed

On June 1, GitHub moved every Copilot plan onto a meter. Where the old subscription counted "premium requests" against a monthly cap, each plan now ships with a monthly allowance of something called GitHub AI Credits, and once you spend through it you either set a budget to keep going or wait for the next cycle. Within a day the reaction arrived. The GitHub community discussion thread filled with complaints, coverage such as gHacks reported developers watching credit balances drain within hours, and"meter shock" became the shorthand. The framing almost everywhere was the same: Copilot had just gotten more expensive.

That is the wrong place to put your attention. The short answer is that the sticker price of the plans did not change; what changed is the shape of the cost. A bill that used to be flat and predictable is now metered, moving with how hard you lean on the tool in a given week, and GitHub shipped that meter before most of its users had any habit of watching one. That shift, from a fixed monthly fee to a usage meter, is the part worth understanding, because the same move is arriving across nearly every AI tool you pay for, and learning to manage it on Copilot is cheaper than learning it everywhere at once.

What actually changed on June 1

The mechanics are less exotic than the new vocabulary makes them sound. Here is how it works. Under the old model your plan handed you a bucket of premium requests, and most ordinary actions either fit inside that bucket or did not count against it. Under the new model GitHub meters what you consume by tokens, the input you send, the output the model generates, and the cached context it reuses, and it prices that consumption per model, with the more capable models costing more per token. Each plan includes a monthly amount of credits to cover that consumption, and the heavier the plan the larger that included amount. When the included amount runs out, GitHub's documentation lays out the options: set an additional spending budget and keep working, billed at the end of the month, or stop until your allowance resets on the next cycle.

One detail in that change does more to settle the panic than anything in the announcement. Code completions, the gray ghost text that finishes your line as you type, along with the next-edit suggestions, are not billed against credits at all and stay unlimited on paid plans. What spends credits is the heavier machinery: Copilot Chat, the command-line interface, the cloud and coding agents that go off and work through a task on their own, and similar high-token features. So a developer whose daily use is mostly autocomplete with the occasional question will see a very different burn rate from one who fires an autonomous agent across a repository several times a day. Among the reported gHacks and community examples, the accounts describing the fastest drain tend to involve that second kind of heavy, agent-driven use, while others report ordinary work eating credits faster than they expected. Either way, how agentic a workflow has become matters more to the bill than the volume of the outrage suggests.

GitHub did pair the meter with controls, which is the part the angriest threads tend to skip. Alongside the billing change the company made user-level budgets generally available for organizations and enterprises; GitHub's changelog describes administrators setting a universal spending limit across users or overriding it for specific groups, with email notifications as a budget is approached. Individual accounts get the equivalent lever: a spending budget you set yourself, so that "usage-based" cannot quietly slide into "unbounded." The meter is real, and so is the ceiling you are allowed to put on it. That makes the budget setting the first thing worth checking, whatever your reaction to the change.

Why the meter, and why now

It helps to read this as something larger than one company's pricing decision. Flat-rate, all-you-can-eat AI was always a temporary arrangement, subsidized while vendors raced for adoption and market share. The cost of running these models does not evaporate when you buy a subscription; it sits underneath every chat turn and every agent run, and it scales with exactly the heavy, multi-step usage that the best coding agents now actively encourage. A single autonomous agent session that reads dozens of files, reasons across them, and rewrites several consumes far more model output than a handful of hand-typed prompts ever did. A plan priced as unlimited for the light pattern cannot stay solvent under the heavy one, and the gap between those two patterns has only widened as agents got more capable.

Someone has to pay for the tokens. For years, it was not quite you.

That is the bind GitHub was in, and the company is not alone in it. The drift toward usage-based pricing is the same pressure now reshaping the entire AI tooling market, the reason enterprise teams have started rationing AI spend and treating tokens as a budget line instead of a flat monthly cost. It is also why the newer, smaller coding models matter commercially and not only technically. Microsoft's pitch for the fast, low-token model it just dropped into the Copilot picker is aimed straight at this meter, on the logic that a model finishing the same job with fewer tokens is a model that costs less to run. Once the unit of billing becomes the token, the whole incentive structure of these tools tilts toward efficiency, and that tilt now shows up on your bill whether or not you ever thought about model choice before.

Who feels this, and who barely will

The reason the reaction split so sharply is that two very different users were handed the same email. Picture a solo developer on an individual plan who uses Copilot the way most people did in 2024: autocomplete running constantly, a few chat questions an hour, the occasional ask to explain an unfamiliar function. For that person the meter is close to a non-event, because the constant part of their usage, completions, is the part that does not count, and the metered part is light. Their monthly experience after June 1 looks much like it did before, and the credit balance is a number they will rarely think about.

Now picture a developer who has fully adopted agentic workflows: handing whole tickets to a cloud agent, letting it crawl a large codebase, running several of those sessions a day, sometimes in parallel. That person is the one watching credits fall, and their bill is where the real economics of heavy AI use finally surface. A small team lead sits somewhere in between, and has the more interesting problem, because the team's total burn is now a function of habits the lead cannot see at a glance, which is precisely why GitHub put the administrator budget controls in the same release. The lesson buried in that spread is that your exposure to this change is set almost entirely by how agentic your workflow has become, rather than by which plan tier you happen to be on. The more you have offloaded to autonomous agents, the more the meter is about you.

What the backlash gets right, and where it misfires

Some of the anger is earned. Moving much of a large developer base from a predictable subscription to a meter is a genuine change in the deal, and doing it with a brand-new currency, credits priced per model and metered by token, adds a layer of opacity a flat fee never had. A developer who only wants to know what this will cost each month now has to reason about which features burn credits, which models are pricier, and how an invisible token count maps onto their own workflow. That is a worse experience in at least one concrete way, and the complaints about no longer being able to predict spend are legitimate rather than merely nostalgic.

A good deal of the reaction, though, misreads what happened. The "credits vanished in hours" reports collected by gHacks and the community thread describe running expensive agentic work continuously and watching a meter for the first time, rather than proof that ordinary use has become unaffordable. The developer keeping an autonomous agent looping over a large codebase is now seeing the price of something that used to hide inside an unsustainable flat rate. That cost was always being incurred; what changed is that it became visible. Visibility is uncomfortable, and it is easy to mistake for a price hike. What a meter actually does is put a running number on your heaviest habit, the one the flat rate had been quietly absorbing. The fair summary is that GitHub exposed the real economics of heavy AI use and did a mediocre job of preparing people to manage it, a communication failure stacked on top of a defensible pricing one.

The thing actually worth doing

The rational response is unglamorous. The single setting that matters is a spending budget, which converts an open meter back into a ceiling the user chose rather than one the end-of-month invoice reveals. Beyond that, the only thing worth knowing is the shape of your own usage: completions are unlimited and effectively free, while chat and agent runs are where the credits, and the choice of model, actually land. A developer who internalizes that can verify where the spend goes and shape their habits around the meter instead of being ambushed by it.

This is a less satisfying conclusion than either "Copilot is a ripoff now" or "nothing really changed," and it is the accurate one. Metered pricing was the unavoidable end of subsidized, unlimited AI, and it will not stop at GitHub. The better move is to treat Copilot as the cheap place to build a budgeting reflex, low stakes and the controls already in the box, before every other AI product you depend on starts asking for the same discipline.