My Actual Dev Setup: Google Antigravity + Claude Code

Google Antigravity is an AI-powered IDE that Google launched alongside Gemini 3 in late 2025. If you use VS Code, it'll feel familiar — because it's basically a fork of VS Code with AI agents baked into every layer.

The big idea is "agent-first." Instead of an AI assistant that suggests code while you do the work, Antigravity lets you dispatch AI agents that go off and do things independently. Write code, run tests, fix bugs, iterate — while you work on something else.

Key things to know:

• It's free right now. Public preview with generous Gemini 3 Pro rate limits. No idea how long that lasts.
• It's a VS Code fork. Your extensions, keybindings, and settings import directly.
• Multi-agent. You can run multiple agents at once — one working on a bug fix, another writing tests, another refactoring a component.
• It supports other models. Including Claude Sonnet 4.5. So you're not locked into Gemini.

If you've used Cursor or Windsurf, Antigravity is in that same category but with Google's resources and Gemini 3 behind it.

Claude Code is Anthropic's CLI tool. It lives in your terminal, not in your IDE.

You run it, give it a task, and it reads your files, edits code, runs commands, and works through problems — all from the command line. It connects to your existing editor (VS Code, Antigravity, whatever) but it doesn't replace your editor.

Key things to know:

• Terminal-first. No GUI. You talk to it in your terminal and it works in your codebase.
• You stay in control. It asks permission before editing files or running commands. You approve every action.
• It's really good at complex tasks. Multi-file refactors, debugging across a codebase, understanding how pieces connect.
• It costs money. Pro plan required. But you're paying for Claude, which is arguably the best coding model right now.

Think of it this way: Antigravity is like having a whiteboard and a QA team — great for designing systems and testing them. Claude Code is like having a senior developer sitting next to you who already read all your code — great for actually writing the implementation.

Here's my real workflow on a typical day:

System Design & Architecture → Antigravity

When I'm evaluating a non-trivial architectural decision, I use Antigravity. Real examples from the last few weeks:

• "We need to migrate our Firestore real-time listeners from v8 to v9 modular SDK without breaking the live reaction counts." I dispatched three agents in parallel: one to map every Firestore import and listener across the codebase, one to draft a migration plan with the modular equivalents, and one to flag any patterns that would break (like the compat layer vs. full modular trade-offs). Comparing those three outputs side by side gave me a migration plan in 20 minutes that would've taken me a couple hours of reading docs.

• "Should we server-side render the blog posts for SEO, or pre-render at build time, or keep the SPA and add meta tags dynamically?" Each option has real trade-offs for a React app deployed on GitHub Pages. I had agents evaluate each approach against my actual constraints (no Node server, static hosting, need for OG tags per post). The trust artifacts laid out the pros/cons in a format I could actually present to a stakeholder.

The Manager View is underrated for this. You're not just getting text responses — you're getting structured implementation plans you can review before anyone writes a line of code.

Writing the code → Claude Code

When it's time to actually implement, I switch to Claude Code. This is where it earns its keep on the hard stuff:

• "Refactor the theme system to support three themes (terminal, dark, light) across 14 components without breaking any existing styles." Claude Code read my entire ThemeContext, every component that consumed it, and the Tailwind config. It understood the cascade — which classes were shared, which were theme-specific, where the conditional logic lived. Then it made changes across all 14 files that were consistent with each other. That kind of cross-codebase awareness is something Antigravity's per-file agents just can't match.

• "The Firebase reactions are double-counting on mobile Safari. Fix it." I gave it the bug report and it traced from the click handler through the Firestore transaction to the optimistic UI update, found the race condition (StrictMode double-mounting + the useEffect cleanup not canceling the pending write), and fixed it. The fix touched three files and required understanding how React lifecycle, Firebase transactions, and localStorage fallbacks all interacted.

It asks permission before every edit, so I'm reviewing as it goes. It feels like pair programming with someone who already read all my code.

Testing → Antigravity

Once the code is written, I go back to Antigravity for testing. This is where multi-agent parallel execution really pays off:

• After the theme refactor: I dispatched one agent to write snapshot tests for each theme variant, another to write integration tests for the theme toggle, and a third to run the full existing suite and flag any regressions. All three running simultaneously while I moved on to reviewing the next PR.

• For the Firebase race condition fix: One agent wrote a test simulating the rapid double-click scenario on mobile, another verified the localStorage fallback still worked when Firestore was unreachable, and a third tested the cleanup behavior across mount/unmount cycles.

The agents handle the write-test → run → fix → rerun loop in the background. For a lead managing multiple workstreams, getting testing off your plate while you context-switch to code review or architecture decisions is a real multiplier.

Debugging → Claude Code

When something breaks in a way that isn't obvious, Claude Code wins every time. A recent one:

• "Blog posts render fine locally but show a blank white page in production. No console errors." Claude Code traced it from the router config through the lazy-loaded BlogPost component, found that the markdown file paths used in fetch() were relative and worked with webpack-dev-server's fallback but broke on the static build's routing. The fix was two lines, but finding it required understanding how Create React App's dev server differs from the production build, how React Router's client-side routing interacts with static file serving, and where the fetch paths were being constructed. That's five files of context to hold in your head simultaneously.

The TL;DR

Task	Tool	Why
Architecture decisions & trade-off analysis	Antigravity	Parallel agents explore approaches, structured artifacts to review
Cross-codebase implementation	Claude Code	Understands how 14 files connect, writes consistent changes
Writing & running tests	Antigravity	Multi-agent parallel execution, handles the test-fix-rerun loop
Debugging production issues	Claude Code	Traces across files, holds full system context
SDK migrations & refactors	Claude Code	Reads every import and usage, makes changes that don't break things
Quick inline edits	Antigravity	Already in the file, no context switch

Antigravity wins at:

• System design & planning. The visual agent workflow and trust artifacts make it great for thinking through architecture before you write a line of code.
• Testing. Dispatch multiple agents to write and run tests in parallel while you keep working. This alone saves me hours.
• Parallel work. Multiple agents working simultaneously is a real productivity multiplier.
• Price. It's free right now. Claude Code is not.

Claude Code wins at:

• Actually writing code. When it's time to implement, Claude Code produces code that fits your existing patterns because it understands your whole codebase, not just the current file.
• Complex reasoning & debugging. When the task requires understanding how multiple systems connect or figuring out why something is broken, Claude is better.
• Safety. It asks permission before every action. Antigravity's agents are more autonomous, which is faster but riskier.
• Explaining things. Ask it "why is this component re-rendering?" and you'll get a real answer, not just a code suggestion.
• Consistency. Claude's outputs are more predictable. Antigravity's agents occasionally go off-script.

I'm not going to pretend this setup is perfect.

Antigravity issues:

• It's a preview. Things break. The IDE freezes sometimes when agents start tasks. It's not production-stable yet.
• Security concerns. Researchers have flagged risks in the default configuration. Be careful with sensitive codebases.
• Agent quality varies. Sometimes an agent generates great code. Sometimes it generates something that looks right but subtly breaks your app. You still need to review everything.

Claude Code issues:

• It costs money. You're paying for Claude API access. If you're on the Pro plan, usage adds up.
• Terminal-only might not be for you. If you're not comfortable living in the terminal, the learning curve is real.
• It can be slow. For simple tasks, waiting for Claude to read your codebase and reason through it is overkill. Sometimes you just need a quick autocomplete.

Using both:

• Context switching. Bouncing between two AI tools means you're managing two mental models. It takes a minute to develop the instinct for which tool to reach for.
• Occasional conflicts. If Antigravity and Claude Code both edit the same file, you'll need to resolve that. I've learned to give them separate lanes.

If you're already using VS Code: Trying Antigravity is a no-brainer while it's free. Import your settings, play with the agents, see if it clicks. The worst case is you go back to VS Code.

If you're already paying for Claude: Adding Claude Code to your workflow is worth the experiment. It's particularly good if you do a lot of debugging or work across large codebases.

If you're using neither: Start with Antigravity (it's free) and see how you feel about AI-assisted development before spending money on Claude Code.

If you're using Cursor or Windsurf: Antigravity is in the same category but with Google's backing and Gemini 3. Worth trying as a comparison. Claude Code is a different kind of tool entirely and can complement whatever IDE you use.

The point isn't that everyone needs two AI coding tools. The point is that these tools are good at different things, and once you figure out which one to reach for when, the combo is greater than the sum of its parts.

At least that's been my experience. Your mileage may vary.