Skip to main content

What It Costs to Fix a Vibe-Coded App

What decides the cost of fixing an app built with AI: patch, refactor or rebuild, the drivers that move a quote, and how to compare quotes first.

Category Planning
Read Time 10 min read
Updated October 2026
Steps 6 steps

Who This Guide Is For

This guide is for business owners who built an app, internal tool or automation with AI, found that something about it is wrong or worrying, and want to know what putting it right will cost before they ask anyone for a quote. It sits with our other planning guides. You will come away knowing which kind of fix your app needs and what pushes its cost up or down, so you can tell a sensible quote from a guess.

It assumes the app already exists and mostly works. If you are still deciding whether it is ready for customers at all, start with how to get a vibe-coded app ready for real users, which covers the checks you can run yourself. Come back here once you know there is something to fix.

Before You Start

Write down what made you think the app needs fixing. Perhaps a customer saw another customer’s booking, the AI bill doubled last month, a page keeps timing out, or a developer friend looked at it and said it needs work. Each of those points at a different kind of problem, and the difference shows up in the price.

Then gather what anyone quoting will ask for: access to the code (the project in your AI tool, or a repository), the hosting account, a list of the outside services the app uses, and a few sentences on what the app is meant to do. Without the code, nobody can give you a real figure, only an estimate built from screenshots and a description.

Step 1: Get the Problems Named Before You Price Them

The most expensive way to fix an app built through vibe coding is to start fixing before anyone has read it. A developer who opens the code to fix one visible bug will often find the cause sits somewhere else, and the job grows as they follow it.

So the first cost is a review: someone reads the code against what the app is meant to do and writes down what fails, how serious each finding is, and roughly how much work each one is. That list is what every later decision rests on. It also stops you paying to fix things that don’t matter much while the thing that does matter waits.

A useful review gives you findings you can act on. A typical entry reads something like this:

  • Finding: the key for the AI service is in the code that runs in the visitor’s browser.
  • Why it matters: anyone can copy it and run up charges on your account.
  • Severity: high.
  • Fix: move the key to the server, send the AI calls through it and replace the old key. Small, part of a day.

A report of general advice with no severity and no effort against each item can’t be priced from, so ask for one that has both.

Step 2: Sort Every Finding Into One of Three Kinds of Fix

Once the problems are named, each one falls into one of three groups, and the group decides most of the cost.

A patch fixes the problem where it sits without changing how the app is built. Moving an exposed key, adding a missing permission check to one screen, switching on backups, putting a spending cap on an AI service, adding error logging. Patches are usually hours of work rather than days, and many apps only need patches.

A structural refactor keeps the app but changes how part of it works underneath. Refactoring is the right call when the same mistake is repeated across the app. A typical case is that every screen fetches data in its own way and none of them checks who is asking, so fixing one screen at a time would mean patching the same hole forty times. A refactor puts one proper rule in one place and points everything at it. Expect days, sometimes a few weeks, depending on how far the pattern has spread.

A rebuild keeps what you learned and replaces the code. It is the answer when the findings run through the foundations: the data is stored in a way that can’t support what the app now has to do, or the code is so tangled that every fix breaks something else. A rebuild costs something closer to building the app properly in the first place, though it is faster than starting cold because the working prototype already answers most of the questions a new build would have to ask.

Most apps end up with a mix: a handful of patches, perhaps one area that needs a refactor, and rarely a rebuild. A quote that recommends a rebuild without showing which findings make patching pointless deserves a second opinion.

Step 3: Check the Things That Move the Cost

Two apps with the same problems can cost very different amounts to fix. These are the drivers that make the difference, roughly in the order they matter:

  • How much code there is. A single-purpose tool with a handful of screens is a different job from a customer portal with payments, accounts and an admin area. Size sets the floor for the review and for every fix.
  • How many outside services it talks to. Each payment provider, email service, AI model or other system the app connects to is something else to check and something else that can fail. Fixes that touch those connections need testing against the real service, which takes longer.
  • Whether real customers and real data are already in it. Fixing an app nobody uses yet is straightforward. Fixing one that holds customer records means the fix has to keep that data intact, and sometimes the data itself needs cleaning up after the problem is closed.
  • How many rounds of prompting it went through. Apps built in one session are usually consistent. Apps changed through months of prompts often contain three different ways of doing the same thing, plus code left behind from features that were later removed. That layering is a form of technical debt, and sorting it out is where refactor time goes.
  • Whether there is version control and any tests. Without a history of changes, nobody can see what changed when the problem started, and without tests every fix has to be checked by hand.
  • Whether it acts on its own. Automations and agents that send emails, move money or change records need their permissions worked out and a person put back in the loop where it matters. That is design work as well as code.
  • How quickly it has to be done. A fix that must go out tonight without taking the app offline costs more than the same fix done carefully over a week.

Which AI tool built it matters less than people expect. Code written in ChatGPT, Claude, Cursor, Lovable, Bolt or Replit all gets read the same way, and the tool tells you less about the cost than the drivers above.

Step 4: Decide Between Patching, Refactoring and Rebuilding

With the findings sorted and the drivers in view, the decision usually follows from three questions.

Is anything urgent? Exposed keys and customer data visible to the wrong user get patched first, whatever else you decide, because they can cost you money or a data breach report while you think.

Are the problems scattered or repeated? Scattered problems mean patches. The same problem on every screen means a refactor of that one area is cheaper than patching it everywhere.

Will you keep building on it? If the app will stay roughly as it is, patch it and stop. If you plan to add a lot more, money spent on structure now saves money on every later change. If the foundations can’t hold what you plan to add, that is when a rebuild starts to make sense.

Here is how that plays out. Say a lettings agent built a tenant portal over a month of evenings. Tenants log in to report repairs and upload photos. A review finds the uploaded photos are publicly reachable by anyone who guesses the address pattern, the AI key used to summarise repair reports is visible in the browser, and every page checks the login in its own way, two of them not at all. The key and the photo storage are patches. The login checks are a small refactor: one rule, applied everywhere, instead of fixing pages one by one. Nothing points to a rebuild. The agent ends up paying for a day of review and fixes, plus a short refactor quoted separately, and the portal keeps running throughout.

Step 5: Read a Quote Properly

When the quote arrives, check it against the findings rather than the total at the bottom. A quote you can rely on has:

  • Each finding listed with the fix proposed and the effort against it, so you can choose to do the urgent ones now and the rest later.
  • A clear line between what is included and what would be extra, especially for anything marked “investigate further”.
  • A retest after the fixes, so someone confirms each problem is closed.
  • A named version. The fix applies to the code as it stood when it was reviewed. If you keep prompting changes into the app while the work is under way, the quote is for a moving target.
  • An answer to what happens afterwards: who looks after the app once the fixes are in, and on what terms.

Be wary of a fixed price for “making it production ready” with no findings behind it. Either someone has already read the code and is not showing you what they found, or nobody has and the price is padded to cover what they might find.

If you would rather hand the whole thing over than manage a list of fixes, our article on whether we can take over an existing software project explains how a full handover works.

Step 6: Budget for After the Fix

The fix is a cost for one version of the app. The next feature you prompt in creates a new version that nobody has reviewed, and the problems can come back with it. That is the cost most owners leave out.

There are two ways to handle it. Some owners stop prompting changes into the live app and send changes to a developer instead. Others keep building with AI and have each significant change reviewed before it goes live. Either way, set aside something each month for looking after the app, the same as you would for any software the business relies on. Our guide on how to budget for software maintenance sets out what that budget usually needs to cover. If you want a developer accountable for the code as it changes, that is what a support retainer is for.

Common Mistakes

  • Asking the AI tool to fix what the review found and not checking afterwards. The tool will make a change and tell you it is fixed; only a retest tells you whether it is.
  • Fixing the bug you can see and calling it done. A customer seeing someone else’s booking is usually one symptom of a permission gap that exists on other screens too.
  • Paying for a rebuild because the code looks untidy. Untidy code that works and is secure can be left alone; a rebuild is for foundations that can’t carry what you plan to add.
  • Prompting new features in while the fixes are being made, which moves the target and turns a fixed quote into an open one.
  • Treating an automated scan as a review. Scanners are good at known patterns and miss logic, such as whether the app checks whose data is being requested. Our comparison of AI code review tools vs developer sign-off sets out where each one stops.

What Good Looks Like

You have a written list of what was wrong, sorted by severity, with the urgent items already closed. Each remaining fix has a cost against it and you have chosen which to do now and which can wait. The quote you accepted names the version it covers and includes a retest. You know whether the app needed patches, a refactor or a rebuild and why, and nobody has sold you more than the findings support. You also know who looks after the app from here and how much a month that costs.

Next Steps

Our AI Sign-Off starts with that first step: a developer reads the code against what it is meant to do, fixes what fails, and signs off the version reviewed. It starts from £750 + VAT for one day on a small app or automation, with the small fixes included. Larger codebases are quoted after a first look, and anything bigger than a day’s fixes is quoted before work starts. If the review shows the app needs hardening beyond that, our security hardening service covers the deeper work. More practical walkthroughs are in our guides.

Written by

Alex

CEO

I’m a software developer and CEO of Digital Royalty, helping growing teams scale their SaaS platforms without losing quality, visibility, or control. I focus on building structured, maintainable systems with clear processes, reporting, and accountability. With over a decade of experience across agency and in-house roles, I specialise in delivering long-term, scalable solutions that support complex, evolving products.

Portrait of Alexander De Sousa, founder of Digital Royalty
Founder-led
“I’ve put everything I know into how this company works — the standards, the method, the care on every project. It runs through the whole team, and I hold us all to it.”

Alexander De Sousa · Founder LinkedIn

Featured on BBC Radio Solent

Get started

Tell us what you need

A few quick questions, then a straight answer from a real person — usually within a few hours.

What happens next

  1. 1 We reply A real person reads your answers and gets back to you, usually within a few hours.
  2. 2 Questions or a short call If anything isn't clear, we ask by email or book a short call. Before any call we audit your website and make the quick fixes it finds, free.
  3. 3 Your fixed quote A clear, fixed price in writing, within 48 hours of any call. There is no obligation to go ahead.

Tell us what you're working on

Whether it's a new site, a platform, or a process that shouldn't be manual any more — we'll tell you honestly if we can help.