The projected bills started circulating last week. One developer's Copilot usage was estimated to jump from around $29/month to nearly $750. Someone else posted screenshots showing a rise from roughly $50 to approximately $3,000. "What a joke," one comment said. "Cancelling."
GitHub's switch to usage-based billing goes live June 1 — tomorrow. The old model counted "premium request units": one request for a quick question, one request for a six-hour agentic coding session. The new model charges in GitHub AI Credits based on actual token consumption — input, output, cached. Copilot Pro ($10/month) now gets $10 in monthly credits. Pro+ ($39/month) gets $39. Code completions — the quiet inline suggestions while you type — remain free.
The frustration is real. But before I join the pile-on, I want to sit with it for a minute.
What the Old Model Actually Was
The premium request model had a property almost nobody talked about: it made heavy usage invisible. Whether you asked a focused question or kicked off an agentic refactor across a dozen files, the dashboard showed the same: one request consumed.
GitHub's own explanation is direct: "escalating inference costs from increasingly agentic, resource-intensive usage patterns." Translation: AI coding shifted from "smart autocomplete" to "here, build me a whole module" — and the flat pricing was never really designed for the second use case.
The developers now seeing $750 projected bills weren't wronged — they were subsidized. GitHub was eating the difference between what their usage actually cost and what the flat plan charged. At some point that math stops working, and the thing that changes is the bill.
This is a familiar arc in developer tooling. GitHub Actions gave everyone 2,000 free minutes. Vercel let you deploy freely until the build minutes caught up. "Generous until the usage patterns change" is a real strategy, and the surprise when it ends is real — but the underlying math was always running.
The Numbers That Make This More Interesting
Here's where it stops being just a pricing story.
CodeRabbit's State of AI vs Human Code Generation report analyzed 470 open-source GitHub pull requests — 320 AI-co-authored, 150 human-only. AI code produced 10.83 issues per PR compared to 6.45 for human-written code. That's the 1.7x figure. Security vulnerabilities appeared at up to 2.74x the rate in AI-authored PRs. Logic and correctness errors were 75% more common.
And separately, TechCrunch reported this week that Uber burned through its entire 2026 AI tooling budget in four months with no measurable increase in shipped projects. Amazon's internal token-tracking effort got shut down after employees were generating tokens without productivity gains to show for it.
Put these two pieces together and something interesting falls out. If AI-generated code has more issues per PR, then some of those expensive agentic sessions — the ones burning enough tokens to produce $750 bills — were generating code that then required significant debugging and review time. Under flat pricing, you saw none of that cost on your Copilot dashboard. Under token pricing, the generation half becomes visible. The debugging half is still invisible — it's in your calendar.
The real cost of AI coding has always been: generation + review + debugging + maintenance. The old billing model only metered generation, roughly. The new model meters it more accurately. That's clarifying, even if it's uncomfortable.
My Take
I've done the vibe coding thing. Not as a confession — as an honest description of what I actually do sometimes when I reach for a chat prompt instead of just writing the function. Iterate fast, accept the output, figure out the rough edges later. It works well when I understand the domain well enough to catch the problems quickly. It costs more when I don't.
The pattern I keep noticing in my own work: AI saves the most time when I'm writing something I already know how to write. It costs the most time when I'm using it to figure out something I don't yet understand. In the second case, the generation is fast, the debugging is slow, and I end up spending more total time than if I'd thought through the problem first.
Token pricing doesn't change that. But it does change the visibility of the first half of the equation. If I'm burning credits on an agentic session that ultimately produces code full of edge-case gaps, the new billing will tell me how much compute I spent on the generation. The debugging hours remain off the books.
I'm also noticing what GitHub chose to exempt: code completions stay free. That's the "quiet" mode of Copilot — inline suggestions as you type, fast, targeted, lower stakes. The stuff that gets billed is the "chatty" mode: long prompts, big context, multi-turn conversations. And the chatty mode is exactly what CodeRabbit's data applies to — AI generating whole functions and modules, not just completing lines. That's also the mode where the quality gap is largest.
I don't know if that pricing line was drawn with this in mind. But it maps pretty cleanly onto the distinction between "AI as a sharp tool" and "AI as a first-draft machine."
Maybe that distinction matters. Maybe it doesn't and I'm reading too much into a pricing spreadsheet. I'm genuinely not sure.
The Quiet Part
The developers complaining about $750 projected bills have a real grievance: the expectation was set differently, and the floor moved on them. GitHub encouraged heavy agentic usage. Switching the pricing model after that habit formed is a legitimately frustrating thing to do to your users.
But the math that produced those bills was always running.
Token pricing just moved it from the background to the foreground.
I keep thinking about what changes if you can actually see that number.
Maybe nothing. Maybe you use the tool exactly the same way and just pay more.
Or maybe you get a little more deliberate about when you reach for the prompt and when you just write the thing yourself.
I'm not sure the second outcome is bad.