Google's Antigravity vs. Claude Code: What the I/O 2026 Launch Reveals About the Future of Agent Workflows

Source: Lenny Rachitsky's "How I AI" podcast, Google I/O 2026 Day 1 recap with Claire Vo

What launched at Google I/O 2026 (30-minute day 1 recap)

Google just shipped a direct Claude Code competitor. It's called Antigravity 2.0, it runs on Gemini 3.5 Flash, and the slash command design is worth studying — not because you should switch, but because the competitive pressure is clarifying exactly what makes Claude Code's architecture better and where it's exposed.

Claire Vo's live-testing session on day one of Google I/O 2026 is the most useful practitioner walkthrough of the new tooling. Here's what matters for your workflows.

The Competitive Landscape Just Shifted — Here's the Actual Topology

Before drilling into mechanics, map the battlefield accurately:

graph TD A[Agentic Coding CLI Tools] --> B[Claude Code\nAnthropic] A --> C[Antigravity 2.0\nGoogle] A --> D[Codex CLI\nOpenAI] B --> B1[Strongest: /goal structured workflows\nMulti-agent orchestration\nLarge context window\nMature CLAUDE.md ecosystem] C --> C1[Strongest: /grill-me slash command\nScheduled tasks\nNative Workspace integration\nSubagent architecture] D --> D1[Strongest: OpenAI ecosystem\nCodex model fine-tuning\nAPI native] B1 --> E[Claude Code wins on:\nRepeatable structured workflows\nLong-running supervision] C1 --> F[Antigravity wins on:\nGoogle Workspace integration\nAggressive clarification UX]

The important signal from Claire Vo's live test: Antigravity 2.0 shipped real features on launch day — projects, scheduled tasks, subagents, and slash commands — and some of them worked in the live demo. That's notable because Google's historical pattern is announce-then-wait. The gap between announcement and actual availability has been a persistent complaint, and Vo confirmed it was still a problem for some of the Day 1 products (more on that below). But Antigravity itself appeared functional.

Antigravity 2.0: What They Actually Shipped

Per Claire Vo's live CLI test, these are the confirmed-working features as of May 19, 2026:

Projects — persistent context containers, analogous to Claude Code's project-scoped CLAUDE.md. You define a project once; the agent remembers architecture decisions, conventions, and preferences across sessions.

Scheduled tasks — fire-and-forget async jobs. Set a task to run at a defined time without babysitting the process. Claude Code doesn't have native scheduling; you're currently doing this with cron + shell scripts wrapping claude commands.

Subagents — Antigravity can spawn child agents within a task. This is their answer to Claude Code's multi-agent orchestration. The architecture is similar: an orchestrator delegates subtasks to subagents, collects results, synthesizes.

Slash commands — the most immediately applicable feature for Claude Code power users, because the concept is directly portable.

The /grill-me Command: Why This Is Architecturally Interesting

This is the thing worth studying carefully.

/grill-me is Antigravity's clarification-forcing slash command. When invoked before a task, it puts the agent into an adversarial questioning mode — the agent actively probes your requirements, challenges your assumptions, and extracts ambiguity before writing a single line of code.

Per Vo's walkthrough, this is distinct from standard clarification flows in a specific way: it's aggressive and structured, not passive. Standard Claude Code behavior when encountering ambiguity is to make a reasonable assumption and proceed (configurable via your CLAUDE.md with instructions like "ask before proceeding when X"). /grill-me inverts this — the agent treats your initial prompt as a draft specification and interrogates it.

Why this matters for your Claude Code workflows:

Claude Code's clarification behavior is currently controlled through CLAUDE.md instructions and prompt engineering. You can approximate /grill-me behavior right now with a custom slash command. Here's the pattern:

# .claude/commands/grill-me.md

Before starting any implementation, enter specification interrogation mode:

1. Identify every ambiguous requirement in the task description
2. List all assumptions you would normally make silently
3. For each assumption, ask whether it should be confirmed or is safe to proceed
4. Identify edge cases the spec doesn't address
5. Challenge the approach: is there a simpler solution that achieves the same goal?
6. Only proceed to implementation after I've responded to your questions

Do not be polite about gaps. Surface problems aggressively.

Save this as .claude/commands/grill-me.md in your project root. Invoke it with /grill-me in Claude Code.

"The /grill-me slash command could be a more aggressive alternative to Claude Code's clarification flow."
— Claire Vo

The underlying mechanism: forcing an explicit specification interrogation phase before execution dramatically reduces mid-task corrections. The cost is a longer setup conversation. The benefit is the agent doesn't burn 20 minutes implementing the wrong thing while you're doing something else.

When to use it:

New features where requirements are genuinely unclear
Tasks touching multiple systems (high blast radius if wrong)
Anything you're delegating to a subagent that you won't supervise in real-time

When NOT to use it:

Well-defined, bounded tasks (adds friction with no upside)
Bug fixes with clear reproduction steps
Tasks where you've already written a tight spec

Gemini 3.5 Flash: The Model Powering Antigravity — Benchmarks vs. Claude

Per the episode, Gemini 3.5 Flash is positioned as the primary model for agentic coding tasks in Antigravity. Vo tested it live and compared against Claude and GPT baselines.

The benchmark framing: speed + agentic coding task completion. Flash is optimized for throughput, not just quality — which matters for multi-step agent loops where latency compounds across tool calls.

flowchart LR A[Model Choice for\nAgent Tasks] --> B{Task Type} B --> C[Long context,\ncomplex reasoning] B --> D[High-frequency\ntool calls, speed matters] B --> E[Structured output,\npredictable format] C --> C1[Claude 3.5 Sonnet\nStill leads here] D --> D1[Gemini 3.5 Flash\nCompetitive on throughput] E --> E1[Either, with\nprompt engineering]

The practical implication for Claude Code users: you're not switching. Claude Code's architecture, CLAUDE.md ecosystem, and multi-agent supervision patterns are too mature and Brian-specific to abandon for a speed advantage on individual tool calls. But if you're designing workflows where you need to call out to an external agent for a high-frequency subtask, Gemini 3.5 Flash via API is now a legitimate option to benchmark.

Subagent Architecture: How Antigravity's Pattern Compares to Claude Code's

The most structurally important Antigravity 2.0 feature is the subagent system. Here's the comparison:

graph TD subgraph Antigravity["Antigravity 2.0 Subagent Pattern"] A1[Orchestrator Agent] --> B1[Subagent 1\nDefined by task type] A1 --> B2[Subagent 2\nDefined by task type] A1 --> B3[Subagent 3\nDefined by task type] B1 --> C1[Results] B2 --> C1 B3 --> C1 C1 --> A1 end subgraph ClaudeCode["Claude Code Multi-Agent Pattern"] A2[Orchestrator\nClaude Code session] --> B4[Worker Agent\nSeparate git worktree] A2 --> B5[Worker Agent\nSeparate git worktree] A2 --> B6[Worker Agent\nSeparate git worktree] B4 --> C2[PR / diff output] B5 --> C2 B6 --> C2 C2 --> A2 end

Key structural difference: Claude Code's multi-agent pattern uses isolated git worktrees per worker, which prevents agents from clobbering each other's changes. This is a hard architectural advantage — it gives you merge-time conflict resolution rather than runtime conflict resolution.

Antigravity's subagent model isn't documented as having this isolation layer. If two subagents are modifying the same codebase simultaneously without worktree isolation, you have a coordination problem that the system has to solve at the orchestration layer instead of the filesystem layer. That's harder to get right.

The Claude Code multi-agent protocol you should already be using:

# Spawn parallel workers in isolated worktrees
git worktree add ../feature-auth -b feature/auth-refactor
git worktree add ../feature-payments -b feature/payments-api

# Launch Claude Code workers in each
cd ../feature-auth && claude "Implement OAuth2 flow per spec in SPEC.md. 
Work autonomously. Output: working implementation + tests."

cd ../feature-payments && claude "Implement Stripe webhook handler per spec.
Work autonomously. Output: working implementation + tests."

# Orchestrator reviews and merges
cd ../main-repo
git diff feature/auth-refactor feature/payments-api

This pattern scales to N parallel agents without coordination overhead because filesystem isolation handles the hard problem.

Scheduled Tasks: The Gap in Your Claude Code Workflow

Antigravity's scheduled task feature is the one capability that's genuinely absent from Claude Code and worth thinking about.

Current state: if you want Claude Code to run a task at 3 AM, you're writing a cron job that shells out to the claude CLI. That works, but it's fragile — no retry logic, no status reporting, no integration with the rest of your workflow.

What Antigravity is promising: native task scheduling within the agent framework, so the agent retains context about why the task is running, can handle failures intelligently, and reports back through a consistent interface.

How to approximate this in Claude Code today:

# .claude/scripts/scheduled-task.sh
#!/bin/bash
TASK_NAME=$1
TASK_PROMPT=$2
LOG_FILE="$HOME/.claude/logs/${TASK_NAME}-$(date +%Y%m%d-%H%M%S).log"

echo "=== Task: $TASK_NAME ===" > $LOG_FILE
echo "=== Started: $(date) ===" >> $LOG_FILE

claude --no-interactive "$TASK_PROMPT" >> $LOG_FILE 2>&1
STATUS=$?

if [ $STATUS -ne 0 ]; then
    # Alert mechanism — swap in your notification method
    echo "Task $TASK_NAME failed" | mail -s "Claude Task Failure" brian@yourdomain.com
fi

echo "=== Completed: $(date) ===" >> $LOG_FILE

Then in crontab:

0 3 * * * /path/to/.claude/scripts/scheduled-task.sh "nightly-review" "Review all open PRs in this repo, summarize status, flag anything blocked"

This is a workaround, not a solution. Antigravity's native scheduling, if it actually delivers on the promise, is genuinely better. Worth watching.

Google AI Studio + Workspace Integration: The Enterprise Play

Per the episode, Google AI Studio shipped a native Workspace integration designed to own the internal productivity app use case — connecting AI workflows directly into Docs, Sheets, Gmail, Calendar.

This is not a threat to your Claude Code coding workflows. This is Google playing in a different arena: the "replace Zapier + internal tools" space. If your team is heavily Google Workspace-native and you're building internal automation, this is worth a look. If you're doing serious software development, it's tangential.

The strategic read: Google is segmenting the market. Antigravity for engineering workflows, AI Studio + Workspace for productivity workflows. Claude Code is primarily competing in the former bucket.

The Creative Tools: Omni, Flow, Stitch, Pomelli

Vo tested all four live. These are genuinely outside the Claude Code workflow bucket, but the Stitch tool has one interesting implication for agent-assisted product development.

Stitch is a streaming UI design tool with inline edits — you describe a UI, it generates, you edit inline, it streams updates. The "streaming UI design" pattern is relevant because it's the same interaction model you should be using with Claude Code for frontend work: generate → review → inline correct → iterate. Stitch just makes this visual.

If you're using Claude Code for frontend tasks, the Stitch pattern suggests a workflow improvement: instead of specifying full UI requirements upfront, use an iterative streaming approach where you give Claude Code a rough spec, review the first pass, then issue targeted correction prompts rather than full rewrites. Less token-heavy, faster convergence.

The other three tools (Omni for video, Flow for cinematic editing, Pomelli for brand identity) are creative tools with no direct workflow overlap. Vo's live test showed they worked but had access availability issues — the announcement-to-availability gap problem she flagged throughout.

The Availability Gap Problem: How to Handle It in Your Workflow

Per Vo, Google's persistent failure mode is announcing features that aren't actually accessible yet. Several Day 1 products either had waitlists, returned errors, or required access requests that hadn't been fulfilled.

This is a workflow management issue, not just a PR problem. If you build a workflow around a tool that's announced but not available, you've introduced a dependency on vaporware.

Protocol for evaluating new tool announcements:

graph TD A[New AI Tool Announced] --> B{Can you access it\nright now, today?} B -->|Yes| C{Does it work on\nyour actual use case?} B -->|No| D[Add to watchlist.\nDo not build dependencies.\nCheck back in 30 days.] C -->|Yes| E{Does it beat your\ncurrent tool?} C -->|No| F[Prototype failed.\nStay on current stack.\nRe-evaluate at next major release.] E -->|Yes| G[Controlled migration:\n1 workflow, 30-day test,\nthen decide] E -->|No| H[Log the benchmark.\nStay on current stack.]

Antigravity 2.0 passed the first test (Vo accessed it and ran a live CLI test). The specific features she tested — slash commands, basic agentic task — appeared functional. The scheduled tasks and more complex subagent features weren't fully demonstrated, which means they sit in "verify before building on" territory.

What This Means for Your Claude Code Investment

The honest assessment: nothing announced at Google I/O 2026 Day 1 is a reason to reduce your Claude Code investment. Here's why, point by point:

On Antigravity 2.0: It's a capable competitor with some genuinely good ideas (scheduled tasks, /grill-me). But it's running on a different model, has an immature ecosystem relative to Claude Code, and lacks the worktree isolation architecture that makes Claude Code's multi-agent pattern safe to run at scale. The CLAUDE.md system you've built represents months of accumulated prompt engineering that doesn't port.

On Gemini 3.5 Flash benchmarks: Speed on individual tool calls doesn't matter when your bottleneck is task specification quality and supervision overhead. Get those right first; model speed becomes relevant later.

On the /grill-me pattern: This is a direct import. Build this slash command into your Claude Code setup today. The specification interrogation pattern is independently valuable regardless of which tool pioneered it.

On scheduled tasks: This is a real gap. The workaround above covers 80% of the use case. Watch Antigravity's implementation; if it matures, it's worth a narrow migration for scheduled/async tasks while keeping Claude Code for interactive development.

On subagent architecture: Claude Code's worktree-isolation approach is structurally superior. Don't abandon it.

Action Checklist: What to Actually Do With This Information

[ ] Build /grill-me into your Claude Code setup. Create .claude/commands/grill-me.md with the specification interrogation prompt from above. Use it on every non-trivial task before execution.
[ ] Set up the scheduled task script. Even the cron-based approximation is better than running tasks manually. Get 2-3 recurring reviews automated this week.
[ ] Benchmark Gemini 3.5 Flash for a specific high-frequency subtask in one of your agent workflows. Not a wholesale switch — a controlled comparison on a bounded task type.
[ ] Add Antigravity to your 30-day watchlist for scheduled task features specifically. If that capability matures, it's the one feature worth a narrow migration.
[ ] Document your CLAUDE.md as a competitive moat. Every project-specific convention, every workflow protocol, every architectural decision you've encoded there is switching cost against any competitor. Keep building it.

Today's One Action

Create your /grill-me slash command in Claude Code today. The specification interrogation pattern — forcing aggressive clarification before execution rather than after — is the single highest-leverage thing to import from Antigravity. Takes 10 minutes to implement, reduces mid-task corrections on complex workflows by a significant margin. Open your project root, create .claude/commands/grill-me.md, paste the prompt from the "Antigravity 2.0 Slash Commands" section above, and use it on your next non-trivial task this morning. The discipline of interrogating specs before execution compounds across every agent workflow you run.