Antigravity vs Claude Code: I gave both one brief, neither built it

Antigravity vs Claude Code: which should you use?

I gave seven AI coding tools the same six-requirement brief this year. Five of them read it and started building. These two stopped and asked me something first — and only one of them was supposed to.

That is the finding this comparison turns on, because it is the opposite of the standard framing. That framing says Google Antigravity is the autonomous one, the agent-first platform with auto-accept defaults that goes off and does the work, while Claude Code is the cautious terminal tool that stops for approval at every step. On one controlled test, with an identical prompt and no follow-up messages, that framing was half right and half backwards.

How Antigravity and Claude Code compare

The test both of them took

Every tool got the same message, once, with no follow-up instructions: build a single-page subscription tracker called Stack Cost, with six numbered requirements. Add a tool with a name, cost and billing cycle. Annual plans must display a monthly-equivalent cost rather than the annual figure. A running monthly total pinned at the top. A cancelled state that removes an item from the total but keeps it visible in its own section. Persistence across reloads via localStorage. A dark theme.

Two of those are traps. Requirement two asks the tool to display something other than the number you typed, which means storing the raw figure and deriving the display value. Requirement four asks for an item to be simultaneously excluded and visible. Each needs two ideas held at once, and each is the kind of thing that gets quietly half-implemented.

I verified every result the same way: served the app, used it in a browser, checked the running total against a calculator, and read the localStorage payload. Not by reading the code and assuming.

G

Google Antigravity: strengths and gaps

It planned before it built, and then stopped. Twenty seconds in, Antigravity had produced an implementation plan and a sentence saying it would proceed once approved. It did not proceed. I clicked approve, it asked separately for a permission grant, and only then did it write files. Total wall clock was about two and a half minutes including my reading time.

It wrote and ran its own unit tests, which almost nothing does. It produced a test file, executed it under Node, and recorded six assertions — annual-to-monthly conversion, quarterly and weekly normalisation, the running total, cancellation behaviour, and a localStorage round-trip. I checked each against the shipped app and they held. Of the seven tools I have given this brief, exactly two tested their own work, and this was one.

It costs nothing, and the free tier is real. Antigravity’s own pricing page contains exactly one number and that number is $0. The free tier lists Gemini 3.5 Flash, Gemini 3.1 Pro, Gemini 3 Flash, Claude Sonnet and Opus, and gpt-oss-120b. My entire build ran on it.

The sprawl is the problem. It wrote 2,894 lines across three files for six requirements. That is a like-for-like count of project code — its test file lives outside the project folder, so none of those lines are tests. Unasked, it added a six-currency switcher, a category spend breakdown, a command-palette search, grid and table views, and JSON import and export. On a prototype that is free polish. On something you intend to maintain, it is nearly three times the code to read.

Here is what it added that nobody asked for, next to what the brief actually specified:

Every one of those is defensible on its own. Together they are the difference between 585 lines and 2,894.

Nobody, including Google, publishes what an agent request is. Google’s own plan comparison prices Flow Music Credits to the exact credit — 3,000, 10,000, 30,000 per month — and gives Antigravity four adjectives and no numbers at all. “Basic weekly rate limits” on free, “more generous” above it. You cannot budget against that.

C

Claude Code: strengths and gaps

It refused to build, and that was not a permission problem. Given the brief, Claude Code wrote zero files. It replied with “Question 1 of ~3: What shape should the deliverable take?”, offering three options with a recommendation and a reason. Then a second question about billing cycles, then a third about what you can do to an item after adding it. Then a two-part design document covering the data model and the layout. Eight exchanges passed before a single line of code existed, and it only built when I typed “Build it.”

Its opening reply, verbatim:

Empty directory — greenfield. A few quick questions before I design this.

Question 1 of ~3: What shape should the deliverable take?

  A. Single self-contained index.html — vanilla JS + CSS inline, no build
     step, no dependencies. Double-click to open, works offline.
  B. Vite + React — component model, hot reload, needs npm install.
  C. Vite + vanilla TS — type safety and a build step, no framework.

My recommendation: A. The whole app is one list, one form, and one derived
total. localStorage is a native API, so there's nothing a framework buys
you here that hand-rolled render-on-state-change doesn't cover.

Which do you want?

The run log records no permission denials. Nothing was blocking it. It chose to ask. Note that it answered its own question in the same breath, which makes the interruption cheaper than it first looks — but it still would not proceed until I replied.

When it finally built, the code was the best of the seven. It stored money as integer cents, and explained why without being asked: summing 9.99 and 19.99 as floats gives 29.979999999999997. It also rounds the annual division once at format time, so twelve $120-a-year plans total exactly $120.00 a month rather than $119.88. No other tool went near this, and it is precisely the class of bug that surfaces months later in a spreadsheet that does not reconcile.

It shipped a 28-assertion test suite that actually passes. Corrupt JSON, non-array payloads, storage that throws on read, negative costs, float precision. I ran it: 28 passed, 0 failed.

It was honest about what it had not checked. Its closing message was “Built, but not yet verified — I couldn’t execute anything,” because its own sandbox blocked Node. That is the same failure Antigravity hit, and in both cases the tool told me rather than claiming success.

It is slow and it is expensive. The build turn alone ran 394 seconds. Across the session it cost about $2.56, more than eight times the dearest of the hosted builders and infinitely more than Antigravity’s zero.

How they differ on price

This is the least close section in the comparison, and the one most likely to decide it for you.

Antigravity is free. Not trial-free, not free-with-a-card — the Individuals tier costs nothing and my entire build ran on it, including the model calls behind an agent that wrote and executed its own tests. Paid access is not an Antigravity subscription at all; it is a Google One AI plan. Read in a US-locale browser, that ladder is $4.99 a month for AI Plus, $19.99 for AI Pro, $99.99 for Ultra 5x and $199.99 for Ultra 20x. What those buy you in Antigravity terms is “expanded” or “higher” agent requests, which is as specific as Google gets.

Claude Code has no free tier. It arrives with a Claude subscription: Pro at $20 a month, or $200 billed annually which works out at about $17; Max 5x at $100; Max 20x at $200. You can also run it against metered API billing, which is what my test did, and that is where the $2.56 came from.

Two things are worth separating here, because they pull in opposite directions.

The first is that $2.56 for one small app is genuinely a lot. It is more than eight times what the dearest hosted builder charged for the same six requirements, and Antigravity did it for nothing at all. If your work looks like a stream of small greenfield tasks, that arithmetic is brutal and it does not improve.

The second is that the per-build figure is the wrong lens for how Claude Code is actually bought. Nobody pays API rates by choice for daily work; they pay $20 or $100 a month flat and stop counting. The eight months of daily use behind our separate Claude Code review ran on a subscription, and on a subscription the marginal cost of one more build is zero — the same as Antigravity’s, just with a floor under it.

So the honest framing is not “Antigravity is cheap and Claude Code is dear.” It is that Antigravity’s floor is zero and Claude Code’s floor is $20 a month, and that below some volume of work the difference never earns itself back. Where Antigravity’s pricing genuinely fails is predictability: it will not tell you what an agent request is or how many you get, so you cannot know in advance which side of that line you are on.

How they differ on quality

Both met all six requirements. Both handled the two traps correctly: a $2,400 annual plan displayed as $200.00 a month with the annual figure kept as sub-text, and cancelling an item dropped it out of the total while leaving it visible in its own section. On the brief as written, this is a tie.

The separation is in how they got there, and it is wider than the shared 6-of-6 suggests.

Claude Code’s version is 1,052 lines including its test file. Antigravity’s is 2,894 lines excluding its test file. Both are self-contained apps doing the same six things. That ratio is the single most useful number in this comparison, because it is a proxy for how much you will have to read the first time something goes wrong.

Then there is the integer-cents decision. Antigravity used floating point for money, which is what almost every tool does and what almost every tutorial does. It will produce correct-looking totals for a long time and then, on some combination of values, produce 29.979999999999997. Claude Code stored cents as integers, rounded the annual division once at format time, and volunteered the reasoning. That is not a stylistic preference; it is the difference between a total that reconciles and one that does not.

The test suites tell the same story at a different scale. Antigravity’s six assertions cover the happy path: does conversion work, does the total sum, does storage round-trip. Claude Code’s 28 cover the paths where things actually break — a corrupt JSON payload, a stored value that is not an array, a storage API that throws on read, a negative cost. Both tools deserve real credit here, because five of the seven wrote no tests whatsoever. But one of them tested that the feature works and the other tested what happens when it does not.

The suites side by side:

The honest limit on all of this: both suites test store logic rather than rendered UI, and in both cases the tool’s own attempt to verify its work in a browser was blocked by its own sandbox. Neither actually watched its app run. I did that part for both of them.

How they differ on speed and workflow

Antigravity finished in about two and a half minutes including an approval gate. Claude Code’s build turn alone took 394 seconds, and the full session ran to roughly eight and a half minutes across eight exchanges. On raw wall clock this is not close.

But the interesting difference is shape, not duration.

Antigravity’s interruption is a checkpoint: it does the thinking, shows you a plan, and waits for a yes. You read a document and click once. Claude Code’s interruption is a conversation: it asks what you want, offers options with a recommendation attached, and waits for an answer. Three times. Then it writes a design document and waits again.

Whether that is diligence or friction depends entirely on the job. For the test I set — a fully specified brief where I had deliberately written down every requirement — it was friction, and it is why Antigravity gets to working code faster. But the brief was artificial in exactly the way that flatters tools which start typing immediately. Real work is usually underspecified, and the questions Claude Code asked were not padding: whether to ship a single file or a build step, which billing cycles to support, whether items should be editable. Those are the decisions that get silently guessed wrong and then cost an afternoon.

There is a broader point here about the claim that either of these runs unattended. Neither does. Both stopped. If what you want is a tool that takes a prompt and returns a finished app with no interaction at all, neither of these is that tool, and the hosted builders are — Lovable did the same brief in 109 seconds with no interruption at all.

Who should pick Google Antigravity

Anyone testing whether agentic development suits them. This is the strongest case and it is close to unarguable. The free tier does real work, and finding out costs nothing but time. There is no other tool in this category where the answer to “is this for me” is available for free.

People who want to see the work rather than read it. Antigravity is a desktop IDE with an agent manager, a plan artifact you can read before anything runs, and a built-in browser for visual feedback. If a terminal is where your attention goes to die, this is the shape that fits.

Anyone whose spend needs a hard zero. Students, side projects, and anyone who cannot expense a subscription. The catch is that the free tier’s “basic weekly rate limits” are undefined, so you will find the ceiling by hitting it.

Not for you if you are maintaining what gets built. The sprawl is real, and 2,894 lines for six requirements is a lot of code to inherit from a tool that will not tell you how many requests you have left.

Who should pick Claude Code

Anyone working on a repository that already exists. This is the job it is built for and the job my test did not measure. The brief here was a greenfield single-page app, which is the shape that flatters hosted builders. Eight months of daily use on a real codebase sits behind our separate review, and that is where the 4.7 comes from — not from this build.

Anyone who cares more about correctness than speed. The integer-cents decision and the 28-assertion suite are the same instinct showing up twice. If you are building something that handles money, dates, or anything where being subtly wrong is worse than being slow, that instinct is worth $20 a month on its own.

Anyone whose brief is not fully specified. The questions it asks are the ones you would otherwise answer by rejecting a first draft. On a vague task, the interview is faster than the round trip.

Not for you if your work is a stream of small throwaway builds, or if you cannot commit to a subscription. At metered rates this got expensive fast, and there is no free tier to fall back on.

The final word

The consensus on this matchup is wrong in a specific, checkable way. Page one will tell you Antigravity is the high-autonomy tool that runs with auto-accept defaults while Claude Code stops to ask permission at every turn. Given the same brief and no follow-ups, Antigravity stopped and waited for approval, and Claude Code refused to write anything at all until it had interviewed me three times. The direction is right for Claude Code and backwards for Antigravity, and I suspect the reason nobody has caught it is that running a controlled identical-prompt test is more work than reading both marketing pages.

Where I stand, so you can weigh the verdict: this site earns referral credits on Claude signups and nothing at all on Antigravity, and the editorial work here runs on Claude Code. That is an interest, and the result went against it on the axes I could measure most cleanly — Claude Code was the slowest of seven tools, the most expensive by more than eight times, and the only one that would not build from the brief alone. I have left those numbers exactly where they landed.

What it won on was the code. Half the lines, a money model that will still reconcile in a year, and a test suite four times the size that passes. If you are paying for a coding tool anyway, that is the one that matters, and it is why Claude Code takes this at 4.7 against 4.3.

But if the reason you are reading this is that you have not paid for one yet, take Antigravity. It costs nothing, it met every requirement, and it is the only tool in this comparison where finding out whether you like working this way is free.

For context on where these two sit, here is every tool I have given this brief:

Read down the first column and the shape of this comparison becomes obvious. The two tools that stopped to ask are also the only two that tested their own work. That is not a coincidence, and it is the actual axis separating this pair from the rest of the field — not autonomy, but whether the tool treats your brief as a specification to execute or a conversation to have.

One last thing, because it has stopped being a coincidence. All seven tools I have given this brief invented a Restore button for cancelled items. Nobody asked for one. Seven for seven.