GitHub Copilot’s token billing switch went live today, June 1, 2026, and if you opened VS Code this morning and noticed your Copilot usage dashboard looks different, that’s why. The old premium-request model—where every interaction counted as a flat unit regardless of how compute-intensive it was—is gone. Everything chat-related is now metered by tokens, billed against a monthly allotment of AI Credits that differs by plan.
I’ve been tracking this change since GitHub announced it in April, and I’ve spent the last few days reading through the official documentation, the GitHub community discussion thread (which hit over 800 replies before June 1), and the developer reactions spilling across Reddit, X, and Hacker News. The short version: if you use Copilot mainly for completions, almost nothing changes for you. If you run agentic coding sessions through Copilot, today’s change can be expensive in ways the sticker price doesn’t warn you about.
Here’s what actually changed and what to do about it.
The Old System vs. the New AI Credits Model
The previous billing model counted “premium requests.” Each chat message, each /fix command, each code review summary was one request—costing roughly $0.04 flat, regardless of whether you asked a one-line question or kicked off a 40-step agent task that processed 200,000 tokens.
That flat model clearly wasn’t sustainable once agentic AI coding became the norm. A single agentic session—where Copilot reads your repo, writes tests, fixes failures, and submits a PR—can process millions of tokens. Charging that the same as “complete this function” made no economic sense.
The new system replaces premium requests with GitHub AI Credits. One AI Credit equals $0.01 USD. Usage is calculated from the actual token counts for each request: input tokens (what you send), output tokens (what the model generates), and cached tokens (context that was already computed). GitHub publishes the per-token rate for each available model, and those rates track directly to what the AI providers charge GitHub at the API level.
GitHub’s official migration documentation notes one important carve-out: code completions and Next Edit suggestions are still unlimited on all paid plans. They do not touch your AI Credits balance. The metering only kicks in for premium features—chat, agent tasks, pull request summaries, and code review.
How Many Credits Does Each Plan Actually Give You
Every Copilot plan now includes a monthly AI Credits allotment equal to its subscription cost in dollars.
| Plan | Price | Monthly AI Credits | Credit Value |
|---|---|---|---|
| Copilot Pro | $10/month | 1,000 credits | $10 of AI compute |
| Copilot Pro+ | $39/month | 3,900 credits | $39 of AI compute |
| Copilot Business | $19/user/month | 1,900 per user | $19 per seat |
| Copilot Enterprise | $39/user/month | 3,900 per user | $39 per seat |
You can enable overage spending to let usage continue past the monthly allotment—billed at the same per-token rates. If you want a hard ceiling, set your overage cap to $0 in GitHub billing settings. Usage stops when your credits run out, no surprise charges.
What this also means: Copilot Pro’s $10/month gives you exactly $10 of AI compute for premium features. That sounds fine until you look at what premium features actually cost per model.
Which Models Drain Credits Fastest
Not all models are priced the same inside Copilot. GitHub now publishes exact per-token rates that mirror the providers’ API pricing.
| Model | Relative Cost | Best For |
|---|---|---|
| Claude Opus 4.7 | ~27x the old flat rate | Deep reasoning, complex multi-file refactors |
| GPT-5.4 | ~6x the old flat rate | General coding, solid across tasks |
| Claude Sonnet 4.6 | Mid-range | Balanced quality and cost |
| GPT-5.5 | Mid-range | Fast responses, good daily coding |
| Gemini 2.5 Pro | Mid-range | Strong on code with large context |
| Gemini 3 Flash | ~0.33x the old flat rate | High-volume, quick questions |
The multipliers above compare against the old $0.04-per-request pricing. Claude Opus 4.7 at 27x means a session that would have cost $0.40 under the old system now costs roughly $10.80—wiping out an entire Pro month in one sitting.
The developers reporting $30–40 per agentic session on X and Reddit aren’t exaggerating. A two-hour agentic coding session on Claude Sonnet 4.6 runs around $1.20 according to data I found in community benchmarks. On Opus 4.7, that same session is substantially more. For Copilot Pro users with 1,000 credits ($10), a handful of Opus sessions ends the month before the second week.
I tested this logic by reviewing the GitHub community thread that reached 800+ replies before launch. One developer estimated their typical Monday morning agentic sprint—five tasks spanning auth, database migrations, and tests—would cost $38 in the new model. Their monthly Copilot Pro+ budget is $39. That’s not a weekly workflow anymore; that’s a one-day event.
Who Gets Hurt Most
The change hits different users very differently.
Light completions users: Almost no impact. If Copilot is your autocomplete layer with occasional one-line chat questions, your usage will comfortably fit inside the credit allotment. You might not notice anything changed at all.
Chat-heavy but not agentic: Moderate impact. Conversational sessions on lighter models like Gemini 3 Flash or GPT-5.5 are relatively inexpensive. Watch your model selection, and you’ll be fine.
Daily agentic coders: This is where it hurts. If you’re using agentic coding features to run autonomous task loops—something GitHub has been actively encouraging—token consumption scales fast. A single complex agentic run on a frontier model can eat $5–15 in credits. That’s half a Pro month or a significant fraction of a Pro+ month.
Annual subscribers: Possibly the worst-off group. One analysis on Medium calculated that annual plan holders face up to a 27x effective cost increase on premium model access compared to what their locked-in subscription implied. GitHub has not offered adjustments for existing annual subscribers.
What I’ve seen in developer forums is real frustration—not so much about the pricing in absolute terms, but about the trust break. GitHub spent the past two years telling developers to use Copilot more aggressively: more chat, more agents, more reviews. Now the same behaviors that GitHub encouraged are the ones that blow through budgets fastest.
How to Keep Your Copilot Bill Under Control
There are five practical steps that actually work.
1. Set your overage cap to $0 immediately. This is the single most important thing. Go to GitHub billing settings, find Copilot, set the spending cap to $0. You’ll hit your limit mid-month instead of facing a surprise bill, which gives you a forcing function to optimize your usage patterns.
2. Match the model to the task. Not every question needs Opus 4.7 or GPT-5.4. For quick “what does this function do” or “write a docstring” requests, Gemini 3 Flash at 0.33x costs is perfectly capable. Save the expensive models for actual hard problems—multi-file refactors, architectural reasoning, debugging subtle async issues.
3. Manage your context window. Every open file in your IDE gets included in the context sent to the model. GitHub’s token efficiency guide is explicit about this: closing irrelevant tabs before a chat session meaningfully reduces the input token count, and therefore the cost.
4. Use content exclusion. GitHub Copilot’s content exclusion settings let you block entire directories from being included in the context payload. Your node_modules, build artifacts, and test fixtures don’t need to travel with every request.
5. Front-load your tasks. Structure prompts to give the model what it needs in one shot rather than a back-and-forth conversation. Each turn in a multi-round conversation re-sends substantial context, multiplying token costs. Scoped, specific prompts on well-structured multi-agent tasks cost less than open-ended brainstorming loops.
GitHub’s own guide, Improving token efficiency in GitHub Agentic Workflows, is worth reading in full. It gets into VS Code workspace configuration and repository-level exclusion rules that can reduce agentic session costs by 30–50% without changing your workflow.
GitHub Copilot vs. Cursor vs. Windsurf at This Price Point
Copilot isn’t the only AI coding tool that’s moved to token billing. Cursor made the switch in June 2025. Windsurf followed in March 2026. All three now operate on some version of flat fee plus metered overflow.
| Tool | Entry Price | What’s Included | Power Tier |
|---|---|---|---|
| GitHub Copilot Pro | $10/month | 1,000 AI credits + unlimited completions | Pro+ at $39/month |
| Cursor Pro | $20/month | Bundled credits, exact amount varies | ~$60/month with heavy usage |
| Windsurf Pro | $20/month | Raised from $15 in May 2026 | Max tier at $200/month |
| Claude Code | — | API-based, pay per token | No flat tier |
Cursor and Windsurf don’t publish granular per-token rates the way Copilot now does—their metering is less transparent, which cuts both ways. You can’t see exactly what you’re spending on a per-model basis, but you also don’t feel every token click by. The honest comparison for agentic power users is Copilot Pro+ ($39) versus Cursor at $60+ effective monthly cost with heavy sessions.
My recommendation: if you primarily live in GitHub’s ecosystem—PRs, code reviews, the VS Code extension, and GitHub Actions—Copilot is still a strong default, and the new pricing isn’t necessarily worse if you’re thoughtful about model selection. If you work in Cursor or VS Code Insiders and want a tool built first around agentic sessions rather than completions-plus-chat, Cursor’s workflow design is better optimized for that use case.
The Claude Opus 4.8 coding record puts the current frontier model quality in context: top-tier models are genuinely better at hard coding tasks, but not every task is hard. Using Opus 4.7 on routine CRUD work is like hiring a principal engineer to rename a variable. Calibrate the model to the problem.
The Broader Pattern Here
GitHub’s billing change is part of an industry shift that’s been obvious since at least mid-2025. Flat-rate subscriptions made sense when AI coding was primarily autocomplete—predictable, cheap to serve, low token counts. Now that coding agents autonomously execute multi-step tasks with long context windows and frontier models, the economics of a flat fee break down entirely.
According to TechCrunch’s coverage of the developer backlash, the frustration isn’t irrational. The problem isn’t that token billing exists—it’s a reasonable model. The problem is that developers built habits and workflows on a pricing promise that GitHub is now retroactively changing, particularly for annual subscribers who budgeted based on the old structure.
What I find significant is the speed of the transition across the industry. Cursor at $20/month, Windsurf at $20/month, Copilot Pro at $10/month—none of these prices fund unlimited frontier model access anymore. A “$20/month AI coding subscription” now means $20 of metered compute, not unlimited usage. That’s a different product.
Conclusion
GitHub Copilot’s token billing switch is a net negative for heavy agentic users and a non-event for developers who use it primarily for completions. The structural change—from flat requests to metered compute—is honest and probably inevitable, but the execution hits loyal annual subscribers hardest. Set your spending cap today, match your model to the task complexity, and watch your context window. Those three habits alone will keep most Pro users well within their monthly allotment.
