Hands-On With Antigravity: Google’s Newest AI Coding Experiment

When Google launched a new agentic development platform called Antgravity this week, the first question I had was: “What about Jules and Gemini CLI?” But remember, this is Google; they throw a lot of mud against the wall just to see what sticks (very little is the answer, as their graveyard attests). So Google considers Antigravity and Jules to be experiments that examine the same technology from different angles.

Let’s now look at Antigravity, which appears to be ready for “public preview” on all platforms, not just the Mac:

Like Verdent, it isn’t a CLI for the terminal — it’s an IDE app. So I downloaded it for my MacBook and slid it into the Applications folder.

First Impressions and Setup Process

Sensibly, it asks the user to select a theme during setup. Most people set the theme once (dark or light) and rarely touch the option again:

This next setup question is quite intriguing:

This feels like it wants to possibly move towards a parallel runner model, with little human intervention (parallel runner means letting an agentic task run in the background while you start another — in other words, each task is run on isolated branches). Or perhaps Antigravity will be more like document-driven solutions like Kiro. As you can guess, this post is just to set the scene for developers, not to deeply examine what is, after all, an experiment. So I’ll go with the “assisted development” option, which feels like more conventional territory.

After signing in with Google (using its internal 2FA), Antigravity asks you to open a folder or to clone. To create an isolated branch, like a parallel runner it would need a git clone. It also finds likely-looking projects in your user folder.

As you see, I chose Claude Sonnet from the currently available models:

A Familiar IDE With AI-Powered Suggestions

As usual for releases such as this, you get a bunch of free tokens with the proviso that abuses will be curtailed. When it has finished initialising (scanning the project, I assume) we get the standard layout:

Does this look familiar? Yes, it does seem to be some sort of VS Code fork. I’ve written about the dangers of these — but really I don’t know why Google has done this.

On the right I chose “planning mode”; the alternative “fast” mode “is helpful for when speed is an important factor, and the task is simple enough that there is low worry of worse quality” — which is slightly comical, but we know what the writer means.

As far as I can tell, “Agent manager” is closer to the parallel runner agentic CLI mode, since you don’t interact with the editor. The following diagram refers to this:

Having said that, the language used here is rather strange. The text below on the left confirms the parallel tasks model. But the text at the top mentions “Deep research,” which is an odd term to use for software development. Plus, the expectation now is that any task is “background” unless the user has asked for constant intervention. This does not feel like it was written in the same spirit of recent “agentic” code editor releases.

Looking at the Editor window first (right side of diagram), I get good quick code completion and suggestions. I select one of those awkward bits of project code that can be improved — a bounds checker.

After selecting it, I’m given the chance to add it to the query, so we have:

It suggested I use the Min/Max functions. Given I am not pushed for speed, this sounds right. The text in the chat box stated the changes and benefits, and I could accept the changes in context by the code:

Of course, I’m not brave (or foolish) enough to try transplanting my whole build environment into an experimental app. But I will keep the changes and check them later.

Exploring Antigravity’s Agentic Capabilities

So now let’s try the agentic side. Unfortunately, it doesn’t seem to work with independent branches (or doesn’t expect to work this way), so you can probably only work within the same workspace folder:

I think a “conversation” maps to a task. I’ll ask it to improve another method that works with bounds. But it isn’t really designed to keep the task manager open, since it continually shuts it for space for the chat box and (for example) the changes view:

One aspect I did like was the following statement:

This proves it has contextual understanding of its last conversation and the resultant changes. And it is correct — Min/Max is neater (though I would expect it will be far slower).

So, looks like I should retract the idea that this was designed to work on parallel tasks in the same project — it clearly wasn’t. Perhaps Google is waiting for responses to see how they should react.

Conclusion: An Experiment With an Unclear Direction

At this stage, I decided to stop as I don’t quite know what this product is truly going for. It is an app, but it appears to be partly a VS Code clone. It offers an Agent manager, but doesn’t really offer the parallel tasks I’d expect. But it manages to do what Gemini CLI does, or for that matter, what Jules does.

I recognise that Google creates projects from independent teams, and sometimes there are great ideas (I still remember Google Wave) that Google as a company go on to ignore. But often they are misaligned with current trends. I’m going to wait until Google works out what they want to do with this before giving it a fresh look later in its development evolution.