There's Money in Fixing Vibe-Coded Apps
I spend a lot of my time rescuing vibe-coded apps that started as useful personal projects and ended as mentally draining production problems.
The demo works and the landing page looks great. The person building it has been adding features for weeks, everything seems to be coming together, and they’ve decided to let other people sign up.
Then things start breaking. They ask AI to fix a problem, it changes something else, and now they’re trying to explain two problems to it. A few attempts later, they can’t get back to the version that worked. They’ve got users waiting for answers and an app they’re afraid to touch.
There’s paid work here for developers. I know because I’m doing it.
I use AI to write code too, so this isn’t going to be a lecture about how everyone should go back to typing out their own form components. I’m pleased people can build useful software without needing my help to get started. But getting started has become so easy that people can end up running a software business before they’ve learnt much about running software.
Someone has to help them when it breaks. I’d prefer that person understood what they were doing.
The demo doesn’t tell you much
AI can write a working feature in minutes. What takes longer is establishing whether that feature will keep working once someone uses it differently from the person who built it.
Imagine a booking app. You create an account, book a slot and see it appear on a dashboard. You try it again and it works again. As far as you’re concerned, you’ve built a booking system.
Two people booking the same slot at the same time might tell you otherwise.
Or someone pays, closes the tab before returning to your app, and never gets their booking confirmed. Someone else submits a form twice because the first click didn’t appear to do anything. These are ordinary things people do, and none of them is covered by watching yourself successfully click through a demo.
An experienced developer starts looking for those problems because they’ve had to fix similar ones before. If you’ve never built software, you might not even know which questions to ask. You asked for a booking system and got something that appeared to book things. Fair enough.
AI won’t automatically know your deployment setup, your users, or the mistakes it made three prompts ago. You can give it access to logs and project instructions, and that helps. You still need someone to check what it’s assumed, particularly when the deployed app behaves differently from the preview.
And the temptation when something breaks is to paste in the error and ask for a fix. That can work. It can also produce a change that hides the error while leaving the original problem in place. If you can’t read the change, you’re left testing the app again and hoping.
That’s a stressful way to look after something people have started paying for.
Can you send me the app?
Half the time, getting the files is a problem before I’ve even had a chance to look at the code.
They used Base44. Or they built something with Claude or ChatGPT. They’ve got a working app in a browser, and now a developer is asking them to send something they don’t know how to find.
Source code, to someone who hasn’t dealt with it before, isn’t necessarily a folder they know they have. The app might have been built entirely through a chat interface. They might have downloaded several versions without knowing which one matches what’s published. A website address feels like a reasonable answer when someone asks to see what they’ve built.
You can see the app. Why can’t you fix it?
I can understand the confusion. The tool has handled the parts underneath the interface, so the owner hasn’t needed to think about where those parts live. Now they’re being asked about a repository and a database, possibly while trying to deal with annoyed customers.
Throwing more developer terminology at them won’t get you the files any faster.
You need to help them establish what they’ve got. Where is the project? Where is it hosted? Which account owns it? If there’s a database, how do you access it? A code download might only give you part of what you need to run the app, and you want to discover that before promising you’ll have it fixed by Friday.
This takes patience, and it takes time. I think developers should charge for that time. Working out how to get a project running is part of taking it over, especially when nobody involved can give you instructions that have ever been tested.
It’s tempting to treat all this as a bit of admin before the job begins. Then you’ve spent hours helping someone recover accounts and identify services, and you still haven’t reached the bug they originally contacted you about.
Scope the handover. You can be helpful without giving away half a day’s work.
They don’t know what Git is
One of the biggest problems I see is clients building without source control. No Git, no commits they understand, and no dependable way to go back after a change goes wrong.
They often don’t know what Git is. Nobody has explained why they’d want it.
A GitHub integration sitting in a menu doesn’t teach someone why code history matters. If your understanding of software development is asking for a change and checking the result, saving a version before you start isn’t an obvious step. You might assume you can just ask the AI to undo whatever it did.
Then it breaks something, and undoing it becomes another round of prompting.
The app worked before a particular change. You remember that much. But the AI has since changed several files while trying to repair it, and describing the old behaviour doesn’t necessarily put the old code back. You’re asking it to reconstruct something you could’ve saved.
That would drive me up the wall.
With small commits, you’ve got a record you can inspect. You can see what changed, compare it with the previous version and revert a bad change. You can try a fix on a branch without gambling the working version on whether the AI gets it right this time.
Git doesn’t undo everything that happens to an app. Deleted customer data needs backups, and rolling code back after a database migration can take more thought than clicking a button. But having the code history gives you options you’d otherwise be trying to invent during an outage.
Setting up a repository is easy enough. Teaching the owner what it gives them is the part worth spending time on. Show them a change and its diff. Show them how you’d recover the previous version. Explain why the next working feature should get a commit before they ask for another one.
They don’t need a sermon about Git. They need to understand how to avoid losing another weekend to a broken app.
One more feature
Feature creep gets ridiculous when the first version of every feature seems almost free.
Imagine you’ve built a tool to track jobs. Invoices would be handy, so you ask for those. Then you want customers to log in and check progress. Subscriptions sound worth trying too, and the AI is happy to add them. It isn’t going to interrupt you to ask whether anyone wants a monthly subscription to your job tracker.
Each addition appears quickly enough that it feels wasteful to stop. You could spend the evening thinking through the implications of customer accounts, or you could have a customer portal on the screen in ten minutes.
Obviously the portal wins. It even has an avatar menu.
But now a job has an owner and possibly a customer who can see some of it. An invoice needs to agree with the work recorded against that job. Cancelling a subscription might affect access to both. The features you’ve added have started making assumptions about one another, and changing one of them can break a decision buried somewhere else.
Writing all that code quickly doesn’t save you from deciding how it should behave.
By the time a developer gets involved, there can be a pile of half-finished features making the useful part of the app harder to fix. The owner may still be asking for additions because adding things is the part that’s been going well.
I’d want to know which features people use and which ones have been added because they seemed like a good idea at midnight. Sometimes the sensible repair includes turning something off. An unfinished subscription system can wait if people still can’t reliably complete the task they signed up for.
That can be an awkward conversation. You’re the developer who has arrived and started suggesting the app should do less. But taking money to keep extending a system you don’t trust yet is going to make both your lives worse.
A login screen isn’t enough
Security gets left until later, if it gets considered at all. The owner asks for login, login appears, and the app feels ready for customers.
There’s a lot that can go wrong behind that screen.
Take a hypothetical customer portal. It hides admin controls from ordinary users, so the owner assumes those users can’t perform admin actions. But unless the server checks permissions too, someone can bypass the interface and make the request directly. The missing button hasn’t protected anything.
The same applies to customer records. Filtering a list in the browser won’t help if you’ve already sent everyone’s records to that browser. By then you’ve handed over the data.
OWASP’s authorisation guidance recommends denying access by default and checking permissions on every request. It warns against relying on client-side checks. These are checks you need to verify in the running system, regardless of how convincingly an AI tells you it has added security.
Create two users and check whether one can retrieve or edit the other’s records. Check what happens without a login. Follow the requests and look at what the backend accepts. You can learn far more from that than from looking at a dashboard with a padlock icon on it.
Payments deserve attention too. Stripe documents that webhook events can arrive more than once or out of order, and recommends its official libraries for verifying signatures. A checkout working once doesn’t tell you whether the integration handles any of that correctly.
A client might come to you asking why an email isn’t arriving, and you could discover an access problem that needs attention first. You need to be able to explain that change in priority without burying them in security terminology. Show them what one account can see that it shouldn’t, then agree on the repair.
I wouldn’t sell a quick audit as a guarantee that an app is secure. I’d be specific about what was checked and what was fixed. You’ll have enough responsibility without promising you’ve found every possible vulnerability.
Please use a library
The amount of custom code in some of these projects is another problem. AI can write a replacement for an established library quickly enough that nobody stops to ask why they’re building their own version.
Authentication is an obvious example. So are date pickers and form validation. You can generate something that covers the example you gave it, then spend the rest of the project discovering what you left out.
A date picker that looks fine with a mouse might be miserable to use with a keyboard. A calculation that works in your timezone might be wrong for a customer somewhere else. Those details still need dealing with even if producing the initial component cost you a single prompt.
I’d rather use a maintained library whose authors have already spent time dealing with those problems. You still have to evaluate it and use it properly. A library can have bugs, and adding a dependency for something you could sensibly write in a few lines is unnecessary.
But having AI generate your own authentication system because it can is a bloody awful reason to take responsibility for an authentication system.
Part of a rescue can be replacing custom code with something the next developer will recognise. Keep the behaviour the client needs, check it still works, and delete the code you’ve made unnecessary. The owner doesn’t benefit from having more code to look after.
There’s work beyond the rescue
For a developer thinking about offering this service, I’d start with a paid assessment. Get access, get the project running and reproduce the reported problem before quoting the rest of the job.
You might find a small bug. You might find that the client has sent you the wrong version of the app. You might find a project that needs more work than the owner can afford. Trying to cover all of that with a fixed price based on a screenshot is asking to lose money.
Give them a short explanation of what you’ve found and a repair they can agree to. Get registration working. Fix access to customer records. Set up a deployment they can recover from. The owner should know what they’ll be able to do when you’re finished, and you should know how you’ll check it.
Some of these projects won’t be worth rescuing. A useful personal tool doesn’t automatically make a viable business, and an owner might decide to stop once they understand the cost of supporting customers. That’s a reasonable outcome from an assessment too. Better to find out before spending their money on a rebuild.
I’d also resist the urge to rewrite everything in my preferred stack. There are projects that need it, but a change of framework isn’t automatically a repair. Moving a working feature gives you another chance to break it, and the client gets to pay while you find out how.
Once the immediate problems are fixed, there’s room for ongoing work. Reviewing AI-generated changes before they’re released would be useful for an owner who wants to keep building. So would planning a feature with them before it spreads through half the app. A small amount of regular help might prevent the next emergency.
You’d want clear limits on support. An owner who keeps prompting changes into production every evening can keep you employed and ruin your evenings at the same time. Agree on how changes get reviewed and what happens when they need urgent help. Unlimited availability is a miserable thing to accidentally sell.
I’d much rather have these conversations than sit around laughing at someone for trying to build an app. They might know their business well and have built something people want. Being unfamiliar with source control doesn’t cancel that out. It does mean they’ll need help maintaining what they’ve made.
When the job’s finished, put the project in accounts the client owns and leave instructions someone else can follow. They should know where the code is, how it’s deployed and how to give another developer access. If they need help again, they ought to be able to send the files.
Comments