Blog · Vibecoding

Is your vibecoded app
ready for real users?

You built it with Lovable, Bolt, Cursor, Replit, v0, Claude Code or ChatGPT. The demo works. Before real users, or real cards, go through it, run these eight checks. You do not need to be an engineer for any of them. Most take a few minutes.

For
Founders with an AI-built app
Checks
8, each one you can run
Published
19 October 2026
How to use this

Eighty percent is not launched

AI builders get you most of an app quickly. The part they skip is the part real users find: the second login, the refund, the empty screen, the record that belongs to someone else. None of that shows up in a demo.

Go through the checks in order. Write down every one that fails. A short list is normal, and often something you can fix with a few careful prompts. A long list is useful too. It tells you what you are actually launching.

Check 01 · The fix loop

Does one change stay one change?

You ask for one change, it rewrites four files, and now two other things are broken. Every fix costs more than the last. That loop is the first sign the app has outgrown the prompt.

Run it yourself:

  • Ask for something tiny. Change one button label. Then look at what changed: the builder's change history, or the diff in your repo.
  • Count the files. A label change should touch one file. If it touched several, ask why.
  • Click around afterwards. Run through the main screens again. Anything that broke and was not part of the request is the loop.

It fails if small changes keep breaking unrelated things, or you have stopped asking for changes because of it.

Check 02 · Login

Does login hold up after the first try?

Auth is where generated code fails first. Sessions that drop. OAuth that is half configured. A password reset that quietly goes nowhere. You signed up once while building, so you have probably never seen these.

Run it yourself:

  • Sign up as a stranger. Use a private window and an email you have never used on the app.
  • Leave and come back. Log out, log in. Close the browser, open it the next day. Are you logged in, or logged out, the way you expect?
  • Reset the password. Does the email arrive? Does the link work once, and stop working after? Does the old password stop working?
  • Skip the login. Copy the URL of a page behind login. Paste it into a private window. You should land on a login screen, not the page.

It fails if any of these surprise you. Each one is a support email waiting to happen.

Check 03 · Payments

What happens when a real card is charged?

The common state: Stripe is connected in test mode, webhooks were never handled, and nobody is certain what happens when a real card is charged. Test mode looks exactly like it works, because nothing real is moving.

Run it yourself:

  • Check the mode. In the Stripe dashboard, is the app using live keys? Live keys start with pk_live_ and sk_live_. Test keys start with pk_test_ and sk_test_.
  • Check the webhooks. In Stripe, is there a webhook endpoint for live mode, pointing at your app? Are its recent deliveries succeeding?
  • Pay, then undo it. Buy something with a real card. Refund it, or cancel the subscription, in Stripe. Does the app notice? Does the customer lose access?
  • Close the tab mid-payment. Pay, and close the tab before the success page loads. Does the account still get what it paid for?

It fails if the app only knows about a payment because the browser came back to a success page. That is the job webhooks do.

Check 04 · Deploys

Does it run anywhere but the builder?

It runs in the builder and nowhere else. Environment variables, build steps, and domains turn into a wall you cannot get past. Or it is deployed, but only the builder knows how.

Run it yourself:

  • Find the code. Is it in a repository you own, outside the builder?
  • List the settings. Write down every environment variable the app needs. Are they all set where the app is hosted, with live values?
  • Check the address. Is it on your own domain, over HTTPS?
  • Hand it over on paper. Could someone else deploy it from written steps, without you in the room?

It fails if the only way to ship a change is the builder's publish button, and nobody knows what it does.

Check 05 · Security

Nothing has gone wrong yet is not the same as safe

Keys in the frontend, a database anyone can read, no rate limiting. Usually nothing has gone wrong yet. That is not the same as safe. The day it has real users, it also has real data to lose.

Run it yourself:

  • Look for keys in the page. Open the live site, open the browser's developer tools, and search the loaded files for secret, sk_ and key. A publishable key is meant to be public. A secret key in the browser is not.
  • Read someone else's data. Make two accounts. As the first, open a record and note the ID in the URL. Log in as the second and change the URL to that ID. You should see an error, not the first account's data.
  • Check the database rules. If the app talks to its database straight from the browser, as many Supabase-backed apps do, every table needs access rules. Check that each one has them turned on.
  • Knock on the door. Try a wrong password twenty times in a row. Does anything slow you down?

It fails if any one of these works the way an attacker would like. This is the check worth paying for help on, even if everything else passes.

Check 06 · Half-built flows

What happens off the happy path?

The happy path demos beautifully. Everything either side of it, errors, empty states, edge cases, was never built. Real users find all three in the first week.

Run it yourself, on each main flow:

  • Start empty. A brand-new account, with no data. Does every screen say something useful, or show a blank space?
  • Type the wrong thing. Submit a blank form. Paste a very long name. Use an emoji. Enter a date in the past.
  • Be impatient. Double-click the submit button. Hit back halfway through. Refresh in the middle.
  • Go slow. In developer tools, throttle the network. Does the app show it is working, or look frozen?

It fails if the user is left on a blank screen, a raw error, or a duplicate order.

Check 07 · Tests

How would you know something broke?

With no tests, nothing tells you when something breaks except a user. Every release is a guess, so releases stop happening.

Run it yourself:

  • Look for them. Is there a tests folder in the repo? Ask the builder how to run the tests, and whether they pass.
  • Check what they cover. Do any of them sign up, log in, or take a payment? Those are the flows that cost you when they break.
  • Check when they run. Do they run on their own before a deploy, or only when someone remembers?

It fails if the answer to "how would you know" is "a customer would tell us".

Check 08 · The next feature

Can anyone add a feature?

The structure only made sense to the model that wrote it. A developer opening it now quotes you a rewrite. That is fine for a demo. It is a problem the day you need the second version.

Run it yourself:

  • Ask for a map. Ask a developer, or a fresh AI session, to explain where things live: pages, data, payments, login. Is the answer short and clear?
  • Ask where the next feature goes. Pick the next thing on your list. Can they say which files it touches before they start?
  • Ask for an estimate. If the first word is "rewrite", believe it, and find out why.

It fails if nobody, human or model, can add to it without breaking what is there.

When it's more than a checklist

Two apps that came back with a long list

A short list you can often work through yourself. When most of the eight fail, the question changes from "what do I fix" to "what does fixing it take". Two of our case studies started there.

  • A dealership finance tool. It started as a vibecoded prototype. The budget was small, so a month of work was spread across a longer horizon: low commitment, collaborative, progress visible the whole way. It went from prototype to production in four working weeks. Read the case study.
  • An agency app for running paid media. It was built by prompting, and for a while that worked. Within about three months the codebase, 1,285 PHP files with 360 test files among them, was too large for a prompt to hold. Further progress started arriving with regressions, and the app could only keep moving under an LLM operator. Read the case study.
What the fix costs

Four published bands

If the list came back long, the instant estimate tells you what fixing it costs. Seven questions, about two minutes, no email. It gives you one of these bands and a timeline. It is calculated from your answers with a fixed set of rules, not AI guessing, and it is a band, not a quote.

 Price bandTimeline
Triage$500 – $1,0002–3 days
Rescue$2,500 – $6,0001–2 weeks
Production-ready$8,000 – $15,0003–4 weeks
Rebuild / take-over$15,000+4+ weeks, scoped

50% up front, 50% on delivery. The band is agreed in writing before work starts, so the number does not move while we work.

The free audit

Fifteen minutes, and an honest answer

After the estimate, you can book a free 15-minute audit with an engineer who reads the actual code. You leave with a real number. If the app is beyond saving, we tell you then, before you have paid us anything. Sometimes the honest answer is that rebuilding the core is cheaper than untangling it. Sometimes it is that you do not need us at all.

Want to skip the estimate? Book a call directly.

How many came back failed?

Seven questions, about two minutes, no email. You see the price band at the end whether or not you talk to us.