A second opinion only works if it's actually a second opinion
The same read twice
If you want a genuine second opinion on your agent's output, it needs to come from a different model, on a different codebase, with different blind spots. That's the whole case for Antigravity CLI in my pipeline.
A review layer built on the same model that did the work is really just the same read twice.
It's the idea worth taking away even if you never touch the tool itself.
Google cut Gemini CLI, and it's already been replaced
Google announced they're stopping usage of their Gemini CLI coding tool. Ordinarily that would be a shame, but it isn't here: Gemini CLI has already been superseded by Antigravity CLI, and I've been using it daily for a couple of weeks now.
Antigravity ships three surfaces: a CLI, an agent tool, and an IDE. I'll save you some time on the IDE, it's much the same as every other AI-assisted IDE currently on the market, nothing about it changed how I work. The CLI and the agent tool are a different story, both genuinely good, and the CLI specifically is what this post is about.
Why I went looking in the first place
My agent team runs on Claude Code, has done for a while. Claude does the actual coding: filling out my agents, doing the day-to-day build work. That's still true, Claude Code is still the daily driver. The reason I installed Antigravity wasn't to replace any of that, it was more mundane: I'd maxed out my Claude Max plan and needed somewhere else to point some of the workload. Antigravity CLI turned out to be the answer, but not in the way I expected.
Aggy: the agent I built out of it
A couple of weeks ago I slotted a new agent into the team, built on Antigravity CLI instead of Claude Code. The CLI binary is spelt "agy", so the agent got the obvious name: Aggy.
Aggy isn't in the pipeline to write code. She's there because she's different: different underlying model, different codebase, different training data, different assumptions baked in. That difference is the entire point. When Opus, running in Claude Code, finishes a piece of work, I fire it over the fence to Aggy and she reviews it cold.
What "catches things Claude Code doesn't" actually looks like in practice
This is the part worth dwelling on, because it's easy to say "add a second reviewer" and much harder to explain why it matters. I already run CodeRabbit as a review layer alongside Claude Code, so by the time something reaches Aggy, it's already passed two checks. And she has still caught real problems, things that both Claude Code and CodeRabbit missed completely, that would have caused genuine damage if they'd shipped.
That's not a knock on Claude Code or CodeRabbit. It's the nature of review by a single model, or by tools trained in similar ways: they share blind spots. A reviewer built on the same foundation as the author is checking its own working.
Antigravity's value here isn't that it's smarter. It's that it's differently wrong, and differently right, which is exactly the property you want from a second opinion.
Two independent reviewers catch more between them than one reviewer looking twice.
The setup, concretely
The flow is simple. Opus does the work in Claude Code. Once it's done, the diff goes to Aggy, running on Antigravity CLI, for an independent pass. Nothing about the original work changes to accommodate this: it's a genuine handoff, not a shared context.
That's what keeps the review honest: Aggy never sees Claude Code's reasoning, only the output.
If you're running any kind of agentic coding pipeline of your own, that structure is worth copying even if you don't use Antigravity specifically. The principle generalises: whatever your primary agent is built on, your review layer should be built on something else.
Cost, because it matters
Antigravity has a free tier with genuinely usable headroom, you can get a fair amount of real work out of it before you hit a limit. I'm on the £20 a month plan and very rarely bump the ceiling, even running Aggy against a working agent team daily. It's cheap for what it catches, and the pricing hasn't been a reason to hold back on using it properly.
This is the same agent team that builds and runs Inkie day to day, so Aggy's catches aren't theoretical, they ship straight into a live product.
A few common questions
Does Aggy see any of Claude Code's reasoning when she reviews? No, she only gets the finished diff, none of the reasoning behind it. That's the whole point: a shared context would just recreate the blind spot this setup exists to avoid.
What does Antigravity actually cost? There's a free tier with genuinely usable headroom, and I'm on the £20 a month plan myself. I rarely bump the ceiling even running Aggy against a working agent team daily.
Why not just add more Claude Code or CodeRabbit review passes instead? Because they're still reviewing from inside roughly the same model family as the one doing the work, so they share its blind spots. Aggy has caught real problems that both Claude Code and CodeRabbit missed completely, even after the diff had already passed two checks.
Do I need to use Antigravity specifically for this to work? No. The tool isn't really the point, whatever your primary agent runs on, build the review layer on something genuinely different. That's the bit worth copying.
The takeaway
If you've got an agentic coding pipeline and every layer of review sits on the same model family as the one doing the work, that's not a small thing.
You've got a blind spot you can't see from inside it.
Antigravity is worth adding purely as the outside check: the read that isn't grading its own homework. Go have a look at the free tier and see what it catches that your existing setup doesn't.
