GitHub Copilot just flipped the switch on its new pricing model, and users are not handling it well. If you’ve been anywhere near coding forums or social media this week, you’ve probably seen the complaints piling up. The tl;dr: what used to feel like a reasonably predictable subscription now has people watching their credit balances evaporate in real time.
This shift from request-based billing to a usage-based model went live recently, and as Ars Technica reported, it’s causing some genuine sticker shock across the developer community. The old system gave you a set number of requests per month, regardless of whether you asked a quick question or ran a multi-hour autonomous coding session. GitHub absorb the difference, which apparently got expensive as inference costs climbed. The new approach ditches that cushion entirely.
What Changed
Under the updated system, your Copilot subscription now comes with a monthly bucket of AI credits. One credit equals a penny of usage. The Pro plan runs $10 monthly and gives you 1,500 credits, which sounds like a lot until you realize that’s only $15 worth of AI muscle. Pro+ at $39 gets you 7,000 credits ($70 value), and the $100 Max plan lands you 20,000 credits ($200 worth). Simple enough in theory, but here’s where it gets hairy.
The actual credit consumption depends entirely on what you’re asking the AI to do and which model you pick. A million output tokens on OpenAI’s GPT-5.4 nano will set you back just $1.25 through Copilot. That same million tokens on the flagship GPT-5.5 model? A cool $30. And if you’re using Copilot’s “Auto” mode, which tries to pick the best model for your request, you might be inadvertently routing simple queries to expensive models without even realizing it.
The Numbers Don’t Lie
Users have been sharing some pretty eye-opening statistics. One developer tested Claude Sonnet 4.6 and burned 840 credits on their first day, and they hadn’t even done anything particularly complex. Another user blew through 21 percent of their entire monthly Pro allocation in a single day. A “few prompts” could cost you 700 credits. A couple of Copilot-assisted commits? Try 5,000 credits, gone just like that.
Some reported costs from the community include 15 credits for a simple query, 100 credits for generating a small plan, and 171 credits for a single complex prompt. Even the relatively efficient runs aren’t cheap: Ars Technica’s own test building a Minesweeper game through Claude Haiku 4.5 used about 94 credits, which they noted was a decent rate for a toy project but would add up fast on larger work.
There’s also the context window trap. As one developer pointed out on Bluesky, continuing a multi-day chat session now sends your entire conversation history as input tokens every single time. Those input tokens cost credits too, and they add up quickly.
Not Everyone Is Panicking
To be fair, some users are adjusting. One developer going by Henri Kinnunen reported only burning 161 credits in a productive day by staying “very focused and deliberate” with their AI requests, sticking to GPT 5.3-Codex. The people seem to be managing this best are the ones treating their credits like a finite resource rather than an unlimited buffet.
Others are already jumping ship. Several Copilot users have publicly stated they’re looking for alternatives or canceling their subscriptions. Some are turning to more efficient models or integrated tools like Deepseek, with one Reddit user noting they’ve achieved around 7 cents for 15 million tokens in their VSCode setup.
The Bigger Picture
What we’re likely seeing is the beginning of a broader industry shift. If usage-based pricing becomes the norm across AI coding assistants, the economics start to favor the models and tools that can do more with less. An LLM that delivers quality results while chewing through fewer tokens isn’t just convenient, it’s literally cheaper to run. That efficiency gap could eventually determine which AI tools survive and which ones fade into the “remember when?” pile.
Whether GitHub’s approach wins out or competitors find a way to offer more predictable pricing remains to be seen. But one thing is clear: the era of “don’t think about the cost, just write code” is probably over. The question now is whether developers will adapt to the new economics or look for something that feels less like watching a meter run.
