I’ve used all three of the major AI coding tools in production over the past year. Not in toy projects — in actual work, the kind where getting something wrong costs real time. Here’s what I think, without the marketing framing.
The short version: they’re all useful, they’re all annoying in different ways, and the choice depends heavily on how you work rather than which one benchmarks best.
GitHub Copilot
Copilot is the baseline. It’s been around the longest, it’s integrated into almost every editor, and it does one thing very well: tab completion that’s smarter than autocomplete. You’re writing a function, you pause after the signature, and Copilot suggests an implementation. Sometimes it’s exactly right. Sometimes it’s close enough to accept and tweak. Sometimes it’s confidently wrong in a way that takes you longer to clean up than if you’d written it yourself.
The inline suggestion model trains you to be faster at reading code rather than writing it. You scan a suggestion, accept or reject, move on. For boilerplate-heavy work — data classes, CRUD endpoints, test setup, configuration — it saves real time. My rough estimate after about six months of daily use: it handles 30-40% of keystrokes on the kind of work where I know exactly what I want and I’m just translating that into code.
Where it frustrates me: it doesn’t understand your project. It understands syntax and common patterns. Ask it to implement something that requires knowing how your services interact, what your domain model looks like, or what conventions you’ve established — it guesses, and the guesses are generic. The chat feature helps (you can add context), but it’s still working with limited understanding of the codebase as a whole.
Copilot is the right tool if you want to stay in your existing editor with minimal disruption. VS Code, JetBrains, Neovim — it works well everywhere. The friction is low and the benefit is real.
Cursor
Cursor is a VS Code fork with AI baked deeply into the editing experience. The model it adds is called Composer, and Composer is where it gets interesting. You describe a change — “add validation to this form, use the same pattern as the existing fields” — and Cursor reads relevant files across the project, makes a plan, and proposes changes across multiple files at once. You review a diff and accept or reject.
This is a different capability than Copilot. It’s not finishing your sentences — it’s doing a chunk of work and showing you what it did. For refactoring, for adding consistent patterns across a codebase, for “make this look like that” tasks, Composer saves significant time. I’ve used it to add error handling to a dozen endpoints at once in a way that would have been tedious to do file by file.
The tradeoff: you’re using a fork, not VS Code proper. Extensions mostly work. The editing experience is close. But there are occasional rough edges, updates don’t always keep pace with VS Code releases, and some teams have concerns about a third-party fork having access to their code. Whether those concerns are proportionate is a judgment call.
The other thing Cursor does well is codebase chat. You can ask questions about your project — “where is authentication handled?”, “what does this function depend on?” — and get answers that are grounded in your actual code rather than generic language model knowledge. For onboarding to an unfamiliar codebase, I’ve found this more useful than the code generation features.
Claude Code
Claude Code is the one I’ve written about at length here, so I’ll keep this comparative. It’s a CLI, not an editor plugin. That’s a meaningful difference in how you use it.
The strength is agentic work: telling it what you want and letting it read files, write code, run commands, and iterate — all without you directing every step. For multi-file changes that require understanding how pieces fit together, Claude Code handles more complexity more reliably than either Copilot or Cursor in my experience. Plan Mode, where it maps out what it will do before touching anything, is genuinely useful for larger changes.
The weakness is that it’s not embedded in your editing flow the way the other two are. It lives in a terminal. You think in task-sized chunks rather than line-level suggestions. Some developers find this freeing. Some find it awkward. I use it for the “do a complete thing” tasks and use Copilot for the line-by-line typing assistance. They don’t really compete.
Cost is higher than Copilot for comparable usage because you’re burning more tokens per session — it reads a lot more context to do its work.
What Actually Improves With All Three
Code I already understand how to write. If I know exactly what the function should do, AI tools help me write it faster. The improvement is roughly proportional to how routine the task is and inversely proportional to how much project-specific context it requires.
Tests. Writing unit tests is the thing I’ve seen the most consistent improvement on across all three tools. Tests have a clear structure, a clear expected outcome, and a lot of patterns that are the same across projects. AI handles them well. I write fewer tests the hard way than I used to.
Code review assistance. All three can explain what a piece of code does, identify potential issues, and suggest improvements. This is less flashy than generation but quietly useful — especially for reviewing code written by someone else or code you haven’t touched in six months.
What Doesn’t Improve
The design decisions. What should this API look like? How should these components be separated? What’s the right level of abstraction? AI tools have opinions on these questions, but the opinions are based on common patterns, not your specific context. For decisions that matter, you’re still doing the thinking — the AI is just writing the result faster once you’ve decided.
Subtle bugs in complex logic. AI coding tools are much better at writing code than at spotting the kind of off-by-one error that only manifests in edge cases, or the race condition that only appears under specific timing. Don’t use them as a substitute for careful testing and code review.
The suggestion I’d give to someone starting out: use Copilot first. Get used to working with AI suggestions in your editor. Then try Cursor’s Composer for a refactoring task and see if the multi-file approach feels natural. Try Claude Code for a full feature build. You’ll find where each one fits your workflow.
The tooling is good. It’s also easy to overestimate how much of the actual work it does.