AI Coding Assistants Compared: Copilot vs Cursor vs Claude Code vs Windsurf

The four-way answer in one paragraph: There is no single best AI coding assistant, because the four leading tools are built around four different ideas of where the AI should sit. GitHub Copilot lives inside the editor you already use and is the easiest choice for teams already on GitHub. Cursor rebuilds the editor around the AI, and suits developers who want the agent and the editor to be one thing. Claude Code lives in the terminal, takes whole tasks rather than single lines, and suits developers who are comfortable managing an agent like a junior colleague. Windsurf — renamed Devin Desktop by its new owner, Cognition, in June 2026 — is an AI-first editor with both local and cloud agents, but its name, owner, and pricing have all changed in the past year, so buy it with your eyes open. Pick the shape of working first, then the price, and you will rarely regret the choice.

This comparison is not a hands-on test. No code was run through any of these tools for this article, and no benchmark score, acceptance rate, or productivity percentage appears anywhere below — because none was measured. Instead, every feature and every price in this guide was checked against the vendor’s own documentation and pricing pages on 7 November 2026, and the comparison is made feature by feature on that documented record. Where a claim comes from secondary reporting rather than a vendor page — the ownership changes, for example — the article says so. That matters more than usual right now, because two of these four tools changed their pricing or their name within weeks of this article being written.

Checked 7 November 2026. Prices, plan names, and model menus on this page are the ones listed on each vendor’s own pages on that date, and they change fast — Cursor’s pricing page now sells a different subscription to new buyers than the one most guides still describe, and Windsurf’s pricing page now serves Devin’s plans. Before you spend money, re-check the price of the exact plan you intend to buy on the vendor’s pricing page, and confirm the model you want is still offered in that tool. Where this article could not verify a figure on a vendor page in this session, it says so rather than repeating a number as fact.

1. The Short Answer: Which Assistant for Which Developer

<img src="

” alt=”A crossroads with four blank signposts pointing in different directions at sunrise, suggesting choosing between four tools” />

If you only read one section, read this one. The four tools differ first in where they live, and that single difference predicts most of the rest.

Choose GitHub Copilot if you already live in GitHub and in VS Code or a JetBrains IDE, and you want AI help that arrives without changing your tools. It starts at $10 a month for individuals, it is the only one of the four that is a native part of the platform where your code already lives, and its agent can take a GitHub issue and return a pull request. For a team that already pays for GitHub, it is usually the path of least resistance — and the cheapest serious option.

Choose Cursor if you want the editor itself to be the AI tool, and you want the widest choice of models in one place. Cursor is a full editor built on the VS Code foundation, with an agent, a plan mode, and a model menu that on 7 November 2026 ran from Claude’s Fable and Opus through Google’s Gemini to xAI’s Grok and Cursor’s own Composer. Its current pricing for new buyers is the X Subscription — Free, then Plus at $8, Premium at $30, Super at $100, and Ultra at $200 a month — with one usage pool shared across Cursor and Grok. It suits the developer who thinks in code, stays in the editor all day, and wants to switch models without switching tools.

Choose Claude Code if you are comfortable in the terminal and you want to hand over whole tasks, not single lines. It is an agent that reads your codebase, plans, edits across many files, runs the tests, and reports back — and it is included in every paid Claude plan, starting at $20 a month for Pro, with no separate Claude Code subscription to buy. It suits developers who can write a clear task description, set down conventions for the agent to follow, and review everything it produces with discipline. Our site’s short piece on the three ways to code with AI — terminal agent, AI editor, or assistant in your editor makes the same three-way split in brief; this guide is the full version, with Windsurf added and prices checked.

Choose Windsurf — now sold as Devin Desktop — if you want an AI-first editor with both a local agent and cloud agents in one subscription, and you are willing to buy into a product whose ownership changed in 2025 and whose name changed in 2026. Pro costs $20 a month, with a free tier that includes unlimited Tab completions, and the Pro plan includes frontier models plus Cognition’s SWE-2 model and access to Devin Cloud. The trade-off is predictability: usage runs on daily and weekly quotas with no published numbers, and extra usage is billed at each model’s API price.

2. How This Comparison Was Done (and What It Is Not)

Most coding-assistant comparisons you will find online are built on one of two foundations: a hands-on test, where the author ran the same tasks through each tool and scored the results, or a rewrite of the vendors’ marketing pages. This article is neither. It is a third kind of comparison: a systematic check of each tool’s documented feature set and published pricing, done on a single day, so that a reader can see what each tool claims to do, what it costs, and where the documented differences actually lie.

That method has a clear strength and a clear limit, and you should know both before trusting anything below. The strength is verifiability: every price and every feature claim in this guide can be checked against a named vendor page, and the Sources section at the end lists them all. The limit is that documented features are not measured performance. A tool can list an agent mode and still write poor code; a tool can list a 1-million-token context window and still lose track of a large project. This article does not pretend to know which tool writes the best code, because it did not run the experiment. What it can tell you, honestly, is which tool offers which capability, at which price, under which rules — and that is, for most buyers, the decision that comes first anyway.

Two judgements shaped the structure. First, the comparison is organised by task, not by tool, after the four tool profiles: autocomplete, agent work, review and testing, models, pricing, and privacy. That is deliberate. Developers do not buy a list of features; they buy a way of doing the next task, and the task-by-task sections are where the differences show up. Second, prices are quoted as monthly list prices in US dollars, before tax, exactly as the vendors list them — because that is the number you will actually be charged, and annual discounts, where they exist, are noted alongside rather than baked in.

3. The Four Assistants at a Glance

Before the detail, here is the whole comparison on one table. Read it as a map, then use the sections that follow for the territory.

Where it lives: Copilot is an extension and service inside your existing editor and inside GitHub itself. Cursor is a complete editor — a fork of the VS Code foundation rebuilt around AI. Claude Code is primarily a terminal agent, with editor extensions, a desktop app, and a web version. Windsurf, now Devin Desktop, is an AI-first editor in the same mould as Cursor, plus cloud agents.

How you talk to it: Copilot offers inline completions, chat, agent mode, a CLI, and a cloud agent that works from GitHub issues. Cursor offers Tab completions, chat, an agent with a plan mode, cloud agents, and a code-review agent called Bugbot. Claude Code offers a terminal conversation, editor extensions with inline diffs, and a web interface for long-running tasks. Devin Desktop offers Tab completions, a local agent (Devin Local), and cloud agents, managed from an Agent Command Center.

Models: Copilot lets you pick between models, but GitHub says the options vary by plan and feature and change often, so this article names none for it. Cursor publishes a full menu: Claude’s Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5; Google’s Gemini 3.1 Pro, 3.8 Flash and 4 Argon; GPT-5.6 Luna, Sol and Terra; Grok 4.5, 4.6 and 4.7; and Cursor’s own Composer 2.5 and Muse Wonder. Claude Code runs Claude models only — Fable, Opus, Sonnet and Haiku — although its CLI and editor extensions also support third-party providers. Devin Desktop offers frontier models from OpenAI, Claude, Gemini and SpaceXAI, plus open-source models and Cognition’s own SWE-2.

Starting price for an individual: Copilot Pro is $10 a month. Cursor’s current new-buyer ladder starts with Plus at $8 a month, with Premium at $30 as the plan Cursor itself recommends for new AI users. Claude Code starts at $20 a month, because it is included in the Claude Pro plan. Devin Desktop Pro is $20 a month. The cheapest serious tier across all four is therefore Copilot Pro at $10 — but “cheapest” and “best value for you” are different questions, and the pricing section answers the second one.

One more distinction belongs in this overview, because it explains the pricing chaos you will meet if you read older guides: two of these tools changed hands or changed price in 2026. Cursor was reported to have been acquired by SpaceX in June 2026, and its pricing page now sells the X Subscription to new buyers, with the old $20 Pro tier kept only for existing subscribers, according to secondary reporting. Windsurf was acquired by Cognition in July 2025 after OpenAI’s reported $3 billion bid collapsed, and Cognition renamed it Devin Desktop on 2 June 2026. Our category overview of AI coding tools describes the four species these tools belong to — autocomplete, AI editors, terminal agents, and prompt-to-app builders — and this comparison is the head-to-head inside that map.

4. GitHub Copilot: The Assistant Inside the Editor You Already Have

GitHub Copilot is the incumbent, and incumbency is its whole case. It was the first AI coding assistant most developers met, it is built into GitHub — where the code of most professional teams already lives — and it is the only one of the four that does not ask you to change editors, change platforms, or learn a new home for your work. You install an extension, sign in with your GitHub account, and the AI arrives inside the tools you already run.

What Copilot actually does, in GitHub’s own description, is help you write, understand, and ship software across the whole development lifecycle: exploring a codebase, planning a project, automating workflows, reviewing changes, and resolving merge conflicts. The work starts as an issue, gets picked up by an agent, returns as a pull request, gets reviewed, and gets merged — in the same place, with the same context, instead of moving code into a separate tool and back again. That sentence is the product’s thesis, and if your team already works in GitHub issues and pull requests, it is a strong one.

The feature set has four layers. At the bottom is inline completion: as you type, Copilot suggests the next chunk of code, and its next-edit suggestions predict the edit you are about to make. Above that is Copilot Chat, where you ask questions about your code in plain language. Above that is agent mode, available in VS Code, Visual Studio, JetBrains IDEs, Eclipse, and Xcode, where you hand the tool a multi-step job and it plans, edits across files, and checks its own work. And above that is the cloud agent: assign a GitHub issue to Copilot, and it researches, plans, and writes code asynchronously, returning a pull request for review — with or without a pull request attached, and able to delegate tasks to third-party coding agents such as Claude and OpenAI’s Codex, which GitHub lists as a preview. There is also a Copilot CLI for working from the terminal, a desktop app, and availability on the web, on mobile, and even in Slack and Teams, with sessions that can continue across surfaces.

Customisation is a real strength, and it is where Copilot’s GitHub integration pays off most visibly. You can set custom instructions — including an instructions.md file in your repository — define reusable prompts, give the agent repository context, connect external tools and MCP servers, and build custom agents and agent skills. For a team with conventions worth enforcing — a style guide, an architecture rule, a security checklist — this is the mechanism that turns a generic assistant into one that writes code the way your team writes code.

The limits are the mirror image of the strengths. Copilot is an assistant inside someone else’s platform, so its behaviour depends on your plan, your client, and your organisation’s policies — GitHub’s own wording. The model picker exists, but GitHub says the available models vary by feature and change frequently, which is why this article does not list them. Our full GitHub Copilot guide covers all of this in depth — features, tiers, tested examples, and the review workflow — and this section is the summary, not the replacement.

5. Cursor: The Editor Rebuilt Around the Agent

Cursor starts from the opposite bank to Copilot. Instead of bringing AI into your editor, it rebuilds the editor around the AI. It is a full IDE built on the VS Code foundation, so it feels familiar to VS Code users — same layout, same extensions, same shortcuts — but chat, agent work, multi-file edits, and codebase awareness are native to it rather than bolted on. The idea is that you stay in flow: the AI is present in the same window where you think, not a sidebar you visit.

Cursor’s own documentation describes it plainly as “a coding agent for building ambitious software”, and lists the jobs it is built for: understanding a codebase, planning and building features with a plan mode, finding and fixing bugs, reviewing changes before merge, and connecting to the tools a team already uses — GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, and Linear. Customisation runs through one place: rules, skills, MCP servers, and plugins, plus a CLI. The agent is the centre of the product, and everything else — Tab completions, chat, review — orbits it.

The model menu is the widest of the four tools, and it is published in full on Cursor’s documentation, which is unusual and useful. As read on 7 November 2026, it includes Claude’s Fable 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5; Google’s Gemini 3.1 Pro, Gemini 3.8 Flash, and Gemini 4 Argon; GPT-5.6 Luna, Sol, and Terra; Grok 4.5, 4.6, and 4.7; and Cursor’s own Composer 2.5 and Muse Wonder. Default context windows run from 200,000 to 300,000 tokens depending on the model, and most models offer a maximum context of 1 million tokens — Grok 4.7 tops out at 500,000. That breadth is Cursor’s real advantage: if one model is weak at your task, you switch models, not tools. The catch, stated on Cursor’s own pricing page, is that third-party models are billed separately at their API list price on paid plans above Plus, and do not draw from the plan’s usage pool — so the menu is wide, but the expensive models cost extra.

The other thing to know about Cursor in November 2026 is that its pricing page no longer sells the product most guides describe. The page read for this article sells the X Subscription to new buyers: Free, Plus at $8 a month, Premium at $30, Super at $100, and Ultra at $200, with Teams from $30 per user a month and Enterprise on application. One usage pool is shared across Cursor and Grok; the allowance refreshes weekly; and when you reach the included usage you can keep going with top-offs or wait for the refresh. Plus includes Grok models only. Premium — the plan Cursor recommends for new AI users — adds four times Plus’s usage, the latest Grok models, cloud agents and automations, code hosting via Origin, AI code reviews via Bugbot, and third-party models at API list price. Super adds fifteen times Plus’s usage and priority model access at peak times; Ultra adds fifty times Plus’s usage and the earliest access to new products and models. Secondary reporting says the older ladder — Hobby free, Pro $20, Pro+ $60, Ultra $200 — is now legacy-only for existing subscribers, and that Cursor was acquired by SpaceX in June 2026; neither claim could be verified on a Cursor page in this session, so treat both as reported, not confirmed. One further secondary report says OpenAI models will leave Cursor on 12 November 2026 — the docs page read today still lists GPT-5.6 models, so check the model menu before you buy if GPT access is the reason you are choosing Cursor.

6. Claude Code: The Agent in the Terminal

Claude Code is the most different of the four, because it starts from a different assumption: that the developer is a manager, and the AI is a fast, literal junior team. It is, in Anthropic’s own words, “an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools” — and its home is the terminal, where DevOps has always lived.

The unit of work is the ticket, not the line. You describe a task — “write tests for the auth module, run them, and fix any failures” is Anthropic’s own example — and Claude Code explores the repository, plans, edits files across many files at once, runs the tests, and reports back with a summary and a diff. Its strength is autonomy inside a loop it can verify: tests pass or they do not, and the agent can see the result and try again. Its demand on the user is managerial: clear task descriptions, conventions written down for the agent, and disciplined review of everything it produces. Developers who thrive with it describe managing a very fast, very literal junior team — and developers who do not write clear instructions get back very fast, very literal misunderstandings.

Getting started is deliberately low-friction. On macOS, Linux, or Windows Subsystem for Linux, you run the install command from Anthropic’s docs, open a terminal in your project, type claude, and sign in — with a Claude subscription or an Anthropic Console account. Beyond the terminal, there are extensions for VS Code and JetBrains with inline diffs and plan review, a standalone desktop app that runs multiple sessions side by side and schedules recurring tasks, and a web version at claude.ai/code for long-running tasks on repositories you do not have locally. The CLI, VS Code, and JetBrains surfaces also support third-party model providers.

Customisation is where Claude Code shows its depth. A CLAUDE.md file in your project root sets coding standards, architecture decisions, preferred libraries, and review checklists, and Claude Code reads it at the start of every session; if your repository already has an AGENTS.md file, it can read that instead. Skills package repeatable workflows your team can share, like a review or deployment command. Hooks run shell commands before or after Claude Code actions — auto-formatting after every edit, or linting before a commit. Sub-agents let a lead agent split a task across several agents working in parallel, and the Agent SDK lets you build your own agents on Claude Code’s capabilities. It connects to external tools through MCP — reading design docs, updating tickets, pulling data from chat tools — works directly with git, staging changes and opening pull requests, and automates review and triage in CI through GitHub Actions or GitLab CI/CD. It can even run on a schedule, for morning pull-request reviews or overnight failure analysis.

The price is the simplest of the four to understand, and the hardest to predict. There is no separate Claude Code subscription: it is included in every paid Claude plan, and it shares that plan’s usage pool with your chats on the web, desktop, and mobile. Pro costs $20 a month, or $17 a month on annual billing; Max costs $100 a month and gives five times Pro’s usage plus $100 a month in API credits; Ultra costs $200 a month and gives ten times Pro’s weekly usage, no five-hour limit for verified accounts, and $200 a month in API credits. Enterprise costs $20 per seat a month plus usage billed at API rates. For heavy coding sessions you can switch to pay-as-you-go API credits through a Console account, at Anthropic’s standard API rates: Sonnet 5.5 at $2 per million input tokens and $10 per million output tokens, Opus 5.5 at $4 and $20, Haiku 5.5 at $0.10 and $0.50 for prompts up to 100,000 tokens, and Fable 5.1 at $10 and $50. The catch is that Anthropic publishes no fixed message count — how fast you reach a limit depends on the model, the length of your conversations, and the size of your files — so a heavy agent session can eat a week’s allowance in an afternoon, and you will only know when the meter tells you. Our Anthropic explainer covers the company behind Claude, its Constitutional AI approach, and the safety-first bet that shapes how its tools behave — useful context for why Claude Code is built the way it is.

7. Windsurf, Now Devin Desktop: The Editor That Changed Owners Twice

Windsurf is the tool in this comparison with the most complicated story, and the story matters to the buying decision, because you are not just buying features — you are buying into a company, and this product has changed companies twice in eighteen months. Readers who know the name Windsurf should know first that the product they are buying today is called Devin Desktop, and the vendor they are buying it from is Cognition, the company behind the Devin coding agent.

The outline, as reported by multiple secondary sources, runs like this: Windsurf began as Codeium, a free code-completion tool, and launched the Windsurf editor in late 2024 to strong reviews. In July 2025, OpenAI’s reported $3 billion bid for the company collapsed; Google then paid about $2.4 billion to license Windsurf’s technology and hire its chief executive and several researchers; and days later Cognition agreed to acquire what remained — the product, the brand, the rest of the team, and the intellectual property. On 2 June 2026, Cognition renamed Windsurf to Devin Desktop, and windsurf.com now serves Devin’s site. The one part of this that this article verified first-hand is the endpoint: the pricing page at windsurf.com/pricing, read on 7 November 2026, serves Devin’s plans and pricing, under the title “Devin Plans and Pricing”. Older guides that describe Windsurf’s old credit plans are describing a product that no longer exists under that name.

What you actually get is an AI-first editor in the same mould as Cursor — built on the VS Code foundation, with Tab completions and an agent in the editor — plus something Cursor does not offer in the same subscription: cloud agents. Devin Desktop combines a local agent, now called Devin Local, with Devin Cloud agents that work away from your machine, managed from an Agent Command Center, and the subscription covers Devin Desktop, Devin CLI, Devin Cloud, and Devin Review on one set of plans. Secondary reporting says the old Cascade agent was replaced by Devin Local in 2026, and that Devin Local is claimed to be up to 30% more token-efficient — a vendor claim this article could not verify and does not repeat as fact. Windsurf for JetBrains remains available as a plugin, for developers who want the assistant inside JetBrains rather than the full editor.

The pricing, read live on 7 November 2026, is: Free at $0, with a light quota to code with agents, limited model availability, unlimited inline edits, and unlimited Tab completions; Pro at $20 a month, with increased quotas, full model availability including frontier models from OpenAI, Claude, Gemini, and SpaceXAI plus leading open-source models, free use of Cognition’s SWE-2 model, access to cloud agents, and extra usage purchasable at API pricing; Max at $200 a month, with significantly higher quotas; Teams at $80 a month plus $40 a month per full developer seat, for up to 200 users, with centralised billing and an admin dashboard; and Enterprise on application. The allowances refresh daily and weekly, and the pricing page states plainly that the cost per message varies by model, task size, and complexity — which is honest, and which also means the monthly bill for a heavy user is genuinely hard to predict. The page shows no annual billing option.

The honest verdict on Devin Desktop is that it is a capable editor with a genuinely useful combination — local and cloud agents in one subscription, unlimited Tab on every plan including free — sold by a company that is still integrating an acquisition, under a name that is less than six months old. If you buy it, buy the free tier first, run your real work through it for a week, and watch the usage meter before you pay. The product’s past year is a reminder that in this market, the vendor’s stability is part of the feature list.

8. Autocomplete and Inline Suggestions, Compared

Autocomplete is where all four tools began, and it is still the feature you will use most often, because it is the one that fires dozens of times an hour without you asking. The differences between the four are smaller here than anywhere else in this comparison — and they are still worth knowing, because autocomplete is also where a bad tool costs you the most time in small, irritating amounts.

GitHub Copilot defined the pattern: as you type, it suggests the next chunk of code, sometimes a whole function, and you accept with a keystroke or keep typing to dismiss it. Its next-edit suggestions go a step further, predicting the edit you are about to make rather than just the next line. On paid plans, completions are unlimited and do not consume AI credits — GitHub says so explicitly — which means the cheapest tier of Copilot gives you the full autocomplete experience without metering. The free tier is the exception: 2,000 completions a month, after which the suggestions stop. Copilot works in the widest range of editors of the four — VS Code, Visual Studio, JetBrains IDEs, Xcode, Vim, Neovim, Zed, and Eclipse — so if your editor is unusual, Copilot is the safest bet for autocomplete alone.

Cursor’s version is called Tab, and it predicts not just the next line but the next edit, including where your cursor is heading — a small difference that matters in practice, because a good Tab suggestion can complete a refactor across a few lines while you are still thinking about it. Tab is unlimited on Devin Desktop’s free plan, and Cursor’s free tier includes limited Tab use within its limited agent and chat requests. Claude Code, being a terminal agent first, is the weakest of the four at inline completion: its VS Code extension offers inline diffs rather than ghost-text suggestions, and if you want Copilot-style completion inside VS Code while using Claude Code, you will find yourself running two tools. That is not a flaw — it is a consequence of the design. Claude Code is built to take tasks, not to finish your sentences. For how these suggestions are generated in the first place, see our plain-language guide to how AI works — the short version is that the model is predicting the most likely next text, not understanding your program the way you do, which is why every suggestion deserves a glance before you accept it.

The practical advice is simple: if autocomplete is the feature you will use most — and for most developers, it is — judge it by trying it in your own codebase for a week, not by reading about it. All four free tiers let you do exactly that. Watch for two things: whether the suggestions match your project’s conventions, and whether you find yourself accepting without reading. The second is a habit worth breaking no matter which tool you choose.

9. Agent Mode: Who Actually Finishes a Multi-File Task

Agent mode is the feature that separates the 2026 generation of coding assistants from the autocomplete tools of 2023, and it is where the four tools differ most. An agent does not just suggest the next line: it takes a task in plain language, plans the work, edits files, runs commands, checks the results, and comes back with a summary. The question is not whether a tool has an agent — all four do — but how much you can hand over, and how much supervision the handover needs.

Claude Code is the most agentic of the four by design. Its whole product is the agent loop: plan, edit across many files, run the tests, fix the failures, report back. It can spawn sub-agents to work on different parts of a task in parallel, run background agents you watch from one screen, and keep working on a schedule while your computer is off, through cloud scheduled tasks. It is the only tool of the four whose primary interface is a conversation about tasks rather than a code editor, and that is its strength and its risk in the same package: give it a well-specified task and it will do a remarkable amount of work; give it a vague one and it will do a remarkable amount of the wrong work, quickly and confidently.

Cursor’s agent is built for the developer who wants to stay in the editor while the agent works. Its plan mode scopes a change before the agent starts, so you approve the plan rather than discovering it afterwards, and its cloud agents can keep working away from your machine. Copilot’s agent mode works inside VS Code, Visual Studio, JetBrains, Eclipse, and Xcode, and its cloud agent takes a GitHub issue and returns a pull request — the most integrated version of the idea for teams that already run their work through GitHub issues. Devin Desktop’s Devin Local is the local agent in the editor, and Devin Cloud agents run longer tasks away from your machine, managed from an Agent Command Center; the old Cascade agent was replaced by Devin Local in 2026, according to secondary reporting.

One warning applies to all four equally, and it is the most important sentence in this section: an agent’s output is a draft until you have reviewed it and the tests have passed. GitHub says it directly about Copilot — it is “not intended to replace developers”, and generated code deserves the same safeguards and diligence as any third-party code. The same is true of the other three, whether or not their vendors say it as plainly.

10. Code Review, Tests, and Debugging, Compared

Writing code is only half the job. The other half is checking it — reviewing changes, writing tests, and finding the bug — and the four tools differ in how much of that second half they take on.

Copilot’s review features are the most tied to the pull-request workflow. It reviews pull requests in GitHub, offers file-diff reviews inside code editors, and writes summaries of changes — what changed, which files were affected, and what a reviewer should focus on. For a team that reviews through pull requests, that is the review loop with the least friction: the AI’s comments arrive where the human review already happens. Agent mode and the cloud agent also run tests as part of their work, and the CLI can be asked to investigate a failing test from the terminal.

Cursor approaches review from the editor and from automation. Its documentation lists reviewing changes — inspecting diffs, running checks, catching problems before merge — as one of the core jobs, and its Bugbot is a dedicated AI code-review agent available on Premium and above, which reviews code and reports issues rather than waiting to be asked. That is a different shape from Copilot’s: review as a standing service, not a feature you invoke. Claude Code’s strength in this area is verification inside the agent loop: it writes tests, runs them, reads the failures, and fixes them, and its example workflow is literally “write tests for the auth module, run them, and fix any failures”. For debugging, its ability to trace an error through a codebase, identify a root cause, and implement a fix is the same loop applied to a symptom rather than a feature request — and it is the loop the tool is best at, because a failing test is an objective check the agent cannot argue with.

Devin Desktop’s review offering is the least documented of the four on the vendor pages read for this article: the pricing page lists AI code reviews as part of the platform, and Devin Review is one of the products on the shared plans, but the details of how review works in the editor were not verified on a vendor page in this session. If review automation is the feature you are buying for, check the current Devin documentation before paying.

11. Models Under the Hood: What Each Tool Lets You Run

Every coding assistant is, underneath, a way of reaching a language model — and the model matters, because the same task can be easy for one model and hopeless for another. The four tools take four different approaches to the model question, and the approach you prefer may decide the tool.

Cursor is the model supermarket. Its documentation publishes the full menu with context windows, and as read on 7 November 2026 it is the widest of the four: Claude’s Fable 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5; Google’s Gemini 3.1 Pro, Gemini 3.8 Flash, and Gemini 4 Argon; GPT-5.6 Luna, Sol, and Terra; Grok 4.5, 4.6, and 4.7; and Cursor’s own Composer 2.5 and Muse Wonder. Most offer up to 1 million tokens of context. The trade-off is cost: on Premium and above, third-party models are billed separately at API list price and do not draw from the plan’s usage pool, so the model you actually use can cost more than the subscription. And one secondary report says OpenAI models will leave Cursor on 12 November 2026 — the docs page still lists GPT-5.6 models today, so verify before buying if GPT access matters to you.

Claude Code is the single-vendor tool: it runs Claude models — Fable, Opus, Sonnet, Haiku — and nothing else through Anthropic’s own billing, although its CLI and editor extensions support third-party providers. The current API rates, read on Anthropic’s platform pricing page, are Sonnet 5.5 at $2 per million input tokens and $10 per million output tokens, Opus 5.5 at $4 and $20, Haiku 5.5 at $0.10 and $0.50 for prompts up to 100,000 tokens, and Fable 5.1 at $10 and $50. The practical consequence is a simple, legible trade-off: Haiku for high-volume simple work, Sonnet as the default, Opus when the task is hard enough to justify five times Sonnet’s output price, and Fable for the longest, hardest agentic work. All Claude 4.6 and later models include a 1-million-token context window at standard pricing. Our OpenAI API explainer sets out how per-token pricing works in general, and our guide to choosing an AI model walks through the same capability-against-cost trade-off from the user’s side — the logic transfers directly to picking a model inside any of these four tools.

Copilot and Devin Desktop sit between the two extremes. Copilot offers a choice of models, but GitHub says the options vary by plan and feature and change frequently, and this article names none. Devin Desktop’s Pro plan lists frontier models from OpenAI, Claude, Gemini, and SpaceXAI, plus leading open-source models and free use of Cognition’s own SWE-2. The lesson for buyers is to check the model menu on the day you buy, not the day you read about it.

12. Pricing Compared: What Your Money Buys in Each Tool

Pricing is where this comparison is most useful and most dangerous, because it is where the numbers are exact and the meaning of the numbers is not. All four tools sell a monthly subscription; all four then ration usage in a different way; and the rationing matters more than the headline price. Here are the numbers as read on 7 November 2026, all in US dollars per month, before tax.

GitHub Copilot: Free $0; Pro $10 per user; Pro+ $39; Max $100. The billing unit is the GitHub AI Credit, where 1 credit equals $0.01: Pro includes $15 of credits a month, Pro+ $70, Max $200. Agent mode, code review, the cloud agent, the CLI, and the app consume credits; chat consumes credits too. Code completions and next-edit suggestions do not consume credits and are unlimited on every paid plan — so the part of Copilot you use most is unmetered, and the part that costs money is the agentic work. The free tier gives 2,000 completions a month and entry-level models, with limited chat and agent usage. Business and Enterprise plans pool credits across the organisation with admin controls; GitHub did not make organisation seat prices clearly legible on the plans page in this session, so no team price is stated here.

Cursor: Free $0; Plus $8; Premium $30; Super $100; Ultra $200; Teams from $30 per user; Enterprise custom. One usage pool is shared across Cursor and Grok, the allowance refreshes weekly, and top-offs let you keep going past the allowance. Plus includes Grok models only; Premium gives four times Plus’s usage plus cloud agents, code hosting, Bugbot reviews, and third-party models at API list price billed separately; Super gives fifteen times Plus’s usage and priority access; Ultra gives fifty times Plus’s usage and earliest access. Annual billing takes 20% off, according to secondary reporting. Note the trap: the $8 Plus plan looks like the cheapest paid tier in this comparison, but it buys Grok models only — if you want Claude or GPT models, you are paying $30 for Premium plus the API cost of the third-party models you actually use.

Claude Code: there is no Claude Code price, because it is included in the Claude plans — Pro $20 a month ($17 on annual billing), Max $100 (five times Pro’s usage, $100 a month in API credits), Ultra $200 (ten times Pro’s weekly usage, no five-hour limit for verified accounts, $200 a month in API credits). The subscription covers chat and coding from one pool, and heavy sessions can switch to pay-as-you-go API credits. Enterprise is $20 per seat a month plus usage at API rates. The honest cost of Claude Code is therefore the cost of the Claude plan you need for your total usage, and a heavy coding week can consume the allowance you were saving for chat.

Devin Desktop (Windsurf): Free $0; Pro $20; Max $200; Teams $80 a month plus $40 per full developer seat; Enterprise custom. Pro includes frontier models, free SWE-2 use, and Devin Cloud agents; extra usage is billed at API pricing; quotas refresh daily and weekly, with no published numbers. The Teams price deserves a second look: at $80 plus $40 a seat, a five-person team pays $280 a month, against $150 for five Cursor Teams seats at $30 — Devin Desktop is the most expensive team option of the four on the numbers available.

The bottom line on price: Copilot Pro at $10 is the cheapest serious individual tier, and the only one where the most-used feature is unmetered. Cursor Premium at $30 is the cheapest route to a wide model menu, but third-party models cost extra. Claude Pro at $20 is the cheapest route to a genuine agent, and the only price that also buys a full chat subscription. Devin Desktop Pro at $20 matches Claude Pro on price but hides its quotas. Our comparison of ChatGPT’s tiers works through the same question — what each tier actually buys — for the subscription most readers already pay for, and the method transfers: ignore the headline, read what the allowance covers, and check what costs extra.

13. Privacy, Training Data, and Team Controls

An AI coding assistant reads your code. That sentence should make you pause, because your code may contain secrets, customer data, proprietary algorithms, and the kind of detail that would be embarrassing or expensive if it leaked. The four tools handle that responsibility differently, and the differences are worth more than a few dollars a month.

GitHub Copilot’s rule is the most clearly documented of the four, and the most uncomfortable. For individual subscribers, GitHub may use Copilot interaction data — prompts, suggestions, and code snippets from your sessions — to train and improve its models, and you can opt out at any time in your Copilot settings without losing access to features. For Business and Enterprise subscribers, the rules sit under GitHub’s Data Protection Agreement instead. Copilot also offers a public-code filter: in GitHub’s research, fewer than 1% of suggestions matched public code, and an optional code-referencing filter can detect and suppress suggestions that match public code. If you write proprietary code for a living, read the training rule, decide whether to opt out, and do it before your first session, not after your hundredth.

Cursor’s answer is privacy mode, and it is the strongest promise of the four: when privacy mode is enabled, in settings or by a team admin, Cursor guarantees that code data is not used for training by Cursor or by its model providers. That guarantee is stated on Cursor’s pricing page itself, which is the right place for it, because it is a buying criterion, not a footnote. Claude’s plans list model training as opt-out across all tiers, and its Enterprise plan adds the controls a large organisation expects: single sign-on, SCIM, audit logs, custom data retention, and role-based access. Claude Code’s project memory — CLAUDE.md and its auto-memory — is stored in your project, which means your conventions travel with the repository, and so does anything the agent learned about it.

For Devin Desktop, the training-data terms were not verified on a vendor page in this session, and this article states no rule for it — if your code is sensitive, check Cognition’s terms before you sign in. Team controls are a separate question from training, and here the ranking is clearer: Copilot’s Business and Enterprise plans give administrators control over access, feature policies, file exclusions, usage data, and audit logs, with pooled credits and the ability to pause usage at a limit; Cursor’s Teams and Enterprise plans give centralised billing, usage analytics, team-wide privacy settings, custom data retention, SSO, and granular spend controls; Claude’s Enterprise plan gives the same class of controls; and Devin Desktop’s Teams plan gives centralised billing and an admin dashboard. If you are choosing for a team, buy the team plan — or do not buy at all.

14. Verdict by Developer Type

The solo developer on a budget: GitHub Copilot Pro at $10 a month. It is the cheapest serious tier, its completions are unmetered, it works in the editor you already have, and its agent mode is good enough for most multi-file work. Start here unless you have a specific reason to go elsewhere.

The professional who lives in the editor all day: Cursor Premium at $30 a month. The editor is the product, the plan mode keeps the agent honest, the model menu is the widest available, and Bugbot adds review as a standing service. Budget for third-party model costs on top, and check the model menu on the day you buy — it changes fast, and one secondary report says OpenAI models may leave on 12 November 2026.

The developer who wants to delegate whole tasks: Claude Code, through Claude Pro at $20 a month. Nothing else in this comparison is as good at taking a ticket, doing the work, running the tests, and reporting back. The price is really the price of a Claude plan, and the skill you need is management: write clear tasks, write down your conventions, and review every diff. If you cannot do those three things, Claude Code will disappoint you faster than any tool here.

The developer who wants local and cloud agents in one subscription: Devin Desktop Pro at $20 a month — with the free tier first. Unlimited Tab, frontier models, free SWE-2 use, and cloud agents are a genuinely useful combination, and $20 is a fair price for it. But go in knowing the quotas are unpublished, the name is six months old, and the company behind it is still digesting an acquisition. Try it for a week on real work before you pay.

The team choosing for everyone: Copilot, on a Business or Enterprise plan, unless your team has a specific reason to standardise on Cursor’s editor or Claude Code’s agent. Copilot’s GitHub integration, pooled credits, admin controls, and $10 starting price make it the easiest team decision to defend. Whichever you choose, pilot it with five developers for a month before rolling it out to fifty — the tool that wins a pilot is the one your team actually uses, and no comparison article can tell you which one that is.

That is the comparison. Four tools, four theories of where the AI should sit — inside your editor, as your editor, in your terminal, or in the cloud beside your editor. The right one is the one that matches how you already work, at a price you can predict, from a vendor you trust with your code. Start with the free tier, run your real work through it for a week, and let the tool earn the subscription.