Google I/O 2026 was not subtle. While everyone expected a new Gemini model, the real bomb was Antigravity 2.0 — a full-scale pivot from "AI-powered IDE" to multi-agent orchestration platform. And the internal test numbers are hard to ignore:
- 93 agents working together, consuming 26 billion tokens, built a complex system project from scratch
- A team of agents built a fully running operating system — from scratch — for under $1,000 in API costs
- Gemini 3.5 Flash runs 12x faster than other frontier models inside Antigravity, with zero quality loss
If Antigravity 1.0 was "hire one AI assistant," 2.0 is "you become the project manager of an entire AI construction crew." But like any powerful tool, there's a right way and a wrong way to use it. After spending serious time with the platform, here are 10 tips that will save you hours of frustration.
1. Enable Review Mode — Don't Go Full Auto on Day One
When you first install Antigravity, you get four options for how the agent behaves. Pick the second one:
| Mode | For Beginners? | What It Means |
|---|---|---|
| Secure Mode | No — too noisy | Agent asks permission for everything |
| Review-Driven | Yes — pick this | Agent pauses at key steps, waits for your OK |
| Full Auto | No — dangerous | Agent runs wild, you find the damage later |
| Custom | No — skip for now | Tweak this when you know what you're doing |
Additionally, in Settings → Agent → Permissions, build a safe command whitelist. Add things like command(git status) and command(ls) so those never trigger confirmation popups. Small quality-of-life tweak, big sanity saver.
2. Always Submit in Planning Mode First
This is the single biggest time-saving habit. Before you hit submit on any non-trivial request, flip the mode toggle to "Planning" in the top-left corner of the input box.
You type: "Build me an e-commerce homepage"
Agent outputs first:
┌─────────────────────────────────┐
│ Implementation Plan │
│ 1. Create project scaffold │
│ 2. Set up routing and layout │
│ 3. Build product listing │
│ 4. Add cart logic │
│ 5. Browser test │
└─────────────────────────────────┘
↑ You review here.
If step 1 doesn't match your mental model, you correct it now — before a single line of code exists. That's 10x cheaper than fixing it after the agent has built the wrong thing.
3. Comment Directly on Output — Don't Rewrite the Prompt
Antigravity has a Google Docs-style review workflow. When the agent produces something, you don't type a new prompt saying "actually, do it differently." You comment directly on the output:
Agent generates code
Your comments (written inline on the output):
→ "Use FastAPI instead of Flask here"
→ "Add error handling for the DB call"
→ "Store data in SQLite, not in-memory"
→ "Don't create a new auth component — reuse the existing one"
The agent reads your comments and fixes only what you flagged. This is 3-5x faster than writing a whole new prompt from scratch, and it preserves the parts that were already correct.
4. Parallel Agents Need File Boundaries
When you spawn multiple agents to work simultaneously, there's one fatal trap: two agents touching the same file. Antigravity has no merge conflict resolution — the last writer silently overwrites the first.
The fix is dead simple:
Agent 1 → only touches /api/ (backend)
Agent 2 → only touches /components/ (frontend)
Agent 3 → only touches /tests/ (testing)
Never let two agents own the same directory.
Say it in natural language: "Agent A, you build the backend API, files go in /api/. Agent B, you build the frontend components, files go in /components/. Do not touch each other's folders."
5. Write It as a Rule Immediately — or Lose It Forever
Antigravity does not remember what you taught it between sessions. Spend 20 minutes coaching an agent through comments — close the window, reopen it — gone.
Iron rule: Every time you teach the agent something important through comments, immediately write it into a Rule file.
# .agents/rules/code-style.md
- All Python follows PEP 8
- Use pydantic v2 model_validate, never parse_obj
- All API responses wrapped in a unified Response class
- Database connection strings read from env vars — never hardcoded
- Every new feature gets a test file
There are two scopes:
| Type | Path | Scope |
|---|---|---|
| Global | ~/.gemini/GEMINI.md |
All projects |
| Workspace | .agents/rules/*.md |
This project only |
6. Use / to Summon Workflows — One Slash, Job Done
Do you keep asking the agent to do the same thing? "Generate unit tests." "Review my code." "Deploy to staging." Stop retyping the instructions every time. Create a Workflow:
# .agents/workflows/generate-tests.md
- Generate pytest unit tests for the current file
- Use mock objects for external dependencies
- Name test files as test_[original_filename].py
- Auto-run tests after writing and confirm they pass
Then in the agent input box, just type /generate-tests. What used to be a paragraph is now a single keystroke. Workflows can even nest — call one workflow from inside another for complex pipelines.
7. Opus for Thinking, Gemini for Doing — The Smart Budget Combo
The most common beginner mistake: running Claude Opus 4.5 Thinking for everything because it's the smartest. It is — but it also burns your quota the fastest.
The correct pattern — model switching:
| Phase | Model | Why |
|---|---|---|
| Planning / Architecture | Claude Opus 4.5 Thinking | Best reasoning |
| Implementation | Gemini 3 Pro (Low) | Cheap + fast, good enough |
| Simple refactoring | Gemini 3 Flash | Lightning fast |
Antigravity lets you switch models mid-task — switch in the top-right panel and the agent continues the same conversation. Plan with the expensive brain, execute with the efficient one. Same result, much less quota burned.
8. Skills Need Good Descriptions — or the Agent Won't Load Them
Skills are knowledge packs for your agent — markdown files that teach it domain-specific patterns. But the agent doesn't load all skills; it reads the name and description first and decides whether to activate.
Good description:
name: db-migration-guide
description: When adding or modifying database tables,
this skill provides the project's migration
conventions and Prisma workflow.
Bad description (agent won't know when to use it):
name: db-stuff
description: Database related things
Formula: "When [trigger condition], this skill [does what] to [achieve what outcome]"
9. Playground First, Project Second
Antigravity has a Playground feature specifically for rapid idea validation. No project creation, no workspace setup, no config — just type an idea and go.
The flow:
- Have an idea: "Can an agent build a Snake game?"
- Open Playground, describe it in one sentence
- Browser auto-opens, you test it
- Works? → Convert to a real project and build the full version
- Doesn't work? → You lost five minutes, not five hours
Playground is for feasibility, not for polished products. Validate fast, then commit.
10. Browser Testing Without Writing a Single Test Script
Antigravity has built-in Chrome browser control. The agent can open web pages, click buttons, and capture screenshots — automatically.
All you need is one extra sentence in your prompt:
"After building, test it in the browser — confirm buttons work
and data loads correctly."
The agent will:
- Open the page
- Analyze the DOM structure
- Click key elements
- Screenshot the results for you
No Selenium. No Playwright scripts. No test framework setup. For frontend beginners, this is revolutionary — browser verification used to require learning a whole testing stack. Now it's one sentence.
Bonus: What to Do on Day One
Before you build anything, spend 10 minutes setting up these three files. They'll save you 100 hours down the line.
Global Rule (~/.gemini/GEMINI.md)
# My Coding Conventions
- Never hardcode passwords or API keys — use environment variables
- All functions must have docstrings
- New features go in separate files
- Run tests before every commit
Project Rule (.agents/rules/project-rules.md)
# Project-Specific Conventions
- Backend: FastAPI + Pydantic v2
- Frontend: React + TypeScript, no `any` type
- API routes prefixed with /api/v1
- Database: Prisma ORM
Automation Hook (.agents/hooks.json)
{
"hooks": [
{
"event": "on_commit",
"action": "run_workflow",
"workflow": "run-tests",
"filter": "src/**/*.py"
}
]
}
From that point on, every git commit auto-runs your test suite. You never think about it again.
The Bottom Line
Antigravity 2.0 isn't about having a smarter AI — it's about you becoming the project manager, and agents becoming your construction crew. Master these 10 tips and you won't just use Antigravity. You'll command it.
Top comments (0)