AI / Landscape
Prompt-to-app builders and what they really hand you
Lovable, Bolt, v0, and Replit Agent all turn a paragraph into a running application. They are not the same product, they do not produce the same artifact, and the difference that matters most is rarely mentioned on their landing pages: what you can take with you when you outgrow them.
About 8 min read. Capabilities and plan structures verified August 2026.
What separates a builder from a coding assistant
A coding assistant edits a repository you already own. An app builder owns the whole loop: it scaffolds the project, writes the code, runs it, hosts a preview, and in most cases provisions a database and an auth provider on your behalf. You never see a terminal unless you ask for one.
That is a genuine capability, not a toy. A designer can have a working, deployed, authenticated CRUD app in an afternoon, and a founder can put a real interface in front of ten customers before writing a line of code. The category earns its place.
It is also where the sharpest cliff in modern development sits. Everything is easy until it is not, and the moment you need something the builder does not have an opinion about - a background job, a webhook signature check, a third-party SDK, a query the ORM will not express - the tool goes from accelerating you to blocking you in a single step. So the question to ask on day one is not "how fast is it" but "what do I get to keep".
The four that matter
Lovable
Strongest all-rounder for a SaaS MVP
Generates React and Tailwind front ends with an unusually good default sense of layout, spacing, and responsive behavior - the output tends to look designed rather than generated, which matters more than it should when you are showing a prototype to someone who is not technical. It wires up a Supabase backend for the database, auth, and storage, and it syncs the project to a GitHub repository you own, so the code is in version control from the start rather than trapped in a workspace.
Lovable states plainly that you own your code, the apps you build, and the AI output. Pricing is credit-based, with a small free daily grant and paid tiers that top up a monthly balance; plan mode costs more per message than the default mode.
Verdict: the default pick if the goal is a real subscription product and the frontend needs to look finished. lovable.dev
Bolt
Fastest to a working prototype
StackBlitz's builder runs the whole toolchain inside your browser using WebContainers, so there is no cloud environment to spin up and no cold start between prompt and preview. It is the least opinionated about framework - React, Vue, Svelte, and Astro all work, and it supports mobile output through Expo, which none of the others match.
Billing is raw LLM tokens rather than task credits, which is honest and slightly punishing: token burn grows with the size of your project, so the twentieth prompt costs meaningfully more than the second. The free tier is generous enough to evaluate properly.
Verdict: best for throwing an idea at the wall, for non-React stacks, and for anything that has to run on a phone. bolt.new
v0
Next.js-native, and it shows
Vercel's builder generates React, Tailwind, and shadcn/ui components that drop straight into an existing Next.js codebase, which is a materially different value proposition from the others: v0 is at its best producing a piece of an app you already have rather than the whole thing. It imports from Figma, and deployment is one click because you are already inside Vercel's platform.
The tradeoff is the narrowest lane here. If you are not on Next.js and not deploying to Vercel, most of the advantage evaporates. Pricing is token-denominated credits, with a free tier that includes a small monthly allowance.
Verdict: the strongest option for teams already on Next.js who want components and screens, not a whole generated application. v0.app
Replit Agent
The one with a real backend underneath
Replit is a full cloud development environment first and a builder second, and that inverts the usual limits. Real server-side code in Python, Node, Go, and more; PostgreSQL provisioned in the workspace; cron jobs, background workers, and WebSocket servers that actually stay running. Hosting is included rather than bolted on, and Agent 3 will iterate autonomously for long stretches.
The frontend polish is behind Lovable's, and you are working inside a browser IDE, which some developers find liberating and others find claustrophobic. Billing is effort-priced checkpoints drawn against a credit balance.
Verdict: the pick for backend-heavy projects, Python work, scheduled jobs, and complete beginners who want one environment for everything. replit.com
What each one really ships
The row that decides your future is "code you keep". Everything above it is a preference; that one is an exit cost.
| Dimension | Lovable | Bolt | v0 | Replit Agent |
|---|---|---|---|---|
| Frontend output | React and Tailwind, strongest visual defaults | React, Vue, Svelte, Astro, plus Expo for mobile | React, Tailwind, shadcn/ui, Next.js-shaped | Whatever you ask for; polish is your job |
| Backend | Supabase: Postgres, auth, storage | Connect your own; browser runtime limits what can run | Next.js server routes; you bring the database | Real processes, Postgres, jobs, websockets |
| Code you keep | GitHub sync; you own the code | Download or push to a repo | Copy components straight into your repo | Full workspace; export or connect a repo |
| Hosting | Publish from the platform, or deploy the repo yourself | Deploy targets you choose | Vercel, one click | Included in the platform |
| Metering | Task-weighted credits; plan mode costs more | Raw tokens; burn grows with project size | Token-denominated credit balance | Effort-priced checkpoints against credits |
| Wall you hit first | Logic that does not fit Supabase's shape | Anything needing a persistent server process | Not being on Next.js | Design quality and browser-IDE fatigue |
Gotcha: the entry paid tiers all cluster around 20 to 25 dollars a month, and they are not comparable. One bills tokens, one bills task-weighted credits, one bills checkpoints by effort. Run the same three-hour build on two of them before you commit a year.
Code ownership is not the same as code portability
Every builder here will tell you that you own the code, and every one of them is telling the truth. Ownership is a licensing question and it is settled. Portability is an engineering question and it is not.
The code you export is real, readable, and yours. What comes with it is a set of assumptions: which auth provider issues the tokens, which database client is imported everywhere, which platform's environment variables the build expects, which preview URL is hardcoded in a callback. None of that is malicious. It is what any framework does. But it means "export the repo" is the start of the migration, not the end of it.
Three habits make the export genuinely cheap, and all three cost nothing on day one:
- Connect a git repository immediately. Not when you are ready to leave - on the first day. A project with real commit history is a project you can hand to a developer; a workspace snapshot is not.
- Own your data layer from the start. A Postgres database you provisioned yourself, with migrations in the repo, is portable regardless of what generated the app around it. A database that only exists inside a platform is a hostage.
- Keep the domain on your own registrar and DNS. Trivial to do early, genuinely annoying later, and it means switching hosts is a DNS change rather than a negotiation.
The graduation path to a real stack
Nobody stays on a builder forever, and that is fine - it did its job. The signal to move is not a feeling, it is a specific set of blockers.
Move when you hit one of these
- You are prompting your way around a limitation instead of building a feature.
- You need a background job, a queue, a webhook receiver, or a scheduled task the platform cannot host.
- A second developer joins and needs a local environment, a branch, and a code review.
- You are taking money, and payment or compliance requirements now dictate architecture.
- The monthly credit spend has quietly passed what a hosted stack would cost outright.
How the move actually goes
Pull the repo down and run it locally. Replace the platform-specific pieces one at a time - environment configuration, then auth, then deployment - and keep the generated UI, which is usually the part worth keeping. Point a coding assistant at the result with a rules file describing your target conventions; a codebase-wide cleanup is exactly the mechanical breadth an agent is good at.
Expect days, not weeks, if you connected git early. Expect a rewrite if you did not.
The verdict
Use a builder to find out whether anyone wants the thing. Use Lovable if it is a SaaS product with a real UI, Bolt if you want the fastest possible prototype or a non-React stack, v0 if you are already on Next.js, and Replit if the hard part is the backend. Then graduate deliberately - the weekend MVP stack is the next step for a validated idea, and the SaaS stack guide is where it lives once people are paying.
Where to go next
Once the code is yours, the tool changes: an AI code assistant edits a repository you control, which is a different and more durable relationship than a builder that owns the loop. The workflow guide covers how to keep that productive without shipping code nobody understands.
For the stack decisions a graduated project has to make, see frontend frameworks, databases, auth providers, and hosting. If the product itself is AI-powered rather than AI-built, start at the AI app stack guide.