Before You Run Your First Prompt: The Essential Google Antigravity Setup Checklist

Google Antigravity operates as an autonomous agent harness, not merely an inline copilot, providing shell, browser, and file system access. This distinction is critical; it's an agent-first paradigm. Trying to delegate code with a "prompt-and-pray" approach often leads to context drift, phantom dependencies, and messy Git diffs.

You need a robust setup. The goal here is a quick, actionable checklist that gets you operational in about 15 minutes, complete with guardrails, essential skills, and proper branch hygiene, all before you delegate your first line of code.

Authentication, Runtimes & Quotas

First, authenticate your Google account. Whether you're using a personal Google Account (Free, Pro, Ultra plans) or a business account (Gemini Enterprise), Antigravity requires proper sign-in. For enterprise users, the single sign-on (SSO) flow automatically detects your assigned Gemini Enterprise license tier.

If you're on a business account, select "Business account" during sign-in, then "Continue with Google Cloud," and complete the process in your browser. Enterprise developers must also activate the aiplatform.googleapis.com API in their Google Cloud project and be assigned the "Agent Platform User" IAM role.

Next, verify your local system's PATH detection for core CLI runtimes. Antigravity runs on macOS (Monterey 12+), Windows (64-bit Windows 10+), and Linux (64-bit with glibc 2.28+ and glibcxx 3.4.25+). Ensure Node.js/npm, Python, and Git are correctly installed and accessible.

For instance, testing a local application with Antigravity's built-in browser preview often involves `npm start` or `npm run dev`, which presumes Node.js and npm are present. Post-installation, confirm the integrated terminal launches your preferred shell and that Git is detected.

Branching Strategy & The "Git RFC" Workflow

Always isolate your work on a feature branch. You should never run agents directly on `main` or `develop`. Start by creating a dedicated branch: git checkout -b feature/agent-onboarding. This ensures any changes made by the agent are contained and easily reviewable.

Embrace the "Git RFC" workflow. This means using atomic branches and PR drafts to isolate each agent iteration. Before and after each session, perform clean status checkpoints with `git status` and `git stash` to manage any temporary changes or uncommitted work. This practice prevents context bleed and keeps your repository history clean, making it easier to revert or refine agent-generated code.

Defining Workspace Guardrails (`AGENTS.md` / Rules)

Establish persistent instructions for your agents by setting up a workspace rules file. This file, typically named `.antigravity/rules.md` or `AGENTS.md`, resides in your project root or subdirectories. These rules are always active and auto-applied when you open a project, guiding agent behavior across all tasks.

Define clear file boundaries. Restrict agent edits strictly to target directories like `/src` or `/tests`, and explicitly lock critical configuration files. You can also implement command allowlisting and denylisting.

Whitelist safe commands such as `pytest` or `npm test`, but block destructive operations like `rm -rf`, `git reset --hard`, or unapproved package installations. These rules are paramount for security and maintaining project integrity.

Activating SDLC Skills (Grill Me, Specs & Verification)

Antigravity Skills are reusable agent capabilities designed for specialized sub-workflows. Activating the right skills transforms your agent from a simple coder into a more effective engineering partner. One crucial skill is "Grill Me," which forces the agent to interrogate your assumptions, edge cases, and data contracts before it even starts planning. This proactive questioning prevents many common pitfalls.

Consider the Spec-to-RFC Skill, which can transform raw ideas into formal functional and technical specifications. This ensures that the agent's output aligns with your architectural vision from the outset. Additionally, leverage Verification Skills to automate lint runs, execute test suites, and perform headless browser validation loops, ensuring code quality and functional correctness.

Harness Autonomy Profiles & Permissions

Choose your autonomy mode carefully. "Request Review" is the recommended baseline, requiring approval for every command the agent wants to execute. This gives you granular control. "Auto (Preview)" (available in v2.23.0+) automatically evaluates and runs safe commands outside the sandbox without prompting, while still asking for approval for risky ones.

Configure terminal execution approvals. While you can set zero-prompt approval for safe, whitelisted commands, always gate destructive commands with explicit approval. For browser harness setup, bind local preview ports (e.g., `localhost:3000`) and set URL allowlists for automated UI verification. This ensures the agent can interact with your local development server for testing.

The "First Flight" Validation Task

With your setup complete, perform a "first flight" test. This involves running a controlled, low-risk micro-task, like creating a simple utility helper with accompanying unit tests. Antigravity can be used as a standalone IDE or as an extension for editors like VS Code or JetBrains IDEs.

Review the generated Implementation Plan artifact, treating it like an architectural RFC, before approving any code writes. Inspect the generated diff carefully, confirm passing test output, and then execute a clean branch merge. This full edit-build-verify loop confirms your Antigravity setup is functioning as expected.

Common Setup Pitfalls to Avoid

Skipping the "Grill Me" phase is a common mistake, leading agents to code blindly on ambiguous requirements. Resist the urge to run parallel subagents without clean, decoupled file boundaries. This often results in conflicting changes and increased debugging time. Finally, avoid context bloating by failing to reset sessions between distinct feature tasks; a clean slate ensures the agent focuses on the current objective.

Transitioning from a syntax typist to engineering mission control demands a disciplined approach. By following this checklist, you move beyond basic prompting to operate with mission control confidence. Next steps involve building complex pipelines, orchestrating parallel agent tasks, and ultimately, achieving more autonomous shipping.