On June 1, 2026, GitHub quietly changed the economics of Copilot for millions of developers. If you haven’t looked at your billing dashboard yet, now is the time.
The shift: Copilot moved from a fixed-price “unlimited requests” model to usage-based AI Credits billed per token. For most individual developers this won’t mean much. For teams with heavy Copilot Enterprise usage — especially those using Copilot for code review, multi-file edits, and agent workflows — the numbers can change significantly.
Here’s what I learned after spending a few hours understanding the new model and auditing our team’s usage.
The Old Model vs. The New Model
Under the old model (pre-June 2026), you paid a flat monthly fee and got “premium request” allowances. Heavy users burned through premium request units (PRUs) and hit limits; light users barely noticed. GitHub subsidized the gap.
The new model is simpler but exposes more cost:
| Plan | Monthly Price | Included AI Credits |
|---|---|---|
| Copilot Pro | $10/month | $10 in credits |
| Copilot Pro+ | $39/month | $39 in credits |
| Copilot Business | $19/user/month | $19 in credits |
| Copilot Enterprise | $39/user/month | $39 in credits |
AI Credits = $0.01 each. Credit consumption is based on token usage: input tokens, output tokens, and cached tokens at API rates for each model.
The catch: once you exhaust your included credits, you pay for overages — or hit a hard limit if your admin set a budget cap.
What Actually Burns Credits
This is where it gets interesting. Not all Copilot features consume credits equally.
Low credit usage:
- Inline autocomplete suggestions (still powered by the fast, cheap model)
- Basic chat in the sidebar
Moderate credit usage:
- Multi-turn chat conversations with long context
- Explain/fix code on large files
- Test generation for complex functions
High credit usage:
- Copilot Code Review (now billed against GitHub Actions minutes AND credits)
- Agent mode with multi-file edits
- Using Claude Opus or GPT-o3 as the underlying model
The biggest surprise for most teams: Copilot Code Review now costs Actions minutes in addition to credits. If you have it enabled on every PR, that adds up.
Real Numbers From a Mid-Sized Team
My team of 8 engineers on Copilot Business gets $152/month in combined credits (8 × $19). Let me show you what moderate usage actually looks like.
A typical dev doing:
- 200 inline completions/day → ~0.5 credits/day
- 20 chat messages with context → ~2 credits/day
- 5 multi-file edits (agent mode) → ~5 credits/day
- 3 code reviews via Copilot Review → ~3 credits/day
Estimated daily: ~10.5 credits
Monthly (22 work days): ~231 credits = $2.31/user
8 users × $2.31 = $18.48/monthThat’s well within the $152 included. But an engineer going deep with agent mode on a refactoring sprint could easily burn 30–50 credits/day. For a week-long refactor, one dev could use 50% of their monthly credit allocation.
The real risk is agent workflows on large codebases. If you’ve wired up GitHub Actions to run Copilot agents overnight on issue triage, each run against a 100k-token codebase costs significant credits.
How to Monitor and Control Costs
GitHub now provides granular usage data in the organization billing dashboard.
Check per-user consumption:
GitHub → Organization Settings → Billing → Copilot → UsageYou’ll see a breakdown by user, feature, and model used.
Set user-level budgets (new feature): Admins can now set a universal budget per user or override for specific users. This is critical if you have a few power users driving disproportionate usage.
GitHub → Organization Settings → Copilot → Policies → User BudgetsI set our team at $30/user/month (above the included $19 but capped for overages). If someone’s doing a big agent-heavy sprint, they’ll hit the cap and I get a notification rather than a surprise invoice.
Model selection matters: By default, Copilot now routes to the best available model for each task. But you can configure preferred models in VS Code:
// .vscode/settings.json
{
"github.copilot.chat.preferredModel": "gpt-4o-mini",
"github.copilot.advanced": {
"length": 800
}
}Using gpt-4o-mini instead of Claude Opus for routine chat reduces credit consumption by roughly 4-5x for equivalent quality on simple tasks.
My Practical Recommendations
1. Audit current usage before assuming you have a problem. Most teams I’ve spoken to are using less than 60% of their included credits. The concern is warranted for enterprise teams with heavy automation, but individual developers are fine.
2. Turn off automatic Copilot Code Review on all PRs. Enable it selectively — only on PRs above a certain size, or only on main-branch merges. It’s a useful feature but not worth running on every tiny fix.
3. Cache-aware prompting in agent workflows. If you’re using Copilot agents in GitHub Actions, structure your prompts so the static context (system prompt, repo instructions) comes first and changes last. Cached tokens are cheaper, and you’ll see it in your usage data.
4. Prefer fast models for autocomplete, frontier models for reasoning. Route your “explain this code” and “fix this bug” questions to GPT-4o-mini. Reserve Claude Opus or o3 for architecture decisions, complex debugging sessions, and high-stakes refactors.
5. Watch the Actions minutes integration. If you use GitHub Actions heavily, Copilot Code Review now counts against your minutes. Factor this into your Actions budget planning.
The Bigger Picture
This billing change is honest. The old PRU model was opaque — developers didn’t know what a “premium request” cost or why they hit limits at seemingly random times. Token-based billing aligned with actual API costs is something I can explain to my finance team.
The uncomfortable truth: GitHub subsidized heavy Copilot usage for years to build the developer habit. Now that the habit is built, the bill reflects reality.
For teams using Copilot as a pure autocomplete tool, the change is invisible. For teams that went deep on agent workflows, code review automation, and multi-model chat — which is exactly where GitHub wanted you to go — the economics just changed.
Plan accordingly. Set budgets. Monitor usage. And use the right model for each job.
The tools are better than ever. Now they also cost what they cost.