At a glance

These tools are not competing with each other so much as solving different problems that happen to look similar from the outside.

The useful distinction is not which is best. It is which ones assist a developer and which ones replace one, because that single difference determines what you end up owning.

How we are judging them

One question: after using this, does a human understand the code?

Not "is the output good", because the output is broadly decent across all of them now. What matters is whether the tool leaves you with software someone can maintain, or a black box that happens to work.

Cursor

What it is: a code editor with AI built into it properly. You are still a developer, writing in a project, with the model helping.

Good at: nearly everything we do day to day. It understands the whole codebase rather than a single file, which makes its suggestions genuinely relevant. Multi-file changes, refactors, writing tests, explaining unfamiliar code. It is the one we use most.

Bad at: nothing catastrophic, but it will confidently do the wrong thing if you ask vaguely, and it can quietly sprawl a change across more files than needed. It also makes it very easy to accept suggestions without reading them, which is a discipline problem rather than a tool problem.

Verdict: we happily use it in production work. Crucially, that is because it assists someone who would know if it were wrong. Hand it to someone who cannot review the output and it becomes as risky as anything else here.

v0

What it is: describe an interface, get components back.

Good at: exactly that. Getting from "we need a settings screen" to something real and reasonably tidy, fast. As a starting point for front-end work it saves genuine hours, and the output is usually clean enough to keep.

Bad at: being an application. It gives you the front of the thing. Data, permissions, and everything behind the screen remain entirely your problem, and it does not pretend otherwise.

Verdict: useful and honest about its scope. We would use its output as a first draft and expect to keep most of it.

Bolt

What it is: full application scaffolding, in the browser, from a description.

Good at: speed and completeness. You get something that runs, end to end, startlingly quickly. For validating an idea or building an internal tool nobody outside the building will touch, that is a real capability.

Bad at: depth. The structure it produces is sensible-looking rather than considered, and the further you get from a conventional application shape, the more it strains. It is the first eighty per cent, delivered very well.

Verdict: excellent for prototypes and internal tools. We would not put its output in front of customers without someone going through the data layer and the permissions properly first.

Lovable

What it is: the most ambitious of the four. Aimed at people who are not developers, building complete applications by describing them.

Good at: the thing everyone says it is good at. Non-technical founders genuinely do end up with working software, and that is not nothing. We have seen people get further with it than they would have got with a small budget and an agency, and we are not going to sneer at that.

Bad at: the invisible half. Access control is the recurring one. Data structure is rarely designed so much as accumulated. And because the intended user cannot review the output, there is no natural moment where anyone catches it.

Verdict: genuinely impressive, and we would not ship a Lovable application to production untouched. Not because the code is bad, but because nobody has checked the parts that do not show, and by design the person who built it is not equipped to.

The pattern

Notice what the verdicts track. It is not output quality, which is broadly similar. It is who is expected to be in the loop.

Cursor assumes a developer and is therefore safe in the hands of one. Lovable assumes there is not one, and everything that follows comes from that assumption. Bolt and v0 sit in between, and are correspondingly fine within their scope.

The tool is not the risk. The absence of a reviewer is the risk, and some tools are designed around that absence.

So which would we actually trust?

All of them, for the right job.

Cursor for real production work, with a developer. v0 for interfaces. Bolt for prototypes and internal tools. Lovable to get an idea into the world before spending money on it, with a plan for someone to look properly at it before real customers and real data arrive.

What we would not do is use any of them as a substitute for someone who understands the result. That is not a limitation of these products. It is just what they are.

Our fuller comparison, updated as these tools change, lives here: Lovable, Bolt, v0 and Cursor, the honest verdict.

All four are, in the end, the same thing at different levels of ambition: a brilliant typist and a terrible architect.

Built something with one of these and want a second opinion? Our AI Code Audit is a fixed-price £495 review that tells you plainly what you are dealing with, or get in touch for a no-pressure conversation.