Key Takeaways
- GitHub gave me a personalised estimate: the same models and token usage I had in April 2026 at $39 USD would cost $1,941.07 from June. That is not a price adjustment - it is a price destruction.
- Microsoft deliberately engineered the dependency: for the better part of a year, GitHub actively encouraged developers to build agent workflows around their most expensive models, with no effective cost signal.
- The "rising costs" narrative does not survive scrutiny: a 50x increase in a single billing cycle from identical usage patterns is not an honest response to infrastructure costs. It is a commercial pivot.
- Credible alternatives exist right now: Claude Code now ships a full VS Code extension alongside its CLI. Roo Code, Cursor, and Google's new Antigravity platform - three forms: CLI, IDE, and desktop app - give developers real working alternatives, and the gap to Copilot is smaller than it was six months ago.
- The developer community needs to send a clear signal: switching away from GitHub Copilot is the only response that registers with a Microsoft product team.
I received an estimate from GitHub recently. It showed me what my April 2026 GitHub Copilot bill - $39 USD - would cost if I replicated the same model usage and token volume in June. The number was $1,941.07. GitHub makes this billing preview tool available to all users preparing for the June 1 transition.
I have worked in corporate environments long enough to know that no finance team, no board, and no reasonable interpretation of "rising infrastructure costs" explains a 49-fold increase in a single billing period from identical usage patterns. This is not a pricing adjustment. This is a bait-and-switch, and GitHub and Microsoft deserve to lose developer accounts over it.
How GitHub Built the Dependency
To understand why this is calculated rather than accidental, you need to look at what happened in the twelve months before the pricing flip.
Throughout 2025, GitHub Copilot's agent mode steadily matured. The integration with VS Code improved significantly. Multi-file editing, autonomous terminal commands, iterative debugging loops - all of it became genuinely useful, genuinely fast. GitHub paired this with access to the most capable models available: Claude Sonnet, Claude Opus, and other premium Anthropic and OpenAI models, all included in the base subscription price with no meaningful cost signal to the developer.
The explicit message from GitHub and Microsoft was: use it. Run long agentic sessions. Build complex workflows. Let it read your entire codebase. That is what the product is designed for. I wrote about how this kind of workflow changed the way I build custom WordPress plugins - agents handling implementation while I direct the architecture and review every line before it ships. I restructured years of tooling, habits, and development processes around these agent capabilities.
The implicit message - now obvious in retrospect - was: build the dependency first, price it properly later. Every workflow rebuilt around Copilot's agent mode, every habit formed around particular model behaviours, every team process that assumed this level of capability at this price point represents lock-in, engineered with patience. The billing model change did not happen in isolation. It happened after the dependency was well established.
Why "Rising Costs" Does Not Hold
GitHub's public framing is that the new pricing model reflects "premium model usage" costs associated with "long-running agent sessions." That explanation is offered as if it is self-evidently reasonable.
It is not reasonable when applied honestly to the actual numbers.
I am not arguing that running large language models is cheap. The compute costs are real. The industry has been grappling with the economics of inference at scale since these models went mainstream. But if your business model depends on charging $39 a month for usage patterns that actually cost $1,941.07 to serve, you have an existential problem with your pricing model - not a legitimate case for a 50x increase presented to existing customers as a routine adjustment.
No rational software business operates this way accidentally. You do not build a subscription product, encourage maximum usage of your highest-cost tier, and then discover eighteen months later that you forgot to account for inference costs. That is not operational naivety. It is a deliberate growth strategy: acquire users, integrate them deeply, then monetise them once exit costs are high enough. Any developer who has managed a software budget, or sat in a room while a finance team reviewed vendor contracts, will recognise this pattern without prompting.
The calculation Microsoft is making is that developer workflow lock-in is strong enough to absorb a 50x price increase without meaningful attrition. The only information that challenges that calculation is developers actually leaving.
The Alternatives That Exist Right Now
The honest answer is that GitHub Copilot's VS Code integration is, as of today, the most polished AI coding tool in the market. The inline completions are fast, the agent mode is deeply integrated with VS Code's workspace model, and the overall experience has had more development time behind it than its competitors. I am not pretending otherwise.
But "most polished" and "worth $1,941.07 a month at my usage level" are not the same sentence. Here is what I am switching to.
Claude Code
Claude Code is the most logical immediate alternative for anyone already dependent on Anthropic models - which, if you have been running Copilot's agent mode seriously, you almost certainly are. The important update here: Anthropic now ships a full VS Code extension alongside the original CLI, and with over 15 million installs it is not a niche experiment. The extension provides a native graphical panel in VS Code with inline diff review, plan mode (where Claude describes what it intends to do before touching a file), @-mention context for files and folders, conversation history across sessions, and the ability to switch back to the original terminal interface if you prefer it. The surface area is directly comparable to what Copilot's agent mode provides.
Billing goes directly to Anthropic via your Claude Pro, Max, or Team subscription, or pay-as-you-go API rates. There is no intermediary who can reprice your usage by 50x without notice. For developers who have spent a year learning Claude's reasoning patterns and model behaviour, this is the closest to a direct swap that currently exists.
Roo Code and Roomote
Roo Code is an open-source VS Code extension that provides agent-mode coding similar to Copilot, with the critical difference that you supply your own API keys. It supports Anthropic, OpenAI, Google, and local models through a unified interface. Because you own the billing relationship directly - paying Anthropic or OpenAI at their published rates - no third party can reprice your usage 50-fold overnight. The extension is actively developed and handles multi-file agentic tasks competently.
The Roo Code team is also building Roomote, which takes a more IDE-independent approach to agent-based development. The direction is toward agents that operate at the project level across a development environment, rather than inside a specific editor. This is arguably where the category is heading: agents that work across your entire development context, not just the file open in front of them.
Google Antigravity
The timing of Google Antigravity is not a coincidence. On May 19, 2026, Google announced that Gemini CLI - their open-source terminal agent with 105,000 GitHub stars - is being replaced by Antigravity, a new agent-first development platform. The transition for consumer users (Google AI Pro/Ultra subscribers and free tier) happens June 18, 2026, the very moment GitHub's repricing bites hardest.
Antigravity comes in three forms. Antigravity CLI is the terminal agent: built in Go for speed, it handles async background workflows so a large-scale refactor does not block your terminal session. Antigravity 2.0 is a desktop application - a visual command centre for running multiple agents across projects in parallel, closer in feel to a standalone agent manager than a traditional IDE. Antigravity IDE is a VS Code fork with Gemini integration built in from the ground up, for developers who want a full IDE experience without VS Code's Microsoft ownership overhead.
The billing model mirrors Claude Code's approach: you authenticate with your existing Google AI subscription rather than paying a separate seat fee to a third party. For developers who have been using Gemini models alongside Claude, or who want a Google-backed platform with transparent subscription terms, this is a credible complete stack.
Cursor
Cursor is an AI-native IDE built on VS Code's codebase, with its own agent mode, codebase indexing, and model selection. It has a subscription model with clear usage limits and pricing that has remained transparent. It is not free at scale, but the pricing structure has not demonstrated the bait-and-switch pattern that GitHub's has. For developers who want to stay in a VS Code-style environment without the Microsoft billing relationship, it is the most direct drop-in.
The Honest Assessment
I want to be fair about where things actually stand, because a credible argument requires one.
GitHub Copilot, right now, in VS Code, is a well-made product. The editor integration is tight. The context handling for large codebases is solid. The multi-step agent loops work reliably. I have used it to build production systems - including the agent-driven workflow changes I wrote about earlier this year. It works well, and the development time Microsoft has invested shows.
The competitors have closed the gap significantly. Claude Code's VS Code extension in particular removes the workflow adjustment argument - if you are already in VS Code with a Copilot panel open, moving to the Claude Code extension panel looks and behaves similarly. Roo Code works inside the same editor. Cursor is a VS Code fork you can migrate to in an afternoon. Antigravity IDE is another VS Code fork if you want to leave the Microsoft IDE entirely. None of these require rebuilding your development environment from scratch.
Microsoft's structural advantage - controlling both VS Code and the AI extension simultaneously - is real but shrinking. VS Code's open architecture and the Open VSX registry mean competitors can ship extensions that integrate just as deeply. The moat is thinner than the Copilot team would like to admit.
It will not hold permanently. Open-source tools move fast when they have motivated communities behind them, and the community motivation here is substantial. A 50x price increase creates exactly the kind of urgent, specific problem that open-source communities solve well. The gap between GitHub Copilot and the alternatives today is real but not permanent. Copilot had a significant head start and a product organisation with resources most open-source projects cannot match - and the field caught up considerably in 2025. The same thing will happen again.
What I Am Doing About It
I am switching primary agent tools to Roo Code and Claude Code, evaluating both over the next two months on real production development work rather than contrived benchmarks. I will write about the experience honestly - what works, what does not, and where the workflow gaps are compared to Copilot's current standard.
I am also not pretending this is cost-free. Switching tools mid-workflow has real friction. There is familiarity, muscle memory, and tooling configuration involved. I am not dismissing that. But the alternative - staying with a vendor who has just demonstrated they will reprice my workflow investment at 50x whenever their commercial strategy requires it - carries a higher long-term cost than the short-term friction of switching.
No professional who has managed vendor relationships in any context should have to think twice about this. When a vendor engineers your dependency and then uses it against you, you leave. You document why you left. And you make it easy for the next person to leave too.
GitHub built an excellent product. Then they decided to use it as a mechanism for extracting value from the developers who trusted them. The development community should treat it accordingly.
