You built a working prototype with an AI coding tool. People can click through it, a few of them like it, and maybe an investor has seen it. Now you have to decide what happens to the code.

My answer: keep what proves demand, rebuild what touches money, logins or customer data, and refactor the rest only if a developer can read it and change it safely. Most prototypes end up as a mix of all three.

I've seen this from both sides. I rebuilt this website with Claude Code in October 2026, so I know how fast these tools are and where they need a firm hand. And I've taken over a product halfway through its build, which is the same decision with someone else's code. Here's how I decide.

What is an AI‑built prototype good for?

Speed and learning. A prototype answers "would people use this?" faster than any document, and you get something an investor or a customer can click.

It also teaches you things you couldn't have written down in advance: which screens people skip, which words confuse them, which data you actually need to collect. That knowledge is the most valuable thing the prototype produced, and it survives any decision you make about the code.

Where it's weak is everything it never had to do. A prototype rarely meets two people editing the same thing, a payment that fails halfway, a user typing something strange, or someone trying to open another customer's records. Those are the moments that decide whether a product is safe to charge for.

What should you check before you decide?

When a founder brings me a prototype, I go through five checks before anyone talks about rebuilding. I do them with a developer, because the answers come from reading the code.

  1. Does it handle payments or personal data? If money moves through it, or it stores names, emails, documents or health details, those parts carry the most risk and get the strictest treatment.
  2. Is there a real data model, or is the data glued to screens? A real model has clear records (customers, orders, bookings) that any screen can use. Data glued to screens means each page keeps its own copy, and the copies drift apart.
  3. Can a developer explain any file in five minutes? Pick a few files at random. If a developer can say what each one does and where to change it, the code is workable. If they can't, every change will take longer than it should.
  4. Are there tests? Most prototypes have none, which is fine for a prototype. It means nobody can change the code and know they didn't break something.
  5. Does it break when two people use it at once? Open it in two browsers with two accounts and do the same thing at the same time. Double bookings, lost edits and mixed-up accounts show up fast.
Fig. 01 · The five checks (money or personal data, the data model, readable files, tests, two people at once) sort the prototype into three piles

Keep, refactor or rebuild: what are the signals for each?

The checks sort the prototype into three piles. It's rarely all one pile.

ChoiceThe signalsParts that usually land here
KeepUsers liked it, and an imperfect version can't cost anyone money or expose their dataTested flows and screens, the order of steps, copy, the fields you learned you need
RefactorA developer can read it, the data model is sound, and it mostly lacks tests and structureMain app screens, internal tools, simple reports
RebuildMoney, sign-in, permissions or customer data, or data glued to screensPayments, accounts and roles, anything that stores personal data, the database itself

"Keep" mostly means keeping the design and the learning, even when the code behind it changes. "Refactor" means a developer restructures it, adds tests and leaves the behaviour the same. "Rebuild" means writing it again from a written description of what it must do, with the prototype as a reference.

Why rebuild the money and login parts first?

Because mistakes there stay invisible until a real person pays, or sees something they shouldn't. A confusing screen costs you a frustrated user. A double charge, a refund that never arrives or a customer reading another customer's data costs you trust, and sometimes more.

It's the same reason I keep anything that moves money on fixed rules when I design AI products. In LeanDeck, the AI drafts proposals and agreements, and invoicing follows fixed rules, because a plausible-but-wrong invoice is worse than a slower one. I wrote about where that line sits in Where the AI acts in LeanDeck.

Before launch, run the money and login paths through the same checks you'd run on any launch. My SaaS launch-readiness checklist has the ten I use.

What should you hand a developer?

Three things, and the prototype is only one of them.

  • The prototype, as a living reference for how the product should feel and flow.
  • A written scope: what's in the first release, and what waits until after launch. Without it, a developer will rebuild everything the prototype does, including the parts nobody used. How to scope an MVP walks through how I write one.
  • The rules: who can see what, what happens when a payment fails, what a booking or an order can and can't do. Prototypes rarely write these down, and they're what developers need most.

AI tools help a lot once those three exist. SportsOnTV went live in 5 weeks against an 8-week plan, and part of that speed came from AI-assisted development. The rest came from decisions made before the build: what to integrate, what to build and what the client would run himself. The story is in Live in 5 weeks against an 8-week plan.

How is this like taking over a project mid‑build?

It's almost the same job. In July 2025 I took over AidNetwork, a US healthcare staffing platform, when the project manager who wrote the first version of the requirements left. Restarting would have felt safer, but it would have cost the time the project didn't have.

So I kept the first version as the baseline, listed every open decision and closed each one with the client, and agreed three success metrics before launch. It launched about two months later. The full story is in Taking over a software project mid-build.

A vibe-coded prototype is an inherited project too, and the same order works: write down what exists, decide what's risky, keep the rest moving.

If you'd like help making this call, it's the first part of my MVP blueprint sprint: I go through the prototype with you, sort it into keep, refactor and rebuild, and write the scope and rules your developers build from.

Frequently asked questions

Next essay · No. 025 · 6 minNot enough data for your AI product? What to do before you buildKeep reading