Why does Lovable stop working at 70%?

The short answer

Lovable, Bolt, v0, and every other "describe an app, get working code" tool hit a wall at roughly 70% feature complete. This is not a bug in the tools. It is a property of what a language model can do on its own: it can write the plausible 70% fast, and it cannot close the last 30% without a human who actually understands the code. The last 30% is where real apps are built.

The pattern, named

One of the most-cited reviews of AI app builders in 2024-2025 put it this way: "Bolt gets you about 70% of the way to a working app. The last 30% typically requires professional development to achieve production quality." (Trickle blog, Bolt.new review.) Another founder on Lovable said it more bluntly: "It promises 'build apps with AI' but delivers 'waste hours debugging code that looks right but doesn't work'." (Lovable Trustpilot reviewer.) A Replit user described the wall as: "Hit a wall, get frustrated, hit your $25 limit and give up." (Jeff Brines on Replit.)

These quotes come from our pain-points research — 100 testimonials across AI builders, no-code platforms, and cheap-dev regrets. The 70% wall shows up in every single AI-builder category.

Why the wall exists

Three reasons, roughly in order of severity.

1. The model does not know your system

A language model generating code from a prompt does not know what other code you have. It will happily produce a component that uses a library you do not have, a hook that conflicts with a hook it wrote yesterday, or a route handler that assumes a database table that does not exist. For the first dozen features, this is fine — there is no other system yet. For feature 13, it starts to matter. For feature 30, it is the entire problem.

This is not solved by "better prompting." It is solved by a pipeline that tracks state across features, and by a human who can read the generated code before it ships.

2. Debugging AI-written code is harder than writing new code

When an AI-written component breaks, the debug session looks different from a human one. You cannot ask "why did you write it this way." You cannot interview the author's intent. You are left with the code, which looks confident and reasonable and is also wrong. Founders who are not developers end up asking the AI to "fix it" — which often produces code that "looks right but doesn't work" (the Lovable quote above). Sometimes the fix introduces a new bug elsewhere.

One pain theme from our research calls this "fix-one-break-another iteration" — fixed in one prompt, new problems in the next. That is the second-most-cited complaint about AI builders after the 70% wall itself.

3. The bill scales with debugging, not with features

AI builders charge by tokens or by credits. A feature that works first try costs $1 of credit. A feature you have to re-prompt 15 times costs $50. One Bolt user reportedly "spent over $1,000 on tokens just to fix code problems" (Trickle blog on Bolt).

This is why the curve is not "I am 70% done, let me spend 40% more time to finish." It is "I am 70% done, and the next 10% of progress is going to cost me 5x what the first 70% cost." The economics are the wall.

What the last 30% actually contains

If you've never shipped a production app, the last 30% sounds like "bug fixes and polish." It is not. It is:

• Auth edge cases. Password reset. Email verification. Social login that fails halfway. Session expiry during a form submission.
• Error handling. What happens when the API is down. What happens when the database is slow. What happens when a user hits submit twice.
• Performance at real scale. Not 10 rows — 100,000. Not one user — 500.
• Data integrity. Foreign key constraints. Race conditions. Idempotent webhooks.
• Security. Rate limiting. CSRF. XSS. SQL injection (yes, still). Privilege escalation between tenants.
• Observability. When the app breaks in production — and it will — can you tell why within 60 seconds.
• Deployment. CI/CD. Rollback. Zero-downtime migrations.
• Compliance. GDPR delete. SOC 2 audit trail. Data residency.

Every item on that list is work. None of it is visible to a user on the happy path. All of it is what separates a demo from a business.

What actually gets you past 70%

There are three honest paths.

Hire a developer

A senior full-stack developer costs $140-200k/year loaded. They will close the last 30% in 3-6 months for a reasonably-sized app. The failure mode is the developer leaving before the work is done — covered in the dev shop vs retainer guide.

Use a pipeline, not a chatbot

The difference between an AI builder and a modernization pipeline is that a pipeline reviews its own work. Every change goes through tests, a review step, and a rollback gate. At SoftwareMovers we run 18 review skills on every change — security, performance, architecture, tests. See the AI code review guide for what that actually looks like. The pipeline is the thing that gets you past the wall, not a better model.

Rewrite on a modern stack with humans

For some apps this is the right answer. If you've hit the wall on Bubble or Lovable, your existing screens and data are valuable — do not throw them away. See how to export a Bubble app. The same translation pattern applies to Lovable / Bolt / v0 exports.

What would make this guide wrong

1. A qualitatively better model ships. GPT-5, Claude 5, Gemini 3, or a new architecture could move the wall from 70% to 90%. Our bet: the wall moves, but it does not disappear. The top 10% is about state and context, not raw reasoning.
2. You have an app small enough that 70% is enough. An internal tool, a landing-page form, a one-off admin screen — 70% of those is shippable. Do not over-buy.
3. The AI builder ships a real code-export feature. Lovable in particular has opened this up more than Bubble. If a platform produces clean, editable code that a human developer can take over, the "wall" becomes a handoff instead of a dead end.

Changed since last time

• 2026-04-21 — First published.

Sources

• "Bolt gets you about 70%" quote — Trickle blog Bolt.new review. Cited in softwaremovers/marketing/pain-points-research/04-pain-themes.md, killer-quotes section.
• "waste hours debugging code that looks right but doesn't work" — Lovable Trustpilot review. Same file.
• "$1,000 on tokens to fix code problems" — Trickle blog on Bolt. Same file.

If you have a Lovable, Bolt, or v0 app that is 70% done and you want the last 30% shipped on your own code, start with a $299 legacy audit or see pricing.