How to Use Antigravity AI: Complete Google Antigravity Tutorial

What Is Google Antigravity and How Does It Work?

Google Antigravity is an agent-first platform for delegating coding and knowledge-work tasks to AI agents. Antigravity 2.0 is its standalone desktop command center, while Google also provides Antigravity CLI, Antigravity IDE, and editor extensions for developers who prefer other workflows. Agents can plan work, read and write project files, execute system commands, interact with Chrome, use external tools, coordinate subagents, and create Artifacts such as implementation plans.
That distinction matters.
A traditional AI coding assistant usually works inside the developer’s existing workflow. You remain the main operator and ask for suggestions as needed.
Antigravity pushes more of the workflow toward task delegation. If you are coming from a more editor-centered AI coding tool and want to understand how the working styles differ, the Antigravity vs Cursor comparison gives that distinction more context without changing the basic workflow covered here.
A typical task might look like this:

1. You describe a feature.
2. The agent inspects the relevant project files.
3. It creates an implementation plan.
4. You review or correct that plan.
5. The agent writes or modifies the code.
6. It starts the application through the terminal.
7. It tests the result.
8. It returns a walkthrough, screenshots, plans, or other Artifacts for review.

Antigravity 2.0 is now the main orchestration surface. It organizes work through Projects and agent conversations, while the separate Antigravity IDE remains available for developers who want a full editor-based experience.
You should still treat the agent’s output as code that requires review. Autonomy reduces manual work; it does not remove the need for engineering judgment.

How to Set Up Google Antigravity

Getting started does not require a complicated development environment.

Install Antigravity 2.0

The setup process follows this general path:

1. Download Antigravity 2.0 for your operating system.
2. Install and open the application.
3. Sign in with your Google account.
4. Create a new Project.
5. Add one or more local folders or Git repositories to that Project.
6. Configure Project-specific settings or permissions if needed.
7. Start an agent conversation and choose Local Mode or New Worktree Mode.
8. Choose an available model and submit your first focused task.

Availability, models, and plan entitlements may vary by account and region. If you want to check how those access levels differ before choosing a tier, the Antigravity pricing guide covers the plan structure separately so this tutorial can stay focused on using the product.
If you prefer a longer-duration access option, you can review Antigravity AI access separately from Google’s direct plans.

Choose Your Permission Settings Carefully

Antigravity 2.0 lets you control how much access an agent receives. On macOS and Linux, the main permission presets are:

• Default: runs eligible commands inside the Terminal Sandbox and asks for approval when an action needs to go outside that boundary.
• Request Review: requires approval for terminal commands and keeps file access more tightly scoped.
• Turbo: removes most prompts and gives the agent broad filesystem and command access, so it should be used only when you understand the risk.

Windows uses a different set of execution and file-access controls, so the labels can vary by platform.

For a new user, starting with more oversight is usually sensible.
There is little advantage in granting maximum autonomy before you know how an agent interprets your instructions, how it structures its plans, or what types of changes you are comfortable allowing without review.
As you gain confidence, you can delegate more predictable tasks more aggressively.

Understand the Antigravity 2.0 Workspace

You do not need to learn every menu before using Antigravity, but a few areas are worth understanding immediately.

Projects

Projects define the folders and repositories an agent can work with. A Project can include one or multiple folders, and it keeps settings and permissions scoped to that work. For larger changes, New Worktree Mode can also isolate an agent’s edits from your active working tree.

Conversations and Agents

Inside a Project, you can start separate agent conversations for different pieces of work and monitor them independently.
For example:

• one conversation for authentication;
• another for dashboard UI;
• another for test coverage.

This separation makes failures easier to diagnose and reduces the pressure to keep every requirement inside one long thread.

Artifacts

Artifacts are outputs that help explain what the agent intends to do or what it has completed.
Depending on the task, they can include:

• task lists;
• implementation plans;
• walkthroughs;
• screenshots;
• verification information.

Think of them as review surfaces.
They are not merely documentation generated after the work is finished. An implementation plan can reveal a misunderstanding before the agent touches several files.

Browser and Terminal

Antigravity’s browser and terminal access are what make its workflow more than code generation.
An agent can potentially write a frontend change, start the local application, open it in the browser, interact with the resulting interface, and verify whether the feature behaves as intended.
The terminal also allows development tasks such as running scripts and working with project dependencies.
implement → run → observe → correct → verify
The important word is still verify. A process completing successfully does not necessarily mean the feature meets your requirement.
If you want a separate breakdown of Projects, Artifacts, browser tools, permissions, and other current capabilities, the Antigravity features guide covers those features in more detail.

How to Use Antigravity AI for Your First Coding Task

The easiest way to understand Antigravity is to use it on one small, clearly defined feature.
Avoid making your first task something like:

Build my entire SaaS application.

You will learn far more from a bounded task where success and failure are obvious.

Step 1: Open or Create a Project

Create a new project folder or open an existing repository.
For your first test, a simple project is useful because you can understand every meaningful change the agent makes.
If you’re using an existing application, make sure your repository is committed before allowing an agent to modify it. Version control gives you a clean comparison point and makes unwanted changes much easier to reverse.

Step 2: Start a New Agent Conversation

Open the Project, start a new agent conversation, and choose whether the work should run against your local folders or in a new worktree.
Treat each conversation as one engineering objective rather than one catch-all chat session.
A good task would be:

Add password visibility controls to the existing login and registration forms.

A poor task would be:

Improve the authentication, redesign the dashboard, optimize the database and make the whole website faster.

The second request contains several independent problems. If the result is poor, you will struggle to determine which part of the task caused the agent to lose focus.

Step 3: Describe What You Want Built

Give the agent enough information to understand both the outcome and the boundaries.

Add a show/hide password control to the existing login form. Keep the current form layout and validation logic unchanged. The control should toggle the password field between hidden and visible states. Use the project’s existing icon library rather than installing another package. After implementing it, test both states in the browser.

This prompt specifies:

• the desired feature;
• what must remain unchanged;
• an implementation constraint;
• how success should be tested.

That is far more useful than adding vague phrases such as “make it professional.”

Step 4: Review the Agent’s Plan

If the task produces an implementation plan, read it before approving substantial changes.
Check four things:

• Does the plan solve the problem you actually described?
• Does it touch the files you expect?
• Is it introducing anything you did not request?
• Does the testing plan prove that the feature works?

This review can take a minute and prevent much longer cleanup later.

Step 5: Let the Agent Implement the Changes

Once the plan makes sense, let the agent perform the implementation.
Watch for unnecessary expansion of scope.
If you requested a small form change and the agent starts rewriting the authentication architecture, that is not initiative. It is scope drift.
A useful coding agent should make the smallest reliable set of changes needed to satisfy the requirement unless a broader modification is technically necessary.

Step 6: Test the Result

Do not stop when the agent reports that implementation is complete.
Run or inspect the tests it performed.
>For a UI feature, check the browser yourself.
>For backend behavior, inspect the relevant responses, logs, or automated tests.
>For a bug fix, reproduce the original problem and confirm that it no longer occurs.

Step 7: Review the Final Changes

Before accepting the task, inspect the changed files.

• unrelated modifications.
• unnecessary dependencies.
• duplicated logic.
• removed validation.
• temporary debugging code.
• new warnings or errors.
• changed behavior outside the requested feature.

The agent’s walkthrough tells you what it believes it changed. Your diff tells you what it actually changed.
Those are not always the same thing.

How to Prompt Google Antigravity Correctly

Prompt quality matters, but “write a very detailed prompt” is not useful advice on its own.
The goal is not maximum detail. It is relevant detail.

Use This Antigravity Prompt Framework

A practical Antigravity prompt usually works better when the important requirements are separated clearly instead of buried in a long paragraph.
Goal: State the outcome.

Add server-side pagination to the orders table.

Current behavior: Explain what happens now if that context matters.

The page currently loads every order at once.

Expected behavior: Describe the result you want.

Load 25 orders initially and fetch another page when the user changes pages.

Scope: Tell the agent where the work belongs.

Modify the existing orders page and its current API route. Do not create a second orders API.

Constraints: Mention anything that must remain unchanged.

Keep the existing filters, sorting behavior and table component.

Implementation requirements: Include technical requirements that genuinely matter.

Pagination must happen at the database-query level rather than loading all records and slicing them in the browser.

Testing requirements: Tell the agent what should be verified.

Test the first page, next page, previous page and filtering while pagination is active.

Expected output: For larger work, define what you want returned.

Provide a short walkthrough listing the files changed and how pagination was verified.

This structure works because it reduces interpretation.
If the requirements are still vague, Antigravity’s /grill-me command can help before implementation begins. It prompts the agent to ask targeted questions about areas such as architecture, error handling, performance, and backward compatibility, which is useful when a short feature request hides decisions that need to be resolved first.

Bad Prompt vs Better Prompt

A weak debugging prompt:

Fix checkout.

The agent has to guess what “fix” means.
A better version:

Checkout currently creates an order even when payment initialization fails. Change the flow so an order is created only after payment initialization succeeds. Keep the existing cart and pricing logic unchanged. Reproduce the failure case first, implement the fix, and then test both successful and failed payment initialization.

That prompt gives the agent a measurable definition of success.

Planning Mode vs Fast Mode: Which Should You Use?

Antigravity distinguishes between Planning Mode and Fast Mode.
Planning Mode creates a more detailed plan before execution, while Fast Mode is intended for quicker, more direct changes.
Neither is universally better.

When to Use Planning Mode

Use Planning Mode when the main risk is making the wrong changes, not simply writing the code incorrectly.

• architecture work.
• features spanning several modules.
• significant refactoring.
• changes involving unfamiliar code.
• tasks with important constraints.

The plan gives you an opportunity to correct the direction while changing a few lines of text is still cheap.
For repository-level planning, Antigravity also provides the /plan command. It can inspect the codebase, identify the files likely to be affected, and produce a structured implementation plan for review before code changes begin.

When to Use Fast Mode

Fast Mode makes more sense when the work is already obvious.

• changing button copy.
• adjusting a known UI component.
• fixing a straightforward styling issue.
• updating a clearly identified function.
• carrying out repetitive but tightly specified edits.

Using a full planning cycle for every tiny change slows down the workflow without adding much safety.

How to Choose the Right Antigravity AI Model

There is no useful answer to “Which Antigravity model is best?” without asking best for which task?
Model capabilities change over time, and the difference between model families cannot be reduced to a permanent rule such as “Flash is only for simple code” or “Pro should always handle reasoning.” A better approach is to look at the current models available in Antigravity and choose according to the type of work, the amount of reasoning required, and how much supervision the task needs.
Current Antigravity options include Gemini 3.8, 3.7 and 3.6 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6, Claude Opus 4.6, and GPT-OSS-120B, although availability depends on the plan and can change over time.

Do Not Treat Flash and Pro as Fixed Capability Levels

Older Antigravity workflows often treated Flash as an implementation-focused option and Pro as the model reserved for complex reasoning.
That distinction should not be treated as a permanent rule.
Model generations improve, and newer Flash-class models can handle substantially more reasoning and agentic work than earlier versions. Likewise, a Pro-class model may still make sense when a task requires deeper analysis, architectural judgment, or careful review, but the model label alone should not decide the workflow.
A better rule is:

Choose the model based on the current task and the capabilities of the model version available to you, not only the name attached to it.

A Better Model Workflow for Larger Tasks

For larger tasks, separate the work by stage instead of forcing a fixed Pro → Flash → Pro sequence.
Start by using a model capable of understanding the project and producing a reliable implementation plan.
Once the plan is clear, implementation can be handled by whichever available model performs the task efficiently without losing the required context.
After implementation, use testing and review to decide whether the task needs another reasoning pass.
A practical workflow looks like this:

1. Give the model the requirement, relevant project context, constraints, and existing behavior.
2. Ask for an implementation plan before major changes.
3. Review the proposed files, architecture, and testing approach.
4. Use an appropriate available model to perform the implementation.
5. Run the relevant tests and inspect the application behavior.
6. If something fails, provide the error, failed test, logs, and changed files rather than simply saying “it doesn’t work.”
7. Use a stronger reasoning pass when the problem requires diagnosis, architectural review, or regression analysis.

This keeps model selection flexible and avoids wasting higher-capability usage where it adds little value. If you are deciding whether the free access is enough for this workflow or whether paid access makes more sense. the Antigravity Free vs Pro comparison looks at that decision separately without interrupting the tutorial itself.

How to Use Antigravity Projects and Multiple Agents

Multiple agents become useful when parallel work is genuinely separable.
Antigravity 2.0 organizes those conversations inside Projects and can use subagents for parallel work, but more agents are not automatically better than one.
Launching several agents against the same codebase without clear boundaries can create overlapping edits, conflicting assumptions, and more review work than it saves. For substantial parallel changes, isolated worktrees can reduce conflicts between conversations.

Give Each Agent a Clear Role

• Agent 1 — Architecture and planning: reviews the codebase and proposes the implementation.
• Agent 2 — Implementation: builds the approved feature.
• Agent 3 — Testing: checks expected behavior and edge cases.
• Agent 4 — Review: examines the implementation for regressions or unnecessary changes.

Another project might separate agents by technical boundary:

• frontend;
• backend;
• tests.

The specific division matters less than avoiding ambiguous ownership.

Keep Agent Tasks Independent Where Possible

Parallel agents work best when their changes do not constantly depend on one another.
For example, asking one agent to redesign the authentication API while another simultaneously rewrites the login interface around the old API creates obvious coordination risk.
Parallelism is useful only when the tasks can move independently or when their interfaces have already been clearly defined.

How to Test and Verify Code With Antigravity

Generated code should be treated exactly like code from another developer: review it and test it.
Antigravity’s browser integration makes verification more practical, particularly for web applications, but “the page opened successfully” is not enough.

Functional Testing

Test the actual requirement.
If the task was to prevent duplicate form submissions, clicking the button once proves almost nothing.
You need to reproduce the behavior that caused duplicate submissions.

Browser Testing

For interface changes, ask the agent to interact with the application instead of only compiling it.

• whether elements appear.
• whether controls respond.
• whether navigation works.
• whether state updates correctly.
• whether error messages appear where expected.

Regression Checking

One of the easiest mistakes in AI-assisted coding is fixing the requested behavior while breaking something adjacent.
If the agent changes login logic, test more than one successful login.

• invalid credentials.
• validation.
• redirects.
• existing sessions.
• logout behavior where relevant.

The exact regression tests depend on the change. The principle does not.

Error-State Testing

Agents naturally gravitate toward proving that the happy path works.
Production bugs often live outside the happy path.

• an API fails.
• input is empty.
• data is malformed.
• a required resource is missing.
• a network request takes longer than expected.

Compare the Result With the Original Requirement

A technically working feature can still be the wrong feature.
Return to the original prompt and check each requirement explicitly.
That final comparison is often more valuable than another round of generated tests.

How to Review Antigravity Artifacts Before Accepting Changes

Artifacts are most useful when you treat them as evidence rather than decoration.

• Did the agent understand the requested scope?
• Which files changed?
• Were unrelated files touched?
• What assumptions did the agent make?
• Were new libraries or dependencies introduced?
• What tests were executed?
• What did the browser verification actually prove?
• Were any known limitations left unresolved?

One practical habit helps a lot:

Compare the plan, the final walkthrough, and the actual Git diff.

If they tell three different stories, investigate before merging the change.

How to Fix an Antigravity Agent When It Gets Something Wrong

When an agent makes a mistake, restarting everything is rarely the best first move.

Identify the Failure

• misunderstanding the requirement;
• editing the wrong component;
• missing existing project logic;
• an incorrect assumption;
• incomplete testing;
• a regression introduced elsewhere.

The correction depends on the cause.

Give Targeted Feedback

What is wrong

The modal now closes when validation fails.

What should happen

It should remain open and show the validation message.

What must remain unchanged

Do not change the current successful-submit behavior.

That gives the agent a narrow correction target.
“Try again” gives it almost nothing.

Escalate Difficult Problems

If the model repeatedly makes local fixes that create new problems elsewhere, stop asking it to patch the symptoms.
Move the problem to a model capable of deeper diagnosis and provide:

• original requirement;
• implementation plan;
• current diff;
• failed tests;
• errors;
• behavior you observed.

At that point, you need diagnosis more than another code edit.

How to Use Antigravity With an Existing Codebase

Existing applications require more caution than greenfield demos.
The agent has to understand decisions it did not make.
Before asking for a significant feature, let it inspect the relevant architecture.
If your workflow is more browser-first than local-repository-first Replit Core access is a separate alternative worth evaluating rather than mixing that decision into the Antigravity setup itself.

1. Open the repository.
2. Ask the agent to inspect the parts related to the feature.
3. Have it explain the existing architecture before editing.
4. Correct any misunderstanding.
5. Define the exact feature boundary.
6. Request an implementation plan.
7. Review the files it intends to touch.
8. Let it implement the change.
9. Run existing tests.
10. Test the new behavior.
11. Review the final diff.

Suppose you need to change billing logic.
Starting with:

Add annual subscriptions.

is risky if the agent has not yet examined how subscriptions, payments, renewals, and product plans currently relate to each other.
A better first request is:

Inspect the existing subscription and payment flow. Explain how plan selection, checkout, subscription creation, and renewal are currently connected. Do not modify any files yet.

Once its understanding is accurate, planning the change becomes much safer.

Antigravity AI Best Practices

• Keep tasks narrow. One clear objective is easier to implement, test, review, and revert.
• Give context before complex work. An agent cannot make good architectural decisions if it does not understand the relevant architecture.
• Use planning where mistakes would be expensive. A short plan review can prevent a large incorrect implementation.
• Tell the agent what not to change. Constraints are often as valuable as requirements.
• Separate reasoning from repetitive execution. Use capable models for uncertain decisions and efficient models for implementation that has already been specified.
• Ask for verification explicitly. “Implement this” and “implement and prove this behavior works” produce different workflows.
• Inspect the diff. Agent-generated explanations can be useful, but the repository remains the source of truth.
• Commit before large agent tasks. Good version-control hygiene makes experimentation much safer.
• Correct wrong assumptions early. Once an agent starts building on a false assumption, later corrections become progressively more expensive.

Common Mistakes When Using Antigravity AI

Using Vague Prompts

“Improve this page” gives the agent too much room to invent your intent.
Define the actual problem.

Combining Unrelated Tasks

Large prompts often feel efficient because you only need to submit them once.
They are usually harder to verify.
Separate work that can fail independently.

Using the Strongest Model for Everything

A higher-capability model is unnecessary for every predictable text, styling, or repetitive code change.
Use stronger reasoning where judgment and project context actually matter.

Choosing a Model by Name Instead of the Task

Model families and versions change over time.
Do not assume that every Flash model is only suitable for simple implementation or that every complex task automatically requires a Pro-labelled model.
Look at the current model’s capabilities and match them to the work.

Skipping the Plan

On a three-line change, this may not matter.
On an authentication refactor, it can matter a great deal.

Accepting “Task Complete” as Verification

Completion status tells you the agent stopped working.
It does not prove that the feature is correct.

Ignoring Unrelated Changes

An agent may technically satisfy your request while cleaning up, refactoring, or changing code you never asked it to touch.
Review that work rather than assuming additional changes are improvements.

Frequently Asked Questions

How do I use Google Antigravity for coding?

Create or open a Project, start an agent conversation, describe the feature or problem clearly, choose the appropriate mode, review the agent’s plan when needed, allow it to implement the changes, then test and review the result. For complex work, give the agent project context and constraints before asking it to write code.

What is Google Antigravity AI used for?

Google Antigravity is used to delegate coding and other multi-step tasks to AI agents. Depending on the workflow, agents can inspect files, modify code, execute commands, interact with Chrome, create implementation plans, use external tools, and coordinate subagents. Common uses include feature development, debugging, testing, code review, research, and automation.

Is Google Antigravity free?

Yes. Google currently offers an Individual Antigravity option at $0 per month with basic weekly rate limits, unlimited Tab completions, and unlimited Command requests. Google AI Pro and Ultra provide more generous usage limits and additional AI-credit options. Limits and plan details can change over time.

Is Google Antigravity suitable for beginners?

It can be approachable for beginners because much of the workflow uses natural-language instructions, but beginners should avoid treating generated code as automatically correct. Starting with smaller projects and more review-oriented settings makes it easier to understand what the agent is changing and why.

What replaced the Antigravity Agent Manager?

Antigravity 2.0 replaced the older Agent Manager as the main standalone orchestration surface. Work is now organized through Projects and agent conversations, while the separate Antigravity IDE remains available for developers who prefer a full editor-based workflow.

Should I use Planning Mode or Fast Mode?

Use Planning Mode when a task is complex, risky, multi-file, or requires architectural decisions. Fast Mode is better suited to narrow changes where the implementation is already obvious.

Which Antigravity model should I use?

Choose according to the task rather than looking for one universal “best” model. For architecture, debugging, unfamiliar code, or high-risk reviews, prioritize a model with strong reasoning and codebase understanding. For clearly defined or repetitive implementation, a faster capable model may be more efficient. Because model capabilities change, check the options currently available in Antigravity rather than relying on an old model hierarchy.

How should I prompt Google Antigravity?

Describe the goal, current behavior, desired behavior, scope, constraints, implementation requirements, and how the agent should verify the result. You do not need an enormous prompt. You need enough relevant information to remove important ambiguity.

Can Antigravity test the code it generates?

The Antigravity workflow includes terminal and browser capabilities that can be used during implementation and verification. For web development, this allows an agent to run an application and interact with it in the browser rather than stopping after generating code. You should still review important tests and reproduce critical behavior yourself.

Can I use multiple agents in Antigravity?

Yes. Antigravity supports multi-agent workflows, but multiple agents are most useful when responsibilities are clearly separated. Giving several agents overlapping ownership of the same files can create coordination problems, so divide work by feature, technical boundary, or role when possible.

Getting Better Results From Antigravity AI

Knowing how to use Antigravity AI effectively comes down to managing the development process rather than simply writing clever prompts.
Define one task clearly. Give the agent the context it needs. Use planning when the task contains meaningful uncertainty. Match the model to the type of work. Review the implementation plan before expensive changes, test the result against the original requirement, and inspect the actual code before accepting it.
A reliable Antigravity workflow looks like this:
Define → Plan → Implement → Test → Review → Correct → Verify
Once that process becomes routine, the useful question stops being “How much code can the agent generate?”
If Antigravity is one part of a wider AI development stack Primingo AI tools lists other software subscriptions separately so those choices do not distract from the workflow covered here.
The better question is:

How much development work can I delegate while still understanding and verifying the result?

That is where agent-based coding starts becoming genuinely useful rather than simply faster.