Fixing an app you built with AI: the process, the real cost, where to go

When an app you built with AI stalls, fixing it runs through three stages: first you learn the code's real condition, then scope and a fixed price get set, then the fix and handover happen. What sets the cost isn't an hourly rate, it's which layer broke: auth, payments, and the data model cost the most; interface copy costs the least. Below: how to run your own quick diagnosis, how the process actually moves, what drives the price, and what to prepare before you contact anyone.

How to diagnose your own code in the first five minutes

When a developer takes over your project, the first five minutes look exactly like this: how many files exist, how much code there is, how many unresolved TODO/FIXME markers were left behind, whether any tests exist at all. Those four numbers set the scope before anyone quotes a price. If you still have repository access (most tools, including Lovable, Bolt, Cursor, and Replit, let you export to GitHub), you can run the same four commands yourself.

$ git ls-files | grep -E '\.(js|jsx|ts|tsx)$' | grep -v node_modules | wc -l
$ git ls-files | grep -E '\.(js|jsx|ts|tsx)$' | grep -v node_modules | xargs wc -l | tail -1
$ grep -rInE "TODO|FIXME" --include=*.js --include=*.jsx --include=*.ts --include=*.tsx . | grep -v node_modules | wc -l
$ find . -path ./node_modules -prune -o -type f \( -name "*.test.*" -o -name "*.spec.*" \) -print | wc -l

To make the method concrete, we ran it against a real production repository, the one behind this site. Your own numbers won't match; what matters is the method, which reads the same way on any codebase.

Zero TODOs and zero test files is right for this particular repository. Expect the opposite from typical AI-generated output: dozens of TODOs and zero tests is the norm, and even a single test file is rare. That gap between what a diagnostic can find and what a fix actually needs is exactly why a fixed price never comes before the read.

How the process actually runs: four steps from access to handover

Every honest process runs in the same order, regardless of who does the work.

Step 3 only exists after step 2 is done. A quote that arrives before anyone has read the code is a guess wearing a number. If you also want to know how to vet the person doing the reading, we covered that separately in hiring a developer to fix your vibe-coded app; this guide focuses on what the process and the cost look like once you've picked someone.

Rescue or rewrite: a quick comparison

The diagnosis in step 2 usually lands on one of these two answers.

What actually determines the cost

Not the hour, the layer. Some parts of a broken app are cheap to fix, others rarely are.

Where you can save, where you can't

Some corners are safe to cut. Others cost more later than they save now.

• Bring your own list of known bugs. It removes hours of exploratory reading.
• Skip a fresh design pass if the interface already works for users.
• Don't skip the NDA to save time. It costs nothing and protects both sides.
• Don't let anyone start on full admin access instead of read-only.
• Don't defer a known security gap to "phase two." It stays exploitable until it's closed.

Five things to prepare before you contact anyone

1. Export the codebase to GitHub if it's still trapped in Lovable, Bolt, or a similar platform. See the export walkthrough for what comes with it.
2. Write down every bug you already know about, with steps to reproduce.
3. List who currently holds the domain, hosting, and API key access.
4. Get a realistic budget range before the call, not after. The vibe coding cost calculator estimates one from your project's real shape.
5. Back up any real user data before anyone else touches the project.

When this process isn't needed yet

If the app has no real users and no real data at risk, hiring anyone may be premature. Fixing it yourself, slower but free, is a reasonable call at that stage. Our guide to shipping vibe-coded projects correctly covers the discipline that keeps a solo build from reaching this point at all.

FAQ

Is the first diagnosis free?
Often, yes, but ask directly before sending access. A refusal to even discuss it is its own small warning sign.

Does the fixed price ever change mid-project?
Only if new scope surfaces that wasn't visible during the read-only review, and that should be disclosed and agreed before any extra work starts, not billed after the fact.

Is my data safe during the process?
An NDA before deeper access and read-only access to start are the two checks that keep it that way. Full admin access at step 1 is a sign to walk away.

How long does the whole process take?
Diagnosis is usually a few days. The fix itself ranges from days to a few weeks depending on which layers broke, per the cost factors above.

What happens if the rescue doesn't work out?
A reviewer who reads the code first will usually flag a rewrite before you've paid for anything, which is a sign to trust rather than push back on.

If nobody has read your app's code end to end since it went live, that first read-only review is where our own AI-project handover process starts too.