We Vibe Coded Our Startup

January 05, 2026 • John

TL;DR: AI is fast. Really fast. But speed without direction just gets you lost faster.

At BoothIQ, AI writes 100% of our production code. Since development began in June 2025, we went from proof of concept to a mature, production application with real users. Without AI, we’d likely still be shipping an MVP. AI has been invaluable for our one-person engineering team. Here’s what we’ve shipped, what the day-to-day looks like, what worked well, what’s still hard, and our major takeaways.

What We’ve Shipped

This isn’t everything, but here are some of the biggest things we shipped with AI in six months:

Universal badge scanning - QR codes, barcodes, business cards, handwritten name tags
Real-time contact enrichment with multiple data providers
Integrations: HubSpot, Salesforce, Zoho, Google, Microsoft, and more
One-tap follow-ups: emails, calendar invites, one-pagers
Offline mode for recording and scanning without wifi
AI transcription and conversation summaries
Native iOS app built with SwiftUI

The codebase is roughly 165,000 lines across the web app, backend, iOS app, and tests.

I’ve seen teams take longer launching a single page on an existing app.

What is BoothIQ?

BoothIQ is a universal badge scanner and event manager for trade shows and conferences.

The problem: you leave an event energized, but by Monday you’re staring at a stack of business cards or a CSV of names you don’t recognize. No context. No memory of who was interested and who just wanted a free t-shirt.

BoothIQ fixes that. Any phone becomes a badge scanner. Scan a badge, business card, or name tag. Record the conversation or leave a voice memo. We find their contact info, generate an AI summary, and give you quick actions: schedule a follow-up, send a one-pager, add to CRM. One app for all your events.

The Workflow

The title says “vibe coded,” but the reality is closer to what I call “AI First Development.” It’s not “type a prompt and ship whatever comes out.” There’s a review loop.

The workflow looks like this: AI writes code. I review it. I give feedback or new direction. AI revises. I review again. Repeat until it’s right. Then I merge and ship.

On a typical day, I supervise up to three instances of Claude Code, each working in its own copy of the code.

The role feels less like developer and more like PM or engineering manager. I describe what I want in a few sentences, review the changes, try it out, keep it or revert it, and repeat. Changes that used to take hours now take minutes.

What AI Made Possible

Let me go deeper on a few of these. Here’s what we shipped, and what it would have looked like without AI.

Native iOS. I had almost no experience with SwiftUI or Apple development. Without AI, this rewrite wouldn’t have happened. We would have stuck with React Native and accepted its limits. Instead, we shipped a native app to the App Store.

Offline mode. Recording audio and saving meetings without wifi is table stakes for a trade show app. But it’s not easy to build. iOS takes security seriously. Microphone permissions need to be right. When the app goes to background, you need to keep recording. If the app is killed, you have to stop gracefully. If the user opens a different app that uses the mic, you need to handle that. These are all sharp edges. We would have hit them eventually. Some users would have gotten angry. Or worse, we would have failed to capture info they were counting on. They would have lost trust in the app. AI researched the options, recommended an approach, and built it in days.

External integrations. I’ve never written a Salesforce integration. But thousands of developers have. It wouldn’t have been hard, but it would have been tedious. Look up the docs. Figure out how they handle login. Understand the refresh logic. Learn the Salesforce-specific query syntax. Claude already knew all of that. Same with HubSpot, Google, Microsoft, and others. The knowledge of the entire developer community is just… available.

Design and UI polish. We didn’t need to hire a designer. Claude’s design skills gave us UI polish that fits our brand. That saved money. It also saved time. Fewer people means less back-and-forth. We all know how much gets lost in translation.

Dark mode. I never would have prioritized this until we hired another engineer. Claude handled it with ease. Features that would have been put off forever became afternoon tasks.

All of this let us go from proof of concept to mature product in a fraction of the time.

What’s Still Hard

Organization. This is the biggest one. It cuts two ways.

First, there’s code structure. As the product grows, someone has to think about where things live, how pieces relate, and where the boundaries are. AI writes the code, but I still make the architecture decisions.

This is where pure “vibe coders” get stuck. Growing a codebase requires good structure. AI is fast. But people with little experience still have the same problems: messy code, fragile code, code that’s hard to change. They just get there faster.

Second, there’s user experience. How do you show information to users? What’s most important? How should they interact with it? AI can make good guesses, but you have to ship, get real feedback, and iterate. There’s no shortcut.

Code review. This is where I spend most of my time. Someone has to review what gets merged, read the changes, think through edge cases, and catch what the AI missed. The review work didn’t go away. It got more intense because code gets written so fast.

Most review rules still apply. But one thing is different: you have to let go of style nitpicks. Many tools enforce style rules automatically. “Soft” rules are often left to humans. AI can catch these easily, which helps. But if the code works, even if you would have written it differently, let it go. Get it merged. Treat the AI like an eager junior coworker, not a faster version of yourself.

I expect this to get easier as AI improves. AI memory will grow. It will run longer, handle bigger features, and take on larger tasks. A mature “AI First Development” workflow will go through several rounds of writing and review before a human sees it. At that point, you should be able to merge with just a quick look.

Building the right thing. AI is fast. But if you’re not building the right thing, you’re just going nowhere faster. Getting the product into real users’ hands, hearing their feedback, making good product decisions: that’s still the hard part. That hasn’t changed.

What’s Gotten Easier

Prioritization. Before, when you had two ways to solve a problem, you picked one. You told yourself you’d try the other way if the first didn’t work. Then you ran out of time. You shipped whatever you built first, even if it wasn’t great. Now I can spin up two instances, build both approaches, test them side by side, and pick the one that works better. The “what if we tried it the other way” question actually gets answered.

Refactoring. Bad early decisions are expensive. We’ve all seen codebases where a choice made in the early days still causes problems and blocks better solutions. Big changes used to be painful. Find and replace. Regex. Searching through the code. Fixing broken tests. A full day’s work, and you’d still miss things. Now I can rename a concept across the whole codebase or change how data flows without dreading the work. Claude handles the tedious parts. I review the changes.

Experiments. “What if” questions now cost almost nothing. “What would it look like if X worked like Y?” I can start a Claude Code instance, drop that question in, and move on. When I have time, I check what it came up with. If it’s worth keeping, we keep going. If not, we drop it. Either way, I didn’t slow down on the important work.

Conclusion

The main thing I learned in 6 months: writing code, reading code, and getting up to speed on existing code is no longer a bottleneck. The longest wait now is shipping a feature, seeing how people use it, and making changes. But even that is faster because writing and testing code takes so much less time.

When you ship faster, you learn faster. When you can test two approaches at once, you make better choices. When fixing code is cheap, you’re not stuck with early mistakes. You get more chances to build the right thing. You course-correct sooner.

That’s the real advantage. Not that AI writes the code. It lets you find the right product faster.