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