This is a submission for the Google I/O Writing Challenge

Hook: The Tool That Changed How I Contribute to Open Source

I'll be honest — for the past two years, whenever someone asked me what AI coding tool to use, my answer was automatic: Claude Code or Codex, pick your poison. Google? Not even in the conversation.

Then Google I/O 2026 happened.

In roughly 24 hours, Google dropped over 20 tools — and one of them stopped me mid-scroll. Antigravity 2.0: a standalone desktop agent orchestration platform, free to start, built on Gemini 3.5 Flash, and designed to spin up parallel AI sub-agents the way a senior engineer delegates work to a team.

I didn't want to just read about it. I wanted to put it to work on something real. So I pointed it at a problem I run into constantly as an open-source contributor: walking into an unfamiliar codebase and trying to figure out what's already there before you touch anything.

Right now I'm using it to review WPFAevent, a WordPress plugin by FOSSASIA that integrates with the Eventyay event platform. It's a real repo — 14 open issues, 17 pull requests, PHP + JavaScript + CSS — and it gave me a good surface for testing how well Antigravity handles the kind of context-gathering work that usually eats the first hour of any contribution session.

This is the full walkthrough of how I use it, what genuinely impressed me, where I hit friction, and what every developer contributing to open source should know before they dive in.

What Is Antigravity 2.0?

Antigravity 2.0 is Google's new standalone desktop app for AI agent orchestration. Less than a year ago, Google shipped the Antigravity IDE — a full code editor with an Agent Manager baked in. It was powerful but intimidating. Antigravity 2.0 strips that away entirely. What remains is a clean chat interface that anyone can open and immediately use, backed by agents that coordinate complex work automatically.

The key word is agents — plural, parallel, autonomous.

Where a tool like Claude Code (as of this writing) requires developers to manually configure sub-agent workflows, Antigravity 2.0 is designed from the ground up around the idea that one task can, and often should, spawn multiple specialized agents working simultaneously. A code analysis agent. A research agent cross-referencing docs. A QA agent running browser tests. All at once, reporting back to you, asking for approval only when needed.

At Google I/O, the team ran Antigravity 2.0 for 12 hours straight on stage — 93 sub-agents running in parallel — and produced a working operating system. That's the scale this thing is designed to operate at.

Where it fits in Google's ecosystem: Antigravity connects directly to Google products via installable skills and plugins — Chrome DevTools, modern web guidance, and more — and the whole stack runs on Gemini 3.5 Flash, which is reportedly capable of generating code at close to 800 tokens per second. That raw speed changes how iteration feels in practice.

My Hands-On Experiment: Reviewing WPFAevent

Environment & Prerequisites

• OS: Linux Mint 22.3 - Cinnamon 64-bit
• Antigravity version: 2.0.6 (Manual Tarball Release)
• Google account: Required for sign-in
• Repo: fossasia/WPFAevent — cloned locally
• Prior Antigravity IDE experience: None needed (though existing IDE users get a smooth migration path)

Step 1: Installation and Onboarding

Head to antigravity.google and grab the installer for your platform — Apple Silicon, Intel Mac, Windows (two installer options), or Linux.

# macOS: Drag to Applications, open from Spotlight
# Windows: Run the installer directly
# Linux: Build available from the site

For Linux Mint, instead of using the standard apt package manager (which still defaults to the older 1.x stable branch), you manually download the compressed package and extract it directly into the system's optional application directory.

# Extract package to system application directory
sudo tar -xzf Antigravity.tar.gz -C /opt/

Troubleshooting the Linux Desktop Shortcut

Initially, I attempted to create a standard terminal-based desktop entry using a .desktop file configuration pointing to internal package assets:

# NOTE: This automated script method did NOT work natively for pinning the icon/shortcut
cat << 'EOF' > ~/.local/share/applications/antigravity-ide.desktop
[Desktop Entry]
Name=Antigravity IDE
Comment=Antigravity IDE v2.0 - Experience liftoff
GenericName=IDE
Exec=/opt/Antigravity/antigravity %F
Icon=/opt/Antigravity/resources/app/resources/icon.png
Type=Application
Categories=Development;IDE;
Terminal=false
StartupWMClass=antigravity
EOF

update-desktop-database ~/.local/share/applications

Because the build structure handles asset routing differently (resulting in a generic gear icon or the shortcut missing from the Mint menu entirely), I verified the core application manually by calling the binary file directly from the terminal:

/opt/Antigravity/antigravity

Final Visual Icon Solution

To successfully map the IDE to the Linux Mint application menu with its real branding, I bypass text configurations entirely and configured it manually using the Cinnamon Desktop environment tools:

1. Download the official brand logo directly from the Antigravity Press Asset Kit.
2. Right-click the Linux Mint Menu button (bottom-left corner) -> Click Configure.
3. Navigate to the Menu tab and click Open the menu editor.
4. Locate the Antigravity IDE entry under your designated development categories, click it, and open Properties.
5. Click on the icon tile on the left side of the properties window, browse to your downloaded press asset image, and hit Save.

Open the app, sign in with your Google account, and you'll land in a short onboarding flow.

During onboarding, you hit the "Build with Google" page. This is where you install skills and plugins — essentially integrations that give your agents context about specific tools.

I installed:

• Modern Web Guidance — helps the agent reason about web development patterns and best practices
• Chrome DevTools — gives the agent the ability to interact with and inspect the browser

If you're migrating from the Antigravity IDE, keep the "Keep Antigravity IDE" checkbox selected — your old setup carries over cleanly.

Step 2: Creating a Project

Antigravity 2.0 is project-centric. A project is simply a folder on your local machine that the AI reads from and writes to directly.

Click the + icon next to Projects
→ New Project
→ Select your cloned repo folder
→ All agent context and output is scoped to this folder

I pointed it at my local clone of WPFAevent. From this point forward, every question I ask is answered with reference to the actual source files in that directory — not generic knowledge about WordPress plugins, but this specific codebase.

Step 3: Orienting to the Codebase

Before jumping to any specific issue, I sent an orientation prompt to get a high-level map of the project:

"Give me an overview of this codebase. What does it do, how is it structured, and what are the main entry points I should know about?"

The agent read through the directory, identified the plugin's purpose (WordPress integration for Eventyay event data), traced the main entry point through wpfaevent.php, and walked me through the key classes in includes/:

• class-event-loader.php — initializes hooks and shortcodes
• class-event-api.php — handles remote API fetching with transient caching
• class-event-admin.php — admin settings page (API config, cache TTL)
• class-event-speakers.php, class-event-sessions.php, class-event-schedule.php — logic for each shortcode

What used to require 20 minutes of directory spelunking took about 30 seconds.

Step 4: Digging Into GitHub Issues

Here's where the workflow gets genuinely useful. I opened the WPFAevent issues list alongside Antigravity and started feeding it specific issues to reason about.

Issue: Caching behavior on API failure

Walk me through how class-event-api.php handles caching.
What transient keys does it use, and what happens when the API call fails?
Is there a risk that a failed response gets cached and served to users?

The agent read the file, traced the transient logic, and identified exactly where an error condition could result in stale or empty data being cached — something I would have had to trace manually through several function calls to find.

Issue: Adding a new shortcode

Which files would I need to touch to add a new shortcode
for displaying event sponsors? Walk me through the pattern
used by the existing shortcodes so I follow the same conventions.

Rather than guessing at the pattern, I got a step-by-step breakdown: create a new class in includes/, register it in class-event-loader.php, add a display template in public/partials/, and enqueue any new assets correctly. The agent even flagged that I'd need to update the translation template in languages/ if I added new user-facing strings.

Issue: Schedule endpoint and multi-day events

There's an open issue about the schedule endpoint not handling
multi-day events correctly. Based on the current implementation in
class-event-schedule.php, what's the most likely cause, and what
would a fix look like?

The agent read the schedule class, identified that the current grouping logic assumed a single date field per session without accounting for sessions spanning midnight, and suggested where the grouping function would need to be extended. I came out of this with a concrete hypothesis to test — before writing a single line.

Step 5: Inline Comments on Artifacts

One feature that surprised me was how naturally Antigravity handles iterative refinement. When the agent produces an analysis artifact — say, a breakdown of what changes are needed for a fix — I can leave comments directly on that artifact, the same way you'd annotate a Google Doc.

I used this to push back on one of its suggestions:

[Comment on artifact]: "This approach modifies the API response parsing — but can we keep the change isolated to the display layer instead? I don't want to touch class-event-api.php for this."

The agent re-read the constraint, updated its recommendation, and produced a revised approach scoped entirely to the template file. No need to rephrase the whole context in a new message.

Step 6: Parallel Agents for Broader Analysis

When I had several open issues I wanted to evaluate at once, I used parallel conversations with work trees — Antigravity's mechanism for running multiple agent threads against separate copies of the codebase simultaneously.

Work Tree = a new folder containing a copy of the project, so agents can explore different issues or approaches in parallel without interfering with each other.

I kicked off three parallel threads:

Thread 1 — Dependency audit:

Check composer.json and the includes/ directory.
Are there any outdated dependencies or missing requirements
relative to the WordPress 5.8+ target stated in the README?
→ New Work Tree

Thread 2 — i18n coverage:

Review the codebase for any user-facing strings that are
not wrapped in __() or _e(). List them by file.
→ New Work Tree

Thread 3 (main thread) — PR review:

There are 17 open pull requests. Based on the current codebase,
which open issues do you think represent the highest-impact
and lowest-risk changes for a new contributor to start with?

All three running simultaneously. While I reviewed the PR analysis coming back on the main thread, the dependency audit and i18n coverage checks were still running. The i18n thread came back with a list of specific files and line numbers — exactly the kind of output that's tedious to produce manually but trivial to act on.

Step 7: Scheduled Tasks for Ongoing Contribution

The final feature I explored was Scheduled Tasks — brand new to Antigravity 2.0.

Scheduled tasks let you run any prompt on a recurring schedule, with the app running silently in the background even when all windows are closed. A menu bar icon shows how many agents are active.

For ongoing open-source contribution, this opens up a genuinely useful workflow. I set up a task called "WPFAevent Issue Digest":

Name: WPFAevent Issue Digest
Schedule: Every Monday, 8:00 AM

Prompt:
Review the current state of the WPFAevent codebase in this project folder.
Check if there are any new patterns or inconsistencies introduced since last week.
Summarize which open issues now have enough context in the codebase to act on,
and flag anything that looks like it might conflict with work already in progress.

Every Monday morning, a brief lands in the app summarising where things stand — without me having to re-orient from scratch each time I come back to the project. For anyone juggling multiple open-source repos alongside their main work, this kind of ambient awareness is genuinely valuable.

The same pattern applies beyond open source: PR status checks, dependency monitoring, documentation drift alerts — any recurring check you'd otherwise do manually.

What Worked Well

Speed changes the cost of asking questions. Gemini 3.5 Flash at close to 800 tokens/second means there's no friction to firing off a quick question about a file you're not sure about. The low latency makes exploratory questioning feel natural rather than effortful.

Parallel agents change the math on codebase analysis. Running a dependency audit, an i18n coverage check, and a PR review simultaneously — each scoped to its own work tree — compressed what would have been a multi-hour orientation into a single focused session.

Inline artifact comments are intuitive. Instead of rephrasing context in a new message, I could annotate the agent's analysis directly, redirect its approach, and get an updated response — exactly like commenting on a Google Doc. This interaction model clicked immediately.

Voice input is underrated. For longer, more nuanced questions about a codebase, speaking is faster and more natural than typing. The agent handled complex multi-part prompts accurately.

Command approval flow builds trust. Knowing exactly what terminal commands the agent wants to run — and having the ability to approve, reject, or whitelist them — means you never feel like you've lost control of your machine.

Self-testing via /browser is a big deal. For issues that involve frontend behavior, being able to ask the agent to verify its own proposed fix in a real browser — and watch it catch its own mistakes — is meaningfully more reliable than code review alone.

Free model access is exceptional value. Gemini 3.5 Flash, Claude Sonnet, Claude Opus, and GPT models are all accessible from the model picker in the free tier. Limited usage, but the breadth is remarkable for zero cost.

What Was Challenging

Model switching restrictions are a regression. In the original Antigravity IDE, you could mix and match — Claude for one task, Codex for another, choosing the best model for the specific job. That flexibility is currently gone. You work with what Google gives you out of the box. For developers who've built workflows around model-specific strengths, this is a real limitation worth acknowledging upfront.

Early rate limits were brutal — though largely fixed. In the first few days post-launch, users were hitting weekly caps after just a couple of work sessions. The backlash was significant. Google responded by tripling rate limits across paid plans, resetting quotas, and then tripling again. Paid users now have roughly 9x the original launch runway. If you tried it early and walked away frustrated, it's worth revisiting. Free tier limits remain tighter.

Browser setup requires a manual step. Connecting the /browser agent to Chrome requires enabling Remote Debugging in Chrome — it's a two-click process, but it's not automatic. First-timers will need to follow the setup prompt before browser testing works.

Sub-agent oversight can feel like a second job at scale. When you have 5–10 sub-agents running simultaneously, monitoring the overview panel and approving occasional blocked actions requires attention. The UI handles this reasonably well, but it's worth being mentally prepared for — this isn't a "fire and forget" tool for complex tasks.

Key Takeaways

1. Antigravity 2.0 is genuinely designed for agents, not retrofitted for them. The parallel sub-agent architecture, work trees, and /browser command make this feel purpose-built in a way that competing tools don't.

2. Codebase orientation is a first-class use case. Dropping a repo into a project and asking targeted questions about architecture, issue context, and implementation gaps is one of the most practical things you can do with the tool — and one of the least talked about.

3. Scheduled tasks turn it into an autonomous employee. The ability to set recurring prompts that run in the background — even with the window closed — opens a class of use cases most AI coding tools don't address.

4. The free tier is a genuine on-ramp. There's enough free usage to complete a real contribution session, evaluate the tool properly, and decide whether a paid plan makes sense. You don't need a credit card to form a real opinion.

5. Speed changes behavior. When a tool responds this fast, you ask questions you'd have otherwise skipped. You explore tangents. You pressure-test assumptions before committing to an approach. The raw throughput of Gemini 3.5 Flash has real downstream effects on how you think through a problem.

Who should try it:

• Open-source contributors who need to understand existing codebases before diving into issues
• Developers onboarding onto new projects at work who want to compress the orientation phase
• Developers who want faster iteration cycles on complex multi-part features
• Developers running background research, audit, or monitoring workflows
• Anyone who has been waiting for a free, capable alternative to Claude Code or Codex

Final Verdict

Would I recommend it? Yes, with awareness of the current limitations.

Is it production-ready? For codebase analysis, contribution workflows, and sophisticated side projects — absolutely. For mission-critical production pipelines where model flexibility and guaranteed uptime matter more than cost, the rate limits and model restrictions are worth factoring in. Google has shown it responds fast to user feedback, so this calculus may shift.

What excites me most? Not any single feature — it's the direction. Antigravity 2.0 is a bet that the future of software development is orchestration: you describe intent, agents coordinate execution, and you stay in the loop as a reviewer and decision-maker rather than a line-by-line author. That model of working is going to win. The question is which platform it wins on.

After this session, Google has a serious claim to that platform.

Check it out at antigravity.google.