TL;DR
On June 1, 2026, GitHub Copilot moved 4.7 million paid users to token-based billing. Power users are bracing for 10x to 50x jumps on agentic work.
The sticker price barely moved. What changed is that you now pay by the token, for input, output, and cached context, on every single model call.
Most of that spend is self-inflicted. It comes from how we use these tools, not the tools themselves.
Six small changes in habit can shrink the bill without slowing a single developer down.
On June 1, the rules for your GitHub Copilot bill changed. The first invoice under the new system has not landed yet, but you have seen the pricing, maybe peeked at the projections, and done the quick math in your head. Nobody hired more engineers. Nobody plans to ship twice as much. So why does the forecast read like you did both?
Sounds familiar? You’re not alone.
That’s why I’m writing this for Vivek’s GAG (Grounded AI Gazette), to cut through the noise and give you the straight talk on AI, in language that makes sense. Today we’re talking about the thing keeping a lot of engineering leaders up at night: the AI coding bill that's about to look very different, and what your team can do before it arrives.
On June 1, 2026, GitHub flipped Copilot to usage-based billing for every paid plan. Instead of counting “premium requests,” you now spend GitHub AI Credits, where one credit is worth a cent, and credits drain based on the tokens an interaction burns through. That means input tokens, output tokens, and even cached context, all metered against the published API rate of whatever model you picked.
In fact, the prices of the plans themselves barely moved. Pro is still ten dollars. Pro+ is still thirty-nine. Microsoft kept the labels and changed what sits behind them. So you can get a “price increase” that hits like a freight train even though the plan you’re on looks identical to last quarter.
And the people getting hit hardest are not the casual users. They’re your best, most enthusiastic engineers, the ones living inside agent mode all day. Early projections for heavy agentic sessions land somewhere between 10x and 50x the old cost.
That sounds terrifying. However, a huge chunk of that spend is avoidable, and it has nothing to do with Microsoft’s pricing.
Before we proceed further, we need to acknowledge that there are still two ways that are completely free without any limits.
Ghost text suggestions - This is where Copilot predicts what you are going to type next, immediately after your current cursor position.
Next edit suggestions - This is where Copilot suggests your next edit, perhaps in a different part of the file than where your cursor is right now.
Picture this. Every time your developer talks to an AI coding assistant, the tool does not just send their latest message. It sends everything. The whole chat history. The files in context. The list of every tool the assistant is allowed to use. All of it, re-sent, on every turn.
Why? Because the model has no memory.
It’s a next-word predictor with amnesia. To answer your eleventh message, it has to re-read the previous ten, plus all the scaffolding around them. You pay for that re-reading every time.
So the real cost driver is not “how clever was my question.” It’s “how much baggage did I drag along to ask it.” Once you internalize that, the six habits below stop sounding like nitpicks and start looking like money.
I see this constantly:
“Commit this change.”
“Run all the commands mentioned in the README.md”
“Do the setup.”
You typed eight words. Feels cheap, right? It isn’t. To run that command, the assistant loads context, decides on an action, executes it, then reads back the output, often pages of build logs, install log spam, and stack traces, and feeds all of that back into the model so it can decide what’s next. You just paid premium model rates to parse a terminal dump that your shell would have shown you for free.
The fix is not “never let AI touch the terminal.” The fix is intent. Use the AI to run a command only when you actually want it to read the output and act on it, like debugging a failing test. For committing, scaffolding, or setup, your own keyboard is faster and costs nothing.
“Create a Python Flask project.”
“Create a React app.”
Think about what's happening here. The AI generates, token by token, a folder structure, a package file, boilerplate config, and a hello-world route that has existed, unchanged, for years. You're paying a frontier model to retype what npm create vite spits out in two seconds.
Worse, you’ve now spent output tokens and polluted the context with a pile of generated files the model will keep re-reading on every later turn.
Scaffolding tools exist. They’re deterministic, instant, and free. Let npm, vite, or a cookiecutter template lay the foundation. Bring the AI in for the part it’s actually good at: the logic that makes your project different from everyone else’s.
This one is the quiet budget killer, so pay extra attention here.
Every MCP server you connect dumps its full set of tool definitions into the context window, before your developer types a single word. And these are not small. One analysis found GitHub’s official MCP server alone eats roughly 17,600 tokens per request just to describe its tools. Each individual tool runs somewhere between 550 and 1,400 tokens.
Now stack a few of those. One team reported three MCP servers consuming 143,000 of their 200,000 token window. That is 72 percent of the model’s working memory gone, spent describing tools it would mostly never call, leaving almost no room for the actual code.
You are paying for that overhead on every turn. And it gets worse than money: a crowded context makes the model dumber. It picks the wrong tool, it forgets earlier instructions, it loops. So the bloat costs you twice, once on the invoice and once on quality.
The fix is almost embarrassingly simple. Turn on the two or three MCP servers this task needs. Turn the rest off. Treat your tool list like luggage, not like a junk drawer.
A long-running chat feels productive. It is, in fact, a meter that spins faster with every message.
Remember the mental model. On message fifty, the assistant is re-reading messages one through forty-nine to answer you. That entire history is re-sent, re-tokenized, and re-billed, every single turn. The input token count does not grow linearly with effort. It compounds.
So when a task is done, or when the conversation has drifted somewhere new, start a fresh chat. You’ll cut the bill and get sharper answers, because the model is no longer wading through a swamp of stale context to find what matters now.
“Refactor the auth module, add tests, update the docs, and fix that flaky CI job” is one prompt and four problems.
When you hand the AI a giant, vague task, two bad things happen.
It loads enormous context to attempt all of it at once, which is expensive. And with that much ambiguity, it starts guessing, which is where hallucinated APIs and confidently wrong code come from.
Then, you spend more tokens cleaning up the mess.
Small, scoped tasks are the opposite. Less context per request, so a lower bill. Tighter instructions, so fewer hallucinations. And you stay in the driver’s seat, reviewing each step instead of untangling a sprawl. Cheaper and safer is a rare combination. Take it.
Not every task needs the biggest model on the highest reasoning setting. There are two variables at play here:
Model choice
Reasoning effort choice
Renaming a variable does not require Claude Opus thinking hard for thirty seconds. A boilerplate getter does not need a frontier model’s full power. But the premium models charge premium token rates, and “high reasoning” means the model generates a pile of extra thinking tokens you also pay for, even on a job a smaller model would have nailed instantly.
Match the model to the task. Reach for the heavy, expensive, high-reasoning option when you hit something genuinely hard: tricky architecture, a nasty concurrency bug, a design with real tradeoffs. For the routine 80 percent, a lighter model is faster, cheaper, and perfectly capable. Your wallet will feel the difference immediately.
Since completions and ‘Next Edit’ suggestions don't burn credits, reach for inline completion and "next edit" for the routine 80% before opening a chat or agent. The cheapest interaction is the one that costs nothing.
The June 1 change did not break your budget. It just removed the all-you-can-eat buffet that was quietly hiding bad habits. Token billing is brutally honest. It charges you for exactly what you consume, and it turns out we were consuming a lot of nothing.
None of the seven fixes above asks anyone to use AI less. They ask everyone to use it deliberately.
Run commands when you want the output read, not to save a keystroke. Scaffold with scaffolding tools. Carry only the tools you need. Keep chats short. Work in small steps. Pick the right-sized model with a right-sized reasoning budget.
Do that, and the same team, doing the same work, costs a fraction of what those panic-inducing projections suggest. The leaders who win the next year of AI-assisted development will not be the ones who spent the most (Hello, tokenmaxxxers 🤩). They’ll be the ones who learned to spend on purpose 😁
If you're looking at the new pricing and wondering whether AI coding is still worth it, you're exactly who I'm writing for. It is worth it. You just have to stop paying the lazy tax.
If this helped you feel a little more grounded and a little less ambushed by your own tooling, why not subscribe to Vivek’s GAG (Grounded AI Gazette) on Substack?
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.