Stuck Building an App With AI? What to Do Next

It's a scene I see almost every week. Someone has a genuinely good idea, opens Lovable, Bolt or v0, types what they want, and within a couple of hours there's something on screen that looks like a real app. The first feeling is pure elation. "I built this myself, and it actually works." Then comes the second evening. People need to be able to sign up. You need to take a payment. The data has to live somewhere instead of vanishing when the page reloads. It needs to go live on the internet, not just sit on localhost. And suddenly everything grinds to a halt.

You ask the AI to "connect payments" and it generates code that looks right but doesn't work. You ask it to fix that, and it patches one spot while breaking three others. Ten rounds in, you've no idea which bit of code does what, the deploy throws an error neither you nor the AI understands, and that elation has curdled into the strange panic of having 70% of a product and not the faintest idea how to cross the last 30%. This is vibe coding meeting the wall it always meets.

If that's you, read to the end. Over the years I've taken plenty of these "nearly finished" projects and turned them into something that actually runs in production. In this article I'll be straight with you about why this happens to nearly everyone, what "production-ready" honestly means, the three real options you have when you're stuck, and what each one costs in pounds. No hype, no hand-waving.

Why almost everyone gets stuck in the same place

This isn't your fault, and it isn't a measure of how clever you are. AI tools are built to get you to an impressive result as fast as possible, and the most impressive, easiest-to-show part is the visuals. Screens, buttons, forms, animations, a tidy layout. That's exactly what AI generates brilliantly, because there are millions of examples of that kind of code online and it's self-contained — it doesn't have to talk to your real database or your real bank.

The catch is that the impressive part was always the easy part. The real work — the work that turns a pretty mock-up into a functioning business — starts precisely where the AI hits a wall. I call that wall the hard 30%: authentication, payments, the database, security, GDPR, deployment, integrations and edge cases. That 30% of the scope eats 70% of the time and needs experience the tool simply can't hand you.

There's another reason you got stuck now rather than earlier. The AI works with a limited "memory" of your project. While there's not much code, everything's fine. But as the files pile up, the tool starts forgetting what it wrote earlier, and its fixes break working code more and more often. That's not a glitch — it's a limit of how the thing works. I go deeper into how a prototype differs from a product in a separate piece on vibe coding and why an AI prototype isn't a product yet.

What "production-ready" actually means

A lot of people assume "finished app" equals "looks good and works on my screen". In reality there's a chasm between those two things. Production-ready means the app works reliably for real people, on the real internet, with real money and real data — without you sitting next to it restarting the server every time something breaks.

Here's an honest picture of what AI did well in your project and where you almost certainly hit the wall:

Area	What AI does well	Where it hits the wall
User interface	Smart screens, forms, buttons, responsive layout	Almost nowhere — this is where AI is genuinely strong
Authentication	Login form, "forgot password" screen	Secure sessions, tokens, password hashing, real sign-in, passkeys and 2FA
Payments	The look of the basket and checkout pages	Real money moving, Stripe/PayPal webhooks, failures, refunds, PCI scope
Data	Simple CRUD examples, demo data	A real database that persists, migrations, backups, secure rules
Deployment	It runs on localhost	Domain, hosting, environment variables, SSL, actually going live
Security & GDPR	Next to nothing	UK GDPR, cookie/PECR consent, ICO registration, access control, a privacy policy
Edge cases	The "happy path" where everything goes right	What happens on bad input, a dropped connection, a declined payment

Look at the right-hand column. That's your "remaining 30%". It isn't cosmetic — it's the core of the product. An app that looks gorgeous but loses a customer's payment, or leaks their data, is worse than no app at all, because it destroys trust in your business. And in the UK specifically, the Data Protection Act 2018 and UK GDPR apply to every business — there's no small-business exemption. AI-built apps almost always ship with no privacy policy, no lawful basis, no cookie consent and no ICO registration. That's not a detail to bolt on later; it's a legal baseline.

The three options when you're stuck

When you reach this point, you really have three roads. None of them is right for everyone — it all depends on how much it matters to you to get this to market, and how much time and patience you can spare.

Option 1: keep fighting it yourself with AI

This road suits you if learning it yourself is the point, if it's a side project with no deadline, and if the risk of breaking for a real user costs you nothing. If that's the case, genuinely, use AI and keep at it. I say that openly, because not every project needs a developer, and I'm not in the business of selling you something you don't need.

Option 2: scrap it all and start over somewhere else

The truth is that not everything from your work is lost, even if you do start fresh. The idea itself, the user flows, the screen logic, what you actually want — that's valuable work you can carry forward. I write about how people travel from an idea to a real app, and the traps along the way, in my piece on going from a ChatGPT idea to a real app.

Option 3: hire someone to finish it or rebuild it

This road suits you when it matters to launch for real, when actual customers or payments are waiting, and when you understand that your time is worth more spent on the business than on wrestling deploy errors. That's exactly where I come in.

Why I rebuild cleanly rather than patch spaghetti

I want to be honest about how I work, because it tends to surprise people. When someone brings me a stuck AI project, they often expect me to "just fix their code". I don't always do that — and it's a deliberate choice in your favour.

First, I review your repository and assess its state. If AI produced a decent structure and you only got stuck on integrations or deployment, I'll continue on your base — there's no point redoing what's already tidy. But if the code is what I call spaghetti — layer upon layer of AI patches where each change breaks three others, with no clear architecture — then patching it would be more expensive and less reliable than rebuilding cleanly.

Here's the heart of it: I'm not offering to "tidy up your code". I'm offering to "build it so it works and earns". Those are different things. Tidying code means sticking yet another plaster on something already creaking. Building it to work means making sure payments go through, data is safe, sign-in is reliable, the deploy is stable, and when something does go wrong the system doesn't fall over. The expectation I always set up front: the hard 30% is the most expensive and the most time-consuming part, and it's the precise reason people get in touch.

The best part of your work — the idea, the screens, the flows — is almost always preserved. Rebuilding "cleanly" doesn't mean throwing everything away. It means putting a solid foundation under the visuals, the one the AI never built.

One more thing UK buyers rightly ask about: who they're trusting with this. I work as a registered company, I'll speak plainly about risk — security, data, downtime — rather than in jargon, and I take over and own the outcome. You can see how I approach delivery on my app development page.

The local integrations AI can't wire up for you

There's a separate category within the hard 30% I want to single out, because it's specific to the UK market and AI is powerless in it. These are the real-world integrations. AI can generate a pretty checkout form, but it physically can't connect the live systems behind it for you.

The concrete examples I end up wiring by hand again and again:

• Payments via Stripe, PayPal, Apple Pay and Google Pay — account verification, webhooks, failure and refund handling, and staying out of PCI-DSS scope by using hosted flows correctly, not just a form that looks like a checkout
• GoCardless Direct Debit and subscription billing — recurring payments, mandates and dunning, not "connect the API in five minutes"; the same goes for Klarna or Clearpay if you sell BNPL
• Auth and identity — Auth0, Clerk or Supabase Auth done securely, passkeys and 2FA, plus KYC via Onfido or Yoti and e-signing via DocuSign where the use case demands it
• Accounting and tax — pushing invoices into Xero or QuickBooks and meeting HMRC Making Tax Digital for VAT (with mandatory B2B/B2G e-invoicing via PINT UK/Peppol on the roadmap for around 2029)
• Shipping — Royal Mail Click & Drop, DPD or Evri label generation and tracking, plus Click & Collect, wired through carrier REST APIs rather than a plugin

AI only "knows" these systems superficially, and the code it generates often doesn't even compile or doesn't meet the provider's requirements. This is work that needs a human — sign-up, testing in a real sandbox, and experience. I go deeper into exactly why AI reaches its limit here in my article on the local integrations AI can't wire up.

What it really costs to get unstuck

Let's get to the numbers, because that's what you actually need. I'll give real ranges for the UK market, quoted ex-VAT as UK B2B buyers expect — always add VAT on top. I'll stress this: the exact figure depends on the state of your code and how many features are left to finish, so I always give a firm price after reviewing the repo.

Scenario	What it covers	Indicative price
AI app health check / audit	Fixed-price review of code, security, GDPR gaps and a clear plan	£500 - £1,500 + VAT (~€590 - €1,750)
Finish an MVP on the existing code	Decent AI base, missing backend, auth and deployment	£3,000 - £8,000 + VAT
Clean rebuild to production	Auth, payments, data, security, deploy on a solid foundation	£8,000 - £15,000+ + VAT
Local integration (each)	Stripe billing / GoCardless / Xero + HMRC MTD / shipping — per serious one	+£1,500 - £4,000 + VAT

For context, my day rate sits in the £400-£650/day + VAT range that a senior independent UK developer charges — and that matters. A £450+/day quote signals someone who can actually ship to production, as opposed to a £5/hr marketplace gig that lands you back where you started. Notice, too, how these figures overlap with normal web app development costs. That's no accident. Because AI does the easy half and the hard 30% is left to you, the cost of finishing often resembles building a serious chunk from scratch. People are sometimes surprised — "but half of it's already done." The cheap half is done. The expensive half is still waiting.

And it almost always pays off. Weigh up the alternative: a month of your own time fighting bugs, plus the risk of launching something that loses payments or doesn't meet UK GDPR. A professional finish takes that risk off the table and gets your product to market faster than you'd manage on your own.

What to do before you get in touch

If you decide you need a hand, here are a few steps that will speed everything up and bring the final price down. The clearer the starting state, the more accurately I can scope the work.

• Export the code. If you used Lovable, Bolt or v0, download the project or push it to a GitHub repository, so the whole structure is visible — not just the screens.
• Write down what you were trying to achieve. A few sentences on what the app should do and who your user is — that's worth more than ten screens.
• Mark exactly where you stopped. "Won't deploy", "payments don't work", "data disappears" — the more specific, the faster I can assess.
• Gather your access. If you already have a domain, hosting account or a payment provider you've trialled, have that information ready.

In short: what to do when you're stuck

If you started building an app with AI and got stuck, the first thing to know is that it's normal and it happens to nearly everyone. AI gets you to 70% beautifully, but it leaves the hard 30% — authentication, payments, data, security, deployment and local integrations — to you. That's not cosmetics; it's the core of the product.

You have three roads: keep fighting it yourself (fine for a side project with no deadline), start from scratch (risking the same wall), or hire someone to finish it or rebuild it cleanly (when launching for real matters). If you pick the third, I review the code, tell you honestly whether the existing base is worth saving, and build the product so it works and earns. You stay the owner of the code, I use mainstream technologies, and the hard 30% becomes my problem, not yours.

To carry on with the theme, it's worth reading how an AI prototype differs from a product, and the five traps on the road from a ChatGPT idea to a real app. And if you'd like someone to look at your stuck project right now, get in touch.

Frequently asked questions