GitHub Copilot Review: The $10 Floor That Stopped Being Flat

GitHub Copilot is the tool most working developers already have. It crossed 20 million cumulative users in July 2025, reported roughly 4.7 million paid subscribers by January 2026, and commands something like 42% of the paid AI-coding market in the 2026 aggregations. For two years its pitch was the simplest in the category: $10 a month, it lives in the editor you already use, and you never think about it again. On June 1, 2026, the part of that pitch that mattered most quietly changed, and the most useful thing this review can tell you is what kind of bill you are now signing up for.

What it is

An AI coding assistant that lives inside the editor, primarily VS Code, with strong JetBrains support. The core three layers will be familiar to anyone who has used the category. Inline code completion suggests the next line or block as you type, and it remains free and unlimited even after the billing change. Copilot Chat answers questions and edits code in a side panel, with model selection on paid plans. And agent mode, generally available on both VS Code and JetBrains since March 2026, takes a higher-level instruction, plans the steps, edits across files, runs terminal commands, and iterates until the task is done.

Above that sits the autonomous layer: a background coding agent you assign a GitHub issue to, which works in the background, writes code, runs tests, and opens a pull request for review. That is the feature meant to answer Cursor’s background agents and BugBot, and on paper it competes; in practice the reviewer consensus still rates Cursor’s autonomous workflows as more mature. Model choice on paid plans spans GPT-5.x, Claude Sonnet 4.6 and Opus, and Gemini, so the underlying capability is the same frontier roster every serious tool now exposes.

The pricing, decoded

Here is the structure plainly, because it is the section that decides purchases. Five tiers per GitHub’s plans page: Free (50 premium or agent requests plus 2,000 code completions a month), Pro at $10/mo with 300 premium requests, Pro+ at $39/mo with 1,500, Business at $19/user/mo, and Enterprise at $39/user/mo. Note that Enterprise also requires GitHub Enterprise Cloud, so the effective seat cost lands higher than the headline.

The change that reshaped all of those numbers took effect June 1, 2026. Copilot moved from counting premium requests to metering token usage through AI Credits, where 1 credit equals $0.01 and your included dollars are drawn down by input, output, and cached tokens at each model’s published API rate. Code completions stay free. Everything else, chat, agent runs, code review, now meters against a real pool. When the pool empties, GitHub no longer falls back to a cheaper model automatically the way it used to; usage either stops or bills overage, depending on whether you have configured additional billing.

That is the same transition Cursor went through in June 2025, and it produced the same result: a floor price that is no longer the price. One Pro+ user cited by Visual Studio Magazine reported burning roughly 8% of a month’s credit allocation in about two hours of agent work. The headline $10 and $39 still buy you in; what they buy is a credit pool whose lifespan depends entirely on how hard you push the agent.

The practical math is worth internalizing before you subscribe. Because credits are drawn against each model’s published API rate, the same agent task can cost wildly different amounts depending on which model you route it to and how much context it pulls in. A long agent run on a frontier model can chew through several dollars of credits in a single session, which is why some developers reported single agentic sessions consuming far more than the old request counts would have suggested. The included credits track the subscription dollars, so Pro’s $10 buys $10 of model usage and Pro+‘s $39 buys $39, with Business and Enterprise seats including their headline amounts as credits. For autocomplete-only users this is academic, since completions stayed free and unmetered. For anyone running agents, it is the single most important number to model out, and it is the number GitHub’s marketing is quietest about.

Where it wins, where it doesn’t

The honest competitive picture in 2026 has several poles, and our best AI coding assistant guide ranks the full field. The Cursor review covers the other side of the head-to-head in detail.

Against Cursor: Copilot wins the price war and roughly ties on raw agent task completion. It is half the entry price ($10 vs $20), and in the most-cited 500-task SWE-bench comparison its agent actually scored higher, 56% to Cursor’s 51.7% (Morph), though Cursor completed each task about 30% faster. Where Copilot loses is workflow maturity: Cursor’s background agents, BugBot review, and in-editor agent loop are widely judged more polished, and its G2 sits at 4.7 against Copilot’s roughly 4.3 in the comparison the field cites. The clean read is that Copilot is the rational pick for autocomplete-heavy, agent-light work, and Cursor earns its premium only if you run agents daily.

Against Windsurf: a similar shape. Windsurf Pro is $20, twice Copilot’s floor, and its argument rests on Cascade’s aggressive agentic workflow rather than price. If your work skews toward telling an agent what to do and letting it run, Windsurf’s Cascade is the stronger commercial agent; if it skews toward autocomplete and the occasional chat inside VS Code, Copilot is both cheaper and the path of least resistance.

Against Claude Code: less a competition than a difference in shape, and the pairing both tools point toward. Claude Code is a terminal-first agent built for long autonomous tasks, multi-file refactors, and large-codebase exploration. Copilot’s coding agent can open a PR from an issue, but its center of gravity is the in-editor loop. The common 2026 power stack is an IDE-integrated tool for daily work plus Claude Code from the terminal for the big jobs, and Copilot at $10 is a perfectly reasonable IDE half of that pair.

A note on the model story, because it is where the marketing overreaches. No tool in this group owns a better underlying model. Claude Fable 5, which topped its June 2026 launch chart at roughly 95% on SWE-bench Verified (detailed in our Fable 5 coding guide), runs in Cursor and Claude Code and reached general availability in Copilot on June 9, 2026. The same frontier models are selectable across all of these tools, so the differentiator is workflow, not exclusive model access. Which exact models are live in a given tool does shift over time, so check the current roster rather than buying on a launch headline.

Treat every cross-tool benchmark above as directional. The SWE-bench comparison is a third-party aggregation, not a standardized eval, and OpenAI de-emphasized SWE-bench Verified in early 2026 over saturation and contamination concerns, steering new evaluations toward SWE-bench Pro. The same caution we apply to robot-vacuum lab splits applies here: the variance between testing setups regularly exceeds the gap between tools.

Living with it

The day-to-day experience is the smoothest in the category for the simplest reason. There is nothing to migrate to. If you write code in VS Code, Copilot is an extension and a sign-in, and the inline completions, which most users still rate as Copilot’s best feature, work immediately and cost nothing against the meter. For a developer whose AI use is mostly autocomplete plus occasional chat, the June billing change barely registers, because completions stayed free.

The friction lives entirely in the agent layer, and it is new friction. The dominant complaint in Copilot’s 2026 coverage is not capability, it is cost predictability under the AI Credits model. The removal of automatic model fallback means an agent session no longer degrades gracefully when quota runs low; it stops or bills overage. The practical defense is the one GitHub provides: set an additional-usage budget, and set it to $0 until you understand your consumption, so heavy agent runs cannot quietly accrue overage. As with Cursor, watch the usage dashboard for your first month before trusting any budget figure, including ours.

What you do not see in the complaint threads is people actually leaving in numbers that dent the install base. The backlash is real and the trust hit is real, but Copilot’s ubiquity, enterprise penetration (a reported 90% of the Fortune 100), and zero-migration default keep it sticky. The G2 score around 4.3 trails Cursor’s 4.7 and reflects exactly this: a competent, ubiquitous tool whose critical reviews now cluster on pricing rather than on the code it writes.

The productivity case for the autocomplete layer remains the strongest part of the pitch and the part the billing change did not touch. GitHub’s own figures put the share of code written with Copilot assistance well above where it launched, and the company has cited task-completion speedups in studies involving thousands of developers. Take vendor productivity numbers with the usual skepticism, but the directional point holds and matches what most working developers report: the inline completions are the feature that earns the subscription, and they are free. Everything contentious about Copilot in mid-2026 sits in the metered layer above them. That is the right way to frame the decision. If your AI use lives mostly in completions, the controversy is somebody else’s problem; if it lives in the agent, the controversy is the whole story.

Verdict

Our synthesis score is 8.3. Where it comes from: a competitive agent benchmark (the cited 56% SWE-bench run actually leads Cursor’s), the category’s lowest serious entry price ($10), the largest install base and the smoothest VS Code-native experience anywhere, and access to the same frontier models as every rival, which together argue for a high mark. We dock it below Cursor’s 8.9 for three reasons. The June 1, 2026 billing transition is genuinely worse for buyers in the short term, removing the graceful fallback and producing a documented credit-depletion backlash. The agent and autonomous workflows are still judged less mature than Cursor’s. And its G2 (around 4.3) sits below the category leader. The number reflects a tool that is the rational default for most developers and the wrong choice for the heaviest agent users.

Buy GitHub Copilot if AI coding means autocomplete and occasional chat to you, if you live in VS Code, and if you want the cheapest credible entry into the category. Set a spending cap, watch the meter for a month, and the $10 will be the easiest line item in your tooling budget to justify. If you delegate whole tickets to agents every day, price out Pro+ against Cursor’s tiers honestly, or do what most experienced developers now do and pair a cheap in-editor tool like Copilot with Claude Code from the terminal for the heavy work.