In a hands-on workflow comparison published by XDA Developers, writer Parth Shah tested both environments by building the exact same complex web project from scratch. Instead of relying on third-party AI coding assistants like Claude Code or Codex, Shah pitted the default built-in AI agent experience in VS Code (using GitHub Copilot) directly against Google Antigravity running the Gemini 3.8 Flash model.
The headline takeaway—cutting total development time by nearly 50%—sounds like a massive victory for Google’s agent-first approach. However, when you look closely at what was tested and compare it against the actual capabilities documented in both IDEs, a much more nuanced picture emerges. This is not a story about VS Code lacking modern agentic features; it is a story about how interface design, default model behavior, and reduced rework can drastically alter a developer's day-to-day friction.
The Anatomy of the Test: One Website, Two Agent Workflows
To understand where the time savings came from, we first have to look at the scope and limitations of the test. Shah set out to build a multi-page website featuring a dashboard with a sidebar, interactive charts, and responsive layouts.
In Antigravity, Shah used Google’s Gemini 3.8 Flash model, noting that Gemini 4 Argon was not available in the IDE at the time. That detail aligns with Google’s official Antigravity documentation, which lists Gemini 3.8 Flash as a supported reasoning model across all tiers (from Free and Google AI Plus up to Enterprise), while noting that Gemini 4 Argon is restricted to Google AI Ultra and Enterprise plans—and specifically unavailable within the Antigravity IDE surface itself, being reserved for the Antigravity app, CLI, and IDE extensions.
At the same time, it is important to treat the "nearly half" time reduction and the claim that Antigravity got "nearly 80% of the work right on the first attempt" as one developer's subjective workflow impression rather than a controlled laboratory benchmark. The XDA Developers account does not disclose exact stopwatch timings, the specific GitHub Copilot model selected inside VS Code, the exact prompt text, or a formal scoring rubric for what "80% right" means.
Even so, the account offers valuable insight into where modern AI-assisted coding workflows succeed or stall. According to Shah, the speed boost did not come from Gemini generating raw text faster than GitHub Copilot. Instead, the time was saved because the initial output required far less manual rework and fewer follow-up prompts.
Key Areas Where Antigravity Pulled Ahead in the Test
- Single-Prompt Comprehension: When given a single comprehensive prompt describing the website's structure, navigation, design language, and features, Antigravity with Gemini 3.8 Flash produced a first draft that matched the vision much more closely than VS Code’s default agent, leaving mostly minor polish.
- Reduced Micromanagement: In VS Code, Shah found it necessary to break larger tasks into smaller step-by-step instructions, verify the output, and issue follow-up prompts. Antigravity handled broader, end-to-end descriptions—such as building out the full dashboard and responsive views—with greater autonomy.
- Zero-Friction Project Scaffolding: Starting a project from an empty folder usually involves choosing a framework, creating directory structures, installing dependencies, and configuring the development server. While VS Code’s agent can perform these steps, Shah reported that Antigravity planned the structure, generated the files, and spun up the dev server without requiring constant context-switching between the file explorer, terminal, and chat window.
Section Summary: The reported 50% time savings in XDA Developers' test stemmed primarily from fewer prompt iterations and less code rework during initial project setup and UI generation, rather than raw token-generation speed.
Feature Parity vs. Workflow Friction: What Official Docs Reveal
If you only read casual social media chatter, you might walk away thinking that Google Antigravity can control a browser, run parallel tasks, and manage terminal commands while VS Code is still stuck offering simple line-by-line autocomplete. That couldn't be further from the truth—and to Shah’s credit, the XDA Developers report explicitly acknowledges that VS Code already possesses these core features.
Why, then, did Antigravity feel so much more effortless in this test? Let’s compare how both platforms actually architect these capabilities according to their official documentation.
| Capability Category | Google Antigravity IDE | Microsoft Visual Studio Code |
|---|---|---|
| Core Architecture | Built as an "agent-first" environment (forked from VS Code) where agents operate across the editor, terminal, and browser. | Traditional code editor enhanced with the Agents window, Chat view, and built-in agent tools. |
| Browser Automation | Uses a Browser Subagent to read and actuate Chrome for UI testing, dashboard reads, and verification. | Built-in Browser Tools (workbench.browser.enableChatTools) allow agents to navigate, click, read console errors, and run Playwright code without an external MCP server. |
| Visual Deliverables | Generates structured "Artifacts"—including Markdown plans, code diffs, architecture diagrams, screenshots, and browser video recordings. | Captures screenshots, console logs, and DOM elements; supports interactive "Add to Chat" element commenting and live tab sharing. |
| Parallel Execution | Supports asynchronous local agents and parallel subagents across workspaces via the Agent Manager. | Supports running multiple parallel agent sessions simultaneously via the Agents Manager view. |
The Browser Testing Loop: Artifacts vs. Integrated Tools
One of the standout moments in Shah’s test involved browser validation: asking Gemini to open the newly built site in Chrome, navigate between pages, verify the checkout workflow, and test interactive elements. What won Shah over was how Antigravity packaged the results, generating screenshots and browser recordings as reviewable "artifacts" that provided a clear visual receipt of what the agent actually did.
According to Google’s Antigravity documentation, "Artifacts" are a foundational concept of the IDE—structured deliverables ranging from rich Markdown plans and architecture diagrams to images and browser recordings designed to verify task completion. (Google’s docs also note that an internal model called Nano Banana 2 handles generative image tasks when an agent produces UI mockups or system diagrams.)
However, Windows and web developers already entrenched in Microsoft’s ecosystem don't need to switch IDEs just to get automated browser verification. According to Microsoft’s official Visual Studio Code documentation, built-in browser tools are enabled by default via the workbench.browser.enableChatTools setting and require no external Model Context Protocol (MCP) server.
In VS Code, an agent can modify your application code, start the dev server, launch the app in an isolated ephemeral browser session, click buttons (clickElement), fill out forms (typeInPage), inspect console errors, take screenshots (screenshotPage), and even execute focused Playwright scripts (runPlaywrightCode). Furthermore, VS Code offers a "Share with Agent" toggle in the integrated browser toolbar for testing authenticated flows that rely on your existing cookies and sign-in state, alongside an "Add to Chat" feature that lets you click directly on a broken navigation menu or misaligned form in the rendered page and attach its HTML, CSS, and console logs to your prompt.
In short, both tools have closed the loop between writing code and visually verifying it in a browser. The difference in Shah's experience came down to presentation: Antigravity’s automatic compilation of browser recordings into standalone artifacts felt more convenient out of the box.
Parallel Agents and the Missing Kanban Board
When building a complex project, waiting around for a single AI thread to finish refactoring a component before you can work on routing is a productivity killer. Both IDEs solve this through parallelization. Antigravity allows developers to spawn multiple parallel agent conversations across workspaces, while VS Code’s Agents Manager also supports parallel sessions.
Even though Shah preferred Antigravity’s agent-first layout for delegating and reviewing parallel work, he noted a key limitation: Antigravity still lacks a visual task-board overview like Devin Desktop’s Kanban board, which organizes multiple active agents into columns so developers can track and act on parallel streams at a glance.
And while Shah found Antigravity freed him from micromanaging tasks, other testers have experienced the exact opposite. In an earlier hands-on evaluation published by XDA Developers in January 2026, a different writer reported feeling fatigued by the sheer volume of micro-decisions and validations required to keep Antigravity's agent moving forward, noting that validating its choices sometimes took longer than typing the code manually. How much time an agentic IDE saves depends heavily on the nature of the project—spinning up a greenfield prototype from a single prompt is much more forgiving than surgical refactoring inside an existing, opinionated codebase.
Section Summary: Official documentation confirms that VS Code already matches Antigravity in core capabilities like built-in browser automation and parallel agent sessions. Antigravity's advantage in this specific test came down to its artifact presentation and how Gemini 3.8 Flash handled a broad, greenfield prompt.
How to Test Agentic Workflows on Your Own Windows PC
If you are wondering whether Google Antigravity or VS Code’s built-in agent loop can actually cut your development time down, don't rely on someone else's stopwatch. Because Antigravity is built as a fork of VS Code, transitioning your keybindings and extensions over to test it is relatively painless.
Here is a practical, apples-to-apples way to evaluate both tools on your own machine:
- Define a Fixed Specification: Write a single, saved Markdown prompt for a multi-page prototype (for example, a local dashboard with a responsive sidebar, a data table, and a multi-step checkout or settings form) so both agents receive the exact same starting instructions.
- Explicitly Select Your Models: In Antigravity, check the model selector below the prompt box to confirm whether you are running Gemini 3.8 Flash or a thinking model like Claude Sonnet 5.5 (if your plan supports it). In VS Code, explicitly note which model your GitHub Copilot agent is using rather than leaving it on an unknown default.
- Turn On Browser Verification in Both IDEs: In Antigravity, ask the agent to verify the rendered UI in Chrome and generate browser artifacts. In VS Code, ensure
workbench.browser.enableChatToolsis enabled, and explicitly instruct the agent in your prompt: "Start the development server, open the app in the browser, test the form flow at desktop and mobile viewport sizes, and fix any console or layout errors before finishing." - Measure Rework, Not Just First-Pass Speed: Track how many follow-up prompts and manual code edits you have to make after the initial generation to get the app to a working state. As the XDA Developers test showed, avoiding rework is where the real time savings hide.
For rapid prototyping—where the goal is moving from a blank folder to a working UI as quickly as possible—Antigravity paired with Gemini 3.8 Flash is clearly making a strong case for itself. Meanwhile, VS Code remains the mature, extensible anchor of the developer world, complete with deep enterprise privacy controls, network filtering, and built-in browser verification tools that are far more capable than many developers realize. Whether you switch editors, adopt a hybrid workflow, or simply learn to push VS Code’s Agents window harder, the days of manually scaffolding boilerplate and clicking through every routine browser check yourself are rapidly coming to an end.