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 September 2026. They have converged a little since spring (all three now run agents in parallel and can drive a browser), but the center of gravity of each is still very 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 2025 as a CLI for Claude users who already lived in their terminal, and the CLI has stayed deliberately minimalist: a prompt, a plan, and a tool loop. Around it, though, Claude Code has grown other surfaces: IDE extensions, a desktop app whose sidebar runs several sessions in parallel (each in its own git worktree), Claude Code on the web, and the Claude in Chrome extension for driving a real browser. Since September 22, 2026 its default model is Claude Opus 5.5.

Google Antigravity bets on supervision. It launched as a forked VS Code IDE 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. It left preview in 2026, and at I/O in May Google turned it into a family: the IDE, a standalone editor-less Antigravity 2.0 app built around the Agent Manager, an Antigravity CLI that replaced Gemini CLI, an SDK, and (since August) extensions for VS Code, JetBrains, Visual Studio, and Zed. Gemini's Flash models (3.5 Flash was the 2.0 launch default) and Gemini 3.1 Pro do most of the work; Claude Sonnet 4.6, Claude Opus 4.6, and OpenAI's open-weight gpt-oss-120b are the other options. 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, Agent mode for autonomous tasks, and cloud agents (formerly Background Agents) that run on Cursor's infrastructure while you work. Cursor 3 (April 2026) added an agent-first Agents Window for running many agents in parallel and an integrated browser, and Cursor now trains its own coding model, Composer (2.5 since May 2026). You get to keep your VS Code muscle memory, your extensions (mostly), and your keybindings, while gaining the AI surfaces. Alongside Composer you get the frontier models from Anthropic, OpenAI, and Google (Claude Opus 5.5 arrived the day Anthropic released it), with Auto mode 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: every tool now has a "parallel agents" row entry, but the feel is very different. Antigravity is built around supervising several agents; Cursor and Claude Code added parallelism to a product built around one. 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 everything is tied to a Google account and quota, but the tasks you queue are mostly natural-language prompts plus diffs, and its hooks and skills look a lot like Claude Code's. The Manager view itself is the thing you would miss.
• Cursor is medium-high because rules, cloud agent environments, and the Composer model 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

Cursor and Claude Code have both added ways to run agents in parallel since this comparison first went up, but the Manager view is still the most complete take on supervision. 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, Agent mode (on Cursor's fast Composer model or a frontier model) handles "change this thing across these files" and longer autonomous runs, and the Agents Window is there when you want several at once. 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 while the desktop app now runs parallel sessions, if you stay in the CLI, "run three things at once" still means three terminal panes you babysit yourself.

Antigravity: fast-moving, and split four ways

It is out of preview, but it still moves like a preview. At I/O Google split it into an IDE, an editor-less 2.0 app, a CLI, and an SDK, then added editor extensions in August, and each surface has a different feature set. Paid use is quota from a Google AI plan, drawn from one pool at API pricing, so heavy Pro or Claude runs drain it fast. And its Claude options (Sonnet 4.6, Opus 4.6) trail Anthropic's current Claude 5 lineup. 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 sounds fine until heavy agent use pushes you to Pro+ ($60) or Ultra ($200), or you multiply Teams seats from $40 each across a team. 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: the Composer model and cloud agents are Cursor-specific. 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:

• Cursor is my editor. Open the project, write code, accept or reject Cursor Tab suggestions, use Agent mode 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 expected in May, and what happened

When this page first went up in May 2026, I listed three things I expected to change by the end of the year. Four months in, here is the scorecard.

• Antigravity's preview ends. It did, though not with a per-seat fee: there is a free plan, and paid quota comes bundled with Google AI Pro and Ultra, the same bundled posture as Claude Code. The feature shape did not settle; it split into four products. The question is still whether the Manager view earns a place in your week, and my answer is the same: yes for supervision-heavy work, not yet for everyone.
• Claude Code grows a dashboard, or stops needing one. It grew one, just not in the terminal: the desktop app's session sidebar runs parallel sessions in separate worktrees, and subagents can run in the background. The CLI stayed terminal-first, and Claude Code did not become a forked IDE.
• Cursor's auto-router gets enough better that picking a model becomes unusual. Half right. Auto mode and Cursor's own Composer model cover more of the everyday work, but frontier launches (Claude Opus 5.5 landed in Cursor the day it shipped) keep people reaching for the picker. I am still a little uneasy about what "you stop knowing which model wrote which line" does to debugging.

The frame in Part 06 is still 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