Forget feature checklists. What matters is how each tool feels under real engineering work — the kind I do every day as a senior software engineer at Meta. I built this site primarily with Claude Code, but I’ve put serious hours into the others.
What I Evaluated #
Five things matter in an AI coding tool:
- Context understanding — Can it reason about your whole project, or just the open file?
- Autonomy — Can it execute multi-step tasks, or does it need hand-holding?
- Code quality — Does it generate production-ready code, or prototyping-quality code?
- Speed — How fast is the feedback loop from prompt to working code?
- Cost — What are you actually paying per month, and what does it get you?
Each tool occupies a different niche.
Claude Code #
Agentic Full-project context Multi-surface
Claude Code is no longer terminal-only. It runs as a CLI, a VS Code extension, a JetBrains plugin, a Mac/Windows desktop app, a web app at claude.ai/code, and on iOS. The conversation moves between surfaces — start a task in your terminal, hand it off to your phone, finish in the desktop app.
What sets it apart: agentic workflow plus the extensibility model. Claude Code creates files, runs commands, executes tests, iterates on results. Plan Mode lets you review a multi-step approach before any code gets written. And the ecosystem around it — Skills (loadable markdown procedures), Subagents (isolated contexts for parallel work), MCP servers (external tool access), Plugins (bundles of all of the above), Hooks (deterministic event triggers) — makes it a customizable engineering harness rather than a single chat product.
The CLAUDE.md convention is still the highest-leverage feature. Drop a file describing your project’s architecture, conventions, and constraints into the repo root, and every session starts with that context loaded. The onboarding doc your AI pair programmer actually reads.
Where it shines:
- Full-stack projects touching config, code, CI, and content
- Scaffolding new features or migrating between frameworks
- Any task that requires understanding the project as a whole
- Workflows you want to package and share — Skills make procedures reusable across projects
Where it’s weaker:
- Inline editing within a file — you’re working at the conversation level, not the cursor level
- Discovery: the feature surface (skills, subagents, plugins, hooks, MCP) is large enough that newcomers can miss the right tool for the job
- Tight inline-diff IDE workflows feel less native than in Cursor or Copilot
Cost: Tied to your Anthropic API usage or Claude Pro/Max subscription. The Max plan gives the most predictable spend for heavy agentic use.
Cursor #
VS Code fork Inline editing Agent mode
Cursor is a fork of VS Code with AI integrated directly into the editor. Inline completions, a chat sidebar, code selection with diff previews — all inside the familiar VS Code interface.
What sets it apart: structured control over inline edits. Highlight a function, ask for a refactor, see a diff preview before accepting. Composer handles multi-file edits with a UI that shows every change across your project. Agent mode layers autonomous multi-step work on top — terminal commands, file creation, iterative debugging. Closer to what Claude Code does, but inside the editor.
Where it shines:
- Focused refactoring within a known codebase
- Visual diff review before accepting changes
- Teams already on VS Code — zero workflow disruption
- Tab completion that’s genuinely fast and context-aware
Where it’s weaker:
- Cross-cutting concerns spanning dozens of files still favor a true agentic terminal flow
- “Auto mode” picks the model for you; reaching for a specific frontier model burns your credit pool
- Extension ecosystem is less mature than Claude Code’s Skills/Plugins surface
Cost (May 2026):
- Hobby (free) — strict caps, evaluation only
- Pro ($20/mo) — $20 in usage credits, unlimited tab completions, unlimited Auto mode
- Pro+ ($60/mo) — 3x the usage credits
- Ultra ($200/mo) — 20x usage multiplier, priority feature access
- Business ($40/seat/mo) — Pro plus admin controls and shared team rules
The old “unlimited everything for $20” framing is gone. Premium-model requests now draw from a credit pool.
GitHub Copilot #
Autocomplete IDE extension Ubiquitous
Copilot was the first mainstream AI coding tool and remains the most widely adopted. It runs as an extension in VS Code, JetBrains, and Neovim (I have it wired into my LazyVim setup). The core experience is inline autocomplete: you type, it predicts what comes next.
What sets it apart: autocomplete speed. Copilot’s tab-completion is fast and context-aware enough that it often finishes your thought correctly. For boilerplate, test cases, repetitive patterns — it saves keystrokes every minute.
Copilot Chat and the cloud agent have layered more agentic capability on top. Autocomplete is still the core value. The Business plan now bundles the cloud agent for organization-wide policy control.
Where it shines:
- Writing code in your editor with fast inline suggestions
- Boilerplate and repetitive patterns (test scaffolding, CRUD operations)
- Codebases you know well where you just need to type faster
- Broad language support across practically every editor
Where it’s weaker:
- Context understanding beyond the current file is still its weakest dimension
- Multi-file tasks need more manual orchestration than the agentic tools require
- Chat quality lags dedicated agent products for nuanced reasoning
- Will confidently suggest plausible-looking but incorrect code
Cost (May 2026): GitHub split Copilot into five tiers.
- Free — limited completions
- Pro ($10/mo) — includes $10 in AI Credits
- Pro+ ($39/mo) — includes $39 in AI Credits, premium model access
- Business ($19/user/mo) — adds the cloud agent and policy controls
- Enterprise — tied to GitHub Enterprise Cloud
Heads up Starting June 1, 2026, all plans move to usage-based billing. Every request will draw from your monthly AI Credit allotment instead of counting against unlimited premium requests.
Windsurf #
Agentic IDE Cognition-owned Cascade
Windsurf had a wild 2025. OpenAI tried to buy it for $3B; the deal collapsed. Google then paid roughly $2.4B to license its tech and hire away the CEO plus around 40 top engineers. In December 2025, Cognition AI (makers of Devin) acquired what remained for approximately $250M and started folding Devin’s autonomous agent capabilities into the product.
The product came out the other side stronger than the chaos suggested. As of early 2026, Windsurf was ranked #1 in the LogRocket AI Dev Tool Power Rankings — ahead of both Cursor and Copilot — driven by its Cascade agent flow and the tight loop between autonomous edits and human review. The Codemaps feature visualizes what the agent is touching across your codebase before it commits.
Where it shines:
- Long-running autonomous tasks where you want to step in only at decision points
- Enterprise teams attracted to the Devin integration story
- Visual project-level reasoning via Codemaps
Where it’s weaker:
- Brand whiplash — the product has changed hands twice in a year, and the roadmap reflects that
- Pricing tightened in 2026; the previously generous free tier now hits paywalls fast
- Smaller community than Cursor or Copilot
Cost: Free tier with limits, paid plans starting around $15/month. Enterprise pricing on request.
Honorable Mentions #
Other tools worth knowing about:
- v0 (by Vercel) — Specialized for generating React/Next.js UI components from descriptions. Great for frontend prototyping; not a general coding tool.
- bolt.new — Browser-based full-stack app generator. Useful for quick demos, weaker on production codebases.
- Aider — Open-source terminal-based coding assistant. Less polished than Claude Code, fully customizable, strong community.
- Zed AI — Zed editor’s built-in AI features. Lightweight if you already live in Zed.
Comparison Table #
| Feature | Claude Code | Cursor | Copilot | Windsurf |
|---|---|---|---|---|
| Interface | CLI + IDE + desktop + web | VS Code fork | IDE extension | VS Code fork |
| Primary mode | Agent + conversation | Inline edit + Agent | Autocomplete + chat | Agent (Cascade) |
| Project context | Full codebase | Open files + indexing | Current file + neighbors | Full codebase + Codemaps |
| Can run commands | Yes | Yes (Agent mode) | Limited (cloud agent) | Yes |
| Plan before code | Yes (Plan Mode) | Partial | No | Yes (Cascade preview) |
| Multi-file edits | Yes (agentic) | Yes (Composer) | Manual | Yes (Cascade) |
| Extension model | Skills/Plugins/MCP/Hooks | Rules + MCP | Limited | MCP |
| Best for | Full-stack projects | Focused refactoring | Fast inline coding | Long-running autonomy |
| Learning curve | Moderate | Low | Low | Low-moderate |
| Price | API / Pro / Max | $0 / $20 / $60 / $200 | $0 / $10 / $39 / $19 (biz) | $0 / ~$15+ |
My Recommendation: Different Tools for Different Jobs #
No single “best” tool. The right one depends on the shape of the work.
flowchart TD
A[What are you doing?] --> B{Scaffolding or
cross-cutting work?}
A --> C{Focused refactoring
in an editor?}
A --> D{Inline autocomplete
while typing?}
A --> E{Long autonomous
tasks with check-ins?}
B -->|Yes| F[Claude Code]
C -->|Yes| G[Cursor]
D -->|Yes| H[Copilot]
E -->|Yes| I[Windsurf]
F --> J[Full-project reasoning,
multi-step tasks, Skills/Plugins]
G --> K[Precise edits, visual diffs,
Composer for multi-file]
H --> L[Fast completions,
boilerplate, stay in editor]
I --> M[Cascade agent flow,
Codemaps, Devin integration]
The tools aren’t mutually exclusive. I run Copilot in Neovim for daily autocomplete. For scaffolding or complex migrations, I switch to Claude Code in a tmux pane. A VS Code-native engineer doing focused refactoring would reach for Cursor. Enterprise teams wanting long-running autonomous tasks with a review checkpoint at every step are the natural fit for Windsurf.
What I Actually Use Daily #
My daily stack:
- Claude Code for project-level work — new features, blog posts, CI changes, anything that touches multiple files or needs reasoning about the project structure. Skills and Subagents handle the workflows I run repeatedly.
- Copilot in Neovim for inline autocomplete while writing code in my editor.
- Neither for architectural decisions, debugging subtle issues, or anything requiring deep domain knowledge. Faster to think through those myself.
The tools will keep blurring into each other. By 2027 I expect Cursor’s Agent mode, Windsurf’s Cascade, and Claude Code’s harness to look much more similar than they do today. What matters is the paradigm — agentic, inline, autocomplete — not the feature list that looks longest on a marketing page. Pick the one that matches how you actually work.
For a real-world look at how I use Claude Code on an actual project, see my vibe coding workflow post. For the bigger picture on what this means for engineering as a profession, read why vibe coding amplifies senior engineers.