Using Antigravity to switch from React to Swift in one shot
Part two of the GlassMeter story. What "one-shot" agentic coding actually feels like, and what it changed about how I build.
A couple of weeks ago I wrote about GlassMeter, the film light meter I built because I bought a Hasselblad with no meter and discovered I had no idea how to expose a scene without one. That post was about why I built it. This one is about a single afternoon last November when an AI agent rebuilt the entire thing in a language I barely knew, and what that did to my sense of how software gets made.
First I have to tell you about the two months I left out of the last post.
The version I don't show people
GlassMeter started life as a React Native app called GroundGlass. I reached for React Native because it's where I'm fast, and I wanted to be moving. For about two months it worked, sort of. It put a number on the screen. It had rotary dials and a calibration screen and a little tutorial.
But a light meter lives or dies on one thing: what it can read off the camera sensor, frame by frame, in real time. And every layer I'd stacked between my code and that raw pixel buffer was a place where the truth got rounded off, or slowed down, or fought me. I was writing native camera modules and then reaching them through a bridge, which is a polite way of saying I was doing the hard part twice. The abstraction I'd picked to go faster had quietly become the ceiling on what the app could ever be.
So I knew it had to be native Swift. And I dreaded it. A from-scratch rewrite, in a language and a UI framework I'd never shipped, was exactly the kind of multi-week slog that kills side projects in the crib. I had a working-ish app with a barrier in front of the version I actually wanted.
The afternoon
Then Google Antigravity launched an agent-first coding environment, and I did the thing you do with a new toy. I pointed it at the React Native repo and asked it to port the whole app to native Swift and SwiftUI.
It did. In one pass. Not a function, not a file, the app: the metering screen, the dials, the film selection, the settings, rebuilt natively. My commit history from that day reads like a single held breath. "Pre-Swift transition: save current React Native state," and then, minutes later, "Migrate to native Swift/SwiftUI, archive React Native code." The entire React Native version is still sitting in the repo in a folder literally named __ARCHIVE__, a whole parallel app I will never touch again.
I want to be honest about what "one shot" does and doesn't mean, because the phrase gets oversold. It does not mean I typed a sentence and went to get coffee and came back to a finished product. I still had to know exactly what I wanted: the architecture, the Hasselblad-style interface, what "correct" even meant for a meter. The agent didn't decide the product. It executed a translation I could specify because I'd already built the thing once, wrong, and learned it cold. And I spent the next day chasing build errors and polishing the UI. The git log says so, plainly: "Fix build errors" is right there.
But here is the part that still gets me. The work I had been dreading, the weeks-long rewrite that was going to cost me a month of evenings I didn't have, happened between lunch and dinner.
The thing that actually changed
The port wasn't even the surprising part. The surprising part was the velocity after.
Within forty-eight hours of standing on native ground, I had added the LiDAR rangefinder through ARKit, true spot metering, real reciprocity math, film halation, and grain. Features that had felt like someday-maybe items behind the React Native bridge just started falling, one after another, because the tax I'd been paying on every single one was suddenly gone. The rewrite didn't save me a month one time. It changed the slope of everything that came after it.
For most of my career, the cost of re-platforming was the moat around a bad early decision. You picked the fast framework to get going, and then you were married to it, because tearing it out was a month you couldn't spare. So you lived with the ceiling. Agents collapse that cost. Changing my mind about the foundation of the app went from "a month, so no" to "an afternoon, so sure." That's not a productivity tweak. It quietly moves a whole class of decisions from irreversible to reversible, and reversible decisions are the ones you can afford to get wrong on the way to getting them right.
What I'd actually tell you
The agent is exactly as good as your ability to say what you want. It ported my app cleanly because I knew precisely what my app was. It would have just as happily ported my confusion. The skill that mattered that afternoon was not Swift, which I still barely know. It was knowing the product down to the pixel, and I only knew it that well because I had built the wrong version first and let it teach me.
Which is the same lesson the whole GlassMeter project keeps handing me. You don't get the shortcut until you've earned the map. The agent didn't replace the part where I had to understand the thing. It just made the understanding the only expensive part left.
The strange thing is that I build AI products for a living, and it took a hobby light meter to make this land. Next in the series: the lessons from this little film app that followed me all the way back to my day job.
Have you let an agent re-pour the foundation of something real yet? I want to hear where it worked and where it bit you.