Lovable logo

Let me be clear upfront: I’m not here to tell you Lovable is a scam. People are making money with it. People are shipping products with it. Some of those products are genuinely useful.

But I won’t use it. And after watching the “vibe coding” wave crash into reality over the past year, I think it’s worth explaining why.

What Lovable Actually Is

For those unfamiliar: Lovable is an AI app builder. You describe what you want in plain English, and it generates a full React application with Tailwind CSS, Supabase integration, and deployment. In minutes.

It’s genuinely impressive as a demo. Type “build me a habit tracker with user auth and a dashboard” and watch it scaffold an entire application. The UI looks polished. The code runs. You feel like a wizard.

Then you try to change something.

The Loop of Death

Here’s what Lovable users don’t talk about in their X/Facebook GHL Group success stories:

The debugging loop. You ask for a feature. It breaks something else. You ask it to fix that. It reintroduces the original bug. You burn through credits watching an AI argue with itself.

One reviewer put it perfectly: “The moment you start integrating ANYTHING, moving anything, making changes to anything THINGS START TO BREAK. Buttons break, functionality are a JOKE. You must prompt it 20 times and you are LUCKY if it even works.”

This isn’t a bug. It’s the fundamental architecture of how these tools work. The AI doesn’t understand your codebase. It doesn’t have context beyond the current prompt. Every change is a fresh hallucination that happens to compile.

The Security Problem Nobody Talks About

In May 2025, researchers found that 170 out of 1,645 Lovable-created web applications had security vulnerabilities that would allow personal information to be accessed by anyone.

That’s a 10% critical vulnerability rate. On production apps. Handling real user data.

The AI generates code that looks correct but contains what security researchers call “shadow bugs” - structural vulnerabilities that pass surface-level review but expose your users to real risk.

Technical Debt at Warp Speed

I’ve been building software for years. I’ve seen codebases decay. But I’ve never seen anything like what vibe coding produces.

Kin Lane, who’s been in tech for 35 years, said it best: “I don’t think I have ever seen so much technical debt being created in such a short period of time.”

The pattern is predictable:

  1. Ship fast, feel great
  2. Add features, things start breaking
  3. Ask AI to fix it, more things break
  4. Realize no human understands the codebase
  5. Rewrite from scratch or abandon

That’s not building. That’s generating disposable prototypes and pretending they’re products.

But People Are Making Money!

Yes. They are. I’m not denying that.

Here’s who Lovable actually works for:

Template sellers. Build a generic SaaS starter, sell it 100 times, move on. The buyer’s maintenance problem isn’t your problem.

Validation MVPs. Need to test if anyone wants your idea before building it properly? A Lovable prototype can answer that question in a weekend.

Marketing sites with forms. No complex logic, no edge cases, no scaling concerns. Totally fine.

People learning concepts. Seeing how an app comes together, even messily, has educational value.

But here’s what I’ve noticed: the people making real money with Lovable are selling to people who don’t know better. The SaaS templates work until the buyer tries to customize them. The agencies using it are praying their clients never ask for changes.

That’s not a sustainable business model. That’s a game of hot potato.

How I Actually Use AI for Development

Here’s the thing: I love AI for coding. I use it every single day. I can’t imagine going back.

But I use it completely differently.

Claude Code is my daily driver. It’s an AI that works inside my terminal, understands my entire codebase, and helps me write code that I then review and own. It suggests. I decide. The code is mine.

Cursor works the same way - AI assistance inside a real IDE. It helps me refactor, explains bugs, generates tests. But I’m still the developer. The architecture decisions are still mine.

The difference is fundamental:

  • Lovable: AI generates the app, you prompt for changes
  • Claude/Cursor: You build the app, AI accelerates your work

One produces code you can’t maintain. The other makes you faster at producing code you understand completely.

The Tailwind Docs Problem

Here’s a story that keeps me up at night.

Tailwind Labs had to lay off staff because their documentation traffic dropped 40%. Why? AI tools like Lovable install Tailwind automatically and generate all the CSS. Developers never visit the docs. Never learn the framework. Never discover the commercial products that fund the open source work.

Adam Wathan explained: “The docs are the only way people find out about our commercial products, and without customers we can’t afford to maintain the framework.”

Vibe coding isn’t just creating bad code. It’s potentially killing the ecosystem that makes the code possible.

The Real Problem with Vibe Coding

The framing was wrong from the start.

Vibe coding was sold as a replacement for engineering. “Anyone can build apps now! No code required!”

But software engineering isn’t just producing code. It’s:

  • Maintaining systems over time
  • Managing risk
  • Handling scale
  • Navigating edge cases
  • Debugging production issues at 2am

AI tools are genuinely bad at that kind of stewardship. Not because they’re not smart enough, but because stewardship requires continuity, context, and ownership. An AI that forgets everything between prompts can’t steward anything.

My Hot Take

Lovable and tools like it will create a generation of “developers” who can ship but can’t maintain. They’ll build apps that work until they don’t, then start over.

Some will make money. Most will burn out fighting their own codebases.

Meanwhile, developers who use AI as a tool rather than a replacement will compound their skills. Every project makes them better. Every codebase teaches them something. The AI accelerates their growth instead of substituting for it.

In five years, the gap between these two groups will be massive.

Where I Actually Agree with the Vibe Coders

Look, I get the appeal. Traditional software development has too much gatekeeping. Too much “you need to learn algorithms before you can build a todo app.” Too much credentialism.

If Lovable gets more people excited about building things, that’s genuinely good. Some of them will hit the walls I described and decide to actually learn. That’s a valid path.

And for certain use cases - quick prototypes, validation experiments, learning projects - these tools are legitimately useful.

I just think we should be honest about what they are: scaffolding generators that produce code you’ll eventually throw away.

What I Recommend Instead

If you want to build real products with AI assistance:

  1. Learn the fundamentals anyway. HTML, CSS, JavaScript basics. Enough to read what the AI generates.

  2. Use AI as a copilot, not a pilot. Cursor, Claude Code, GitHub Copilot. Tools that assist rather than replace.

  3. Own your architecture. Decide your stack. Understand your data model. Let AI help with implementation, not decisions.

  4. Review everything. AI-generated code needs human review. Always. This is non-negotiable for production.

  5. Build things you can maintain. If you can’t debug it, you don’t own it.

I love AI. I use it constantly. It’s genuinely made me a better developer.

But I don’t use Lovable. Not because it doesn’t work - it does, for a while. But because I want to build things that last. And you can’t build lasting things with tools that don’t understand what lasting means.

Currently: using Claude Code to build actual software that I actually understand.