Google Antigravity is the first agent-first development environment I recommend to beginners without a long list of disclaimers — not because it writes the best code, but because it makes the shape of agentic development visible. You describe what you want, watch an agent plan, edit files, run the app, and verify its own work in a browser, and you approve or redirect at each step. That loop is the future of the job, and Antigravity teaches it for free. This guide is my consolidated, kept-current walkthrough: what Antigravity is now, how to set it up sanely, which settings matter, and how it fits alongside Claude Code — the tool I still do most of my paid work in.
A quick calibration on recency, because this tool has moved fast. Antigravity launched in November 2025 alongside Gemini 3 as Google's agentic IDE. At Google I/O in May 2026, Google relaunched it as Antigravity 2.0 — less "editor with an AI bolted on," more agentic platform that happens to include an editor, now with a standalone desktop app, a CLI, and an SDK for building your own agents. It remains free during the public preview and runs on macOS, Windows, and Linux. Everything below reflects the 2.0-era product.
What Antigravity actually is
Strip the branding and Antigravity is three ideas bolted together:
An agent, not autocomplete. You work at the level of tasks ("build a TypeScript React app with a landing page and contact form"), and the agent plans, scaffolds, installs dependencies, writes components, and iterates. The editor is still there when you want to touch code directly, but the primary interface is delegation.
A verification loop with eyes. The piece that genuinely distinguishes it: through its browser integration (originally a Chrome extension, now deeper in the platform), the agent opens your running app, clicks through it, takes screenshots and recordings, and checks whether what it built actually works. Agents produce artifacts — plans, screenshots, walkthrough recordings — you can review instead of reading raw diffs. For a beginner, seeing the agent test its own contact form is worth a semester of "always verify AI output" lectures.
An agent manager. Antigravity is built for running more than one agent — one on the frontend, one on an API, one testing — each in its own workspace, coordinated from a mission-control surface. Beginners should ignore this on day one; it becomes relevant the first time you catch yourself waiting on one agent while planning the next task.
One more 2.0-era fact that surprises people: Antigravity is not Gemini-only. The model picker includes Gemini 3.1 Pro and 3.5 Flash, but also Anthropic's Claude Sonnet 4.6 and Opus 4.6, and the open GPT-OSS-120B. Google shipping an IDE that lets you route work to a competitor's model tells you where the industry's actual battleground is — the agent harness, not the model.
Setup and the settings that actually matter
Getting started: download Antigravity from antigravity.google, sign in with a Google account, open a folder as a workspace, and — when prompted — enable the browser integration, because agent self-verification is the whole point of the product. Then spend two minutes in settings, because the defaults define your relationship with the agent:
- Review policy. This controls whether the agent asks before applying changes. My advice runs opposite to most tutorials: start on request review, not "always proceed." Watching and approving each step for your first few sessions is how you learn what the agent is actually doing; graduate to auto-proceed once its behavior stops surprising you. Autonomy is something the agent earns.
- Terminal auto-execution. Letting it run
npm installand dev servers unattended is fine in a scratch workspace. In any repository you care about, keep an approval gate on commands — the same discipline I apply to every agentic tool I run. - Auto-fix lints. Turn it on. Mechanical cleanup is exactly the work you want machines doing.
- Web tools. Allow the agent to search for current package versions and docs; without it, you inherit the model's training-cutoff view of the ecosystem, and that is how deprecated APIs end up in fresh projects.
For your first build, resist the tutorial-demo trap: pick something small that you actually want to exist. Prompt with specifics ("a TypeScript React app with a landing page, sticky nav, three feature cards, and a working contact form — modern, dark, mobile-responsive"), watch the live preview, then iterate conversationally. The screenshot loop is the beginner superpower: capture any part of the UI, say "make this feel less generic — gradient accent, more whitespace, smooth hover states," and let the agent work from visual context.
The instruction-file habit that separates toys from tools
Here is the insight I most want beginners to take from this page, because it transfers to every agentic tool you will ever use: agents are only as consistent as the written conventions you give them. Antigravity reads project instruction files (the GEMINI.md/AGENTS.md layer) the same way Claude Code reads CLAUDE.md — and this is not theory for me. Every repository I run keeps standing instructions in exactly these files: stack conventions, commands to run before finishing, patterns to copy, things never to touch. My Laravel platform's agents follow a written rule set covering everything from "use the existing form-request pattern" to "run the formatter before you claim you are done."
Without an instruction file, every session starts from zero and the agent re-guesses your preferences. With one, corrections compound: each time you catch the agent doing something you dislike, you write the rule down once and never repeat the correction. Start yours on day one, even if it is three lines. It will become the most valuable file in the project.
Using Antigravity with Claude Code: the hybrid that survived
Two of my earlier posts chased the same question from different ends — how Antigravity and Claude Code fit together — and the answer that survived contact with real work is a division of labor, not a winner:
Antigravity for exploration and visual verification. Free preview credits, a fast scaffold-to-preview loop, and browser-based self-testing make it ideal for prototyping UI, validating an idea, and the "does this even work when clicked?" class of verification. Its planning surface with a top-tier Gemini model is also a genuinely good place to think through a build before any code exists.
Claude Code for the codebase you live in. My daily driver remains Claude Code, because production work is mostly editing existing systems, and that rewards deep instruction-file conventions, skills, hooks, and terminal-native workflows accumulated over months — the muscle I document across my Claude Code beginner's guide and parallel-agent worktree setup. Plan and prototype where iteration is cheap; implement and maintain where your conventions are strongest.
The economics angle from the old "stop burning credits" post still holds in principle — route expensive-model work to the steps that need it, use the free/cheap loop for drafts and verification — but treat any specific credit math you read (including mine) as perishable; preview pricing is a moving target.
If design quality is your bottleneck rather than code, the same routing logic applies one layer up: generate visual direction in a design-first tool, then hand components to the agent to wire up. That design-to-agent pipeline is a pattern I use across ecosystems, documented in my NotebookLM + Gemini + Antigravity research workflow and, on the commerce side, my Antigravity vibe-coding Shopify build.
Honest limitations before you commit
Preview-era friction is real. Rate limits on the flagship models have been Antigravity's most-reported complaint since launch week, and while 2.0 improved matters, a free preview means you are sharing capacity. Expect occasional throttling at exactly the wrong moment; the multi-model picker is your relief valve.
Generated architecture is generic. Left unguided, you get sensible, forgettable structure and design. Fine for learning and prototypes; anything client-facing needs your taste applied deliberately — through instruction files, specific prompts, or a design pass.
Autonomy without review is a trap for beginners. The settings make it easy to let the agent run unattended, and unattended agents confidently build the wrong thing at scale. Review checkpoints are not friction; they are how you learn to direct these tools — the skill that actually compounds. The broader craft of prompting agents well is the same regardless of vendor; my vibe coding guide covers the habits that transfer.
It is a preview product. Features move, UIs reshuffle, and free tiers eventually meet pricing pages. Build your skills on the concepts — agent delegation, verification artifacts, instruction files, multi-agent orchestration — not on the location of buttons.
Who should use it, and how to start today
Use Antigravity if you are a beginner who wants to build real things while learning how agentic development works, a developer who wants a free, fast prototype loop with visual verification, or an experienced engineer curious how Google's agent-manager model compares to terminal-native tools. Skip it (for now) for regulated codebases and teams needing mature review workflows — direct those through your established tooling.
Your first session, scoped: install it, open an empty folder, write a three-line instruction file, and build one small real thing end to end with review mode on. You will learn more about where AI development genuinely is — capabilities and rough edges both — in that hour than from any amount of launch-week commentary. After 8+ years and 1,500+ projects, my strong opinion is that the developers who thrive with these tools are the ones who practiced directing them early.
Bringing agentic development into a team — tool selection, instruction-file conventions, guardrails, and the workflows that survive real projects — is work I do. Tell me where your team is stuck and I will point you at the smallest useful first move.
