A developer on Reddit posted that their Copilot bill jumped from $29 to nearly $750 in their first full month under the new system. Another reported burning through 8% of Pro+‘s monthly credit budget in two hours of agent work. A third posted a screenshot showing a charge trajectory pointing to $3,000 for the month.
These aren’t edge cases. They’re predictable outcomes of a billing model change that GitHub announced months ago but that most developers didn’t fully process until the June 1 switch actually happened.
If you haven’t opened your billing dashboard since June 1, go do it now, then come back.
What Changed on June 1
GitHub replaced “premium requests” — a blunt per-interaction unit — with AI Credits, a token-based billing system. One AI Credit = $0.01 USD. Credits are consumed based on the actual tokens processed: everything you send to the model (code context, chat history, file contents), everything it returns, and cached context that carries across turns in an agent session.
Your subscription fee still buys a monthly allotment of included credits. When that allotment runs out, GitHub charges $0.01 per additional credit against your payment method on file. By default, there’s no automatic shutoff — GitHub sends email alerts at 75%, 90%, and 100% of your included budget, but the meter keeps running unless you manually enable a hard cap.
The per-request cost varies by model. A chat turn handled by GPT-4o costs less than one routed to o3 or Claude Sonnet. You can control which model your IDE defaults to, which matters more than most developers realize.
One important caveat before the panic sets in: code completions and Next Edit suggestions don’t use credits at all. They’re still unlimited on every paid plan. The meter only runs on chat interactions, agent tasks, Copilot CLI, Copilot Spaces, and Spark. If your workflow is 90% inline autocomplete with occasional questions, you may not notice any change.
This is also why a lot of early coverage of the billing change was more alarming than the reality for most developers. The majority of Copilot’s day-to-day value — the thing that completes your function signatures and catches typos in real time — is completely untouched. The credits model is specifically about the LLM-heavy features where compute costs are nontrivial.
Plan-by-Plan Breakdown
Here’s the current credit situation across plans:
| Plan | Monthly Price | Included Credits | Credit Value |
|---|---|---|---|
| Pro | $10/user | 1,500 | $15 |
| Pro+ | $39/user | 7,000 | $70 |
| Business | $19/user | 3,000 (promo)* | $30 |
| Enterprise | $39/user | 7,000 (promo)* | $70 |
| Max | $100/user | 20,000 | $200 |
*The promo allowances for Business (3,000) and Enterprise (7,000) run through September 1, 2026. After that, Business drops to 1,900 and Enterprise to 3,900 per user.
The individual plans (Pro, Pro+) are genuinely good value in credit terms. You get $15 worth of credits on a $10 plan, $70 worth on a $39 plan. The issue isn’t the initial math — it’s how quickly those credits disappear under agentic workloads.
The Max plan at $100/month includes 10,000 base credits plus 10,000 “flex” credits — $200 total. It’s designed for developers running sustained agentic workflows throughout the workday, not occasional heavy users. If you’re not spending hours per day in agent sessions, Pro+ at $39 is almost certainly enough.
How Fast You Actually Burn Through Credits
The uncomfortable part of the new billing model is that token consumption is invisible inside the IDE. Here’s what different usage patterns actually look like in credit terms.
Light user: ~150–400 credits/month. Mostly autocomplete (free), maybe 20–30 chat questions per week asking about specific functions or errors. Single-turn questions with minimal context. Pro’s 1,500 credit budget is way more than enough. You’ll never hit overages.
Heavy chatter: ~600–1,200 credits/month. Multi-turn debugging conversations with code pasted in, “explain this codebase” sessions, asking Copilot to review PRs and explain diffs. The hidden cost driver here is context accumulation — as conversations grow longer, every new turn re-sends the full conversation history as input tokens. A 30-turn debugging session with 500 lines of code attached can cost 80–120 credits on its own. Run a handful of those per week and Pro’s budget gets genuinely tight.
Agent user: 400–600 credits per session. Running Copilot’s agent to scaffold a feature, refactor a module, write tests, and iterate based on test output involves multiple round-trips to the model. Each round-trip includes the current file state plus conversation history. A moderately complex agent task — fixing a non-trivial bug, generating a service with tests — runs 300–500 credits. Two hours of sustained agent work burns roughly 8% of Pro+‘s monthly 7,000 credits, which is what one developer reported. That math works out to about 12–14 focused agent sessions per month before you’re in overage territory on Pro+. For someone whose daily workflow depends on agent mode, that’s probably not enough.
Multi-model switching amplifies everything. If you’ve switched your default chat model to something more capable — o3, Claude Sonnet, or similar — you’re paying a higher per-token rate on every interaction. The credit cost for a complex reasoning task on o3 can easily be 3–5x the same task on the default model. Check your IDE settings and confirm what model you’re actually using before assuming the default.
There’s no public unified table from GitHub showing exact per-model credit rates, which is a real transparency gap. The rates live in the billing documentation and are subject to change. If you want to know what your current usage is costing per model, the billing dashboard breaks it down — but it requires clicking into the usage detail view, not just the summary page.
September 1 Is a Cliff Worth Noting
Business and Enterprise customers need to plan ahead. The promotional allowances (Business at 3,000, Enterprise at 7,000 per user) expire September 1 — at which point per-user budgets drop to 1,900 and 3,900 respectively. That’s a 37% reduction for Business teams and 44% for Enterprise.
GitHub almost certainly set the promo window to let teams build habits around agentic features before pricing normalizes. If your engineering organization adopted Copilot Business in the last few months and has been ramping up agent usage under the promo, the Q4 spend projection deserves a conversation with your manager before September, not after.
A team of 10 on Business currently gets a pooled 30,000 credits per month. After September 1, that becomes 19,000. If the team is routinely running agent sessions, that’s a meaningful constraint.
7 Things to Do Right Now
Set a hard spending limit. Go to Settings → Billing → Spending limits. Enable “Stop usage when budget limit is reached.” Set your overage budget to $0 if you want zero risk, or a modest number if you want a buffer. This is the single most important action — by default, GitHub doesn’t stop when you exceed your included credits.
Audit your default model. In your Copilot settings (both at github.com and in your IDE extension), check which model handles chat by default. Cheaper models like GPT-4o are still very capable for most everyday tasks. Reserve expensive reasoning models for the work that actually needs them rather than running everything through them.
Start fresh sessions deliberately. Because you’re charged on cumulative context length, a 60-turn conversation where you keep appending files costs meaningfully more than 6 focused 10-turn conversations. When a task is done, close the chat and start a new one. Don’t carry 3,000 lines of unrelated context into your next question.
Give agents bounded tasks. An agent asked to “improve this whole module” will explore, iterate, and burn through turns trying to figure out what you actually want. An agent given a specific task — “extract the email validation logic from UserService into a standalone validator with tests” — runs fewer turns, costs less, and produces better output anyway.
Disable passive agent features. Some Copilot configurations keep background agents running to generate proactive suggestions, draft PR summaries, or run code review automatically. These consume credits without you explicitly asking for anything. Check your IDE extension settings and, if you’re on an enterprise plan, your organization’s Copilot policy to understand what’s running passively.
Check usage weekly. The billing dashboard breaks down usage by day. A spike on Tuesday is much better caught by Friday than at month-end. Spend two minutes a week looking at the bar chart in your billing settings — it takes seconds and prevents bill shock.
If you do need overages, set an explicit budget. Rather than leaving it uncapped, set a specific overage budget you’re comfortable with — say $20 or $50. That way you get the flexibility of occasional overages without the risk of a runaway bill.
When the Math Doesn’t Work Anymore
Copilot still makes sense for developers who primarily use autocomplete and do moderate chat. The economics are fine, the ecosystem integration with GitHub is genuine, and the included credit buffer on Pro and Pro+ is reasonable for typical usage.
Where the math breaks down is heavy agentic use by individual developers. If you’re running 2–3 hour agent sessions daily, you’re looking at $100+/month on Pro+ once promos end, possibly more.
Cursor ($20/month Pro) still has flat-fee pricing for most usage patterns and is competitive for agentic workflows. It lacks GitHub’s native PR and issues integration, but if you’re doing standalone coding work rather than cross-repository operations, that gap matters less.
Claude Code bills directly against Anthropic’s API. If you already have Anthropic API access, the per-token costs are transparent and often comparable to Copilot’s credit rate, with no platform markup. Less plug-and-play, but fully auditable.
Raw API calls for specific workflows — automated code review, generation pipelines, batch refactors — can undercut Copilot significantly once you’ve replaced the general-purpose “ask Copilot anything” pattern with purpose-built scripts.
None of these are clean swaps. Copilot’s GitHub integration (code review summaries, auto-generated PR descriptions, issue-linked context) is real value that doesn’t transfer. But if you’re spending $80–150/month on credits alone, it’s worth the comparison.
The bigger question for most developers right now: do you actually know what your Copilot usage costs under the new model? Pull up the dashboard, look at the last two weeks, and figure out your monthly run rate. Then decide whether your current plan is right-sized, or whether you’re paying for an allowance you’ll never use — or heading toward one you’ll blow through by week three.