DEV Community

James Miller
James Miller

Posted on

One Prompt, One App: Hands-On with Google Antigravity

#antigravity #google #gemini #webdev

Google Antigravity has been making a lot of noise lately. As Google’s own “agent-first” IDE, it’s already being called a Cursor killer in some circles.

Unlike traditional AI coding tools, Antigravity isn’t just “ChatGPT inside VS Code.” It’s more like a control tower for AI agents: you describe what you want, and multiple agents can plan, write code, run commands, and even use a browser to test your app end to end.

In this post, we’ll:

  • Walk through setup and initial configuration
  • Explain the key “agent-first” concepts
  • Show a real example: from one sentence to a running web app
  • Discuss how to integrate Antigravity into a broader local AI dev stack (Gemini CLI, Node.js 20, local LLMs, etc.)

From “Code Monkey” to “AI Project Manager”

Most AI coding assistants today follow this pattern:

  1. You write some code.
  2. You pause, send a prompt.
  3. Wait for the AI to suggest code.
  4. Copy/paste, tweak, repeat.

Antigravity flips that model:

  • AI agents are proactive actors with their own plans.
  • You, the developer, act more like an architect or tech lead:
    • Define the goal.
    • Set guardrails.
    • Review plans and artifacts.

You’re still coding, but a lot more of your time goes into orchestrating, not micromanaging every line.

Installing and Initializing Google Antigravity

Antigravity is currently in public preview, free to use with a Google account.

Basic steps:

  1. Download and install
    • Grab the installer from the official Antigravity site (Windows, macOS, Linux builds are available).

  1. First launch
    • Sign in with your Google account.
    • Import settings from VS Code / Cursor or start fresh.

  1. Pick your theme
    • Dark/light/high contrast—very familiar for VS Code users.

The most important part comes next: configuring agent permissions.

Critical Setup: What Are Agents Allowed to Do?

During setup, Antigravity asks you to define Terminal execution and Review policies. This is what makes it “agent-first” instead of “chat-first”.

1. Terminal Execution Policy

Controls whether agents can run shell commands directly:

  • Off

    • No automatic commands.
    • Every command requires your confirmation.
    • Safest mode, but slower.

  • Auto (Recommended)

    • The agent evaluates risk.
    • “Safe” commands auto-run; risky ones prompt for approval.
    • Good balance between speed and control.

  • Turbo

    • Almost everything runs automatically unless blacklisted.
    • Great for throwaway prototypes and sandboxes.
    • Use with caution on real environments.

2. Review Policy

Defines who approves plans and code changes:

  • Always Proceed

    • The agent never stops to ask.
    • Fastest, but easiest to lose oversight.

  • Agent Decides

    • The agent asks for review only at “important” checkpoints.
    • Useful when you want fewer interruptions but still key control.

  • Request Review

    • Every major artifact (plan, diff, etc.) requires explicit approval.
    • Slower, but appropriate for critical codebases or teams.

A good starting point is an “Agent-assisted development” style preset: agents act autonomously most of the time, but still seek your input at key steps.

The UI: Agent Manager + Editor

Antigravity is built on VS Code, but the UX is reorganized around two main surfaces.

Agent Manager: Your Control Tower

When you launch Antigravity, you see an Agent Manager view, not a file tree.

  • Each high-level request = a “mission” for an agent.
  • You can run multiple missions in parallel:
    • “Refactor auth module”
    • “Upgrade dependency tree”
    • “Write tests for billing service”
  • Each mission shows progress and artifacts independently, so you’re not stuck in a single linear chat thread.

Editor: A Code Editor That Knows About Agents

Press Cmd/Ctrl + E to switch to the Editor view:

  • Familiar VS Code experience: file explorer, syntax highlighting, extensions.
  • On the right is an Agent Panel that’s context-aware:
    • Highlight a block of code → ask the agent to refactor, explain, add tests, or port it to another framework.
    • The agent sees the current file and project context.

It feels like VS Code with a deeply integrated AI teammate, wired into the global “mission” system you saw in Agent Manager.

Browser Agent: AI That Actually Uses a Browser

When you give tasks like:

  • “Read the official docs at X, then configure the project accordingly.”
  • “Run the app, log in as a test user, and verify the checkout flow.”

Antigravity spawns a browser sub-agent:

  • It controls a dedicated browser instance: clicks, scrolls, typing, reading console logs.
  • This browser environment is isolated:
    • No shared cookies or history with your main browser.
    • Clean, reproducible test runs.
    • Better privacy and more objective results.

Artifacts: Plans, Diffs, Screenshots, and Video

When an agent says, “Done,” you shouldn’t have to just trust it.

Antigravity gives you Artifacts:

  • Task Plans – a human-readable outline of what the agent intends to do.
  • Code Diffs – standard diff views, just like reviewing a PR.
  • Screenshots – for UI-related changes.
  • Screen Recordings – video of the browser agent interacting with your app, e.g.:
    • Click “Log in”.
    • Wait for redirect.
    • Check UI text and behavior.

You can review artifacts before merging or deploying, like a “mini CI report” generated by your AI teammate.

Demo: From One Prompt to a Running Web App

Let’s go through a simple example: creating a small to‑do web app with a hand-drawn style.

Step 1: Describe the App

In the Agent Manager playground, you type:

“Create a simple todo app with a hand-drawn aesthetic. Minimal UI, with completed state and local persistence.”

Step 2: Planning

The agent will:

  • Summarize the requirements.
  • Propose a stack (for example Vite + React + Tailwind + custom CSS).
  • Generate a Task Plan:
    • Initialize project.
    • Design page layout.
    • Build TodoItem and TodoList components.
    • Add localStorage persistence.
    • Optionally write some smoke tests or basic E2E checks.

You can edit this plan — remove steps, add constraints, or change tech stack — before letting it run.

Step 3: Execution and Auto-Testing

During execution:

  • The agent initializes the project and installs dependencies.
  • Writes/updates files, each change visible via diff artifacts.
  • When done, a browser agent launches the app and:
    • Adds a few tasks.
    • Marks some as complete.
    • Reloads the page to ensure data persists.

The entire test session is recorded and attached as an artifact.

Step 4: Review the Result

After a few minutes, you have:

  • A working project in your workspace.
  • Plans, diffs, screenshots, and a video of the app in use.

You can then:

  • Polish the UI and animations.
  • Add more sophisticated logic.
  • Ask the agent to write additional tests or deployment scripts.

This is just a small example, but the pattern scales up to more complex tasks like:

  • “Build a kanban board with authentication and persistent storage.”
  • “Add unit tests and integration tests for the existing payment module.”

The key is that Antigravity gives you a closed loop: plan → implement → run → verify → show artifacts.

Don’t Forget Your Local Stack: Gemini CLI, Node.js 20, and Local LLMs

Antigravity is powerful as an IDE + agent platform, but real-world workflows rarely live entirely inside one tool.

You might also want to:

  • Run Gemini CLI locally to interact with Gemini 3 models via terminal.
  • Prototype data pipelines, agents, or tools that call Gemini directly.
  • Run local LLMs (Gemma, Qwen, Llama, etc.) for privacy‑sensitive tasks or offline experimentation.
  • Attach databases and external services for end‑to‑end testing.

This is where your local environment matters:

  • To run Gemini CLI locally, you typically need a proper, up‑to‑date Node.js runtime (often Node.js 20+).
  • You may be juggling multiple languages and versions (Node, Python, Go, etc.) across projects.

You can roll your own stack with nvm, pyenv, Docker, and ad‑hoc scripts, but that quickly becomes fragile and time‑consuming.

A more sustainable route is using a local dev environment manager (like ServBay) that can:

  • Provide curated runtimes and services per project.
  • Handle Node.js 20 and beyond without manual installer drama.
  • Keep local services (databases, queues, local LLMs) isolated yet easy to spin up.

That way, Antigravity covers your “agent-first IDE” needs, while your local stack handles Gemini CLI, service orchestration, and any compute you want to keep on your own machine.

Final Thoughts

Google Antigravity is one of the clearest glimpses so far of what “agent-first” development can look like:

  • Multiple agents, each with their own mission.
  • Deep control over editor, terminal, and browser.
  • Artifacts that make AI work auditable instead of mysterious.

Combined with a solid local setup—where you can run Gemini CLI, manage Node.js 20 and other runtimes, and spin up local models—you get a workflow that feels much more like you directing a team of AI engineers, not just “asking a chatbot for snippets.”

Have you tried Antigravity yet, or are you using tools like Cursor, Windsurf, or plain VS Code + extensions?

Which workflow feels the most natural and productive to you? Share your experience in the comments—this space is evolving fast, and we’re all figuring it out together.

Top comments (0)