GitHub Copilot AI Credits — The Meter Was Always Running

This isn’t a pricing story. It’s a trust story. Microsoft spent three years telling developers to hand more work to Copilot — let it run, let it fix, let it review — while quietly absorbing the inference bill. On June 1, the meter became visible. The habits are already formed. And 4.7 million paid subscribers just discovered that the product they were using to automate their way through code now costs 10x to 50x more to run the same way.

TL;DR

• What: GitHub Copilot switched all paid plans from flat-rate Premium Request Units to token-metered AI Credits on June 1, 2026
• Cost reality: Agentic sessions burn large shares of monthly credit allotments in a single sitting; community reports project 10x–50x cost increases for power users
• Hidden trap: Copilot code review now consumes both AI Credits AND GitHub Actions minutes — two separate billing lines
• Deadline: Promotional credit buffers for Business and Enterprise expire August 31. September 1 is the real billing cliff.

What Happened

On June 1, 2026, GitHub transitioned every paid Copilot subscriber — Pro, Pro+, Business, Enterprise — from flat-rate Premium Request Units to usage-based GitHub AI Credits. One credit equals $0.01. Consumption is calculated on input tokens, output tokens, and cached tokens, multiplied by per-model rate cards. Not per request. Per token.

The subscription prices didn’t change. What changed is what you get for them:

• Pro ($10/mo): $10 base credits + $5 flex allotment = $15 total
• Pro+ ($39/mo): $39 base credits + $31 flex allotment = $70 total
• Business ($19/seat/mo): $19 base credits per seat, no flex
• Enterprise ($39/seat/mo): $39 base credits per seat, no flex

Code completions and Next Edit Suggestions remain unlimited — they cost nothing. Everything else — chat, agentic coding sessions, code review — now eats credits at model-specific token rates.

Here’s the segmentation line that matters: if you only use Copilot for tab-completion, nothing changes. If you’ve been running agentic sessions — multi-file edits, autonomous coding loops, automated PR review — you’re about to find out what those sessions actually cost at inference time.

And there’s a detail that makes this worse: under the old system, exhausting your premium requests triggered a fallback to a cheaper model. Work continued, just slower. That fallback is gone. When credits run out, the metered features stop.

Why This Matters

The raw economics are bad enough. Community reports show single agentic sessions consuming hundreds of credits. Developers in GitHub community discussions describe instances of sessions burning large shares of monthly allotments in just a few hours. TechTimes documented projected cost increases of 10x to 50x for developers who relied on multi-hour autonomous sessions, and those projections are consistent with what the token math predicts when you’re hitting frontier models for complex reasoning tasks.

But the economics aren’t the real problem. The real problem is the double-billing trap hiding inside Copilot’s code review feature.

Copilot code review moved to an agentic architecture running on GitHub Actions. Every PR review now consumes AI Credits for the model inference AND GitHub Actions minutes at standard per-minute rates. These are two separate line items on two separate billing dashboards. If your team automated PR review across dozens of daily pull requests, your CI bill and your Copilot bill just collided — and neither dashboard shows the combined cost.

This is the kind of architectural decision that looks elegant from Microsoft’s side and catastrophic from the engineering manager’s side. You built automated review workflows because Copilot made them easy and the flat rate made them cheap. Now each review triggers a metered inference call plus a metered CI execution, and you’re paying for both without a unified view of the spend.

The comparison to Claude Code and direct API access is unavoidable. Both Anthropic and OpenAI offer per-token pricing through their APIs — no bundled IDE integration, but predictable, transparent costs that you control at the request level. If you’re already managing API keys for other services, the overhead of switching isn’t zero, but the billing model is at least honest about what each call costs. With Copilot’s credits, you’re paying a subscription fee for the privilege of paying token rates multiplied by model-specific coefficients you didn’t negotiate.

The multipliers matter. Frontier models cost an order of magnitude more per token than lightweight models — check GitHub’s model rate card for exact coefficients, because they vary significantly by model and token type. If you’re defaulting to frontier models for every chat interaction — which is what most developers do when the UI doesn’t force a choice — you’re burning credits at rates that would make direct API access look cheap.

Check your model selection in Copilot settings immediately. Reserve frontier models (Claude Opus, GPT-5.x) for complex reasoning tasks. Switch to lighter models for routine chat and code explanations. The credit difference between a frontier model and a lightweight model on the same query can be 10x or more.

For organizations, there’s a temporary buffer. Business plans received an additional $30/user/month in promotional credits on top of their base allocation; Enterprise received $70/user/month. These run through August 31. Business and Enterprise plans also pool credits across the org, meaning unused credits from light users can offset heavy users — if you configure teams accordingly.

But the buffer expires September 1. That’s the real cliff. Organizations that don’t audit their agentic usage patterns between now and September will walk into Q4 with credit overruns they didn’t forecast and budgets that assumed flat-rate pricing.

For teams that built agentic workflows inside Copilot because the economics seemed settled — they aren’t. The AI coding tools landscape now splits cleanly between tools with transparent per-token pricing (Claude Code, Aider with BYOK) and tools with subscription-plus-metering models (Copilot, Cursor). That split didn’t exist six months ago when most teams chose their stack.

The Take

I keep coming back to the trust angle. Microsoft actively encouraged developers to lean harder into agentic workflows — Copilot Edits, agent mode, automated code review — while the flat rate absorbed the cost. Habits formed. Workflows solidified. CI pipelines were rebuilt around automated review. And then the billing model changed underneath all of it.

The September 1 cliff is what I’d be planning for right now if I managed a team on Business or Enterprise. Here’s what I’d do this week:

Set org-level and user-level budget caps in the Copilot billing dashboard. Not next sprint — today. Run a two-week audit of actual credit consumption per developer. Identify which workflows are burning frontier-model credits on tasks that don’t need frontier reasoning. And start benchmarking the cost of those same workflows against direct API access to Anthropic or OpenAI, even if the IDE integration story is worse.

The end of flat-rate AI subscriptions is an industry-wide shift, not a GitHub-specific one. But GitHub was the one that had 4.7 million developers building habits under the old model. That’s what makes this transition sharper than the rest. The meter was always running. Now you can see it.