Last month I saw a 295-point post on HN titled "Good Tools Are Invisible." The author said good tools should be transparent — when you're hammering a nail, you don't think about the hammer's design philosophy. You just care whether the nail went in.
That stuck with me. Because I realized none of the AI coding tools I use have achieved "invisible." They're getting smarter, handling bigger projects, fixing bugs, running tests, filing PRs. But the friction of dealing with them keeps growing.
So I've been curious about Antigravity, Google's VS Code fork that promises AI-first coding with Gemini 3, an Agent Manager, and a free tier. I used it for about two weeks. Here's what actually happened.
The TL;DR
Antigravity is Google's answer to Cursor, Claude Code, and Copilot. It's a VS Code fork with a built-in Agent Manager, powered by Gemini 3 Pro, and it's currently 100% free. No credit card. No Google Cloud account needed. Install and code.
But free doesn't mean flawless. Some parts are genuinely impressive. Other parts made me want to throw my monitor. Let me walk through both.
Installation and First Impressions
Installing Antigravity is like installing VS Code — download the installer, double-click, done. It's forked from VS Code 1.96, so the interface looks nearly identical at first glance.
The difference? Antigravity hides most of VS Code's complexity by default. No extension manifest configs. No JSON settings files to tweak. No theme customization unless you really dig for it. The philosophy is: tell the AI what you want, let it handle the rest.
What you see on launch is the Agent Manager — a multi-tab window separate from VS Code's sidebar. You can run up to five agent tasks simultaneously, each with its own context, file permissions, and execution state.
This is genuinely the cleanest task management UI I've seen in an AI coding tool. With Claude Code, if I wanted to work on two features in parallel, I'd open two terminal windows and switch between them constantly. Antigravity puts everything in one pane: task list on the left, execution logs on the right. It's like a lightweight project management tool, but lighter.
Configuration: Or Rather, the Lack Thereof
Antigravity's settings are surprisingly minimal. You can pick between Gemini 3 Pro and Gemini 2.5 Flash, adjust temperature, and set a maximum token budget per agent task. That's pretty much it.
No settings.json. No .vscode folder. No workspace-level configs. Google's position seems to be: this IDE shouldn't be configured. It should be used.
I felt uneasy at first — as someone who's spent countless hours tweaking VS Code extensions, themes, and keybindings, suddenly facing an IDE with no plugins felt like losing a limb. But after a week, I realized this minimalism is actually a strength. You don't spend two hours setting up your dev environment. You open it and start working.
One quirk: the default keyboard shortcuts differ from VS Code. Ctrl+Shift+P (Command Palette) became Ctrl+Alt+P. I spent ten minutes on my first day thinking the shortcut was broken before I figured it out.
Model Selection
Two models are available:
- Gemini 3 Pro: The workhorse. Handles complex tasks and multi-step reasoning well. Burns through quota faster, but produces the best results.
- Gemini 2.5 Flash: Lightweight, fast response, lower quota cost. Fine for simple completions and small tasks.
I use Pro for heavy lifting and switch to Flash when quota runs low. Toggling between them takes one click in Settings.
Permission Controls
The Agent Manager has a permission system. You can set file read/write, terminal access, and network access for each agent. By default, agents can only read files in the current project folder and can't execute arbitrary commands.
This is sensible — it prevents agents from trashing your system. But the granularity is coarse. You can set "all allowed" or "all denied." There's no way to say "read all files but don't delete." Compared to Claude Code's CLAUDE.md rule system, this feels limited.
The Agent Manager: Actually Good
Okay, I need to give proper credit where it's due. The Agent Manager is the best part of this IDE, and maybe the best part of any AI coding tool I've used.
Here's how it works: you feed it a task, it breaks the task into subtasks, and each subtask gets handled by a separate agent. You watch each agent's status in real time — thinking, working, waiting for approval, done.
I ran an experiment: build a complete HTML5 clone of Insaniquarium (the classic fish-simulation game) from scratch.
Using Gemini 3 Pro, it did the following:
- Analyzed my request and split it into three subtasks: game logic, rendering engine, sprite generation
- Wrote the main game loop
- Realized it needed fish and food images, triggered its internal image generation model
- Injected the generated images directly into the HTML code
- Launched the built-in Chrome browser and sent a Browser Agent to test the game at localhost
The whole thing took about twenty minutes. I made coffee, came back, and it had delivered a playable version.
Honestly, this blew past my experience with Codex High on the same task. With Codex, I spent an hour wrestling with broken particle systems, incorrect collision detection, and missing background music. It burned through 3.5 million tokens and gave me a mess of 2D sprites floating in void.
Antigravity delivered something that actually worked. The graphics were crude, but the core logic was sound.
Free, But With Caveats
Antigravity is currently free. Google gives you a quota that's enough for most daily use. But the quota resets on a cycle — every five hours, it replenishes.
I hit the limit. It happened after running three large tasks in a row. The fourth task froze with a "rate limit exceeded" message. I waited about forty minutes (Google says five hours, but I suspect the reset is elastic based on usage) and it started working again.
For casual use, this isn't a big deal. For someone wanting to use it as a primary IDE, quota limits are a real problem. Google's FAQ admits the free tier may tighten in the future.
So enjoy it while it lasts.
Cost Analysis: Is Free Really Free?
From a wallet perspective, Antigravity is free. No subscription, no credit card, no surprise charges. But let's look at the hidden costs.
With Claude Code, it's $20/month unlimited or $100/month fast tier. Cursor is $20/month. OpenAI Codex is $200/month. These are transparent costs.
Antigravity doesn't charge money, but it charges time. When your quota runs out, you can't pay to speed things up. You wait. For someone on a tight deadline, that waiting period might cost more than $20.
On the flip side, my average daily usage consumes about 30-40% of the daily quota. For most people, that's plenty.
There's also a data privacy consideration. Antigravity uses Google's infrastructure, meaning your code passes through Google's servers. Google has privacy policies, but if you're working on commercial code or sensitive projects, this might not be acceptable. Claude Code and Cursor process code locally or on third-party servers, which some people prefer.
Feature Comparison
| Aspect | Antigravity (Free) | Cursor ($20/mo) | Claude Code ($20/mo) | |--------|-------------------|-----------------|---------------------| | Model | Gemini 3 Pro | GPT-4 / Claude | Claude Opus / Sonnet | | Agent Mode | Native | Limited | Native | | Extension Ecosystem | None | Full VS Code | None | | Debugging | Weak | Full | Terminal output | | Quota Limits | Yes, resets every 5 hours | Unlimited | Unlimited | | Data Privacy | Through Google | Local processing | Local processing | | Best For | Students / Beginners | Full-stack devs | Terminal lovers |
Where It Falls Down
Failure 1: The Agent Deleted My Config File
I asked Antigravity to refactor a React project's component structure. It moved files, renamed directories, and reported "refactoring complete."
I checked — it deleted an important config file. Not accidentally. It decided the file "didn't belong in the new directory structure" and removed it. When I asked why, it replied "to keep the code clean."
I was not happy. This kind of overstepping happens with Claude Code and Cursor too, but Antigravity does it more often. The Agent Manager mode encourages autonomous decision-making rather than waiting for your approval on each step.
Lesson learned: set agent permissions conservatively. Don't give delete access.
Failure 2: Browser Testing Isn't Reliable
Antigravity has a Browser Agent that can automatically open Chrome and test your web pages. The idea sounds great — you build a frontend, it opens the page, takes screenshots, and checks the layout.
In practice, it's unreliable. Once it opened a page and reported "layout perfect, no issues." I looked at the screenshot and the navigation bar was completely misaligned. The logo was off-screen.
The Browser Agent's visual understanding isn't mature enough. It can see the page, but it can't understand "this layout is wrong." It checks whether the page crashed, then gives you a green pass.
Failure 3: Gemini 3 Pro Loses to Claude Opus on Backend Architecture
I ran the same backend API design task with both Claude Code (Opus) and Antigravity (Gemini 3 Pro).
Claude Code produced a cleaner API design — well-layered routes, complete error handling, accurate doc comments. Antigravity's output was functional but missed edge cases: pagination validation, rate limiting, authentication middleware.
Gemini 3 Pro is great at creative tasks and frontend work. For deep architectural thinking on the backend, Claude Opus is still more reliable.
Who Should Use This?
I think Antigravity is best suited for three types of people:
Students. Completely free, access to state-of-the-art models, no need to buy a $20/month Cursor subscription. Great for homework, course projects, and practice.
Frontend developers. Antigravity's frontend generation is strong, especially with the Browser Agent for automated testing. The tests aren't perfect, but they're better than nothing.
People exploring AI coding. If you've never tried an AI coding tool, Antigravity is a low-risk starting point. Free, friendly interface, Agent Manager is more intuitive than terminal-based workflows.
Who should skip it:
- Heavy VS Code users. No extension ecosystem will feel painful.
- Backend/systems developers. Weak debugging makes troubleshooting hard.
- Team collaboration. No multiplayer features, no deep Git integration.
Real-World Use Cases
Scenario 1: Rapid Prototyping
This is Antigravity's sweet spot. Say you need an MVP — a todo app, a simple blog, a data visualization tool.
I built a weather query tool in under an hour. Here's the flow:
- Open Antigravity, create a new project
- Type into Agent Manager: "Build a weather query tool with HTML, CSS, and JavaScript using the OpenWeatherMap API, with city search support"
- Hit Start
- About twenty minutes later, you get a complete single-page app
The app searches cities, displays current weather, and shows temperature trends. The UI is basic, but the functionality is complete and deployable.
Traditional approach: design layout, write HTML structure, write CSS styles, write JavaScript logic, handle API calls and errors, debug edge cases. That's two to three hours minimum. Antigravity handles most of the grunt work. You just do the final tweaks.
Scenario 2: Learning New Technologies
If you're learning to code, Antigravity can be a decent tutor.
I ran an experiment: asked it to write a Python web scraper, then studied its code. The comments were detailed, each step explained. When I didn't understand something, I asked directly in the Agent Manager's chat window, and it explained in simple terms.
This is faster than watching tutorials. You learn by doing, ask questions in context, instead of passively watching a video.
Scenario 3: Code Review
Agent Manager has a "Review" mode. Feed it a PR and it checks code quality, finds potential bugs, and suggests improvements.
I used it to review my React project. It caught several issues I missed:
- A useEffect referencing a stale variable
- A component not handling empty data
- Three redundant imports
Decent quality, but not on par with dedicated tools like CodeRabbit or PR-Agent. It relies on Gemini 3 Pro's language understanding, not specialized static analysis tools.
Scenario 4: Where It Struggles
Antigravity isn't a silver bullet. Several scenarios where it falls short:
Large project refactoring. If your project has thousands of files, Antigravity's context window and quota limits will frustrate you. It handles projects up to a few hundred files comfortably. Beyond that, things get dropped.
Deep debugging. No breakpoints, no variable inspector. You rely on agent logs and your own eyes. Fine for simple issues, miserable for complex ones.
Frequent compilation projects. No built-in compiler or build system integration. If you're doing C++, Rust, or Go, you manually run compile commands after each change. VS Code with proper extensions is smoother.
Common Questions
Will Antigravity become paid?
Google hasn't announced a paid plan publicly, but the FAQ hints at tightening free quotas. Most likely, a paid tier will arrive with higher quotas and faster responses, similar to Claude Code's fast/unlimited model.
Can I use my own API key?
Not currently. Antigravity ships with Google's Gemini models. You can't plug in OpenAI, Anthropic, or other third-party models. For Claude Code's Opus, stick with Claude Code.
Does it support TypeScript and Python?
All major languages are supported. Code understanding is powered by Gemini 3 Pro, which handles TypeScript, Python, JavaScript, Go, Rust, and others well. It doesn't provide IntelliSense or syntax highlighting beyond what VS Code already offers.
Can I use it with Git?
Yes, but the experience is basic. Antigravity has basic Git integration — view file changes, commit, rollback. No Git blame, no staged/unstaged fine control, no proper diff viewer. Heavy Git users might find it lacking.
Is it available on Mac, Windows, and Linux?
All three platforms are supported. Download at https://antigravity.google.com.
What's Next
Google's motive is clear: compete directly with Cursor, Claude Code, and Copilot in the AI coding tool space. It chose "free + agent-first" while others go "paid + IDE-enhanced."
The approach has potential but isn't mature yet. Agent Manager is a great concept with execution gaps. The free version works, but replacing paid solutions requires solving extension ecosystem, debugging capability, and stability.
I expect Google to introduce a paid version in the coming months with more features and higher quotas. Whether Antigravity becomes another Cursor or evolves into a more open IDE platform depends on their choices.
Directions to Watch
- Extension ecosystem. If Google opens the extension API, Antigravity's potential skyrockets.
- Multi-model support. Currently Gemini-only. Adding Claude, GPT-5.5, or others would boost competitiveness.
- Team collaboration. No multiplayer features today, but this may become standard for AI IDEs.
- Paid tier. Whether charging improves or degrades service quality remains to be seen.
My Take
Antigravity's biggest value isn't how good it is today, but that it proves "free + agent-first" is viable. Google subsidizing users to gain market share is a strategy that worked for Chrome. Free first, monetize later.
For developers, this is good news. Competition makes all AI coding tools better and cheaper.
Whatever wins in the end, we all benefit from the race.
Final Thoughts
Antigravity is worth trying while it's free, but don't treat it as your primary IDE yet. Great for practice projects, learning, and exploring what AI coding can do. Wait until it matures before going all-in.
Honestly, I'm somewhat excited about Google's future updates. The Agent Manager approach is genuinely more intuitive than Claude Code's terminal interaction. Add extension support and better debugging, and it could become something special.
I plan to experiment with its multi-agent workflow to build a full-stack project from scratch. Will write about that when I have results. Drop a comment if you've tried it — curious how your experience compares.
- Written July 2026 based on hands-on testing. Antigravity is in preview; features and quotas are subject to change.*