The experiment

I gave the same prompt to four different AI app builders: Lovable, Bolt, v0, and Rork. The prompt was deliberately specific: "Build a habit tracking app with daily streaks, a calendar view, push notification reminders, and a simple stats dashboard showing weekly and monthly completion rates."

Not trivial, but not insanely complex. The kind of app a freelancer might build for a client, or a solo founder might build as an MVP. Here's what each platform produced, how long it took, and whether the result was actually usable.

Lovable: The overachiever

Lovable produced the most complete result. Within about 15 minutes, I had a full-stack web app with user authentication, a PostgreSQL database (via Supabase integration), the calendar view I'd asked for, and a stats dashboard that actually calculated completion rates correctly.

The UI was polished. Not "AI-generated" polished, where everything looks generically clean. Actually polished. The colour scheme made sense, the spacing was consistent, and the interactions felt natural. Lovable clearly has strong opinions about design, and those opinions are mostly good ones.

The streak tracking worked correctly, including edge cases like timezone boundaries and partial days. I was genuinely impressed by this because streak logic is one of those things that seems simple until you try to implement it properly.

What didn't work: push notifications. Lovable generated the UI for notification settings but the actual notification logic wasn't connected to anything. This is understandable since web push notifications are a pain to implement, but it means the prompt wasn't fully satisfied.

Time to working app: 15 minutes. Time to deployed app: 25 minutes (Supabase + Netlify).

The numbers behind Lovable are staggering. They hit $206M in annual recurring revenue, up from $7M at the end of 2024. That's roughly 2,800% growth. They have 8 million users building 100,000 products per day. Whatever they're doing, the market is responding.

Bolt: The speed demon

Bolt was the fastest. Within about 8 minutes, I had a working prototype with the calendar view, streak counter, and a basic stats page. The speed is Bolt's biggest selling point and it delivers.

The trade-off is depth. Bolt's output felt like a prototype, which is probably exactly what they're optimising for. The UI was clean but generic. The stats dashboard showed weekly data but the monthly view had a bug where it counted the wrong number of days. The database was a simple in-memory store rather than a proper backend.

For showing a client "here's roughly what the app could look like," Bolt is perfect. For actually shipping to users, you'd need to spend significant time adding a real backend, fixing edge cases, and adding the polish that Bolt skips in favour of speed.

Time to working prototype: 8 minutes. Time to production-ready: would need significant additional work.

v0: The component artist

v0 by Vercel does something different from the others. Rather than building a complete application, it generates individual UI components with remarkable quality. The calendar component it produced was beautiful. The stats cards were elegant. Each piece looked like it belonged in a design system.

But v0 didn't produce a connected application. It gave me individual components that I'd need to wire together myself. The calendar view worked visually but had no data layer. The stats dashboard was a static mockup with placeholder numbers.

For a developer who wants high-quality UI components to integrate into an existing project, v0 is excellent. For a non-technical user who wants a complete working app, v0 is the wrong tool. It's a component generator, not an app builder, and I think Vercel is pretty clear about that to be fair.

Time to beautiful components: 10 minutes. Time to working app: you'd need a developer.

Rork: The one that shipped

Rork did something none of the others could: it produced a native mobile app that I submitted to the App Store. The app took about 20 minutes to generate, which is slower than Bolt and Lovable, but the output was a genuine Expo/React Native project with proper app icons, splash screens, and a sensible file structure.

The habit tracker worked. Streaks were calculated correctly. The calendar view was native and smooth. Push notifications actually functioned (the one feature the others all failed on). The stats dashboard was basic but accurate.

The design was the weakest of the four. Functional rather than beautiful. You could tell it was generated rather than designed. But it was good enough for an MVP, and the fact that it actually ran on a phone as a native app makes the comparison somewhat unfair to the web-focused competitors.

Time to working mobile app: 20 minutes. Time to App Store submission: about 45 minutes (including provisioning profiles and screenshots).

The no-code market context

These tools exist in a market that's projected to reach $376 billion by 2034. That's not a typo. The demand for "build software without being a developer" is enormous and growing. Each of these tools represents a different bet on what users actually want.

Lovable bets on full-stack web apps. Bolt bets on speed. v0 bets on component quality. Rork bets on mobile.

My honest recommendations

Use Lovable when: You need a complete, deployed web app with a real backend. It produces the most production-ready output and the Supabase integration means your data actually persists. Best for MVPs you plan to show investors or early users.

Use Bolt when: You need a prototype fast and you're okay with it being rough. Perfect for client pitches, hackathons, or testing whether an idea has legs before investing real development time.

Use v0 when: You're a developer who needs beautiful UI components. It's not an app builder, it's a design implementation tool, and at that specific job it's the best of the lot.

Use Rork when: You need a mobile app. There's simply no competition here. If your product needs to be on the App Store or Google Play, Rork is your only realistic AI option.

The verdict

If I could only keep one, I'd keep Lovable. It produces the most complete result for the most common use case (web apps with real backends). Bolt is a close second for pure speed. v0 serves a different purpose entirely and shouldn't be compared directly. Rork wins its category by default since it's the only one playing that game.

The exciting thing isn't any individual tool. It's that all four exist, all four work, and all four are getting better every month. A year ago, none of these produced output you could actually ship. Now, at least two of them do. That's real progress, not marketing hype.