Claude Code vs Antigravity vs Cursor: an honest practitioner comparison.

Three different bets on the same problem

Every "AI coding tool" today is trying to solve the same job: take a problem expressed in natural language, write or change code, and verify the result. What separates them is the shape of the bet they place on how a developer should hold that work. Three shapes are competing for the desk in front of you in May 2026, and they could not be more different.

Claude Code bets on the terminal. One agent, one repo, one focused conversation. The surface is text, the controls are slash commands and hooks, and the sandbox is your shell. Anthropic shipped it in 2024 as a CLI for Claude users who already lived in their terminal, and it has stayed deliberately minimalist. There is no GUI dashboard, no Kanban of running tasks, no manager view. There is a prompt, a plan, and a tool loop.

Google Antigravity bets on supervision. It is a forked VS Code IDE (still in public preview as of May 2026) with two first-class views: an Editor view that looks roughly like Cursor, and a Manager view that is a Kanban board of agents working in parallel across tasks, branches, and even browsers. The default model is Gemini 3 Pro, but Claude Sonnet 4.5 and GPT-5 are also one click away. The premise is that the bottleneck is no longer "can the agent code" but "can a human keep track of three agents coding."

Cursor bets on familiarity. It is the one most teams already use. A forked VS Code IDE since 2023, Cursor has spent three years polishing the in-editor experience: Cursor Tab autocomplete, Composer for multi-file edits, Agent mode for autonomous tasks, and Background Agents that run cloud-hosted while you work. You get to keep your VS Code muscle memory, your extensions (mostly), and your keybindings, while gaining the AI surfaces. Models are Claude Sonnet 4.5, GPT-5, and Gemini 3 Pro, with Cursor's auto-router picking per task.

Three tools, three different theories of what a developer needs. None of them is wrong. They are answering different questions.

At a glance

If you only have ninety seconds, this is the set you are choosing from.

A capability matrix

The three-column comparison gives you the shape; the matrix below gives you the dimensions. Read it as "which tool is closest to what I need on each row," not as a scoreboard.

One thing the matrix flattens: the gap between "single agent" and "multi-agent" is bigger in feel than in features. Running three agents in parallel is genuinely a different way of working, and not every job benefits from it.

How to read the "lock-in" row

Lock-in is the row most often misread, so it deserves a sentence each.

• Claude Code is low lock-in because the surface is a CLI, prompts are plain text, and integrations go through MCP, which is an open spec. If you walked away tomorrow, your hooks and skills would survive as shell scripts and prompt files.
• Antigravity is medium because it is a forked IDE tied to a Google account, but the tasks you queue are mostly natural-language prompts plus diffs. The Manager view itself is the thing you would miss.
• Cursor is medium-high because Composer rules, Background Agent definitions, and the auto-router config all live inside Cursor's surfaces. Migrating off is doable, but it is not free.

Lock-in is rarely the deciding factor in week one, and rarely irrelevant in year two. Worth a moment of thought before you bet a team on any of them.

Where each one shines

The strongest case for each tool, written as if I were trying to convince a skeptical colleague.

Claude Code: the focused, scriptable agent

If your work is "one hard thing at a time," Claude Code is hard to beat. Plan mode lets you see what it intends before any file changes. Hooks let you enforce repo policy (run tests after every edit, block writes to certain paths, post a Slack message when a PR opens). Skills let you package recurring playbooks. And because the whole thing runs in your terminal, you can drop it into a CI job, a cron, or a git pre-push hook without inventing a new pattern. When I need an agent that does the thing and gets out of the way, this is the one I reach for.

Antigravity: when supervision is the bottleneck

The Manager view is the feature nobody else has built well yet. You queue four agents on four branches, watch the Kanban, glance at a browser walkthrough one of them captured, approve a diff, send another back with a comment. For migration work, codebase-wide refactors, or the kind of bug bash where you have a list of twelve issues that are all small but unrelated, parallel agents pay off. The artifacts surface (screenshots, browser recordings, structured outputs) is the part I did not expect to use and now miss in other tools.

Cursor: the editor your team will actually adopt

Adoption is half of any AI tool's value, and Cursor wins this race. It is VS Code with the AI seams in the right places. Cursor Tab catches you on the way to typing what you meant, Composer handles "change this thing across these files," and Agent mode handles longer autonomous runs. For a team that already uses VS Code, the migration cost is roughly zero. For solo work where you just want to be more productive in your editor without changing how you work, it is the lowest-friction choice on the list.

Where each one bites

The honest version. None of these tools is perfect, and the failure modes matter more than the demos.

Claude Code: the surface area is the cost

The thing that makes Claude Code powerful (hooks, MCP servers, subagents, skills, slash commands) is also the thing that makes it slow to onboard. The first week, you will write a hook that fires twice, configure an MCP server that returns the wrong shape, or wire a subagent that loops. There is no GUI to fall back on. If you do not enjoy reading docs and tweaking config files, the curve is real. And because there is no parallel-agent dashboard, "run three things at once" means three terminal panes you babysit yourself.

Antigravity: preview means preview

It is a Google product in public preview. Pricing is unannounced beyond the free preview window. Features land and move; the Manager view changed shape twice in the last quarter. The Chrome integration is genuinely powerful and genuinely scary: an agent that can open a browser tab, log in to a service, and click around is one misconfigured scope away from a bad day. You have to think carefully about which agents get which permissions, which is exactly the kind of thinking nobody wants to do at 11pm. I would not put it on critical-path work yet without a fallback plan.

Cursor: subscription, bandwidth, and the lock-in tax

Three real complaints from real users. First, the cost: $20/mo per seat sounds fine until you multiply by a team and add Business features at $40. Second, autocomplete bandwidth: Cursor Tab quality has wobbled with model changes more than once, and "the autocomplete got worse this week" is a recurring forum thread. Third, the proprietary parts: Composer and Background Agents are Cursor-specific surfaces. If you build your team's workflow around them and then want to leave, the migration is non-trivial. None of these are dealbreakers; all of them are real.

How I'd pick

The decision frame I actually use. Pick the row that fits and the answer falls out.

Can you use more than one

Yes, and most of the practitioners I trust do. The three tools overlap in capability but not in shape, and the overlap turns out to be cheap to manage.

Here is what my own week looks like in May 2026:

• Cursor is my editor. Open the project, write code, accept or reject Cursor Tab suggestions, use Composer for "change this across these five files." This is where 70% of the typing happens.
• Claude Code lives in a terminal split. When I need an agent to do focused work on a hard task (refactor a module, implement a spec, run a CI script and fix what it breaks), I drop into Claude Code, write a brief plan, and let it run. I trust its sandbox model more than I trust an in-editor agent for anything I have not personally reviewed.
• Antigravity comes out for parallel jobs. Migration weeks, large bug-bash sessions, anything where I genuinely have four independent tasks I want running while I do something else. The Manager view earns its keep on these days and sits idle on the others.

Is there overlap? Of course. Cursor's Agent mode and Claude Code's CLI agent will both do "implement this feature." Antigravity's Editor view and Cursor look superficially similar. But the shape of the work is different in each, and I have stopped trying to force one tool to do another tool's job.

If you read the field guides for Claude Code and Antigravity alongside this comparison, you will get the per-tool depth that this page deliberately skips. The point of a comparison is the choice, not the manual.

What I'd reconsider in six months

Three things I expect to change between now and the end of 2026, in the order I think they will land.

• Antigravity's preview ends. Pricing posts, feature shape settles, and the question becomes whether the Manager view is worth a per-seat fee against Cursor's $20/mo or against Claude Code's bundled-into-Claude-Pro positioning. My guess is yes, for the supervision-heavy users; not yet for everyone else.
• Claude Code grows a dashboard, or stops needing one. The pressure to add a parallel-agent view is real; the counter-pressure to stay terminal-first is also real. Either path is fine; the one that would surprise me is "Claude Code becomes a forked IDE." That is not the bet they have placed.
• Cursor's auto-router gets enough better that picking a model becomes unusual. Already trending that way. The end state is "you stop knowing which model wrote which line, and you stop caring." I am cautiously optimistic and a little uneasy about what that does to debugging.

Until then, the frame in Part 06 is the one I keep reaching for, and the multi-tool setup in this part is what I actually use day to day. Comparison done; choice yours.

Pick the surface your work actually has, not the one the demo had. — TWD