- In our own keyword data the term went from 660 monthly searches to 14,800 in eleven months, at a difficulty of 0. A category forms when people need a word to compare things with.
- Five questions decide the pick: where it runs, whether it can run what it wrote, what it does when the repo exceeds the context window, the real per seat cost, and its behaviour when wrong.
- The execution question splits the field harder than model quality does. A tool that can run your tests and read the failure is doing a different job from one that suggests text.
- Every tool solves the oversized repository differently. Aider ranks a dependency graph, Gemini leans on a large context window, and agentic tools search on demand.
- Per seat list prices on 28 July 2026 ran from $10 to $200 a month for individuals, with team tiers at $19, $39, $40 and $120.
- Usage allowances now matter more than the sticker price, because every major vendor has moved to a credit pool on top of the seat.
Six hundred and sixty. That is how many people searched for this category term monthly in our keyword data eleven months ago. Today it is 14,800, at a keyword difficulty of 0, which is the lowest we have measured on any term with that volume. Nobody has planted a flag on the comparison, because the category was still forming while everyone was arguing about models.
That is the situation you are in if your team is about to standardise on one tool and someone has to defend the choice to whoever signs the invoice. Model quality is the wrong axis to defend it on, because every vendor now routes to several models and the rankings change monthly. The same holds when you are choosing the best LLM for coding on price, context cliffs and harness fit rather than on a leaderboard row. The things that do not change monthly are architectural, and there are five of them.
The five questions that actually decide it
Ask these in order. Each one eliminates options, and by the fifth you usually have one or two candidates rather than a shortlist of eight.
- Where does it run? Editor, terminal, browser, continuous integration, or several. This is a workflow constraint, not a preference.
- Can it run what it wrote? A tool that executes tests and reads the failure is doing a categorically different job from one that emits text you paste.
- What does it do when the repository is bigger than the context window? Every real codebase is. The answers differ more than the marketing does.
- What does a seat cost, including usage? The seat price stopped being the price when vendors added credit pools.
- What does it do when it is wrong? Silent confidence and a visible diff are different products.
Everything below fills those in from each vendor's own documentation, checked on 28 July 2026. Prices and features in this space change often enough that you should re-check any figure you intend to put in a budget.
Where does each one run?
Surface area is the constraint people underestimate, because it determines who on the team can actually use the thing. An editor extension is invisible to anyone reviewing a pull request. A terminal tool is invisible to anyone who does not live in one. A browser environment that also hosts what it built moves the question from where you type to where the code lives and who holds the deploy.
Anthropic's Claude Code documentation lists the widest surface set: a terminal CLI, a VS Code extension, a JetBrains plugin, a desktop app, and the web, with the note that each surface connects to the same engine so configuration files and MCP servers carry across. It also documents scheduled runs on managed infrastructure that continue when your machine is off, plus continuous integration paths through GitHub Actions and GitLab.
Copilot's centre of gravity is the editor. The VS Code feature reference describes an agent mode that loops over steps, offering both code changes and terminal commands, compiling, installing packages and running tests inside the editor session. Cursor is an editor in its own right, a fork of VS Code, so the assistant and the environment are the same product. Gemini Code Assist covers VS Code, JetBrains IDEs, Android Studio, Cloud Shell Editor and Cloud Workstations, which is the widest Google Cloud footprint and the narrowest reach outside it. Aider is terminal only, and open source.
Can it run what it wrote?
This is the question that separates the field, and it is worth being precise about what execution buys you. A tool that can run your test suite gets a ground truth signal that no amount of model quality substitutes for. It stops guessing whether the code works and starts knowing.
VS Code's documentation on agent mode is explicit that a single user turn can trigger many rounds where the model searches files, reads code, edits, runs tests, reads the output and iterates on failures, with every tool invocation shown in the interface and terminal commands gated behind approval. Claude Code's overview describes the same shape from the command line, including the pattern of asking it to write tests, run them and fix what fails in a single instruction.
The approval gate is the part to look at during a trial rather than the capability. Any tool that runs commands on a developer machine needs a permission model your team can live with, and the two ends of that spectrum are approve every command, which is safe and exhausting, or approve a session, which is fast and requires trust. Teams that skip this discussion discover their position on it during an incident.
What happens when the repo is bigger than the context window?
Always, in other words. A million line codebase does not fit in any context window on the market, so every tool has a strategy, and the strategies are genuinely different rather than differently branded. The other half of that problem is what you feed in deliberately, which is the argument for writing a specification the agent works from instead of a chat message.
Aider publishes the most legible one. Its repository map documentation describes building a map of the whole git repository with tree-sitter, extracting the classes and functions with their signatures, then ranking that graph so only the most relevant portion is sent. Files are nodes, dependencies are edges, and the map is trimmed to fit the active token budget. When the model needs more, it asks for specific files by name.
Gemini Code Assist takes the opposite route, described in its overview as local codebase awareness that leans on a large context window for in-depth understanding. That documentation does not state a maximum codebase size, which is worth knowing before you assume there is not one.
The agentic tools take a third path: search on demand. Rather than pre-computing a map or loading everything, they grep, read the files that matched, and discard what turned out to be irrelevant. That scales to any repository size and costs a turn every time it guesses wrong about where to look.
None of these is best in the abstract. A ranked map is excellent on a codebase with clean module boundaries and misleading on one where everything imports everything. On-demand search is robust to bad structure and slower on it. This is the axis where a one week trial on your actual repository tells you more than any benchmark, and it is the reason benchmark scores like the ones we broke down in our explainer on what SWE-bench Verified measures travel so poorly to real work.
What does a seat really cost?
Two numbers now, not one. Every major vendor charges for a seat and then meters usage on top, so a team of ten does not cost ten times the sticker price if half of them run agents all day.
These are list prices from the vendors' own pages, checked on 28 July 2026.
| Tool | Individual tiers, per month | Team or business, per seat per month | Usage model on top |
|---|---|---|---|
| GitHub Copilot | Free, Pro $10, Pro+ $39, Max $100 | Business $19, Enterprise $39 | Monthly AI credit allowance per plan, pooled at organisation level |
| Cursor | Hobby free, Pro $20, Pro+ $60, Ultra $200 | Teams Standard $40, Teams Premium $120 | Included third party model spend, $20 on Pro up to $400 on Ultra |
| Claude Code | Requires a Claude subscription or Console account | Sold through the Claude plan, not a separate seat | Terminal and VS Code also accept third party providers |
| Gemini Code Assist | Standard and Enterprise editions | Per user per month licence, monthly or annual term | Figure not verifiable on the public pricing page at time of writing |
| Aider | Free, open source | Free | You pay the model provider directly for every token |
Two honest caveats about that table. The Gemini row is incomplete because the Google Cloud pricing page did not render a figure we could quote on the date above, and we would rather leave a gap than print a number from a blog post. The Aider row looks like the cheapest option and often is not, because paying a provider directly at retail token rates can exceed a $20 seat within a week of heavy use.
The structural point matters more than any individual price. Copilot's plans documentation describes credit allowances attached to each tier, and Cursor's pricing page describes included model spend that scales from $20 on Pro to $400 on Ultra. Both are consumption pricing wearing a subscription costume. Budget the usage separately or your first invoice will teach you the lesson instead.
What does it do when it is wrong?
Rarely discussed, and the thing your team will complain about in month two.
Three behaviours matter. Whether you see a diff before the change lands, whether you can undo cleanly after several changes, and whether the tool tells you it failed or narrates a success it did not achieve. The first two are documented features you can check. VS Code's reference describes rich undo alongside transparent display of every tool invocation. Claude Code's VS Code extension is documented as providing inline diffs and plan review, and its desktop app is described as a place to review diffs visually.
The third behaviour is not a feature and no vendor documents it, so you have to measure it. Run a task you know is impossible on your codebase, something that requires a service that does not exist, and watch what the tool does. The good outcome is that it says so. The common outcome is a confident summary of work that did not happen. That five minute test discriminates between tools better than any benchmark on any leaderboard.
The comparison, in one table
Every cell here comes from the vendor's own documentation, read on 28 July 2026, with the sources linked above.
| Axis | Claude Code | GitHub Copilot | Cursor | Gemini Code Assist | Aider |
|---|---|---|---|---|---|
| Primary surface | Terminal, plus IDE, desktop and web | Editor, plus a cloud agent | Its own editor, a VS Code fork | Editor, across the Google Cloud toolchain | Terminal only |
| Runs commands and reads the result | Yes, documented as edit, run, verify | Yes, agent mode loops and iterates on failures | Yes, agent with cloud agents on paid tiers | Assistance across the lifecycle, IDE centred | Yes, within the terminal session |
| Oversized repository strategy | Search on demand plus persistent project instructions | Workspace search and file reading via tools | Editor indexing plus agent search | Large context window with local codebase awareness | Ranked repository map built with tree-sitter |
| Cheapest paid individual tier | Bundled with a Claude subscription | $10 Pro | $20 Pro | Standard edition, per user licence | Free, you pay the model provider |
| Team seat | Via the Claude plan | $19 Business, $39 Enterprise | $40 Standard, $120 Premium | Per user per month, monthly or annual | None to buy |
| Extensible with your own tools | MCP, skills, hooks, Agent SDK | MCP support in agent mode | MCP support | Google Cloud integrations | Open source, edit it yourself |
| Best fit | Teams automating repeatable work across surfaces | Teams already living inside GitHub | Developers who want one editor that does everything | Shops standardised on Google Cloud | Individuals who want control and their own model keys |
Why extensibility became a real axis
Because the interesting work is rarely inside the repository. It is in the ticket system, the design document, the staging database and the error tracker, and a tool that cannot reach those is guessing about half the problem.
The reason this is now comparable rather than proprietary is that the connection layer standardised. Every tool in the table above except the open source one supports the Model Context Protocol, which means a server you write once is usable from several assistants. That changes the switching cost calculation substantially: the integration work you do stops being an investment in one vendor.
If you are evaluating on this axis, build one small server for your own systems before the trial rather than after, and point every candidate at it. Our walkthrough of setting up an MCP server covers the primitives and the local test loop, and our overview of what MCP makes possible covers why the standard exists. A candidate that struggles with your own server is telling you something a demo never will.
What the growth curve tells you
Here is what our keyword tracking shows for this space, measured while writing this piece.
| Term | Monthly searches, our data | Difficulty | What it signals |
|---|---|---|---|
| ai coding assistant, eleven months ago | 660 | Not measured then | A phrase used mostly by people already inside the tooling |
| ai coding assistant, today | 14,800 | 0 | Mainstream demand with nobody established on the comparison |
| Growth multiple | Roughly 22 times | Not applicable | Category formation rather than a seasonal spike |
| Difficulty comparison | Lowest we have measured at this volume | 0 | The question is being asked faster than it is being answered |
The practical read for a buyer is that most of the writing available on this comparison was published into a category that did not exist yet, by people describing tools they used for an afternoon. That is not a reason to distrust everything. It is a reason to weight vendor documentation over roundups, and your own week long trial over both.
How to run the evaluation in a week
Five days, one engineer, and a decision you can defend in writing.
On Monday, pick one real task from your backlog that touches at least three files and has a test that can fail. Not a toy, and not your hardest problem. Give the identical task to every candidate and keep the transcripts.
On Tuesday, run the impossible task described above and record what each tool does when it cannot succeed. Write down which ones said so.
On Wednesday, point every candidate at one of your own MCP servers and see which handle an unfamiliar tool without hand holding.
On Thursday, look at cost. Not the seat price, the actual consumption across three days of real use, extrapolated to your headcount. This is where a $10 plan and a $40 plan can invert.
On Friday, write one page. The task, the five axes, what each tool did, and the recommendation. Anyone approving spend can read that. Nobody can read a feature matrix copied from a marketing site, which is what most of these decisions get justified with.
Whatever you pick, write the team's permission policy down on day one. Which commands the tool may run without asking, which repositories it may touch, and what happens to credentials in the environment it runs in. That document ages better than the tool choice, and you will reuse it when you switch.
The short version
If your work already lives in GitHub, Copilot is the least friction at the lowest paid entry point. If you want one environment that does everything and you accept switching editors, Cursor is the coherent choice. If you want the widest surface coverage and the ability to automate repeatable work outside an editor, Claude Code's documented surface list is the broadest we found. If your organisation is standardised on Google Cloud, Gemini Code Assist reaches into places nothing else does. If you want control and your own model keys, Aider is free and its repository map is the most transparent approach to large codebases in the group.
None of that survives contact with your codebase without a trial, which is the honest conclusion of any comparison written from documentation. The five axes are what make the trial short. Costs are the part to model most carefully, and if you are sizing what generated code costs per project rather than per developer, our plans and credits breakdown shows the other way of paying for the same work.