GitHub Copilot: Severe Decline in Value — The New Pricing Model Is Practically Unusable (With Evidence)

[Sajjadarasham]

🏷️ Discussion Type

Product Feedback

💬 Feature/Topic Area

Copilot Agent Mode

Body

Copilot's New Usage-Based Billing Is Unpredictable, Non-Transparent, and Unsustainable

Over the past few weeks, since GitHub introduced the new usage-based billing model for Copilot, the experience for many users—including myself—has deteriorated significantly.

This issue is a direct, evidence-based analysis of the current situation.

Objective

The purpose of this issue is to demonstrate that the current pricing model is:

• Unpredictable
• Difficult to understand
• Lacking sufficient billing transparency
• Economically unsustainable for everyday development

If these problems are not addressed, many long-time Copilot users will inevitably migrate to alternative tools despite preferring GitHub's ecosystem.

---

1. Evidence from Real User Reports

The following examples are taken from public GitHub Discussions (including Discussion #197089) and reflect actual user experiences:

• A single simple prompt resulted in a charge of $4.51 USD
• Two ordinary requests consumed 550 credits
• A small VS Code coding session consumed 210 credits
• Fixing a minor UI bug cost approximately $1.50 USD
• One Copilot Pro+ subscriber reported using only 10 prompts before exhausting available credits
• Users reported selecting GPT Mini, while billing reflected Gemini Flash
• Another user reported being charged multiple upgrades within one billing cycle ($10, $20, and $49)

These are not isolated or anecdotal complaints.

They are publicly documented reports within GitHub's own community.

---

2. Copilot's Features vs. Practical Usability

Copilot continues to provide valuable capabilities, including:

• Code completion
• Code generation
• Bug fixing
• Test generation
• Code explanation
• Agentic capabilities (higher tiers)

However, under the current pricing model, these features have become increasingly difficult to use confidently because:

• Credit consumption is unpredictable
• Even simple requests may consume unexpectedly large amounts
• Included credit limits are relatively low
• Users are frequently pushed toward paid upgrades
• The billed model does not always appear to match the selected model
• Billing details are insufficiently transparent
• Every development session introduces uncertainty regarding cost

For a tool intended to be integrated into daily software development, this level of uncertainty is difficult to justify.

---

3. Comparison: Copilot vs. Codex

Copilot

Provides:

• Code completion
• Code generation
• Bug fixing
• Test generation
• Code explanation
• Agentic workflows

Current drawbacks:

• Unpredictable pricing
• Sudden credit consumption spikes
• Low included credit limits
• Frequent upgrade prompts
• Model selection/billing inconsistencies
• Limited billing transparency
• High cost uncertainty

Codex

Provides:

• Fast code completion
• Code generation
• Bug fixing
• Test generation
• Code explanation

Advantages:

• Predictable usage
• Lower operating cost
• No unexpected billing spikes
• No forced upgrade pressure
• Simpler and easier-to-understand pricing

Practical Conclusion

For many everyday development tasks, Codex produces results comparable to Copilot.

The primary difference is cost predictability.

While Copilot often delivers similar output quality, it now does so with substantially higher and far less predictable costs.

From a user's perspective, the current pricing does not appear to be justified by a proportional increase in capability or quality.

---

4. Summary

The current Copilot usage-based billing model is:

• Unpredictable
• Difficult to understand
• Insufficiently transparent
• Economically challenging for regular development
• Poorly suited for daily coding workflows

Copilot remains an excellent product from a technical standpoint.

However, the current billing model significantly undermines its practicality.

Many long-time users would prefer to continue using Copilot within the GitHub ecosystem.

But unless meaningful improvements are made to pricing transparency, predictability, and credit consumption, migrating to alternatives such as Codex will become a practical and economic necessity for many users.

This is not intended as a threat.

It is simply the reality many users are already reporting and experiencing.

[github-actions[bot]]

💬 Your Product Feedback Has Been Submitted 🎉

Thank you for taking the time to share your insights with us! Your feedback is invaluable as we build a better GitHub experience for all our users.

Here's what you can expect moving forward ⏩

• Your input will be carefully reviewed and cataloged by members of our product teams. 
  • Due to the high volume of submissions, we may not always be able to provide individual responses.
  • Rest assured, your feedback will help chart our course for product improvements.
• Other users may engage with your post, sharing their own perspectives or experiences. 
• GitHub staff may reach out for further clarification or insight. 
  • We may 'Answer' your discussion if there is a current solution, workaround, or roadmap/changelog post related to the feedback.

Where to look to see what's shipping 👀

• Read the Changelog for real-time updates on the latest GitHub features, enhancements, and calls for feedback.
• Explore our Product Roadmap, which details upcoming major releases and initiatives.

What you can do in the meantime 💻

• Upvote and comment on other user feedback Discussions that resonate with you.
• Add more information at any point! Useful details include: use cases, relevant labels, desired outcomes, and any accompanying screenshots.

As a member of the GitHub community, your participation is essential. While we can't promise that every suggestion will be implemented, we want to emphasize that your feedback is instrumental in guiding our decisions and priorities.

Thank you once again for your contribution to making GitHub even better! We're grateful for your ongoing support and collaboration in shaping the future of our platform. ⭐

[chowdhary19]

I think the biggest issue isn't necessarily that Copilot is now usage-based, it's that it's difficult for users to predict the cost before they click "Send."

I'd love to see a few improvements that would make the new model much easier to trust:

• Estimated cost before execution. Even a rough range (e.g. "< 1 credit", "5–10 credits", "50+ credits") would help users decide whether to use Agent mode or simplify their prompt.
• Per-session cost breakdown. After an agent run, show how many AI Credits were spent, which model was used, and how many input/output tokens contributed to the total.
• Budget controls. Let users set monthly or daily spending caps, soft limits, or require confirmation before a request that exceeds a user-defined threshold.
• Model transparency. If GitHub falls back to or routes a request to a different model, make that explicit and explain why. Otherwise it's difficult to reconcile the bill with what the user selected.
• Usage insights. A dashboard showing which features (Chat, Agent, Code Review, etc.) are consuming the most credits would make it much easier to optimize usage.

I understand why GitHub moved to token based billing agentic workflows can vary enormously in the amount of work they perform, and GitHub has said the goal is to align pricing with actual token consumption rather than counting every interaction equally.

That said, for a tool that's meant to be used continuously throughout the day, predictability is almost as important as price. If developers have to second-guess whether every prompt will unexpectedly consume a large number of credits, they're naturally going to hesitate before using the product. Better visibility into cost would go a long way toward addressing that.

[Sajjadarasham]

I understand your point, and I agree that predictability is important — but even with that in mind, the current pricing behavior simply doesn’t make sense.

In my own environment, Copilot consumed around $40 for roughly 10 prompts. These were not long agentic workflows, not multi‑step repository refactors, not anything extraordinary — just normal development prompts.

And this is exactly where the model breaks down:
No usage‑based system should ever charge $40 for 10 ordinary prompts.

For comparison, agent systems like Codex can perform the same 10 prompts — with similar output quality — at a dramatically lower cost. Codex’s consumption is predictable, stable, and aligned with what a developer would reasonably expect for everyday usage.

So while I agree that visibility and cost estimates would help, the core issue remains:
Copilot’s current consumption pattern is fundamentally out of line with industry norms.
If 10 normal prompts can unpredictably cost $40, developers will naturally hesitate to use the product, regardless of dashboards or cost previews.

Predictability matters — but baseline economic sanity matters even more.

[chowdhary19]

That's a fair correction. If the figure is genuinely around $40 for 10 ordinary prompts, then cost previews alone would not solve the underlying problem.

GitHub's own documentation says that a quick Copilot Chat question using a lightweight model may cost only a fraction of an AI credit, while expensive usage should generally correspond to longer agent sessions, frontier models, large context windows, or work across multiple files. An average of roughly $4 per ordinary prompt appears difficult to reconcile with that description.

I think the most useful next step would be to determine exactly where that cost came from. For those 10 prompts, could you share a sanitized breakdown showing:

• the Copilot feature or mode used;
• the model selected for each request;
• whether automatic model selection was enabled;
• the AI credits charged per interaction;
• whether the agent made repeated tool calls or reopened large repository context;
• whether cached input, code review, Actions minutes, or another feature contributed to the total.

That distinction matters because there are two possible problems here:

1. The system is working as designed, but ordinary-looking prompts trigger unexpectedly expensive background activity.
2. The metering, model routing, or billing attribution is incorrect.

Either outcome would justify product changes.

If it is the first, Copilot needs stricter default session limits and explicit confirmation before an agent crosses a meaningful cost threshold. If it is the second, users need an itemized ledger that makes billing errors identifiable and disputable.

I also agree that comparisons should focus on equivalent workloads—not merely prompt count. Ten prompts can represent very different amounts of computation. But when a user describes them as normal development requests and the resulting cost is comparable to an entire monthly subscription, GitHub should be able to show precisely what consumed the credits.

So I would revise my earlier point:

Predictability is necessary, but it is not sufficient. Pricing must also remain proportionate to the visible work performed.

A dashboard can explain a reasonable charge. It cannot make an unreasonable one acceptable.

[Sajjadarasham]

Thanks for the detailed breakdown request — here’s the clarification:

Automatic model selection was enabled for all of my prompts except two:

one using Fable 5

one using Sonnet 5

Everything else was handled by Copilot’s automatic routing.

And just to be absolutely clear:
the consumption you see in the screenshot is exactly what happened — nothing more, nothing less.
These were ordinary development prompts, not long agent chains, not multi‑file refactors, not anything that should trigger frontier‑level costs.

So while I understand the need to distinguish between “unexpected background activity” and “billing attribution issues,” the numbers here speak for themselves. If automatic model selection is producing charges of this magnitude for normal prompts, then either:

ordinary‑looking prompts are triggering disproportionately expensive internal workflows, or

the metering/model routing is misattributing cost in a way that doesn’t match the visible work performed.

In both cases, the result is the same from a user perspective:
the pricing is not proportionate to the work Copilot visibly performs.

And as shown in the screenshot, the charges are exactly as reported — no hidden agent loops, no extended sessions, no large context windows reopened. Just normal prompts with unexpectedly high cost.

[awdemos]

This is one of the most concrete write-ups of the problem I've seen. $4.51 for a single prompt, 550 credits for two ordinary requests, and 210 credits for a small VS Code session are exactly the kind of numbers that make usage-based AI impossible to budget in a real sprint.

The core issue is that Copilot is now priced like an API product while users expect it to behave like an IDE utility. IDE utilities have flat costs (JetBrains, VS Code Pro, even Cursor's upper tiers). API products have metered costs. Agent Mode blurs that boundary, so a long agent session can turn a $20/mo tool into a $200/mo surprise.

For teams that need cost certainty, the only durable fix is to move the compute you can control onto a fixed-price plan. We built UltraWork (https://vibecodingagency.com/gpu-cloud/) for exactly this: one monthly price for an H100/A100 GPU workspace where you run Claude Code, Codex CLI, OpenCode, etc. The model calls happen on your own GPUs, so there's no per-token or per-credit meter ticking while the agent is working.

It's not a drop-in replacement for Copilot chat, but for agentic work it's the difference between "hope the bill is reasonable" and "the bill is exactly what we agreed to."