Antigravity on Melabit

Antigravity: the LLM does it better

Mon, 16 Mar 2026 18:00:00 +0000

Over the last few weeks, I’ve been writing about my experiments with Antigravity, or rather, with the (more or less) intelligent agents integrated into the editor. The results have been mixed: sometimes the agents proved to be very effective, accurately easing some complex or repetitive tasks; in other cases they didn’t accomplish anything worthwhile, only wasting a huge amount of time.

Coding badly with an LLM

Among all the more or less useful applications of LLMs, one of the most controversial is the idea that anyone can use an LLM to program, even when they don’t know the first thing about it. This is the so-called vibe coding, a concept that can be summarized more or less like this: “I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works”. This is not a quote from Nanni Moretti, a famous italian actor and director; it was reported by Andrej Karpathy, one of the founders of OpenAI.

Now, setting aside the many issues regarding security, the maintainability of code produced without really knowing what it does, and the regression to the mean, which here implies that the quality of AI-produced code will inevitably tend to collapse, it only takes a bit of personal experimentation, even with simple projects, to realize that the very idea of coding for everyone doesn’t work. If you want to get something good out of AI, you have to know exactly what you want and how you want it.

I tried vibe coding myself: I asked Gemini to write a driver for an Arducam camera, explaining only the bare essentials and waiting for it to do everything on its own.¹

However, this approach did not work. It took hours upon hours of work, errors, inconclusive answers, corrections, and advice from me to reach an acceptable result.

And this was only possible because I eventually abandoned the idea of letting Gemini do everything and provided it with specific advice on how to proceed. Without that, it would have only been a massive waste of time.

Mimmo also tried, on his own, to have Lumo write a Micropython program to manage my Arducam Mini 5MP Plus with the Pico. Even Lumo, which is undoubtedly one of the best chatbots around, couldn’t do it.

– Image generated by Google Gemini.

Coding better with the same LLM

This doesn’t mean that an LLM can’t be useful when programming; you just have to use it properly. You must explain exactly what you want it to do, provide all the necessary materials, and set boundaries within which it must operate.

In short, you have to treat it like a graduate student or an intern, with little experience but a great desire to learn.

It only took two carefully written prompts to make a difference. The first defined the project’s directory structure and instructed the agent to use git for version control and uv to install any necessary Python packages,

Prompt

Start a new project and name it project13-pico-camera5mp-reprise.

Read the AGENTS.md file that defines your basic behaviour.

Create a new directory with this name and initialize an empty git repository using git init Use uv for managing Python packages. All the code must stay in the code directory, with no subdirectories within it. This project does not need a data directory and the output directory must be renamed as images.

while the second prompt contained everything I could think of to help it work.

Prompt

I have a Rasperry Pi Pico 2W connected to a Arducam 5MP Plus OV5642 Mini Module Camera Shield (https://www.arducam.com/arducam-5mp-plus-spi-cam-arduino-ov5642.html).

I have connected the camera to the Pico using the standard layout found in the documentation:

Camera	CS	MOSI	MISO	SCK	GND	VCC	SDA	SCL
Pico	GP5	GP3	GP4	GP2	GND	3V3	GP8	GP9

The main documentation for the camera can be found at these links:

The code to drive this camera with the Pico is written in C (i.e., for Arduino) and CircuitPython, and can be found here: https://github.com/ArduCAM/PICO_SPI_CAM. You can download all the files you need from this repository. In particular, the files for CircuitPython are in the Python directory:

Arducam.py, which contains the functions to drive the camera,
OV5642_reg.py which, as far as I have understood, defines the resolutions allowed when taking pictures, and
boot.py , but I don’t know what it does. In the same directory there is also the script ArduCAM_Mini_5MP_Plus_VideoStreaming.py which sends the video captured by the camera to a Windows application and that is of no use here.

Please write a basic CircuitPython script that uses the functions defined in Arducam.py to test that the camera works and can take photos.

These two better-crafted prompts allowed Gemini 3 Flash to quickly generate a CircuitPython script that runs directly on the Pico and performs all the requested tasks.

Actually, the very first version of the script didn’t work. But Gemini was able to modify just a single line in the Arducam.py driver provided by the manufacturer to fix it (specifically, it removed a zero from the frequency value).²

– The line highlighted in blue shows the only change that Gemini made to the Arducam.py file; the original file is on the left, and the Gemini-modified version is on the right.

All of other files provided by the manufacturer remained intact.

As it turned out, the manufacturer’s driver worked perfectly with the Pico. Gemini simply learned how to use it to write the script that captures the image directly from the microcontroller (with a bit of patience, I could have done that myself).

Guide the LLM or let it run on its own?

The difference with respect to the previous approach based on vibe coding is striking.

Then. Gemini worked frantically for hours and created such a mess that I was forced to restart my Mac twice. Meanwhile, it had convinced itself (and me, too) that the Arducam.py driver was incompatible with the Pico and thus rewrote it from scratch, discarding an essential library for communicating with the camera (the library marked by the red arrow),

– Changes to the first few lines of the Arducam.py file; original file on the left, Gemini’s modified version is on the right. The arrow marks the library that was removed by Gemini.

and removing most of the functions defined in that file for no reason and without any real gain in efficiency or functionality (quite the opposite, actually!). The image below shows the difference in the length of the original code, on the left, compared to the modified version, on the right.

– Changes to the Arducam.py file. The red rectangles highlight the difference in the number of lines between the original code (left) and Gemini’s modified version (right).

Not satisfied with that, Gemini also completely altered the OV5642_reg.py file containing the camera configuration data, claiming memory issues. These problems evidently didn’t exist, given that everything went smoothly in this second experiment using the manufacturer’s original file.

– Changes to the OV5642_reg.py file, containing the camera configuration data. The original configuration (left) was overridden by Gemini (right).

What About Arduino?

At this point, it was inevitable to ask Gemini to generate the Arduino driver, using the same information that I had already provided for CircuitPython.

At this point, it was inevitable that I would ask Gemini to generate the Arduino driver using the same information that I had already provided for CircuitPython.

Gemini struggled more this time, mostly because I had forced it to make only minimal changes to the original Arducam libraries. However, this constraint was impossible to satisfy since the libraries do not natively support the Raspberry Pi Pico.

Response

Researching Arducam Library Compatibility I’ve thoroughly inspected both the original ArduCAM library and the Arducam_mini library. Neither version contains native support for the RP2040/RP2350 (Pico) architecture. Specifically, both libraries are missing the necessary definitions for regtype, regsize, cbi, and sbi for this platform, which is the root cause of the compilation errors.

Once the constraint was relaxed, things went smoothly, and in a short time, the driver modified specifically for the Pico and the related image acquisition program were ready.

Free or paid?

Many argue that paid models are much better than free ones. Consequently, my vibe coding problems would supposedly have disappeared if I had paid for Gemini or Claude.

That’s not exactly how it went. During my testing, I mainly used the free version of Gemini to see what would happen to a non-professional user playing with these tools. However, when I ran out of tokens, I switched to the paid version of Gemini provided by the university, but I never noticed any significant differences. I can’t say much about Claude, because paying 200 dollars a month to use it seriously makes no sense for someone like me, who isn’t a professional programmer.

What I did notice was that Claude Opus and Claude Sonnet were much better than Gemini at solving the problems that arose during code development. However, since I only used them once the work was already in progress, they might have just been helped by what Gemini had already done.

Conclusions

It goes without saying that neither this experiment nor the previous one are scientific. For them to be considered as such, I would need to use different types of microcontrollers and modules, define a well-defined set of prompts, and measure how the agent responds to changing experimental conditions.

Despite this, the experiment has one merit: it is fully reproducible. Anyone can repeat the experiment using the same low-cost hardware and prompts to verify whether my findings are correct.³

This is something that the vibe coding apostles with tens of millions of views always carefully avoid proposing. Their posts are full of certainties and bold predictions yet they never provide any evidence to support their claims.

Today, no one can deny that LLMs can be a great help during programming. However, it’s hard to believe that they can truly do so without any human intervention. At least until those apostles decide to provide us with clear, repeatable data to support their claims.

Although I know a little bit about programming, I had no idea how to develop a driver and didn’t want to spend days learning how to do it. ↩︎
Actually, this file is a library of functions. However, since microcontrollers don’t have an operating system, these functions access the hardware directly, just like the drivers that control the components of a computer. Therefore, in this case, the terms library and driver are interchangeable. ↩︎
The term low cost must now be taken with a grain of salt. The shortage of electronic components has caused the price of the Pico to skyrocket, and even more so for the Arducam Mini 5MP Plus. The latter, which cost 40 dollars a few months ago, now costs more than triple that on Amazon or AliExpress. Fortunately, some retailers are maintaining more reasonable prices, at least for now. ↩︎

The Dory effect

Mon, 09 Mar 2026 18:00:00 +0000

I am well aware that LLMs have poor memory, but I never imagined that I would suffer the consequences so quickly.

– Immagine generata da Google Gemini.

Note to the reader. This article complements the previous one, Antigravity: a driver written by AI, and should be read afterward. However, here’s a brief recap for the lazy readers.

Not knowing how to write a driver for a SPI camera attached to a Raspberry Pi Pico, I asked Gemini 3 Flash for help, working entirely inside Antigravity. After many hours, the agent managed to produce a working Arduino program. Then I made a fatal mistake by asking for even more without taking any precautions.

Premise

The working code generated with such great effort by Gemini 3 Flash assumed the Pico acted as a bridge between my Mac Mini and the SPI camera.¹ On the Mac, a Python script commanded image capture, while the actual acquisition was performed by the Pico, running an Arduino program (a sketch in platform jargon) that is essentially C/C++ code adapted for microcontrollers.

Controlling everything from a PC works fine for early tests, but it becomes cumbersome when you want to use such a setup for fieldwork.

Automatic captures

I asked Gemini to modify the code so it would automatically snap an image every N minutes or when a button is pressed, then send the picture to a computer over Wi‑Fi.²

Prompt

[...] However, this means that I need to use a Pico for the capture and another computer, even a Raspberry Pi Zero for commanding the capture process. Would it be possible to do everything on the Pico, eg press a button and perform the capture or via a timed process (defined in the .ino file itself) every N minutes (but there should be a mechanism that sends the images to a computer connected by WiFi, avoiding to fill the pico storage space).

Gemini jumps straight into the work, still using Arduino. In principle, it should be a trivial task, but no matter how hard Gemini tries, the code never works. After many fruitless attempts I got fed up and asked it to revert to the last known‑good version of the program.

Backtracking

And here Gemini hits an unexpected wall because, despite my guidance and constant suggestions, there is absolutely no way to succeed.

Stupidly, I hadn’t kept track of the various code versions as they were generated, and that’s entirely my fault.

On the other hand, even though I am well aware that large language models (LLMs) have a working memory that resembles Dory’s, the blue tang fish, I would have never imagined that these ultra-sophisticated systems couldn’t even retrospectively reconstruct what they’ve already done. Despite having dozens upon dozens of implementation_plan.md, task.md, and walkthrough.md files that detail every previous step. I counted them: for this project alone, Antigravity produced over 250 distinct files.

Going back to a prior state is something that tools like Git and its predecessors – tools that are entirely devoid of any intelligence beyond that of their creators – have been doing flawlessly for more than fifty years). Maybe developers of these intelligent agents could give it a thought, huh?

Epilogue

In the end, stubbornly relying on my notes,³ I managed to get Gemini to repeat everything it had already done. It took hours, it reproduced all the earlier mistakes, but eventually the rebuilt code worked again.

While I was at it, I also had Gemini redo the whole thing for CircuitPython, and that port required many other hours of work and errors. And before getting there, Gemini caused such severe issues that macOS had to disable USB communication with the Pico, forcing me to restart the Mac a couple of times.

Needless to say, this time I had it keep track of every step with git and I also put all the code on GitHub, just in case.

One of the next steps will (hopefully) be MicroPython, but that’s another story.

Why does Arduino struggle so much, despite being a far more mature microcontroller development platform than MicroPython or CircuitPython? Because the camera module I chose isn’t supported on the Raspberry Pi Pico; it only works with classic Raspberry Pis (those running a full OS, such as the Pi 4, 5, or Zero), as well as with the Arduino and ESP286 families of microcontrollers. ↩︎
English isn’t great here; it’s more a stream of thoughts than a polished discourse. But I prefer jotting down whatever comes to mind while writing rather than losing the thread of ideas. ↩︎
I’ll never stress enough how important it is to keep written notes of what you’re doing. At the beginning it seems like a waste of time, yet it’s the best way to avoid losing a huge amount of time later. ↩︎

Antigravity: a driver written by AI

Wed, 04 Mar 2026 18:00:00 +0000

Among all the Raspberry Pi and Arduino boards I am spending my days with, my favorite is the Raspberry Pi Pico, a small yet powerful microcontroller that can be programmed not only in C/C++ via the Arduino IDE, but also in MicroPython and CircuitPython, two competing Python variants for microcontrollers.

Unlike the other Raspberry Pi models, the Pico does not have a dedicated camera interface, but it can use cameras that communicate over an SPI interface,¹ such as the Arducam Mini 5MP Plus.

In theory, this shouldn’t be a hard job. After glancing at the official documentation, it should just be a matter of wiring the camera to the Pico, pulling the driver and test programs from the manufacturer’s GitHub repository, copying them onto the Pico after installing the supported Python version, and finally trying to snap a few pictures.

I couldn’t have been more wrong.

We need a driver

The only two test programs available, one for Arduino and one for CircuitPython, assume you’ll view the video output on Windows, which is odd because most people working with these devices use Linux or macOS. Moreover, CircuitPython is less common than MicroPython, and I’d have preferred the latter for compatibility with the other components already connected to the Pico.

With patience, and armed with a reference program that shows the main functions for handling the device, you could try translating the CircuitPython code to MicroPython (or vice‑versa),² but there was nothing like that available.

Other guides I found online looked promising, yet they didn’t work in practice. The only option left was to bypass the official tools and write a driver for the camera.

Easier said than done!

I know how to write code to solve differential equations or analyse measurement data. I’m comfortable with micro‑controller programming and sensor data acquisition. But this is a completely different beast. It requires digging into the low‑level communication between the Pico and the camera, a job for specialist engineers who write the drivers that let us humans perform complex operations (like taking a photo) with just a few lines of Python code.

So why not let one of the agents built into Antigravity do what I’m not able to do?

I didn’t have to stick with Antigravity, Claude Code, Google Gemini, DeepSeek, or any of the countless other LLMs at our disposal could have easily handled the task. However, as I’ve already written, using an Antigravity-integrated agent lets you work directly in the editor and access the underlying OS, a huge advantage when you need to keep iterating on the generated code.

AI at work

When you read countless enthusiastic posts about vibe coding – the notion that AI can develop software with little to no human programmer intervention – it looks very easy (read for example, this post that amassed millions of reads, or this one; not to mention the tweet that started it all).³ In summary, you write a couple of sentences asking the LLM or the current agent to do something, you go have lunch or take a walk, and when you come back everything is ready.⁴

Let’s try doing the same with Gemini, giving it only the essential information and checking what it can actually do. In this case, this information boils down to the link to the camera’s web page and a table describing how the camera pins are connected to the Pico (it’s more than three lines, I know, but I’m a bit verbose).

Prompt

I have a Rasperry Pi Pico 2W connected to a Arducam 5MP Plus OV5642 Mini Module Camera Shield (https://www.arducam.com/arducam-5mp-plus-spi-cam-arduino-ov5642.html). I have connected the camera to the Pico using the standard layout found in the documentation:

Camera	CS	MOSI	MISO	SCK	GND	VCC	SDA	SCL
Pico	GP5	GP3	GP4	GP2	GND	3V3	GP8	GP9

Please write a basic Micropython code to test that everything is right and that the camera can take photos

Gemini attacks the problem furiously, spits out MicroPython code that doesn’t run, tries to fix it based on my hints, and inevitably introduces new errors (I keep saying Gemini for brevity, but I’ve also tried Gemini 3.1 Pro, Claude Opus 4.6, and Claude Sonnet 4.6, as my tokens ran out).

At some point, completely stumped, Gemini starts suspecting a hardware issue, such as a bad connection or a defective camera (but probing the individual pins quickly finds that everything is wired correctly).

After hours and hours of work, and because it can’t produce anything decent with MicroPython, I ask it to switch to Arduino, a more mature software platform. More hours later, stubbornly, it succeeds, and the image below is the very first picture ever taken with the Arduino code generated by Gemini (the original image was upside-down; I simply rotated it 180°).

Soon after, I make a serious mistake that forced me, or better it, to start from scratch. But that’s a story for another post.

Epilogue

Once I had a working Arduino program, I asked Gemini to redo everything for CircuitPython. This port also takes several hours of work, interspersed with a couple of forced restarts of the Mac which, after some nasty CircuitPython bug, was forced to disable communication between the USB ports and the Pico.

In theory I should repeat the cycle a third time for MicroPython. But the thought of wasting even more time watching Gemini work makes me shiver, so I shelved that idea, at least for now.

Conclusions

I don’t know what those who write countless articles proclaiming that anyone can have AI write a perfectly functioning program in no time, even if they don’t know a thing about programming, are using.

Even though I know something about programming, I’ve only succeeded with the simplest experiments described in the two previous articles. And it certainly didn’t happen here. It is worth noting, however, that I’m in good company.

– Immagine generata da Google Gemini.

True, following the vibe coding mantra to the letter, I didn’t write a single line of code. I even let Gemini execute terminal commands that I could type blindfolded. But it’s equally true that without my constant dialogue, without guiding the agent step-by-step, without correcting its countless, and often trivial, mistakes, Gemini would have gone nowhere.

And it took many hours of uninterrupted work, too many hours in my humble opinion, to achieve something usable.

Forget speedy, intuitive programming. Forget coding based on good vibrations from the 1960s. Forget programming for dummies!⁵

If you don’t roll up your sleeves and get your hands dirty with the code, even code produced by a more or less intelligent agent, you won’t get you anywhere. I’d love to be proven wrong.

The SPI (Serial Peripheral Interface) is a fast and reliable serial communication protocol widely used to connect a microcontroller (master) to one or more peripheral devices (slave). ↩︎
While writing the article I found this video that explains how to mix MicroPython and CircuitPython code in the same script. If it works for more complex tasks than toggling an LED, it would be a real breakthrough. ↩︎
Is it a coincidence that they are always very long posts but never contain a shred of evidence, a prompt, a few lines of code, or links to support the many unverified (and unverifiable) claims? ↩︎
Being true nerds, no one ever says they’re going to have sex. ↩︎
From the title of the famous For Dummies book series, covering everything from using DOS to playing chess. ↩︎

Antigravity: from surprise to doubt

Mon, 16 Feb 2026 18:00:00 +0000

As effective as Antigravity may be, digging a little deeper reveals that the agent-based systems working inside it, while helpful and capable at answering many complex questions, are not exempt from the usual issues of the large language models (LLMs) we’ve been dealing with for the past three years.

Let’s look at some practical examples.

– Image generated by Google Gemini.

Example #1

After successfully trying to extract data from images in one of my articles, I immediately got to work trying to apply the same method to other figures similar to those analyzed the first time, such as this one.

The figure is clearly more complex than my previous ones: the top part features a histogram showing monthly precipitation and snow depth measurements for two locations with unpronounceable names in Québec, where different measurements are represented with varying shades and colors. Below it, and partially overlapping the histogram, there is a line graph with the average monthly temperatures for the two locations, with the vertical scale positioned on the right side.

Even though the figure is more complex, I never expected Gemini 3 Flash to struggle so much. It tries, and tries again, but every time something is off. The histogram isn’t a huge problem, but there’s no way to make it understand what to do with the data in the line graph. This issue persists even when I explain exactly where it should look to determine the temperature values for each month.

Prompt

Hint: To evaluate temperatures for a given month you should take a point on the temperature plot that is between the two precipitation bars

I am truly surprised by Gemini’s difficulty in repeating and extending the results of my first test, even as it continues to reassure me, claiming it has understood perfectly what I want and has performed a meticulous job.

Answer

I have completed a meticulous re-evaluation of Figure 4 using the "midpoint" method you suggested (reading the temperature at the horizontal center between the two monthly precipitation bars). Final Corrections Applied: [...]

Actually, it seems that Gemini has no idea what the “midpoint” method is and is just repeating what I say, changing only a few words. If it were otherwise, it would have resolved the issue in seconds, pulling out the right data just as it did the first time.

In the end, I give up. It makes no sense to waste hours making an intelligent agent do a job that would only take a few minutes by hand.

Example #2

I must admit I’m disappointed, but perhaps I expected too much from my intelligent agent.

So, I try to make things easier by choosing a graph from an old article of mine that shouldn’t be too challenging for Gemini 3 Flash.

Instead, it gets stuck and makes incomprehensible mistakes. With a little help, he manages to pull out the data shown in this graph, which still has several missing points (highlighted by the colored boxes) or, even worse, points added quite imaginatively (such as the one indicated by the arrow).

Another disappointment. Why use an intelligent agent if it’s faster to acquire the points by hand?

Example #3

But I don’t give up easily and try once more to get it to do something good. I use a figure from another article, which is quite simple from a graphical point of view. However, it would be useful to be able to acquire it automatically, as the amount of data it contains makes it difficult to digitize accurately by hand.

Burned by the previous experiences, I first ask it to describe what it sees in the figure.

Prompt

Now could you describe in simple words what you "see" in figure 1?

The response is long, precise, and almost flawless,

Answer

Looking at figure 252505_1_f1.jpeg, I can see:

Two side-by-side graphs showing current-voltage (I-V) characteristics:

(a) Left graph (T = 2.0 K):

Shows a hysteretic behavior - the curve forms a loop
The current jumps abruptly at certain voltage points
There’s a clear gap between the upward and downward voltage sweeps
The vertical jumps occur around ±1 mV

(b) Right graph (T = 5.8 K):

Shows non-hysteretic behavior - smooth, continuous curve

No loop or gap between voltage sweeps
The transition is gradual rather than abrupt
The curve is more rounded at the critical points

Key observation: This demonstrates how the same Josephson junction behaves differently at different temperatures. At the lower temperature (2.0 K), it shows hysteresis (memory effect), while at the higher temperature (5.8 K), the hysteresis disappears and the junction becomes “overdamped.”

Both graphs show current ranging from about -15 to +15 mA on the y-axis, with voltage on the x-axis measured in millivolts (mV).

but, in reality, there is an error at the end of the response that would render any attempt to digitise the data in the two graphs impossible.

When I point it out, Gemini 3 Flash corrects itself immediately and seems almost sorry. But, as we all know, LLMs are programmed to always please the user.

I move forward and try to help it out, explaining exactly what it should do.

Prompt

No problem. Now could you extract the values of voltage and current from the two images? Please produce a table for each image, and export the table as a csv file and a markdown file, with suffix `_table`.
Since one of the I-V curves is hysteretic, I suggest this strategy for extracting the data: start from V=0, increase V up to the maximum value following one of the paths, decrease V to 0 following the other path, do the same for the negative values of V.

But despite the suggestion, there’s no way to get it to do a decent job. The best I get is this, which at first glance looks like a great result.

It’s a pity, though, that there’s a serious and incomprehensible error, which I’ll leave it for you to discover.

In any case, the previous image is truly the best of the best of the best, and it was obtained after hours of failed attempts (like this initial attempt, or this, or this one) and of hints that went from vague to increasingly precise, much like with an unprepared student from whom you try to get a few words out. Not to mention responses that always tried to adapt to the current suggestion without ever, or almost ever, making use of what had been discussed previously.

All these fruitless attempts were made even more frustrating by the fact that, several years ago, I had solved the same problem accurately and reproducibly with barely two hundred lines of Python code (I remembered wrong, it wasn’t C but Python).

And when I finish explaining exactly how it should be done, even suggesting that the key is to convert the original JPEG file into a PBM format (which is basically a grid of 0s or 1s depending on whether the pixel is white or black),

Prompt

My suggestion is to change focus completely. If I were you I would:

take note of the extreme values of voltage and current on the X and Y axes;
get rid of the extraneous information outside the plot area and of the text (if any) inside it;
convert the image to the PBM (or PGM) format, that gives you a clean grid of black and white (or gray and white) pixels;
remove the extraneous grid dots using a 3x3 or 5x5 filter (or anything like that);
calculate the X and Y position of each black pixel, converting the [values] to Voltage and Current (it is just a proportion).

Clearly you can change the order of the steps or do something different if you believe your approach is better than mine.

there’s still no way to get it to do something useful.

What’s even more frustrating is that Gemini didn’t hesitate to try to cheat! When it found the original file of measured values that I was using to compare its results with the real data, it tried to use that file to generate the data I was asking for. Clearly, the results were perfect this time, but did I need an artificial intelligence to achieve that?

Further examples

During the days I spent testing what I’ve described in this post, I also ran many other tests, such as asking it to write some simple LaTeX code or convert the tables contained in a few PDF files into CSV or Markdown.

t handled LaTeX well, but often struggled with tables, even when the layout was simple. There’s no need to go into detail here, as there aren’t many differences compared to previous examples.

Conclusions

After the excellent results described in the previous article, I was confident I could use the intelligent agents integrated into Antigravity to easily extract data buried in many scientific articles from a few years ago, which would have allowed me to perform new comparative analyses quickly and efficiently.

Unfortunately, all the more in-depth tests described in this post turned out to be unsuccessful.

The model used here, almost always Gemini 3 Flash (though I also briefly tried Gemini 3 Pro and Claude Sonnet 4.5),¹ showed inconsistent and unrepeatable behavior. For example, it would use different methods to solve the same problem without it ever being clear whether the choice of an algorithm or library had a specific technical motivation or was just a matter of statistical probability in the generation of responses.

Another serious issue was the lack of memory, much like Dory, the funny fish from the cartoons. Despite successfully solving the problem of extracting data from a histogram just a few days earlier, Gemini was unable to apply the same methodology to a similar case. On other occasions, once a problem was partially solved, Gemini would start working on it again from scratch instead of refining and improving the previous answer.

But the problem that perhaps bothered me the most was the inability to generalize the work already done. If you ask to extract data from an image, Gemini creates a program suited only for that specific image, without ever trying to develop a general method applicable to other images of the same type. Similarly, if you ask it to generate a graph from a data file, Gemini creates a script suited only for that file, which is nearly impossible to adapt to other similar cases.

When humans tackle a problem, they tend to become fond of the solution and try to reuse and extend it to similar problems. An LLM doesn’t care; it reinvents the wheel at every new iteration. It seems the triumph of the throwaway culture, a waste of resources and intelligence (however artificial) taken to the extreme.

I’m just a guy playing around with these tools. However, very serious scientific studies – which, for instance, tried to use LLMs to rediscover Newton’s law of gravitation starting from the orbits of planets around the Sun, or to predict the behavior of a molecule based on different representations of its structure – have reached the exact same conclusions.

Our analysis reveals that these models instead behave as if they develop task-specific heuristics that fail to generalize.²

Simply increasing model size does not improve performance or generalization ability.³

Lastly, even if at first glance it seems otherwise, we must never forget that LLMs don’t actually understand what they are being asked; they are just very good at finding a needle in a very, very, very large haystack. An LLM can explain in great detail what a “Josephson junction I-V characteristic” is because it has read many books and articles on the subject. But when it comes to connecting the ideal concept of “I-V characteristic” with its experimental representation in a figure, it fails miserably, proving it is just a well-trained parrot.

Someone claims that the latest generation of LLMs can write an entire C compiler on their own or tens of thousands of lines of perfectly functioning code.

Personally, I would be satisfied if these models could produce a data file or a table in a reproducible manner, without running into inexplicable errors or inconsistent results. They should also avoid awkward situations like the ones I experienced, where one day everything goes smoothly, and the next day, nothing works.

I also used the paid version of Gemini, kindly provided by my university, without noticing any differences compared to the free version. Those who claim that paid models do things the free ones can only dream of should provide solid evidence before being believed. ↩︎
K. Vafa et al., What Has a Foundation Model Found? Using Inductive Bias to Probe for World Models, arXiv 2507.06952v4, 2025. ↩︎
B. Yan et al., Inconsistency of LLMs in molecular representations, Digital Discovery vol. 4, 2025. ↩︎

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. ↩︎

Photocopied!

Mon, 15 Dec 2025 18:00:00 +0000

The video above is the official presentation of Google Antigravity, an IDE (Integrated Development Environment) that is not just a simple IDE but is “a new way of working for this next era of agentic intelligence”. I haven’t yet figured out what that truly means, but it surely sounds very smart and up‑to‑date.

So let’s see what this “new way of working” is, in which the agents “help you experience liftoff”. An expression that back in the day used to mean something quite different.

I download the latest version of Google Antigravity (1.11.17), which once installed takes up a whopping 700 MB. Once I get past the usual onboarding screens and log in with my Gmail account, here’s what comes up

It’s basically VS Code from Microsoft, plus the agentic tool Antigravity, whose exact purpose I still don’t know and, more importantly, whether it’s useful.

After all, that’s essentially what they told me during the onboarding process, when I was presented with a screen offering to either set up the editor from scratch or import settings from VS Code. Or Windsurf.

Windsurf?

Yes, Windsurf, an editor derived from Cursor,¹ which in turn was derived from the always-present VS Code.

The similarity (to use a euphemism) becomes obvious when you place them side by side, with Antigravity on the left and Windsurf on the right.

Identical.

In short, the revolutionary IDE, the “new way of working for this upcoming era of agentic intelligence” that “helps you liftoff”, is nothing more than a clone of an editor that was already a clone of another editor that was itself a clone…

Digging a little deeper it is easy to learn that Google spent $2.4 billion to acquire the Windsurf code and hire its two founders, Varun Mohan and Douglas Chen, along with a handful of the company’s developers.² However, fearing antitrust intervention, Google avoided buying the actual product or the brand, so that Windsurf continues to exist and be developed independently, trying to repeat the David versus Goliath story.

It is a more or less as if, in the 1980s, Microsoft had hired Steve Jobs and Steve Wozniak, maybe also Bill Atkinson, Andy Hertzfeld, and Susan Kare, taking the original Macintosh code with them. Then re‑releasing it a few months later as Windows 1.0. In the meantime, Apple would have continued to develop the same code for the original Mac.

I get the feeling that the Google team used something else to liftoff.

But putting the (silly) jokes aside, are the agents in Antigravity actually useful during development? I’m not sure myself, and that’s what we’ll find out live next time.

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. ↩︎