Published
Updated
11 min read
What a vibecoded prototype still needs before it can run a business
AI tools can turn an idea into a working app in a weekend. Here is how to tell what can stay, what can wait through a pilot, and what must be fixed first.

Short answer
A vibecoded prototype proves an idea can work; it rarely proves the software can carry real users, data or a process. Before a pilot or live use, ask four questions: how it fails, which decisions need human review, what happens at ten times the load, and who notices a 2am outage. The answers show what to keep, defer or fix.
Today, an idea for an app can become something working in a few hours. You describe what the app should do to an AI coding tool such as Cursor, Claude Code or Lovable, or to an assistant such as ChatGPT or Gemini, and by the evening you have a version you can show someone. That speed is genuinely useful: you test the idea, put it in front of real people and gather feedback before committing a bigger budget.
That is vibecoding: describing what an app should do in plain language, letting the AI write the code, and judging the result by whether it does the job rather than by reading every line. It is a new way to get from zero to something clickable, and founders and product teams are adopting it for a simple reason: it works, for what it is built to do.
Then the question changes. The prototype answered “is this idea worth pursuing?”. The next question is “can people depend on this?”, and that is a different test. A clickable demo and a product that customers, staff or partners rely on every day are two different things, even when they look identical on screen.
What a fast prototype shows, and what it does not
A vibecoded first version shows the idea can work in principle and gives you something concrete to put in front of users. It rarely shows that the software can carry real users, real data or a real operational process, because those decisions were mostly never made on purpose. Architecture, access control, error handling, what happens when something breaks: little of that makes it into a weekend build. It shows up later, once the cost of having skipped it has grown along with the user base.
None of this is an argument against building fast. It marks where the job changes: from finding out whether an idea works to answering for it running.
The four questions we ask before anything goes further
Before a prototype moves toward a pilot or live use, we run it through the same four questions, no matter where it started:
1. What does this component do when it fails, not just when it succeeds?
A prototype is usually tested on the path where everything works. Look at what happens when an input is wrong, a connected service is down or a step takes too long: is the error visible, and can someone recover from it?
2. Which decisions here should stay reviewed by a person, and which are safe to leave unsupervised?
List the decisions the software makes on its own, especially the ones generated by AI. Anything that affects money, customers or sensitive data keeps a review step until its results have proved reliable.
3. What happens to this at ten times today’s users or data?
A weekend build rarely meets real volume. Check where it would slow down, hit a limit or become much more expensive to run, and which of those limits a pilot would reach first.
4. If this stopped working at 2am, who notices, and how?
Software a business depends on needs monitoring, alerts and someone responsible for responding. If the honest answer is “a customer, the next morning”, that is the first thing to fix.
The answers sort the prototype into three piles: what can be kept as it is, what can wait while a limited pilot runs, and what has to be addressed before customers or sensitive data depend on it. That sorting is the decision. It turns “is it ready?” from a feeling into a plan.
A hypothetical example: demo, pilot, live use
Take a case invented for this article. A founder has vibecoded an interface for a small service business: staff log customer requests, assign them and track them to completion. It replaces a spreadsheet, the team likes it, and the founder wants to start using it with real customers next month.
Run through the four questions, the picture looks roughly like this.
Keep. The screens and the workflow. They came out of real feedback from the people who will use them, which is exactly what a prototype is for. The same goes for the data model, if it has held up against real requests.
Can wait through a limited pilot. Scale and polish. With one team and a few dozen customers, ten-times growth is not next month’s problem. An internal pilot with a fixed set of staff, a named owner, a manual fallback (the old spreadsheet) and sample or synthetic records instead of real customer data can start while these questions stay open, as long as everyone knows the pilot is a pilot.
Must be addressed before customers depend on it. Three things stand out. Customer records: names, contact details and request history are personal data, so where they are stored, who can read them and how long they are kept has to be decided deliberately rather than left to whatever the tool defaulted to. Access control: one login shared by all staff, or admin rights the AI wired up for everyone, is fine for a demo and unacceptable once the data is real. Recovery: if the database is lost or corrupted, there has to be a backup that has actually been restored at least once in a test, and someone who knows how to do it.
Nothing in the third pile stops the idea. Each item is bounded work with a clear finish line. What the sorting gives the founder is a decision path: start the internal pilot on sample data now, fix the three blockers while it runs, open the pilot to real customers and real customer records once those safeguards are in place, and move to live use when the pilot has held up rather than when the calendar says so.
Going deeper: seven bad-day questions
The four questions sort a prototype into three piles. For whatever lands in the third one, the parts that hold money, data and customers, we go one level deeper with seven more questions. A demo runs on a good day, so none of these shows up in one. Each comes with a check you can run yourself, usually in under fifteen minutes.
1. The same payment, twice. Payment providers send a notification again when your app is slow to confirm it. If the app processes both, the customer is charged or credited twice. The design that holds is idempotency: each notification carries a unique key, the app records it before doing the work, and a request it has already seen counts once. Check, in your payment provider’s test mode only: resend a notification the app has already processed and see whether the order changes twice.
2. Two people, one record. Two colleagues open the same order. One changes the delivery date, the other the quantity, and both save. In many apps the second save quietly overwrites the first. The design that holds gives every record a version number: a save that started from an older version is refused instead of overwriting, and the person is told that someone else changed the record first. Engineers call this optimistic concurrency. Check: open the same record in two browser tabs, change a different field in each, save both and look at what is left.
3. A restart in the middle. The server restarts during a long job: an import, an invoice run, an AI analysis. Work that matters goes into a queue that survives a restart, records where each item stands and is safe to run twice. Check: start the longest job in your app and restart the app halfway through. The job should finish or resume on its own, with nothing done twice.
4. A hidden button. Hiding a button is a screen decision; permission is a server decision. The server checks every request against who is asking and whose data it touches, and a record outside your rights behaves as if it does not exist. Check: log in as one customer, open a record and change the record number in the address bar to one that belongs to another customer. “Not found” and “access denied” are both safe answers; seeing the other customer’s data is the failure.
5. A document that gives orders. If an AI model in your app reads files that customers upload, a sentence inside a file can work as an instruction to the model. This is prompt injection. The design that holds gives the model no more rights than the user it works for, and any action with consequences waits for a person to confirm it. Check: list what your AI feature can do on its own, such as sending, deleting, paying or changing records, and who confirms each of those actions.
6. Who changed this, and when. A customer says they were promised a lower price, and the app only shows the current one. An audit trail records every change to the records that matter: who made it, when, the old value and the new one. The history stays exactly as it was written; nothing in the app edits it. Check: pick the field that matters most to your business, such as a price, a status or a credit limit, and try to find who changed it last week and what it was before.
7. Where the data goes. Customer data rarely stays in one database. It ends up in uploaded files, logs, backups, the AI provider and the email tool. When a customer asks what you hold about them, or a larger client asks where their data is processed, the answer should be a list, not a search. The design that holds is a data map kept with the system: every place customer data is stored or sent, and who can reach it. Check: pick one test customer and list every system that holds or receives their data. If that takes longer than fifteen minutes, the map is missing.
Each of these has a known design. Whatever comes back unanswered belongs in the third pile from the example above, and it is usually bounded work that leaves the rest of the prototype in place.
Two different meanings of “AI review”
Two separate questions get blended when people talk about reviewing AI in software, and they need different answers.
The first is about the code. AI-generated code is code like any other: it needs a team that can understand it, test it, secure it, operate it and change it a year from now. The tool that wrote it carries none of that responsibility. Someone has to be able to read the parts that matter, know why they are built the way they are, and take the call at 2am. Custom software development is the part of the job that puts that ownership in place, once the idea has earned the investment.
The second is about decisions the product makes while it runs. If the app uses AI to classify a request, draft a reply, approve something or flag a risk, the question is no longer whether the code was reviewed but whether each decision needs to be. Good AI solutions and automation keep a person in the loop wherever a wrong call is expensive or hard to undo, and let the system run unsupervised only where getting it wrong barely costs anything. A prototype usually makes that choice by default. Live use needs it made on purpose.
What changes when we take it further
Taking a prototype toward something a business can run on is the same work we start every engagement with: understand how the business really operates, design around that reality, build in increments the client can review, and hand over in a state their own team can run and improve. Code, documentation and project accounts stay theirs the whole way through.
For a prototype, that usually means keeping what already earned its place, scheduling the rest against the three piles above, and delivering each increment in a form your team can test with real users before the next one starts. The point is a product that keeps operating after the engagement ends, with the people who own it able to change it.
Where this fits your timeline
Needing this step does not mean the idea is behind schedule. It means it is on schedule. The fastest way from an idea to something customers trust rarely means squeezing more out of the first version. It means bringing in a technical partner at the point the software needs to hold up, before that point gets forced on you by an outage, a hard security question or a user base the original build was never meant to carry.
If you have a prototype and are weighing live use
If you are deciding whether an AI-built prototype can go into a pilot or live use, the most useful thing you can send us through the contact form is four short answers: what the app does, who relies on it, what data it holds, and which failure would interrupt the business. That is enough for a first conversation. We will tell you which questions we can already answer from that description, and which need a closer look at the code and the setup.
Does one of these situations sound familiar?
Bring us the situation as it works today. We will help clarify the requirement and identify a practical next step.
Discuss the situation with usNo prepared specification required. We reply within one business day.


