Copilot enters the pay‑as‑you‑go era — can GitHub’s plan succeed?

GitHub officially announced today: starting from June 1, 2026, all paid Copilot plans will fully switch to usage-based billing. The former "Premium Requests" system is being replaced by a new credit system called GitHub AI Credits, calculated based on actual token consumption, with rates tied to each model’s API pricing.

In plain terms — before, you had a fixed number of advanced model requests per month; once you used them up, that was it. Now, you get a "wallet" filled with credits equivalent to U.S. dollars. Each model call deducts funds from that balance, with varying prices per model—the more tokens consumed, the faster your credits deplete.

This isn’t a minor tweak. It’s a structural rewrite of Copilot’s entire business model.

What Actually Changed

First, the hard numbers:

| Plan | Monthly Fee | Included AI Credits | Change | |------|--------------|--------------------|--------| | Copilot Pro | $10/month | $10 equivalent Credits | Price unchanged, billing logic changed | | Copilot Business | $19/user/month | $19 equivalent Credits | Shared organizational credit pool | | Copilot Enterprise | $39/user/month | $39 equivalent Credits | Shared organizational credit pool |

A few key details:

• Code Completions and Next Edit suggestions do not consume Credits. These are the most frequently used features in daily coding, and GitHub has excluded them from billing—quite reassuring.
• Chat, Agent mode, and Code Review consume Credits. Code Review also consumes GitHub Actions runtime, resulting in dual billing.
• Credits are token-based, including input, output, and cache tokens, with rates directly pegged to model API pricing. That means selecting Claude Sonnet vs. GPT-4o inside Copilot will result in different Credit consumption per request.
• Enterprise customers get a shared organizational pool. Team members who use Copilot less leave room for heavy users. This smart design eases enterprise concerns about unpredictable per-user costs.

Why the Change: GitHub Can’t Keep Absorbing Inference Costs

The official reason: “escalating inference cost.” Inference costs are skyrocketing, and GitHub can’t keep covering them for heavy users.

That’s a blunt, but honest, statement.

Looking back at the timeline, it’s clear why. Copilot initially relied mainly on Codex/GPT series models—limited choices, manageable inference costs. Over the past year, GitHub integrated Claude Opus, Claude Sonnet, Gemini, and more, plus introduced Agent mode—all of which consume far more tokens and cost much more per request.

Typical scenario: you discuss a complex architecture using Claude Opus in Copilot Chat—one conversation might use tens of thousands of tokens. With a dozen such chats a day, your inference cost could easily exceed your monthly subscription. GitHub used to limit “request count,” but the cost per request varies wildly by model and scenario. Fixed request limits meant low-frequency users were effectively subsidizing heavy users.

This was tolerable when user scale was small, but Copilot now has millions of paying users. Even if only 10% are heavy users, their inference costs collectively are astronomical.

So GitHub’s decision is straightforward: whoever uses more, pays more.

Exactly like cloud computing. AWS moved from monthly/yearly packages to per-second billing. AI tools are simply following suit—it was only a matter of time.

Transition Plan: GitHub Offers Cushion, But Lays Traps Too

GitHub knows this change will jolt users, so it prepared a detailed transition plan:

Promotional Credits: Business users get an extra $30 Credits each month in June, July, and August; Enterprise gets $70/month extra. That means Business users effectively have $49/user/month in credits and Enterprise $109/user/month during the transition—more than double their usual value. GitHub is buying time with real money.

Annual Subscription Handling: Existing annual Pro or Pro+ subscribers keep their original request-based system until expiration. But—starting June 1, “model multipliers will significantly increase.” Translation: although requests are still counted, each one consumes more “units,” so your usable volume shrinks. When the annual plan ends, accounts revert to Free; continuing use requires switching to monthly billing.

Budget Control Tools: Admins can set budget caps by organization, cost center, or user and decide whether overages are allowed. This is essential for enterprise IT—usage-based billing without budget control is a ticking time bomb.

Billing Preview in Early May: GitHub will offer a preview so users and admins can estimate costs before the June rollout—a critical step for reducing panic when the switch happens.

Developer Community Reactions: Deeply Divided

The announcement triggered two camps.

Optimists say this is fair market pricing: light users won’t be subsidizing heavy ones. If you mainly rely on completions and occasional Chat, the included $10 in Credits is plenty—you might not use it all.

Pessimists raise valid concerns:

1. Unpredictable cost. With request limits, you knew how many calls you had left; token-based billing means one complex chat could drain a huge chunk of your credits.
2. “Conserve to save” mindset. Constantly worrying about “how much this interaction costs” ruins the experience. AI assistants are meant to make coding fluid—usage-based billing contradicts that.
3. Model choice becomes a cost decision. Previously, choosing Claude Opus vs. GPT-4o was about capability; now it’s about price. Developers might pick cheaper but worse models, degrading overall experience.

Both sides have a point. Usage-based pricing is fairer but will definitely alter habits.

The Bigger Picture: Pricing Dilemma for AI Coding Tools

Zooming out, GitHub’s problem isn’t unique—it’s industry-wide among AI coding tools.

Cursor, Windsurf, Cline, Augment—most are heavily subsidizing inference costs, offering cheap or free access to win users. But as scale grows and models evolve (larger context windows, complex Agent workflows), costs will keep soaring.

No company can sustain unlimited inference under fixed monthly fees forever.

Cursor recently faced backlash for tightening usage limits. Windsurf’s pricing post-acquisition by OpenAI is uncertain. The whole industry is searching for balance—cover costs without scaring users away.

GitHub’s approach: basic features included in subscription, advanced ones billed by usage. This layered model makes sense—completions are essential, so free inclusion preserves the base experience; Chat and Agent are premium, so charging aligns cost with value.

But there’s a risk: if Agent mode becomes the dominant way developers interact (many believe it will), then usage-based billing effectively raises prices for future core functionality. What feels affordable now may become insufficient once Agent workflows become routine—$10 Credits might not last a day.

Enterprise Impact: Double-Edged Sword

For enterprises, this change cuts both ways.

Upsides:

• Shared organizational credit pool is smart. In a 50-person team, maybe 10 are heavy Copilot users while others use it sporadically—pooling avoids wasting per-user purchases.
• Budget control tools give IT managers tangible levers—department- or user-level caps, auto-stop on overages preventing surprise bills.
• Generous promotional credits offer a cushion—three months to assess real cost impact.

Downsides:

• Cost forecasting is harder. It used to be “headcount × rate,” now requires estimating token usage per person. Without historical data, it’s guesswork.
• Dual billing for code review (Credits + Action runtime) could make enterprises reconsider usage.
• A few “AI power users” might drain the shared pool fast, blocking others.

A Subtle but Telling Signal

One small, but revealing, detail:

GitHub said it recently made “temporary adjustments to improve reliability and performance” for Copilot Individual plans (Free, Pro, Pro+, Student) and will relax those limits after usage-based billing goes live.

Translation: GitHub tightened free and low-tier usage just before announcing the billing shift. Not a coincidence—it’s conditioning users: feel the limits first, then pay to unlock freedom.

It’s a common SaaS move—but for developer tools, it feels a bit manipulative. Especially since GitHub was just exposed for defaulting to use Copilot user data for AI training (as of April 24). Now, a major billing overhaul too—community trust is quickly eroding.

Final Thoughts

Is usage-based billing the right direction? Probably yes. Cloud computing took this path; AI tools inevitably will too. Fixed-fee unlimited-use models just can’t survive mounting inference costs.

But GitHub must answer: when developers start calculating the cost of every AI interaction, can Copilot still feel seamless?

The ultimate value of an AI coding assistant is flow—helping developers code without friction. If they’re watching a “balance” instead of staying in the zone, that value erodes.

June 1 marks the switch. The May billing preview will be key—the moment developers see how their habits translate into real dollars. That reaction will be the true barometer.

For developers using multiple AI models daily, monitoring inference cost and maintaining flexibility in model choice is increasingly important. Platforms like OpenAI Hub, which allow you to use a single key to access multiple providers, are becoming handy for transparent cost comparisons in an era of usage-based pricing.

---

References

• Microsoft GitHub Copilot switches to usage-based billing on June 1, introducing AI Credits with unchanged base subscription prices — IT Home — Detailed coverage of pricing changes and transition plan from IT Home