Why I cancelled my GitHub Copilot in 2025.
I cancelled my GitHub Copilot subscription in November 2025. The cancellation was not principled. It was a bookkeeping decision.
The team I was paying for had eight engineers. Each engineer was on a Copilot Business seat at nineteen dollars a month. Six of those engineers were also on Cursor, three on Claude Code, two on Cody. The agent licenses came in at thirty to forty dollars a month per engineer, depending on the tier. The arithmetic was that we were spending roughly fifty to sixty dollars per engineer per month on coding-assistant tooling, and the Copilot share of that spend was producing the smallest fraction of the value.
The honest version of the cancellation memo, which I did not write but should have, was three sentences. Copilot in late 2025 is the weakest of the named coding agents. The team license plus a real agent license is double-paying for a capability we are getting better elsewhere. We should pay for the better capability and stop paying for the worse one.
Three receipts on why the comparative quality landed where it did.
The agentic gap is not closing
The 2025 product cycle for coding agents was the year the pattern shifted from autocomplete-with-context to delegated-task-execution. Cursor's composer and the Claude Code workflow can take a multi-step instruction, plan the file changes, execute against the codebase, run the tests, surface the diff, and accept iterative feedback inside a single session. The capability is not perfect. It is better than the human-edit baseline on a meaningful fraction of routine refactor work, and it is much better than what Copilot ships.
Copilot's response to the agentic shift was a series of beta features that arrived later than the competition, gated behind enterprise SKUs that the Business plan did not include, and shipped with a degraded version of the multi-file context handling that the same problem requires the agent to be good at. The product roadmap appeared to be reactive throughout 2025. Each release was the right idea executed two quarters late and one capability tier short. By Q3 the gap was not converging. By Q4 the gap was visibly widening on the kinds of tasks we were trying to push the agent toward.
The cancellation was not because Copilot got worse. It was because the rest of the field got better and Copilot did not keep up.
The double-pay is structural
The defense of keeping Copilot alongside a real agent license is that they do different jobs. Copilot handles the inline-completion-while-you-type case; the agent handles the delegate-the-task case. The two roles are described as complementary, and each engineer needs both, and the combined spend is justified by the combined coverage.
The argument is partially true and largely structural cover for a sunk-cost commitment. The inline-completion job is one Cursor and Claude Code now do at parity or better, inside the same workflow that handles the agentic case. The single-tool installation produces the same coverage at half the spend, with less context-switching for the engineer between two assistants that disagree about what the code should look like. The complementarity argument falls apart on close inspection because the agent tools have absorbed the autocomplete role into their primary surface and Copilot has not absorbed the agentic role into its.
The double-pay is the tell. Anyone still paying both licenses by mid-2025 is paying twice for one capability and getting the weaker version of the second from the legacy tool.
The enterprise-pull argument has a half-life
The remaining serious case for keeping Copilot in 2025 is enterprise-procurement: GitHub is already approved, the Microsoft enterprise agreement covers it, the security review is done, the procurement cycle to get a different tool through legal and IT is six months. This argument is real. It is also the argument every legacy tool used in the year it lost the category.
The procurement friction is a one-time cost. The capability gap is a recurring cost. The first time a pull request gets shipped slower because the agent on the Copilot side could not handle a multi-file refactor that the Cursor side handled in one session, the procurement-friction defense gets weaker. The second time it happens, the defense is gone. The third time, the manager who blocked the procurement request is the one explaining to leadership why the team velocity is half of the team next door's.
The Microsoft enterprise agreement bundles a lot of value that nobody is going to cancel. Copilot is the line item where the bundle stops earning its place. The enterprise-pull keeps Copilot paid through 2026 in most large shops. It does not keep Copilot the front-line tool in the engineering teams that are paying attention.
What the cancellation actually buys
The cancellation freed up roughly fifteen hundred dollars a month at our team size, which we redirected to upgrading the three engineers on the lower agent tier to the higher one and paying for the larger context windows that the heavier work was hitting. The net spend was lower. The capability per dollar was higher. The team velocity went up over the following quarter on the kinds of work that the agent handles well, which by late 2025 was roughly forty percent of what we were shipping.
The bookkeeping reads cleaner. The honest version of the comparison stopped having Copilot in the middle of it. That is the right outcome.
The recommendation, for the engineering leader still running both lines in early 2026, is to spend a week with the comparison live. Pull the actual usage telemetry from each tool. Map it to the categories of work the team is shipping. The cancellation case writes itself if the data is on the table.
—TJ