An unexpected Antigravity

Wed, 21 Jan 2026 18:00:00 +0000

I confess, when I started using Antigravity I had many doubts, because the new revolutionary editor produced by Google seemed to me like just another clone of Microsoft’s VS Code.¹

But as soon as I started using the agentic features of Google Antigravity, I had to change my mind, because there is truly something good there.

Of course, there are also many limitations, but these are shared by all other LLMs (Large Language Models), which work well when guided step-by-step through the task at hand, but also lack imagination and struggle with new and slightly complicated problems.

– Image generated by Google Gemini.

Editor and IDE

Google Antigravity is an IDE (Integrated Development Environment), that is, an editor with additional features that help write and debug code.

Being a derivative of VS Code, it inherits all its positive and negative aspects, first and foremost the fact that it is based on Electron, a multi-platform framework that is very convenient for developers but also very demanding in terms of resources and disk space.

In fact, as I already noted in my last post, once installed, Google Antigravity occupies a whopping 700 MB on my Mac (696.6 MB to be precise), a hair more than VS Code itself (683.9 MB) and slightly less than its father Windsurf (718.7 MB). For comparison, my two favourite editors, TextMate and BBEdit, occupy 40 MB and 65 MB respectively. ²

There is little to say about the code editing and development support features. They are identical to those of VS Code and can be greatly extended through the 8,500+ extensions available on the Open VSX Registry, a database of extensions specifically designed for VS Code-derived editors.

In theory, one could use VS Code extensions, but Microsoft recently blocked the use of the VS Code marketplace for all other derivative editors (including Cursor, Windsurf, or Antigravity). So much for open-source principles…

Agentic functions

So, what exactly is Agentic Artificial Intelligence? It is an AI system that can act autonomously and achieve complex goals with minimal human supervision, without needing detailed, well-defined instructions.

It’s a bit like the dream of amateur cooks: having a robot that can look at what’s in the fridge and cupboard and prepare a complete lunch all by itself, after we vaguely explain what we want.

But it is also the dream of the amateur vibe coders, those who would like to be able to ask the AI to program an application “like this and that,” go out for a pizza, and find everything ready upon return, including the porting for major platforms and an e-commerce site to sell it.

Putting Antigravity to the test

So far, all these experiments haven’t exactly looked great but, as Sean Connery teaches us, never say never. So let’s see how the agentic functions integrated into Google Antigravity work in practice.

To test them, I asked the program to perform a few specific tasks, ranging from simple things to a particularly complex task. I tried to to leave it free to decide what to do and to intervene only when it was truly necessary. Although I chose tasks that were relevant to my own research, I believe the results are significant nonetheless.

Here is how it went.

Before starting

Before starting, I pretended that I was using Antigravity for the first time, and deleted all the files generated by the application with AppCleaner. I ran the onboarding process again, choosing to Start fresh without importing configurations from VS Code or Windsurf, and to use the Review driven development mode without modifying the default options.

I didn’t install any extensions, because I prefer to decide for myself what I need.

One more thing: the version of Antigravity I used to write this post is 1.11.17. However, given the speed of development, it’s possible that some aspects of the interface and how the program operates may have changed by the time this post is published.

Task #1: Extracting data from images

Let’s start with something simple, yet very important when dealing with old scientific papers: extracting data from images. My goal was to verify whether it is possible to instruct the Antigravity AI to extract data on its own from the figures in this paper, which has recently been published. I am not at all proud of it (to put it mildly), but the referees surprisingly accepted it almost without a word.

Today, the reproducibility of results has become a key principle and it is normal to share all the data from a scientific paper on public repositories like Zenodo, OSF, Dataverse or maybe GitHub. Until a few years ago, however, the original data were essentially only accessible through the figures in papers. This is precisely why it is important to be able to extract them from images.

Although there are many programs dedicated to extracting data from figures (like this, this or this), they require user guidance – at the very least to define the position of the X and Y axes and the coordinate limits. Some programs can work automatically, but only if they deal with well-defined types of images. ³

Before starting, I created a new directory in which to save the graphs that I had downloaded from the paper’s web page, just as a colleague who wanted to repeat my experiment would do. While I was at it, I also included the PDF file of the paper, which I will need later.

NOTE. All of the questions listed below have been copied without correcting typos and clumsy syntax, due (in part) to the excitement of seeing the results quickly. However, these errors are useful because they demonstrate that these systems can understand our requests even when the form is far from perfect.

I chose to use Gemini 3 Pro (High), which is currently the most powerful model in Antigravity. First, I asked it to orient itself within the directory content.

Prompt

In the current directory you will find a pdf file, a couple of folders and some inages in png or webp format. Is all this right?

Gemini thinks for a couple of seconds and then confirms that everything is correct. Very well, then

Prompt

Now open the file containing "Fig1" in the filename. This is an histogram showing the concentration of several chemical species in two kinds of Shungite, type Z (darker bars) and type B (lighter bars). Could you extract the values of concentration from the images? Please produce a table with the name of each chemical species and the associated concentrations for the Type Z and Type B material. Export the table as a csv file named "gemini-fig1.csv" and as a markdown file "gemini-fig1.md"

This is the image that Gemini had to deal with

Despite me being deliberately vague about the file name, Gemini can find it without problems and, after about twenty seconds, produces the two requested files. The table generated by Gemini is

Chemical Species	Type Z (Concentration %)	Type B (Concentration %)
SiO2	41	52
C	33	16
Al2O3	11	16
Fe2O3	5	3
FeO	3	2
TiO2	0.2	1
MnO	0.1	0.2
S	1.2	0.5
MgO	0.5	1.5
Na2O	1.5	1.2
CaO	0.5	2
K2O	1	2
H2O	2	1.5
minor elements	0.5	0.5

Comparing it with the real table with the measured values of concentration

Species	Type_Z	Type_B
SiO2	40.8	52
C	33.4	16.3
Al2O3	10.6	15.8
Fe2O3	4.7	3.2
FeO	3.5	1.9
TiO2	0.4	0.9
MnO	0.14	0.12
S	1.1	0.6
MgO	0.3	1.6
Na2O	1.6	1.2
CaO	0.4	2.3
K2O	1	2.2
H2O	1.6	1.4
Other	0.46	0.48

it is immediately apparent that all the values extracted from the figure are very close to the real values, with minimal approximations of less than 0.5%.

I am truly impressed by the result: Antigravity did everything in a few seconds without any intervention from me other than preparing the files and writing the prompt. While normal chatbots like ChatGPT or Claude can do similar things, Antigravity allows us to work directly on our computer with our files, without having to transfer anything back and forth via a web interface.

Task completed with full marks.

Task #2: Replication of graphs

For reasons that are not relevant here, I contributed very little – and mostly critically – to the writing of the paper mentioned in Task #1. Specifically, I didn’t prepare the graphs as usual. Instead, they were created by a colleague using Matlab, a scientific computing environment much loved by engineers. They are right to love it, because with Matlab you can perform very complicated calculations with little effort. However, producing high-quality graphs is certainly not one of its strengths

Let’s see if I can get Gemini 3 Pro to recreate the histogram from Task #1 using the ggplot2 library in R.

Prompt

Now generate the R code to recreate the same graph, using ggplot2 and whenever possible the functions available in the tidyverse.

After a while, the script is ready and is saved automatically in the project directory. I give it a quick look and it seems fine. Thus, I open the integrated terminal in Antigravity and run the script as suggested.

Rscript recreate_fig1.R

Apart from inverted colors, the figure is identical to the original.

I want to be clear on this point: I didn’t touch a single thing of the code generated in Antigravity by Gemini, and I won’t do so later, either. Yet Gemini manages to recreate an almost perfect copy of the original in R, reading the data in the figure and recognizing all the surrounding elements of the graph, such as the X and Y axis labels, the numerical scales, or the legend.

I know R well enough and could have achieved the same result in a short time, but there is no doubt that, even in cases like this, Antigravity can be a valuable help for those who don’t know programming well.

However, I am a hard guy to please and I ask Gemini to invert the colors

Prompt

Sorry, but the colors are inverted. Type Z is light grey and Type B is dark grey. Please switch the colors so that they are identical to the original. Save the new R code as `Rscript recreate_fig1-1.R`

I run the new script and now the colors are correct. I am pleased to note that the name of the generated png file has also been updated, making it easier to compare the different files produced by Gemini.

Once again, I am very impressed. Gemini did everything perfectly and I didn’t have to correct a single line of code.

It was undoubtedly an easy job, but the result is still very interesting. This is especially true given that we are talking about a specialised language like R, which doesn’t have the same volume of training examples as more popular languages like Python or JavaScript.

It seems that also this task has also been completed with full marks.

Task #3: Generation of new graphs

Gemini was able to successfully recreate the histogram from the paper, but I I would like to check whether there are any more effective alternative representations.

I pass the ball back to Gemini 3 Pro, which comes up with two interesting ideas: a Lollipop chart and a Dumbbell plot, which however don’t fully satisfy me. I try to get it to make some changes, Gemini always performs flawlessly but the result doesn’t improve.

In the end, the most balanced graph is the usual histogram, this time with the X and Y axes swapped and very different colors for the two types of material.

Since I am hard to please, I choose a much more complicated figure from the same paper

and I ask Gemini to repeat the process of generating equivalent graphs using R and ggplot2. Gemini gets straight to work, understanding by itself that the concentration of the elements at day 0 applies to both types of material, a fact that isn’t trivial to understand just by looking at the graph.

Answer

For Day 0 ("untreated sample"), I assigned the same concentration value to both Type Z and Type B in the dataset. This format suggests that both treatments start from the same baseline, which will make plotting lines easier in R.

I’ll spare you the details. Gemini easily produces several different types of data visualisations from the image above, such as a heatmap or a Sankey plot. While the graphs weren’t 100% satisfactory, they demonstrate that Gemini can perform the tasks required by demanding users such as myself.

What truly stuns me is that Gemini understands by itself that, when I asks it to arrange the graphs in two columns, one for each material studied, I actually want what is called a facet in R jargon. This may seem like a small thing, but it means that these more complex representations become accessible even to those who know what they want but cannot express it precisely.

It must be said, however, that as convenient (and even fun) as it is to ask and watch Gemini work, when you get to the finer modifications, you lose much more time writing questions and waiting for answers than working directly on the code. This is a detail to keep in mind.

However, it must be said that, although it is convenient and even fun to ask questions and observe Gemini in action, when it comes to the finer modifications one ends up spending much more time writing questions and waiting for answers than working directly on the code. This is an important detail to consider.

Let’s say that this task deserves a passing grade.

Task #4: Interaction with code and operating system

Now, let’s see if the Gemini 3 Pro integrated into Antigravity can perform basic file and folder management operations. Although I ran all the tests on macOS, the examples should also apply to various incarnations of Linux and BSD Unix.

First, I asked it to tidy up the files generated so far, moving the R scripts to the code directory, the data files to data, and the generated graphs to output. After thinking about it for a moment, Gemini 3 Pro creates a simple shell script to execute the request. It even made an error, noticed it, and asked for authorization to correct it.

First, I ask it to tidy up the files generated so far by moving the R scripts to the ‘code’ directory, the data files to ‘data’, and the produced graphs to ‘output’. After thinking about it for a moment, Gemini 3 Pro created a simple shell script to perform the task. It makes an error, notices it and asks for authorisation to correct it. Very, very good.

But what I like even more is that it automatically updates all the previously written code with the new file paths.

I then ask it to add my usual preamble to each R script, which creates a well-defined R environment. I give it an example from one of my old scripts, but otherwise allow it to do whatever it thinks is best. Gemini does everything perfectly, again updating all the file paths created so far. Truly impressive!

Gemini also handles perfectly the conversion of tabs from two spaces to four spaces, as I like it. In fact, it even recognises the need to do this without introducing formatting errors into the code. Better than a linter.

Lastly, I move on to try code_versioning_ with git which is always useful when a project starts to become slightly complicated.

Prompt

Could you now initialize a local `git` repository for this project? Versioning is very useful as soon as a project starts to become complicated.

Everything works wonderfully; Gemini creates the requested repository, makes the initial commit, and also adds a sensible .gitignore file. Obviously, I can query the repository status or perform all the usual git operations I am used to doing from the Terminal.

While I am a bit afraid to allow an agentic system to perform these operations on my Mac, I must admit that the result is perfect.

What I wrote at the end of the previous task still holds true: a user who is familiar with git commands can work much faster in the Terminal than by asking Gemini. However, for the average researcher (or general user) who is unfamiliar with the Terminal and versioning systems, using an agentic system like this can be an excellent way to interact with code at a low level without having to study large amounts of pages of documentation.

In any case, another task passed with full marks.

Task #5: Statistical data analysis

I won’t make this long, because Antigravity/Gemini 3 Pro is a bit weak on statistical analysis.

If I let it do whatever it wants, it comes up with nonsense, such as creating correlation matrices between concentrations of different heavy metals or trying to compare “differences of effectiveness” between the two materials. Admittedly, it’s not an easy task, but it shows – should it still be necessary to demonstrate it – that these intelligent systems are very useful when given precise instructions, but struggle to work independently when the user doesn’t have a clear idea of what they want to achieve.

In fact, once I explain properly what kind of data I am dealing with and what I want to achieve:

Prompt

The two types of shungite, type Z and type B, are different materials and they are used independently. In other words, the experiments made using type Z material is completely independent from the experiment with type B, so the two materials cannot be directly compared. This means that the stat_difference_boxplot has little sense, and the same is true for the correlation matrix which photographs a single day (I guess day 0 for only one type of material), while we are interested to time series. Therefore you should try to use some statistical analysis able to deal with time series.

Gemini thinks about it for a while, makes some mistakes but manages to correct them on its own, and eventually comes up with a small model showing how type Z material absorbs heavy metals more rapidly than type B material. If there were more data available, it would make sense to reflect a bit on the model, but for now, it’s enough.

Gemini thinks about it for a while, makes some mistakes, but corrects them by itself, and eventually comes up with a small model showing that type Z material absorbs heavy metals more rapidly than type B material. If there were more data available, it would be worth pondering a bit over the model, but for now, this is more than enough.

Hard to give a grade here, let’s say unclassified.

Task #6: Extracting tables from PDF files

Here we enter into hostile territory. Automatically extracting the content of tables in PDF files may seem trivial, but it is a subject that has puzzled hundreds of researchers, myself included. The main problem is that the PDF format is designed to manage the visual aspect of the page, but knows nothing about its content.

For my tests, I asked Antigravity to open the PDF file of one of the Hydrological Yearbooks of the Apulia Region, in southern Italy, and extract the minimum and maximum temperature data measured at a few meteorological stations in Apulia.

While daily data is now available online, the PDF Yearbooks still remain a fundamental resource as they contain temperature and precipitation data from approximately 150 meteorological stations since 1921. This allows us to analyze how the region’s climate has changed over the last century.

Years ago, I solved the problem of extracting data from these PDF files through a combination of R and AWK scripts. However, the procedure is long and complex, as many inconsistencies in the tables must be corrected manually.⁴ In the end, extracting data for one year takes a couple of hours of careful work -— not to bad given the complexity of the task – but it would be very useful to delegate this task to an AI.

Therefore, I try to have Gemini 3 Pro do it, writing a long prompt where I explain exactly what to do

Prompt

Open annale2013.pdf and go to page 6, where you will find a pair of data tables with measured precipitations [sic! sarebbe dovuto essere “temperatures”] for two weather stations. The data is arranged in pairs of columns, and each pair corresponds to a month, G for gennaio (january), F for febbraio (february), etc,. until D or dicembre (december).

As for the pairs, the first column is the minimum temperature and the second column is the maximum temperature.

Each row represents a different day.

At the end of each table there are some summary data, Medie, Med.mens. and Med.norm that you can skip.

Missing data can be marked by either one or more > or < signs, or by = or be simply blank. In some tables there are extraneuous signs that you can skip outright.
Read the table and generate two different csv files, one for the maximum temperature and one for the minimum temperature, following this example

Date,Altamura,Andretta
    2007-01-01,13.4, 7.7,
    2007-01-02,15.7, 9.7,
    2007-01-03, 7.1, 2.7,
    2007-01-04, 9.5, 7.0,

The header contains the date in ISO format, YYYY-MM-DD, and the name of the weather station which is written in bold at the top of each table, just under the months. All other information in thsi area, eg., (Te), Bacino etc. is not useful and can be skipped.

Gemini tries repeatedly to solve the problem using Python, but its scripts produce a lot of errors and skip several days of valid data. After all, it’s not an easy problem, I spent months on it myself, so I give it a little help.

However, at this point Gemini throws an error and it is impossible to make any further progress.

The best option would be to start from scratch, but in the meantime I have reached the quota limit for Gemini 3 Pro (High) and would have to wait several days to continue.

That is clearly not option, so I decide to switch model and try Gemini 3 Flash, which everyone is talking about right now. Gemini 3 Flash starts working and proposes a plan that seems sensible, but that in practice produces a jumbled mess due to the presence of extraneous characters and unclear formatting, as Gemini 3 Flash sadly admits.

I therefore recommend using the pdftools library in R. I have used it myself and it produces far better results than similar Python tools. Finally, bingo! Gemini 3 Flash produces a data file that is 100% correct.

To be truly useful I should have it repeat the process for all stations and for several different years, but for now I’m satisfied, given that I don’t want to waste all my quota on this task. In any case, the result achieved with Gemini 3 Flash is truly promising and deserves further exploration.

On the other hand, it’s impossible to achieve anything worthwhile with Claude Sonnet 4.5 (Thinking). After trying again and again, I reach the quota limit for this model and have to stop.

What about grading this task? Gemini 3 Flash achieves the maximum score, while Gemini 3 Pro should be retested under the same conditions as the smaller model. Lasty, Claude Sonnet 4.5 is unclassified.

Task #7: Programming a microcontroller

Another area in which Google Antigravity’s agentic functions could prove very interesting is the programming of microcontrollers such as Arduino, Raspberry Pi Pico, or ESP32. There are literally mountains of these little gadgets, and it’s difficult to navigate the many different models as well as the thousands of sensors and modules that can be connected to them.

In this specific case, an AI system capable of quickly producing working code would be extremely useful.

For my tests, I decide to use a Nicla Vision, which is essentially an Arduino with a built-in camera. The Nicla Vision is a true gem. It’s not cheap, but it’s worth every penny. However, it is also far less common than standard microcontrollers. If Antigravity can program it correctly, it will certainly succeed with normal Arduinos, Pi Picos, or ESP32s.

I switch back to using Gemini 3 Flash and ask if it knows the Nicla Vision. I also provide it with a link to the product webpage to help it locate the device. Gemini confirms that it knows exactly what I am talking about, and we can begin.

To program these devices, I have only ever used the Arduino IDE and Thonny, and I don’t know if Gemini can manage the microcontroller directly from the editor. When I ask, Gemini replies with a very simple command

% ls /dev/tty.usbmodem* /dev/cu.usbmodem* 2>/dev/null || echo "No usbmodem devices found"

that allows checking if the Nicla Vision is connected to the Mac. Once it has found it, it checks whether the Python libraries required for communication with the microcontroller are installed. Since they are not, it proposes installing them. It also rightly gives me the option of installing them globally or in a virtual environment, and needless to say, I choose the latter option.

Gemini also prepares a short test script that makes the LED blink (the classic “Hello World” of the IoT world). When I confirm that everything works, it proudly proclaims:

Answer

I'm ready to start writing more complex code for your project. What would you like to build first?

Up to now, Gemini has done nothing than I could not have done myself with Homebrew and Conda. However, I would have had to consult pages and pages of scattered web documentation. Here, instead, I managed to configure everything in just a few minutes and I also learnt many useful things.

Since Gemini was so keen to be useful, I asked it to write a small program that uses the Nicla Vision to take photos at set intervals and send them to the Mac via Wi-Fi. The result? Everything worked on the first try.

And Gemini didn’t even get offended when I told it straight out that I didn’t trust it with my Wi-Fi password. In fact, it suggested a more secure alternative. But I am distrustful by nature, so in the end I used my iPhone’s hotspot with a disposable password.

In conclusion, even the last task is passed with full marks.

Leaving a trace

One truly annoying thing about Antigravity is that it doesn’t have a function to export a complete log of what you do, with the questions asked and the model’s answers, and maybe even its thoughts.

Edit. I was wrong, the keyboard shortcut CMD (⌘)-E opens the Agent Manager, a separate Antigravity window that, among other things, lets you view the entire history of what Antigravity has done, including its thoughts. The problem is that there isn’t a specific menu item for the Agent Manager (or at least, I haven’t found one), and the keyboard shortcut is only shown when the program starts.

Edit #2. The Agent Manager can also be opened directly from Antigravity’s toolbar: the corresponding entry is located right next to the icons that allow to change the application layout and perform searches. I don’t know why I didn’t notice it earlier, but in my partial defence I should point out that all the other toolbar commands are represented by icons. For this reason it isn’t immediately clear that this entry is a command rather than just a plain text string, just like the name of the application sitting in the center of the toolbar.

Anyway, after every operation, Antigravity lets me read a detailed Walkthrough of what it did. Right-clicking on the relevant Tab,

I see that it is possible to reveal the file in the Finder. This opens a folder with a large number of Markdown files, all having standard names such as implementation_plan, task, or walkthrough followed by the resolved suffix and a progressive number

that provide the history of everything I do with the agentic system.

Whenever I request something from one of the integrated agents, Antigravity generates three files containing: (1) what it must do, task; (2) the work plan, implementation_plan; and (3) a summary of what it did, walkthrough. At first glance, it’s not easy to relate these files to each other, but the mechanism deserves a closer inspection. For the record, all the files in question are in a directory inside ~/.gemini/antigravity/brain/, but the main ~/.gemini/antigravity/ directory contains many other directories with configuration files, generated code, and more.

Conclusions

It’s clear that I enjoyed using Antigravity. In some cases, those who know how to program risks being slowed down rather than helped, but in general, and in particular for those familiar with Word, Excel and little else, Antigravity’s agentic functions can prove to be a truly valuable help.

In my life as a non-professional programmer, I went from writing code while consulting huge books of documentation to searching for answers on StackOverflow. In my view, Antigravity’s agentic functions are like StackOverflow on steroids: not only do they provide answers to our questions, they also interpret and reason about them, proposing solutions almost autonomously.

But, just as on Stack Overflow, you should always rely on your own knowledge and experience to distinguish useful, working answers from those that are irrelevant.

However, please let’s not talk about vibe coding, i.e. the ability to ask the program to perform a given task and then go for a walk while Antigravity does everything alone! ⁵ As the examples show, if you are not very precise in explaining what you want and you don’t check step-by-step what Antigravity proposes to do, you risk the entire process failing or producing wrong results.

Just like a thesis or PhD student, or a young colleague, Antigravity can be a great help if you know what you want and how to achieve it, and can explain it clearly. However, making it come up with its own ideas – I don’t mean original ideas, just sensible ones – is still just science fiction for now. Or marketing.

The mere fact that Google was using code produced by a direct competitor for one of its development tools seemed, shall we say, rather unusual to me. ↩︎
It is true that TextMate and BBEdit are not true IDEs (in particular TextMate), but the difference in size is still impressive. ↩︎
Several years ago, I developed a C, er Python program that could do that automatically, but only with images from a particular type of digital oscilloscope. ↩︎
The imagination of those who compiled the tables deserves an award. ↩︎
Even a very busy programming guru like Linus Torvalds uses vibe coding, but only for his own projects. In any case, he only uses it fo for his little toys, certainly not for developing the Linux kernel. ↩︎

If you’re interested in the controversy that followed the latest price hikes at Cursor, you can read about it here. ↩︎
The post is behind a paywall, but you can read it freely here. ↩︎

Vs Code on Melabit

An unexpected Antigravity

Editor and IDE

Agentic functions

Putting Antigravity to the test

Before starting

Task #1: Extracting data from images

Task #2: Replication of graphs

Task #3: Generation of new graphs

Task #4: Interaction with code and operating system

Task #5: Statistical data analysis

Task #6: Extracting tables from PDF files

Task #7: Programming a microcontroller

Leaving a trace

Conclusions

Photocopied!