Process Manual: Setting Up Google Antigravity with Claude Code

Vision and Roles: Antigravity + Claude Code

The key is to separate responsibilities. Each tool has a defined role so there is no improvisation or task overlap.

Antigravity

Vehicle

VS Code environment, autonomous agents, MCPs, Workflows, macro tasks and backend

Claude Code

Precision Engine

Frontend, UX/UI, complex refactors, fine debugging, detailed architecture

Result

Consistent Delivery

Less improvisation, more control, repeatability and quality in each iteration

Golden rule: if the task affects infrastructure, data or backend → delegate to Antigravity. If it affects user experience, visual components or fine logic → delegate to Claude Code.

Example: how to decide who executes

# Antigravity (vehicle) - Create table in Supabase - Configure CI/CD pipeline - Run database migrations - Automate deployment to production # Claude Code (precision engine) - Design dashboard component - Refactor authentication logic - Fix visual bug on mobile - Optimize React component performance

Step 1. Installation and Base Environment Setup

Goal: have Antigravity running, Claude Code installed and a review policy that prevents uncontrolled code changes.

1.1 Downloads and Payments (Antigravity and Claude)

Download Antigravity from the official source and install it.
Go to Settings > Billing and Plans in Antigravity and confirm your active subscription.
Go to Settings > Billing & Subscription in Claude and verify your plan. Update payment method if needed.
If you will use Claude locally, download the Claude Local Runtime and check system requirements.

Configuration Paths

# Antigravity Settings > Billing and Plans > Verify subscription # Claude Settings > Billing & Subscription > Update payment method # Claude Local (optional) Download > Claude Local Runtime > System requirements check

Screenshot (English UI): Antigravity download.

Antigravity billing and plans (English UI)

Screenshot (English UI): Antigravity — Billing and Plans.

Claude billing and subscription (English UI)

Screenshot (English UI): Claude — Billing & Subscription.

Screenshot (English UI): Claude Local Runtime download.

1.2 Install Antigravity and Enable Claude Code (extension)

Open Antigravity as your main editor.
Create or open the project folder (File > Open Folder).
Go to Extensions (Marketplace), search for Claude Code and install it.
Verify that Claude Code appears available in the sidebar and in the integrated terminal.

Quick Steps

1. Open Antigravity 2. File > Open Folder > select project folder 3. Extensions (Ctrl+Shift+X) > search "Claude Code" 4. Click "Install" 5. Verify Claude Code icon in sidebar

Screenshot (English UI): installing Claude Code extension from the Marketplace.

1.3 Configure the Review Policy

Go to Settings > AI and locate the autonomy module.
Select Request Review for complex projects or when you are starting.
Use Always Proceed only if the scope is small, the repository is well tested and you have change control.

Review Policy Options

# Recommended option to start Request Review - Each change requires manual approval - Ideal for new projects or forming teams - Maximum control, minimum risk # Option for stable flows Always Proceed - The agent executes without asking for approval - Only use if: tested repository + active CI/CD + experienced team

Screenshot (English UI): agent autonomy and review configuration.

Recommendation: always start with Request Review. Gradually increase autonomy when the flow is stable and you trust the results.

Step 2. Define Rules (Custom Rules)

Goal: eliminate improvisation. Rules define technical decisions, code style and project constraints. There must be global rules (all projects) and workspace rules (current project).

2.1 Global rules (apply to all projects)

Define your preferred stack, naming conventions, folder structure and readability criteria.
These rules apply across any project you open.
Save them in the rules.global.md file in the configuration root.

rules.global.md

# Developer Global Rules ## Base Stack - Frontend: React + TypeScript + Tailwind CSS - Backend: Node.js + Express (or Supabase Edge Functions) - Database: Supabase (PostgreSQL) - Deploy: Vercel (frontend) + Supabase (backend) ## Code Conventions - Variable and function names in camelCase - Component names in PascalCase - Component files: ComponentName.tsx - Utility files: kebab-case.ts ## Folder Structure src/ components/ # Reusable components pages/ # Pages or views hooks/ # Custom hooks utils/ # Helper functions types/ # TypeScript types and interfaces styles/ # Global styles ## Quality Criteria - Readable code over "clever" code - Prefer composition over inheritance - Each function should do one thing - Unit tests for critical logic

2.2 Workspace rules (specific to current project)

Document constraints and priorities for the project you are working on.
Save them in rules.workspace.md at the project root.
Use them as a contract: if something is not in the rules, validate in planning before implementing it.

rules.workspace.md

# Project Rules: [Project Name] ## Priorities - Performance: minimum Lighthouse score 90 in all categories - Accessibility: comply with WCAG 2.1 level AA - Mobile-first: design for mobile first, then adapt to desktop ## Technical Constraints - Images: mandatory compression (WebP, max 200KB) - Lazy loading on all images below the fold - No heavy UI libraries (Material UI, Ant Design) - Prefer native CSS or Tailwind over styled-components ## Key Features - Drag and drop layout for boards - Authentication with Supabase Auth (magic link + OAuth) - Real-time notifications with Supabase Realtime ## Golden Rule If it is not in this document, validate in planning before implementing it.

Screenshot (English UI): global and workspace rule files in the file explorer.

Tip: review and update the rules at the start of each sprint or iteration. Outdated rules cause more problems than having no rules.

Step 3. Give AI Capabilities (MCPs)

MCP Servers (Model Context Protocol) are integrations that connect the AI agent with external tools and services. The criterion: install only the MCPs you will actually use in your workflow.

3.1 Open the MCP Servers manager

Go to Settings > MCP Servers or search Manage MCP Servers in the Command Palette.
Add the server you need and validate its status: Connected or Not connected.
Define permissions: what it can read, what it can write and in which environments it operates.

MCP Configuration (JSON example)

{ "mcpServers": { "supabase": { "command": "npx", "args": ["-y", "@supabase/mcp-server"], "env": { "SUPABASE_URL": "https://your-project.supabase.co", "SUPABASE_SERVICE_ROLE_KEY": "your-service-role-key" } }, "filesystem": { "command": "npx", "args": ["-y", "@anthropic/mcp-filesystem"], "env": { "ALLOWED_PATHS": "/path/to/your/project" } } } }

Screenshot (English UI): MCP Servers list and their connection status.

3.2 Recommended MCPs by project type

Supabase MCP: authentication, database, storage, edge functions and realtime.
n8n MCP: automations, third-party connectors and business workflows.
Filesystem MCP: read and write project files.
Testing tools: automated tests, regression checks and assisted debugging.

MCPs by project type

# SaaS Project (web app) - Supabase MCP > Database + Auth + Storage - Filesystem MCP > Read/write files - Vercel MCP > Deploy and preview deployments # Project with automations - n8n MCP > Integration workflows - Supabase MCP > Data and webhooks - Slack MCP > Team notifications # Project with intensive testing - Filesystem MCP > Access to test files - Testing MCP > Automated test execution - Git MCP > Automatic version control

Security rule: when an MCP has write access to production, keep Request Review enabled. Never grant write access without supervision.

Step 4. Give AI Knowledge (Agent Skills)

Skills are reusable modules of specialized knowledge. Unlike MCPs (which are tools), Skills are specialization: teach the agent about design, architecture, content tone, brand guidelines, etc.

4.1 Install public Skills from GitHub

Go to Skills > Install from GitHub.
Paste the URL of the skill repository you want to install.
Install it in the current workspace so it only applies to this project.

Example: install a skill

# Step by step 1. Open Skills panel in Antigravity 2. Click "Install from GitHub" 3. Paste repository URL: https://github.com/user/my-design-skill 4. Select scope: "This workspace only" 5. Click "Install" 6. Verify it appears in the active Skills list

Screenshot (English UI): installing a skill from a GitHub repository.

4.2 Create a custom Skill from a PDF

Upload your PDF (brand manual, technical guide, design system) in the workspace or the Skills module.
Indicate the name of the skill and the scope: UI, typography, colors, components, tone of voice.
Generate the skill and use it as a standard for all future project changes.

Example: create skill from brand guidelines

# Skill configuration Name: Brand Guidelines - My Company Source: brand-guidelines-2024.pdf Scope: - Color palette (primary, secondary, neutral) - Typography (families, weights, sizes) - Spacing and layout (margins, padding, grid) - Tone of voice (formal, friendly, technical) - UI Components (buttons, cards, forms) Application: current workspace

Screenshot (English UI): creating a custom skill from a PDF.

Tip: combine multiple skills. For example: a brand skill + an architecture skill + an accessibility skill. The agent will apply all of them simultaneously.

Step 5. Development Workflow (Execution)

Goal: never code blind. Force a planning stage before writing code, then execute by specialty (Antigravity or Claude Code), and finally multi-agent coordination if applicable.

5.1 Interactive planning with Planning Mode

Activate Planning Mode and request a plan.md document.
The plan must include: scope, architecture, task list, database schema, validation criteria and risks.
Rule: not a single line of code is written until the plan is approved.

plan.md (copyable template)

# Development Plan: [Feature Name] ## 1. Scope - What will be built (and what will NOT be built) - Clear and measurable acceptance criteria ## 2. Architecture - Components involved (frontend, backend, DB) - Flow or sequence diagram (if applicable) - External dependencies (APIs, services) ## 3. Tasks (ordered by priority) - [ ] Task 1: clear description - [ ] Task 2: clear description - [ ] Task 3: clear description ## 4. Database - New or modified tables - Relationships and constraints - Required migrations ## 5. Validation - Required unit tests - Required integration tests - Lighthouse criteria (performance, accessibility) ## 6. Risks - Risk 1: description + mitigation - Risk 2: description + mitigation ## 7. Assignment - Antigravity: infra/backend tasks - Claude Code: frontend/UX tasks

Screenshot (English UI): example plan.md generated in Planning Mode.

5.2 Heavy lifting and backend with Antigravity

Use Antigravity for: infrastructure, DB migrations, CI/CD, automations and macro tasks.
Delegate repeatable tasks to Workflows and MCPs.
Keep reviews active when the change impacts data or production deployments.

Typical Antigravity tasks

# Infrastructure - Configure environment variables (.env) - Create tables and relations in Supabase - Configure Row Level Security (RLS) # CI/CD - Configure automatic deploy (Vercel / Netlify) - Create testing pipeline in GitHub Actions - Configure preview deployments per PR # Automations - Image optimization workflow - Automatic database backup - Error notifications to Slack

Heavy lifting and backend with Antigravity

Screenshot (English UI): heavy lifting and backend delegated to Antigravity.

5.3 Frontend and complex logic with Claude Code

Use Claude Code for: UI, components, UX, refactors, state logic and fine debugging.
Define the model to use: Opus for complex tasks, Sonnet for quick tasks.
Always validate with tests and visual criteria before merge.

Typical Claude Code tasks

# Components and UI - Create dashboard component with charts - Implement responsive mobile-first layout - Design form with real-time validation # Complex logic - Refactor permissions system (RBAC) - Implement global state with Zustand/Context - Resolve data race condition bug # Optimization - Improve Lighthouse score (LCP, CLS, FID) - Reduce bundle size with code splitting - Implement virtual scrolling for large lists # Recommended model Opus > Large refactors, architecture, complex debugging Sonnet > Simple components, quick fixes, style adjustments

Frontend and complex logic with Claude Code

Screenshot (English UI): frontend and complex logic delegated to Claude Code.

5.4 Multi-agent orchestration (Agent Manager and Agent Teams)

If the project is complex, divide work by domains: frontend, backend, research and QA.
In Antigravity use Agent Manager to launch multiple agents in parallel by folders.
In Claude Code use Agent Teams to form specialists and coordinate interdependent tasks.

Example: agent distribution

# Agent Teams Configuration Agent 1: Frontend Lead - Scope: /src/components, /src/pages, /src/styles - Responsibility: UI, components, responsive, accessibility - Model: Claude Opus Agent 2: Backend Lead - Scope: /supabase, /api, /scripts - Responsibility: DB, migrations, edge functions, RLS - Model: Claude Sonnet Agent 3: QA Lead - Scope: /tests, /e2e, /cypress - Responsibility: unit tests, integration, regression - Model: Claude Sonnet Agent 4: Research - Scope: entire repository (read only) - Responsibility: dependency analysis, vulnerabilities, improvements - Model: Claude Opus

Screenshot (English UI): parallel agents organized by folders and responsibilities.

When to use multi-agent: when the project has more than 3 independent domains or when you need frontend and backend to advance in parallel without blocking.

Step 6. Fix Automation (Workflows)

Workflows are persistent macros. They turn a recurring improvement into a reusable command that executes the same procedure consistently every time.

6.1 Create a workflow for repeated problems

Identify a recurring pattern (heavy images, lint errors, broken tests, low performance).
Define exact and verifiable steps. Avoid ambiguous instructions like "improve performance".
Save the workflow with a short command-style name: /optimize_images, /fix_lint, /run_tests.

Screenshot (English UI): example workflow saved as a command.

6.2 Workflow templates (copyable)

Use these templates as a starting point for your own workflows.
Each workflow must end with evidence (logs, metrics, screenshots, reports).
Without evidence there is no trust.

/optimize_images

/optimize_images 1. Scan repository for images larger than 200KB 2. Convert to WebP format with 80% compression 3. Add lazy loading to all images below the fold 4. Run Lighthouse and capture performance score 5. Create PR with evidence: size before vs after + score

/fix_lint

/fix_lint 1. Run ESLint on the entire project: npx eslint . --fix 2. Run Prettier: npx prettier --write . 3. Review modified files with git diff 4. If there are changes, create commit: "fix: auto-fix lint and formatting" 5. Validate no remaining errors: npx eslint .

/run_full_check

/run_full_check 1. Run unit tests: npm run test 2. Run e2e tests: npm run test:e2e 3. Run production build: npm run build 4. Run Lighthouse on preview URL 5. Generate report with: tests passed/failed + build status + scores 6. If everything passes: approve merge. If it fails: list errors and suggest fix.

/setup_new_feature

/setup_new_feature [name] 1. Create branch: git checkout -b feature/[name] 2. Generate plan.md with Planning Mode 3. Create folder structure if applicable 4. Add test placeholders for the new functionality 5. Create draft PR with plan description 6. Assign agents by domain (if multi-agent applies)

Best practice: each workflow must end with evidence (logs, metrics, screenshots, reports), not just code changes. Without evidence there is no trust.

Final Configuration Checklist

Use this list as a quick validation before starting development on any project.

Verification Checklist

Antigravity installed and workspace properly opened.
Claude Code installed, enabled and accessible from sidebar or terminal.
Review Policy set to Request Review (or justified if set to Always Proceed).
rules.global.md file created with developer conventions.
rules.workspace.md file created with project constraints.
MCP Servers installed only if they contribute to the flow, with controlled permissions.
Skills installed or created (brand, architecture, UX, accessibility).
Planning Mode executed and plan.md approved before writing code.
If high complexity: parallel agents defined by domain.
Workflows created for repeated routines (performance, lint, tests, images).

Quick Checklist (copyable)

# Configuration Checklist - Antigravity + Claude Code - [ ] Antigravity installed + workspace opened - [ ] Claude Code extension installed and active - [ ] Review Policy: Request Review (default) - [ ] rules.global.md created - [ ] rules.workspace.md created - [ ] MCPs configured (only necessary ones) - [ ] Skills installed (brand, architecture, UX) - [ ] plan.md generated and approved - [ ] Multi-agent configured (if applicable) - [ ] Workflows created for repeated routines - [ ] First project commit made - [ ] Draft PR created with initial plan