If you're comparing Cursor, GitHub Copilot, and Sourcegraph Cody, start with a fact that invalidates most articles on this topic: Cody Free and Cody Pro no longer exist for individual developers. Sourcegraph discontinued both in July 2025.
That single change reshapes the comparison, and it's a useful illustration of how quickly this category moves. Any recommendation here — including this one — should be checked against the vendors' own pages before you commit a team to it.
In roughly eighteen months: Cody's individual plans were discontinued, GitHub replaced Premium Request Units with AI Credits (1 June 2026), and Cursor restructured its plans more than once. Any article stating precise prices for these tools is one billing announcement from being wrong. This one deliberately describes pricing models rather than quoting figures that expire. Check Cursor's pricing and GitHub Copilot's plans for current numbers.
What happened to Cody
Sourcegraph announced changes to Cody's plans with a clear timeline:
- 25 June 2025 — new signups for Cody Free and Cody Pro stopped.
- 23 July 2025 — Cody Free, Cody Pro, and Cody within Enterprise Starter were discontinued.
Cody Enterprise remains fully supported and actively developed. Sourcegraph pointed individual users toward Amp, its agentic coding tool, offering transition credits to existing Cody users.
So if you're an individual developer, Cody isn't an option — you're choosing between Cursor, Copilot, Amp, and a wide field of others. If you're an enterprise already running Sourcegraph for code search, Cody Enterprise is very much still on the table, and its integration with Sourcegraph's code intelligence remains its distinguishing feature.
This is worth dwelling on for a moment. Cody was, by most accounts, a capable tool with a genuinely generous free tier — and it was withdrawn from individuals with a month's notice. That's the risk profile of this entire category right now. Build a workflow around a vendor's free tier and you're exposed to that vendor's business model changing.
The three tools today
GitHub Copilot
Copilot is the most widely deployed assistant and the most conservative in design. It integrates into editors you already use — VS Code, Visual Studio, JetBrains, Neovim, Xcode — rather than asking you to adopt a new one.
Its capabilities now span inline completion, chat, and agent mode, which reached general availability on VS Code and JetBrains in March 2026. Agent mode plans multi-step tasks, edits across files, runs terminal commands, reads the output, and iterates.
Copilot's structural advantage is GitHub itself: code review on pull requests, integration with issues, and a coding agent that works against your repositories. If your organisation lives in GitHub, Copilot is the option with the least friction and the shortest procurement conversation.
Billing model: a free tier with capped completions and chat requests, then paid individual and business tiers. On 1 June 2026 GitHub replaced Premium Request Units with AI Credits, moving from counting requests to billing on token usage. Base plan prices were held at the transition. The practical implication: your cost now scales with how much context you consume, so heavy agent use on large files costs more than autocomplete.
Cursor
Cursor is a VS Code fork rebuilt around AI. Because it controls the editor, it can do things an extension can't — its own inline diff UI, its own indexing, its own multi-file agent flow.
The features people actually cite are Tab (multi-line, multi-location completion that predicts your next edit rather than just finishing the line) and Agent/Composer for multi-file changes. It also supports MCP, hooks, and cloud agents on paid tiers.
Being a VS Code fork means your extensions, keybindings, and settings mostly carry over — the switching cost is low. The counterpoint is that you're now on a fork, which trails upstream VS Code and puts your primary editor in the hands of one company.
Billing model: a free tier, then several individual tiers escalating to a high-end plan for heavy agent users, plus team plans. Cursor has iterated on this repeatedly, including a shift toward credit pools spanning first-party and third-party models. If your team runs agents continuously, model the cost before you standardise — this is where surprise bills happen.
Sourcegraph Cody
Cody's premise was always context: Sourcegraph built code search across enormous codebases, and Cody uses that index to answer questions about code the model has never seen.
For enterprises with millions of lines across many repositories, that's a real differentiator. Asking "how is authentication implemented in this monorepo?" and getting an answer grounded in an actual index — rather than whatever files happened to be open — is the problem Sourcegraph is built to solve. Cody Enterprise also supports self-hosted deployments for organisations that require it.
Availability: Enterprise only. Individuals are directed to Amp.
The axis that actually matters: context
Most comparisons focus on completion quality. In practice, models converge — all three can call the same frontier models, and a general-purpose model's raw ability to write a React component is roughly a constant across tools.
What differs is which code the tool puts in front of the model. That's the engineering, and that's where these products genuinely diverge:
- Copilot uses open files, workspace indexing, and explicit references (
@workspace, file mentions). Solid, predictable, tied to what you're working on. - Cursor indexes your codebase and does its own retrieval, with rules files to pin project conventions into every request.
- Cody leans on Sourcegraph's code graph — the strongest story for very large, unfamiliar codebases.
A tool that finds the right three files beats a better model looking at the wrong ones. If you take one thing from this comparison, take that.
Judge these tools on retrieval, not on model quality. They can all call strong models. The difference is whether the tool identifies the relevant code in a repository you don't know by heart — which is why the right answer depends heavily on your codebase's size and shape, not on a leaderboard.
Honest trade-offs
Agent mode is impressive and needs supervision
All three vendors now ship agents that edit across files and run commands. They genuinely work for well-specified tasks. They also produce large diffs quickly, and a large diff is one you're tempted to skim.
The bottleneck moves from writing code to reviewing it — and reviewing code you didn't write is slower and less pleasant than reviewing code you did. Teams that don't plan for this find velocity gains evaporating into review queues. Keep tasks scoped so diffs stay reviewable.
Autonomy that runs commands is a security surface
An agent that runs terminal commands can install packages and modify files. Combined with the possibility of prompt injection through repository content or fetched web pages, this is a real attack surface. Understand what your tool executes without asking, and be deliberate about auto-approval settings.
Vendor risk is not hypothetical
Cody's withdrawal from individuals is the proof. This category is consolidating, pricing models are unsettled, and companies are being acquired and restructured. Prefer tools that don't require rewriting how you work, and be wary of deep dependence on any single vendor's free tier.
Privacy defaults deserve a real look
All of these process your code on remote servers by default. Each offers some form of privacy or zero-retention mode, and enterprise tiers offer stronger contractual guarantees; Cody Enterprise supports self-hosting. If you're on a proprietary or regulated codebase, read the actual data-handling terms rather than the marketing page — and get it past your security team before, not after, a rollout.
What the comparison tables miss
Three factors matter more than any feature grid, and none of them show up in one.
Your codebase shapes the answer more than the tool does. A tool that shines on a modern TypeScript monorepo with clean module boundaries may struggle on a decade-old codebase with implicit conventions and sparse tests. Retrieval quality depends on how legible your code is to an indexer. This is why colleagues give contradictory recommendations in good faith — they're working on different codebases.
Latency changes behaviour. A completion arriving in a fraction of a second gets used; one that takes three seconds gets ignored, because you've already typed the line. This is why raw model capability and practical usefulness diverge: a smaller, faster model you actually accept can beat a stronger, slower one you talk over.
Configuration is a real cost. Rules files, context settings, and MCP servers meaningfully improve results — and someone has to write and maintain them. Tools that work well out of the box have an advantage that benchmarks never capture.
Choosing
Choose GitHub Copilot if your team is on GitHub, you want the least disruption, you value mature tooling across many editors, or you need the shortest path through procurement. It's the safe default, and "safe default" is a legitimate reason.
Choose Cursor if you want the most integrated AI-native editing experience, you do a lot of multi-file work, and you're comfortable making a fork your primary editor. Model the cost if you plan to run agents heavily.
Choose Cody if you're an enterprise with a large, complex codebase — especially if you already run Sourcegraph. It isn't available to individuals.
Consider the wider field. This isn't a three-horse race any more. Amp, Claude Code, Windsurf, Zed, Aider, and Continue all occupy real niches — including terminal-based and fully open-source options that avoid the editor-lock-in question entirely.
How to actually evaluate them
Don't take anyone's word for it, including this article. The tools change monthly, and the only relevant question is how one performs on your codebase.
- Use your real repository. Performance on a greenfield to-do app tells you nothing about a ten-year-old monolith.
- Try a task you understand deeply. You need to be able to judge whether the output is right, which means picking something you could have done yourself.
- Include a task on unfamiliar code. This is where retrieval quality shows, and where the tools genuinely differ.
- Watch the review burden, not the writing speed. Time-to-merged-PR is the metric that matters. Time-to-first-draft is not.
- Check the data terms before rollout, not after.
- Give it a week. These tools have a learning curve, and first-hour impressions mostly measure familiarity.
Most offer a free tier or trial, so evaluation costs time rather than money. That week is worth more than any comparison table — including this one.
