The old GitHub Copilot buying question was easy to phrase: is it worth paying $10 or $39 a month for an AI coding assistant? That question is now too simple. After GitHub's move to usage-based billing, the better question is whether your workflow is predictable enough to put a meter on it.

Developer desk with an AI coding assistant credit meter and budget cap

Copilot is still useful. For many developers it remains the most convenient AI layer inside VS Code, Visual Studio, JetBrains IDEs, the GitHub CLI and pull request workflows. But the product people thought they were buying has changed. The headline subscription price is no longer the whole price. Chat, agentic work, code review, CLI sessions and frontier models can now turn a fixed subscription into a budget-management problem.

So the verdict is not "cancel Copilot" or "keep Copilot". It is more annoying than that. Keep it if you mostly use completions, small edits and GitHub-integrated workflows. Cap it hard if you use agents occasionally. Compare alternatives if you do long autonomous coding sessions. Skip the paid tier if you mainly wanted cheap unlimited AI.

What changed

GitHub announced that all Copilot plans would move to usage-based billing on June 1, 2026. The old premium-request model is being replaced by GitHub AI Credits. Usage is calculated from token consumption, including input, output and cached tokens, using the listed rates for the model selected for the task.

The base subscription prices were not presented as changing: Copilot Pro remains $10 per month, Pro+ remains $39, Business remains $19 per user per month, and Enterprise remains $39 per user per month. But that is only the seat price. Each plan includes a monthly credit allowance, and heavier use can require extra paid usage or hit admin limits.

Two details matter for buyers.

First, code completions and Next Edit suggestions remain included. If you mostly use Copilot as smarter autocomplete, the change may be less dramatic.

Second, the metered parts are exactly the features that made Copilot feel more powerful recently: chat, larger models, agentic workflows, code review and command-line work. GitHub says code review also consumes GitHub Actions minutes in addition to AI Credits. That makes review automation a cost item, not just a convenience feature.

GitHub's reason is understandable. A quick question and a multi-hour autonomous coding session cannot cost the provider the same forever. The old model likely subsidized heavy users. The problem is that many customers built habits while the meter was hidden.

Why developers are angry

The backlash started because real and projected usage numbers looked nothing like a normal subscription.

TechCrunch reported a Reddit user who said their current premium-request usage would go from about $28 to roughly $746 under the new AI Credit model. The RSS version of that Reddit post includes the user's own comparison: "Current PRU billing: $28.12" versus "New AIC usage billing: $746.01." TechCrunch also cited another user screenshot claiming a jump from about $50 to about $3,000. Those are user-reported cases, not official averages, but they explain the mood.

Ars Technica reported that users were seeing large parts of their monthly credit allowance disappear in hours or a day. It also described the new system as one where model choice matters a lot: a cheaper model and a frontier model can price the same task very differently. Ars spot-tested a simple Minesweeper prompt through Claude Haiku 4.5 and saw about 94 credits used. That is not outrageous for a toy task, but it shows how fast larger repository work can scale.

Visual Studio Magazine's author wrote that 1,227 of 1,500 monthly credits were consumed on day one, about 82% of the allowance, and that after a couple of normal days the account was near exhaustion. The Register quoted GitHub Community complaints from users who said they burned a meaningful share of a Pro+ monthly allowance in a short session.

The discussion is not only press outrage. Hacker News threads around the change and early billing shock had hundreds of comments. People argued about whether it is better to cancel and use a pay-as-you-go provider, whether OpenRouter or direct API billing is clearer for overage, whether enterprise procurement will keep teams on Microsoft tooling, and whether the new prices simply reveal what AI coding agents have always cost.

That last point is important. Some users are not angry because Copilot is useless. They are angry because the product became a utility bill after being sold as a subscription.

Who should still buy it

If you mostly use inline completions, Copilot can still be a reasonable buy. The included completions and Next Edit suggestions are the least scary part of the pricing change. If your daily use is suggestions, small refactors, short explanations and occasional chat, the subscription may still beat stitching together several tools.

It is also still attractive if your work lives inside GitHub and VS Code. Integration has value. A tool that works where your pull requests, issues, reviews and editor already live can save friction even if it is not the cheapest raw token provider.

Enterprise teams may also stay for boring reasons that matter: procurement, admin controls, policy management, data governance, auditability and vendor consolidation. A regulated company may prefer a more expensive approved tool over a cheaper tool that creates security review work. That does not make Copilot a bargain, but it can make it the least painful approved option.

Copilot Business or Enterprise can make sense when the organization sets budgets, monitors usage and understands which features are enabled. It is a bad buy if the company hands every developer an agentic assistant with no spending policy and hopes the bill behaves.

Who should be careful

Freelancers and indie developers should be careful. If you pay personally, the risk is not that Copilot costs $10. The risk is that your actual workflow quietly moves into paid metered usage. One agentic refactor on a messy codebase can consume more than a month of casual chat.

Vibe coders should be even more careful. That term gets used lazily, but the cost issue is real: if you ask an agent to explore, rewrite, test, fail, retry and explain its own mistakes, you are buying compute. A long feedback loop can become expensive even when the final patch looks small.

Small teams should not compare only seat prices. A $19 or $39 seat can be cheap, but uncapped agent use across ten developers is a different purchase. The budget question is not "how many seats?" It is "how many autonomous sessions, code reviews, frontier-model chats and repository scans?"

Students and casual learners should probably avoid paying until they know exactly why they need Copilot. Free tiers, local tools, documentation, cheaper chat subscriptions or pay-as-you-go API credits may be enough while learning.

How to avoid bill shock

Set a budget before you test the tool. If Copilot is on an organization account, admins should use spending limits and pooled budget controls. If it is personal, check the billing dashboard early in the month, not after the warning email.

Watch model selection. Do not leave expensive work on Auto mode unless you are comfortable with the model it may choose. A cheap model is often good enough for simple explanations, tests or boilerplate. Save frontier models for tasks where they matter.

Use the tool like an assistant, not a blind contractor. Ask it to inspect specific files. Give it the error message. Run local search, tests and builds yourself when that is cheaper than having the agent rediscover the project. Long context dumps and repeated retries are where costs hide.

Turn off context sources you do not need. Extra MCP servers, large workspace context, irrelevant files and broad repository scans can inflate token usage. More context is not automatically better context.

Separate planning from execution. A cheap model can draft a plan. You can review it. Then a stronger model can handle the hard part with a narrower prompt. That is less convenient than one giant agent session, but it is closer to how people control cloud bills.

Be careful with automated code review. It may save time, but GitHub says Copilot code review consumes AI Credits and GitHub Actions minutes. For a busy repository, that needs a policy.

Alternatives worth comparing

Cursor and Windsurf are the obvious comparisons for IDE-first AI coding. They may fit developers who want an editor built around AI rather than an assistant layered onto GitHub workflows. Pricing and model limits still matter, so do not assume they are immune to the same economics.

Claude Code, Claude Desktop and OpenAI Codex-style tools fit heavier agentic work. They can be more transparent if you buy a plan or API access specifically for that mode. They can also become expensive if you let them run without boundaries.

OpenRouter or direct provider APIs can make spend clearer. The advantage is visibility: you pay for tokens and can cap usage. The downside is setup, key management and weaker integration compared with Copilot in GitHub-native workflows.

Continue, Cline, RooCode, Aider and similar tools are good for people who want more control and are willing to configure models, prompts and repository access. Local models through Ollama or LM Studio can be cheap and private, but they are not a magic replacement for strong cloud models on complex code.

JetBrains AI is worth checking if your team lives in JetBrains IDEs. For many buyers, the best tool is the one that fits the editor, security rules and code review process they already use.

The buying matrix

Keep Copilot Pro if you mostly use autocomplete, short chat and editor convenience, and your usage stays inside the included allowance.

Keep Pro+ or a larger plan only if you have measured your real usage and the model mix makes sense. Do not upgrade because the old plan felt unlimited.

Downgrade if you like Copilot but use expensive agentic features only occasionally. Use Copilot for completions and small jobs, then send heavy work to a separate tool with clearer spend.

Switch if you run long autonomous sessions, prefer frontier models, or want direct control over token costs. Copilot may still be convenient, but convenience is expensive when the meter runs.

Skip paid Copilot if you are learning, coding occasionally, or mainly wanted unlimited AI for a fixed low price. That product is disappearing across the market, not only at GitHub.

What not to do

Do not take one viral screenshot as your exact future bill. Those cases may reflect heavy agentic use, unusual context, expensive models or bugs. Use them as warnings, not forecasts.

Do not trust the headline price alone. A $10 plan with a meter is not the same product as a $10 all-you-can-use subscription.

Do not let a team experiment freely without budgets. AI coding tools are starting to look like cloud services. Cloud services need limits, dashboards and owners.

Do not switch tools only because another product looks cheaper this month. Many AI coding vendors are moving toward the same reality: heavy inference costs money. The winning setup is not the one with the friendliest landing page. It is the one where you can predict and control usage.

Verdict

GitHub Copilot is still worth buying for developers who value tight GitHub integration, use mostly completions and short assistance, and can keep metered features under control.

It is a risky buy for power users who want long-running agents, frontier-model refactors and automated reviews without thinking about cost.

For individuals, the safest path is a one-month test with a hard budget cap. Use your normal workflow for a week, then look at the credits. If the numbers feel boring, keep it. If they feel like a second cloud bill, cancel or downgrade before the habit gets expensive.

For teams, Copilot should now be evaluated like infrastructure. Pick who can use agents, which models are allowed, what budgets apply, and which tasks justify the cost. The tool may still pay for itself. But the buying decision is no longer just "do developers like it?" It is "can we control the meter?