In my last post, I admitted how badly I underestimated building Wrench Wise — how “how hard can it be” became nine months and 400,000 lines of code. But I skipped the part where it first felt possible. Before the long slog, there was a moment of real magic. This is about that magic — and the very real limits hiding inside it.
Describe it to a prompt, and it appears
The tool that got me off the ground was a vibe-coding platform called Emergent. Back in 2025, the way it worked was almost absurd: you typed what you wanted into a command prompt, an AI built a web app from your description, and a working application appeared — running live on their servers.
My first working prototype of Wrench Wise — a very basic maintenance tracker, nothing fancy: track a vehicle, log its service, and not much more — came together in a day or two. Not a mockup. A real, running app I could open in a browser.
Here’s the part that still makes me smile, though: the app came together in a day or two, but the thinking took a week. I spent that week in long conversations with my son — who, unlike me, is a very talented programmer. He was deeply skeptical of the whole AI-coding idea, and (as you’ll see) for good reason. We talked through what I’d built, what it was missing, and whether this was a toy or the start of something real. That ratio turned out to be the whole project in miniature: the code was fast, the understanding was slow, and the understanding was the part that mattered.
What it did genuinely well
The skeptics get this wrong as often as the hype merchants do, so let me be fair: vibe-coding platforms are extraordinary at one specific job — proving an idea, fast.
- Zero setup. The biggest wall for a non-developer — the toolchain, the environment, the “I can’t even get it to run” problem — simply wasn’t there.
- Momentum. I had something real to react to in days. One working prototype teaches you more than a month of planning.
- It was live. No hosting puzzle, no DevOps. I could put it in front of people immediately.
If your only goal is to find out whether an idea is worth building at all, I’d point anyone here.
The corner
Then I tried to make it real, and the limits showed up fast — and they weren’t the kind you patch.
It could only build a web app — no Apple or Google app. That limitation decided the shape of the whole project: Wrench Wise was born in a browser, because a web app was the only thing Emergent could make. A real mobile app on the App Store and Google Play was a long way off — a story for later in this series.
The architecture was a mess. Emergent dumped essentially all of the code into two or three files that just kept growing in size. My son, the programmer, took one look and was genuinely concerned — not because it didn’t run, but because nothing about it was built to grow. And that wasn’t cosmetic. As those files got bigger, every new feature took more processing, more time, and more money — because the tool had to chew through the whole mess again each time. Toward the end, it crossed the line from expensive into broken: the files got so large that Emergent would simply die trying to process them — fail outright, unable to make the change at all. The tool that built the app in two days couldn’t, by the end, reliably change it. It was not scalable, in the most literal sense: the cost of change went up as the project got bigger, which is exactly backwards from how good software is supposed to work.
So the economics turned against me. Emergent charged real money, and I kept feeding it — $20 at a time — trying to fix bugs and coax out reasonable features. There was no single catastrophic bug; there were just many, and getting any feature exactly right was a slog. Over about two weeks I poured close to $300 into it this way, $20 at a time, watching the returns shrink with every update as the files — and the bills — grew.
And then I realized what I was actually paying for. The first clue was small: Emergent let you pick the underlying AI model. Then I started noticing other users talking about features that only existed in Claude. The picture snapped into focus. Emergent wasn’t magic, and it wasn’t really Emergent doing the work — it was a middleman. A friendly command-prompt wrapper around Claude and OpenAI, the same frontier models I could go rent directly. A good layer. But a layer, with a markup.
Walking away
So I left. I walked away from about $100 in unused credits, because at that point throwing more money at it was the worse decision. (They still email me, to this day, asking me to come back.)
The whole Emergent era lasted two or three weeks. And I don’t regret a dollar of it, because it gave me two things I couldn’t have gotten any other way: a real, running app to react to — and a conviction that’s only grown since.
My son was skeptical, and he was right to be. Back then, the AI wrote code like a talented high schooler — it worked, sort of, but it was nowhere near what a professional would ship. That’s not an insult; it’s a snapshot of a moment. And the point is the trajectory: high-school-level then, dramatically better not long after. That’s why I hold both halves of this at once — AI is going to fundamentally change how software gets built, and it still has a long way to go.Holding both is, I think, the only honest place to stand.
The one door
There was exactly one thing that made leaving possible, and I’m grateful for it: Emergent let you export your code to GitHub.
That sounds small. It wasn’t. It was the difference between a prototype I’d have to throw away and a codebase I could actually take ownership of. That single escape hatch is the entire next chapter of this story.
The lesson the engineer in me should’ve seen coming
There’s a principle in systems architecture I forgot to apply to my own project: an abstraction is a trade. It buys you speed by taking away control — and sometimes by quietly bending the cost curve against you. That’s a brilliant trade when you’re proving an idea, and a terrible one when you’re trying to run something for years.
Prototyping tools and production tools are different jobs. Emergent got me to “it works” faster than I’d have believed. It was never going to get me to “you own this, you understand it, and you can run it for the next decade.” The mistake isn’t using the prototype tool — it’s confusing it for the production one, and pouring money into a platform you’ll eventually have to escape anyway.
Next up: the very first commit in my real git history — "Clean repo without large backup files" — what the export actually looked like (spoiler: a mess), and what it felt like to finally own my code. 🔧