Lovable alternatives: 7 tools, and I gave 5 the same brief

Contents

The best Lovable alternatives

Most lists of Lovable alternatives compare feature tables. I gave five of the tools on this page the identical brief — one message, six numbered requirements, no follow-ups — and then used each resulting app to check whether it actually worked.

All five met all six requirements. What separated them was time, cost, and how much code they wrote to get there.

Tool	Best for	Time on my brief	What the build cost
Bolt	The closest swap for Lovable	2–3 min	~$0.25, cheapest measured
Replit	A real backend and terminal	~4 min	31% of its free plan
Cursor	Driving an editor yourself	Under 1 min	$0 on the free tier
Google Antigravity	Staying free indefinitely	~2.5 min + a gate	$0
Claude Code	Code quality above all	~8.5 min	~$2.56
v0 by Vercel	Polished React UI, untested	Not tested	Not tested
Bubble	No-code business logic, untested	Not tested	Not tested
Lovable, for reference	Speed and cost legibility	109 sec	~$0.30

Two of these I have not tested, and I have marked them so throughout rather than quietly blending them in.

How I tested them

One message containing six numbered requirements: add a tool with a name, cost and billing cycle; annual plans must display a monthly-equivalent figure rather than the annual one; a running monthly total pinned to the top; a cancelled state that removes an item from the total but keeps it visible in its own section; persistence across reloads; a dark theme.

Requirements two and four are deliberate traps. Each needs two ideas held at once — show a derived number instead of the one typed in, and exclude an item while keeping it on screen. They are the kind of thing that gets half-implemented.

No follow-up prompts. I then served each app, used it, checked the running total against a calculator and read the stored data. Not one of these results comes from reading a tool’s own summary of what it had done.

1. Bolt — the closest swap for Lovable

B

If you want the thing Lovable does, from a different company, this is it. Describe an app in a chat box, get a working hosted result, no terminal involved.

On my brief it met all six requirements in two to three minutes and cost roughly 25 cents — about 100,000 tokens, which made it the cheapest per build of anything I measured, Lovable included. It handled both traps correctly, rendering the annual plan as a monthly equivalent and keeping cancelled items visible outside the total.

The reason to pick it over Lovable is cost per build and a token meter that is easier to reason about than a credit that expires. The reason not to is that it is the same shape of tool, so if you left Lovable because you hit a structural wall, Bolt is the same wall in a different colour.

What it costs. A free tier with a daily token allowance, and paid plans from $20 a month. My build consumed roughly 100,000 tokens, which is where the 25-cent figure comes from — Bolt counts tokens rather than an invented credit, so the arithmetic is yours to do rather than a rate card to look up.

2. Replit — when you need a real backend

R

The most common reason to leave Lovable is hitting something it structurally cannot do, and Replit is the answer to most of those. It is a full cloud IDE: file tree, terminal, deployment logs, a built-in Postgres database and many languages rather than one framework.

It met all six requirements on my brief in about four minutes, the slowest of the group. The cost is the awkward part. That single build consumed 31% of the free plan’s Agent credits — three builds and the free tier is essentially gone — and I cannot tell you what it cost in dollars, because the free plan shows only a percentage of an unstated total. Replit charges per checkpoint, priced by effort assessed after the work rather than the old flat $0.25.

Take it when your project needs a Python worker, a scheduled job or a database you administer. Do not take it expecting to forecast the bill. Full detail in the Replit review.

What it costs. Starter is free with daily Agent credits. Core is $20 a month, or $18 billed annually. Pro is $100, or $90 annually, and Enterprise is quote-only. The subscription is the cheapest of the hosted tools here — the consumption is not, and the two facts get confused constantly.

3. Cursor — the fastest thing I have measured

C

Cursor is not a prompt-to-app builder, and it still produced a working app faster than any tool I have given this brief: under a minute, 581 lines across three files, six of six, on the free Hobby tier for nothing.

That last part is the fact most comparisons miss. Cursor’s free tier is real and it completed the whole job. What it excludes is frontier models, MCPs and cloud agents, which is the actual line between free and paid rather than the one people draw.

The catch arrives later and it is a real one. Above the free tier, Cursor charges a subscription plus metered usage billed in arrears at the model’s API rate. I paid $510.70 across eleven months on a plan advertised at $20, with one month reaching $159.22. There is a spend limit on every paid tier and it is off until you turn it on. See the Cursor review and the pricing breakdown.

What it costs. Hobby is free. Pro is $20 a month or $16 billed annually, Pro+ is $60 or $48, and Ultra is $200 or $160. Team seats are $40 and $120 per user. Yearly billing is exactly 20% off every tier. All of that sits on top of metered usage, which is the part that produced my $510.70.

4. Google Antigravity — free, and it tests its own work

G

The only tool here whose free tier is free indefinitely rather than a trial with a slower fuse. Antigravity’s pricing page contains exactly one number and it is $0, and the free tier includes Gemini models alongside Claude Sonnet and Opus.

It met all six requirements in about two and a half minutes, and then did something only one other tool of seven managed: it wrote a test file, ran it under Node, and recorded six assertions that I independently confirmed against the shipped app. If you want the thing that built your app to check it before handing it over, this is the free option that does.

Two costs. It will not run unattended — it produces a plan and waits for approval, which took one click and one permission grant. And it sprawls: 2,894 lines for six requirements against Cursor’s 581. Google also publishes no number at all for what the free allowance is, describing it only as “basic weekly rate limits”. More in the Antigravity review.

What it costs. Nothing, indefinitely. Paid access is not an Antigravity subscription at all but a Google One AI plan: $4.99 for AI Plus, $19.99 for AI Pro, $99.99 for Ultra 5x and $199.99 for Ultra 20x. What those buy you in Antigravity terms is described as “expanded” or “higher” agent requests, which is as specific as Google gets.

5. Claude Code — the best code, at the worst price

C

Included because it produced the highest-quality result of everything I tested, and excluded from the top of the list because it is the least like Lovable.

It refused to build from the brief at all. It ran a three-question interview, then wrote a design document, and only produced code when told to — eight exchanges before a single line existed. Nothing was blocking it; it chose to ask.

What arrived was the best of the seven. It stored money as integer cents, explaining unprompted that adding 9.99 and 19.99 as floats gives 29.979999999999997, and it shipped a 28-assertion test suite covering corrupt storage, non-array payloads and float precision. I ran it: 28 passed, 0 failed.

It also took about eight and a half minutes and cost roughly $2.56, more than eight times the dearest hosted builder here. There is no free tier; it arrives with a Claude subscription from $20 a month. See is Claude Code worth it.

What it costs. There is no free tier. It arrives with a Claude subscription: Pro at $20 a month or $200 a year, Max 5x at $100, Max 20x at $200. You can also run it against metered API billing, which is what my test did and where the $2.56 came from. On a subscription the marginal cost of one more build is zero, which is the honest way to read that figure.

6. v0 by Vercel — for polished React UI

V

I have not tested v0, so everything here is its documented shape rather than a measured result.

It generates React interfaces from prompts and is repeatedly named for producing the most polished front-end output of this group, with a natural path into Vercel’s hosting. That makes it the most direct answer to the narrow question “I want Lovable’s UI quality without Lovable.”

What it is not is a full-stack builder in the way Lovable and Replit are. The consistent theme in coverage is that v0 produces interface, and you supply the rest of the application around it. If a front end is the whole job, that is an advantage rather than a limitation.

What it costs. I have not verified v0’s current pricing against its own page, so I am not going to quote figures I have not checked. Vercel publishes tiers on the product site, and the practical question is usually whether you are already on Vercel — if you are, this is the cheapest thing on this page to add.

7. Bubble — no-code, for real business logic

B

I have not tested Bubble either, and it is the least similar tool on this page.

It is a visual no-code platform rather than a prompt-to-app generator: you build by arranging and configuring rather than describing, with a workflow engine and a database designed for business logic that would be awkward to express in a prompt. It is the most established option here by a wide margin and the one most often recommended for applications expected to run for years.

The trade is the learning curve. Lovable’s appeal is that you type a sentence; Bubble’s is that you get real control, and control has to be learned. If you find yourself fighting a chat box to express a rule, that is the signal to look at it.

What it costs. Bubble prices on a tiered subscription with usage-based workload units on top, and I have not verified the current numbers against its own page, so I will not quote them here. The structural point matters more anyway: Bubble’s costs scale with how much your app runs, not with how much you build it, which is the opposite of every other tool on this page.

What the measured results actually showed

Five tools, one brief, and the headline is that capability did not separate them at all. Every one scored six of six on the first attempt, including both traps.

Tool	Requirements	Time	Lines written	Own tests	Cost
Cursor	6 of 6	Under 1 min	581	No	$0 free tier
Lovable	6 of 6	109 sec	Not counted	No	~$0.30
Antigravity	6 of 6	~2.5 min + gate	2,894	Yes, 6	$0
Bolt	6 of 6	2–3 min	Not counted	No	~$0.25
Replit	6 of 6	~4 min	Not counted	No, hooks only	31% of free plan
Claude Code	6 of 6	~8.5 min	1,052	Yes, 28	~$2.56

Three things fall out of that table that a feature comparison would never surface.

The cost range is roughly tenfold for an identical result. Bolt did it for about 25 cents, Claude Code for about $2.56, and both produced a working app meeting every requirement. On a single build that is trivial. Across a project of iterations it is the entire budget.

Only two of the seven verified their own work. Claude Code with 28 assertions and Antigravity with 6. Every hosted builder — Lovable, Bolt, Replit — wrote nothing that checked anything. That gap matters most for the people hosted builders are sold to, who are least equipped to catch a bug by reading the code.

All seven invented a Restore button. My brief asked for cancelled items to leave the total and stay visible. It said nothing about bringing them back. Every single tool added a way to. Read generously, they all inferred correctly that cancelling implies undo. Read less generously, all seven added scope to a spec written to be precise.

What Lovable still does better than most of these

A roundup of alternatives has an obvious bias, so it is worth being explicit about what the incumbent won on my own test.

It was second fastest of everything I have measured. 109 seconds, six of six, first attempt. Only Cursor beat it, and Cursor is not the same kind of tool. Against the other hosted builders it was comfortably quickest — Bolt took two to three minutes and Replit about four.

Its pricing is the most legible in this group. Lovable publishes what individual actions cost: a simple update at 0.50 credits, removing a component at 0.90, implementing authentication at 1.20, a landing page with images at 1.70. My whole build cost 1.20. That means you can estimate a project before starting it, which is more than Replit’s percentage bar or Cursor’s arrears billing allow.

It got the hard requirement right in the right way. The annual-to-monthly trap is easy to fail invisibly: you can store the derived number and appear correct until something changes. Lovable stored the raw annual figure with the billing cycle and computed the monthly equivalent at render, which is the correct model. Not every tool that scored 6 of 6 was doing it the sound way underneath.

Where Lovable won on my own test	Against
Second fastest overall, 109 sec	Bolt 2–3 min, Replit ~4 min
Published per-action rate card	Replit’s percentage bar, Cursor’s arrears billing
Correct data model under the trap	Not every 6-of-6 result was sound underneath
Finished-looking output	No developer tool here competes on this

And the output looks finished. React with Tailwind, on a preview subdomain, presentable to someone else immediately. That is the actual product, and none of the developer tools on this page compete on it at all.

What it does not have is a way out of its own shape. React web apps, a managed backend, and a credit meter where a wrong answer costs exactly what a right one does. Those are the reasons to leave, and none of them is “it is not good at what it does”.

What moving off Lovable actually involves

The alternatives coverage tends to stop at the recommendation. The migration is where the cost really is, and it differs sharply depending on which row of the table you picked.

To Bolt: almost nothing. Same shape of tool, same kind of prompt, same kind of output. You are re-describing an app rather than porting one, which for a prototype is usually faster than migrating anyway.

To Replit or Cursor: a real project. Lovable syncs to GitHub, so the React code is retrievable — that is its documented route out and I have not tested it. What does not travel is the managed layer. An app leaning on Lovable’s cloud and Supabase integration needs somewhere to land, and rewiring it to Replit’s Postgres or to your own infrastructure is work measured in days rather than clicks.

To Bubble: a rebuild. It is a different paradigm, not a different vendor. Nothing ports.

Two things worth deciding before you start rather than after:

Question	If yes
Is the app still a prototype?	Rebuild in the new tool. Migration is not worth it
Does it have real users and data?	Budget the backend rewiring properly, in days
Do you need it running in two years?	Prefer the tool that gives you the code and the runtime
Is cost the only complaint?	Try Bolt before you rebuild anything

The general rule from doing this across seven tools: the convenience you bought is the part that does not travel. Every managed platform here trades portability for speed, and that is a fair trade right up until the moment you want to leave. Deciding early which side of that trade a project sits on is worth more than picking the perfect tool.

The free tiers, compared honestly

“Free” covers two completely different offers in this group, and the difference decides more than the subscription prices do.

Free indefinitely means the tier is a product. Free as a trial means the tier is a countdown you cannot see the end of.

Tool	Free tier	Did it complete my brief?	What ran down
Google Antigravity	Free indefinitely	Yes	Nothing visible. Limits are undefined
Cursor	Hobby, no card	Yes	Nothing. Excludes frontier models
Lovable	5 build credits a day	Yes	1.20 of that day’s 5
Bolt	Daily token allowance	Yes	Roughly 100,000 tokens
Replit	Daily Agent credits	Yes	31% of the plan in one build
Claude Code	None	n/a	n/a

Every free tier here completed a real six-requirement app, which is worth saying plainly because it is not what the marketing implies about any of them.

What separates them is what happened afterwards. Antigravity and Cursor absorbed the build without visibly consuming anything, which is why they are the two I would point anyone at who wants to find out whether this way of working suits them before spending money. Lovable’s daily reset means a bad afternoon costs an afternoon. Replit’s single build taking nearly a third of the plan means about three attempts before you are choosing a paid tier.

The catch on Antigravity is the mirror image of Replit’s. Replit shows you a percentage running down; Antigravity shows you nothing at all, describing its limits only as “basic weekly rate limits”. One tells you that you are running out without telling you of what. The other does not tell you there is a limit until you meet it.

And Claude Code simply has no free tier, which is worth knowing before it appears on a shortlist assembled from posts that do not check.

How each one handled the two traps

Scoring six of six is a low bar if the tools were only ever going to pass. They were not — the two trap requirements exist to be failed quietly, and it is worth showing what passing actually looked like.

Trap one: show a derived number, not the one typed in. I entered an annual plan at $2,400 and every tool had to display $200.00 a month instead.

Trap two: exclude an item from a total while keeping it visible. Cancelling had to change the arithmetic without removing the row.

Tool	Annual → monthly	Cancelled state	Stored the raw figure?
Lovable	$200.00/mo, annual kept as context	Left the total, stayed visible	Yes
Cursor	$200.00/mo, “billed $2,400.00/yr” beneath	Dimmed section, Restore + Delete	Yes
Antigravity	$200.00/mo, annual as sub-text	”Cancelled & Inactive”, Reactivate	Yes
Claude Code	$200.00/mo, “$2,400.00 billed yearly”	Cancelled section, “$100.00/mo saved”	Yes, as integer cents
Bolt	Passed	Passed	Not inspected
Replit	Passed	Passed	Not inspected

The row that matters is the last one. Storing the raw annual figure and deriving the monthly number at render is the correct model; storing the derived value looks identical on screen and drifts the moment anything changes. Every tool I inspected at that level got it right, which was genuinely more than I expected.

Claude Code went one further and stored money as integer cents, on the grounds that adding 9.99 and 19.99 as floats gives 29.979999999999997. No other tool raised it. That is the difference between a total that reconciles in a year and one that does not, and it is invisible on the day you build the thing.

What I left out, and why

Lists like this tend to grow until they stop being useful, so here is what did not make it and the reason.

A long tail of newer hosted builders. Every few weeks another prompt-to-app product launches, and several appear in other roundups of this keyword. Base44 is the one that comes up most often. I have not run any of them through the brief, and adding names I cannot speak to would make this page longer without making it more useful.

Open-source and self-hosted options. There is a real category here for people who want the code on their own machine with no vendor between them and it, and it is a fair answer to the complaint that every tool on this page is a managed platform you eventually have to leave. I have not tested any of them, so I am not going to rank them. If that is what you are after, the thing to check first is which model provider it expects you to bring, because that decides both the bill and the quality far more than the wrapper does.

What is on this page	Basis
Bolt, Replit, Cursor, Antigravity, Claude Code	Measured on the identical brief
Lovable, as the baseline	Measured
v0, Bubble	Documented only, labelled untested
Newer builders, open-source options	Excluded — not tested, not ranked

Anything I could only describe from its marketing. v0 and Bubble are on this page because they answer questions the tested tools genuinely cannot, and both are labelled untested wherever they appear. That is the limit of what I will include on secondary sources.

The five measured results are the reason to read this page. Everything else here is signposting, and it is marked as such.

Which one should you pick?

The useful question is not which tool is best but which problem sent you looking.

If you left Lovable because	Pick
Credits burn too fast on iteration	Bolt — cheapest per build I measured
You need a database, terminal or Python	Replit
You want to own and edit the code yourself	Cursor
You cannot spend anything at all	Antigravity or Cursor’s free tier
Generated code quality is the priority	Claude Code
You only need a polished front end	v0, untested
A prompt cannot express your business rules	Bubble, untested
Nothing in particular	Stay on Lovable

That last row is not filler. Lovable was the second fastest tool I measured, at 109 seconds, and it has the most legible pricing of the hosted builders because it publishes what each type of action costs — a simple update at 0.50 credits, authentication at 1.20, a landing page with images at 1.70. If none of the rows above describe your situation, switching will cost you more in relearning than it returns.

The final word

The reason most alternatives lists are unhelpful is that they compare tools that do not compete. Bolt genuinely replaces Lovable. Replit replaces the thing Lovable could not do. Cursor and Claude Code are a different job entirely, and they appear here only because “I outgrew the builder” is the most common reason people go looking.

On measured results, Bolt is the closest and cheapest swap, Cursor is the fastest and its free tier is better than advertised, Antigravity is the only one that is genuinely free indefinitely and the only free option that tests its own output, and Replit is the answer whenever the words “database” or “Python” appear in your requirements.

And the result I keep coming back to: every one of these tools met all six requirements on the first attempt. The differences were never capability. They were cost, shape, and whether anything checked the work — which is the part no feature table has ever told you.