Sometime in early 2025, a former Tesla and OpenAI researcher named Andrej Karpathy coined a phrase in a tweet — "vibe coding" — and the entire tooling industry reorganized around it within weeks. Describe what you want in plain English, let the AI build it, iterate on the vibes. By 2026 there's a whole shelf of tools racing to own that promise: Lovable, Bolt, v0, Replit, Cursor, and a dozen more, with the design-focused cousins ("vibe design") close behind.
The marketing is intoxicating, and the valuations are real — Lovable hit a $6.6B valuation,
00M in annual recurring revenue, and 100,000 projects a day. The story being sold is that the designer and the engineer are now nice-to-haves. Type a sentence, ship an app.
We build production software for a living, so we went in skeptical — not to dunk, but to find the actual seam between what these tools do brilliantly and where they quietly fall apart. Because both the hype ("anyone can build anything") and the backlash ("it's all slop") are wrong in the same way: they treat a category of tools as one thing, when the only useful question is which job, for which person, with what comes next.
What they're genuinely great at
Let's be fair, because the speed is not a trick. Point Bolt or v0 at a simple brief and you'll have a working interface — a login, a form, a list, real styling — in two to three minutes. v0 in particular produces genuinely beautiful React components fast, which is why developers who need to prototype a UI quickly rave about it and we believe them.
For a specific set of jobs, these tools are a legitimate leap:
Throwaway prototypes that make an idea legible. The highest-value thing a vibe tool does isn't building your product — it's getting a tangible, clickable thing in front of a real developer or stakeholder so the conversation stops being abstract. That's not a small thing. Two years ago the only way to make an idea concrete was to pay someone to build it from scratch.
Front-end speed for people who already code. v0 scaffolding a component library in Tailwind and shadcn, Cursor accelerating a developer who already knows what good looks like — this is the sweet spot. The tool amplifies expertise; it doesn't replace it.
Lowering the floor for exploration. The non-technical founder who can now produce something to react to, instead of a Google Doc full of adjectives, is genuinely better off. The barrier to a first draft has collapsed, and that's a real democratization of the starting line.
Where they break — and it's always the same place
Now the seam. One reviewer spent about £55 and a week trying to ship a real app across five of these tools as a non-coder. The honest conclusion she reached is the one the marketing never tells you: the workflow that actually makes sense is to use Lovable or Replit to prototype something you can show to a real developer — and then pay the developer.
That's not a failure of the tools. It's a description of where the floor is. And the break always happens at the same boundary: the moment the work stops being a plausible-looking surface and starts being a system that has to be correct.
The demo path is free; the edge cases are the product. These tools nail the happy path — the populated, logged-in, everything-works screenshot. They quietly skip the empty states, the error handling, the race conditions, the "what happens when the date passes / the upload fails / two people edit at once." That skipped 80% isn't polish. It's most of the actual engineering, and it's invisible until a real user hits it.
Silent decisions you didn't make and can't see. Every generated app embeds choices — a data shape, an auth strategy, a dependency — that nobody explicitly decided and nobody fully understands. Tellingly, the one tool in that £55 experiment that asked clarifying questions ("what database? do you need auth? what happens when a reminder fires?") was the one treating a vague description as actually vague. The others just guessed, confidently, and the guesses become load-bearing.
Beautiful is not the same as right. v0 builds a gorgeous interface in two minutes. Gorgeous and correct are different claims, and the gap between them — accessibility, performance, security, maintainability — is exactly the work that doesn't fit in a prompt. The tool produces something that looks finished well before it is finished, and an inexperienced builder has no way to tell the difference. That's the dangerous part: the tool is most convincing precisely where the user is least equipped to audit it.
The thing the hype gets exactly backwards
Here's the reframe we'd offer, because it changes how you should actually use these things.
The vibe tools don't remove the need for judgment. They relocate it. In the old workflow, the skill was in the building — the typing, the wiring, the implementation. The AI is now genuinely good at that part. Which means the scarce, valuable skill has moved upstream and downstream of the generation: knowing what to ask for with enough precision that the output is right, and knowing how to tell whether what came back is actually any good.
Both of those are exactly the skills a designer and an engineer have and a prompt doesn't. The clear specification — the states, the edge cases, the data shape, the accessibility requirements — is the thing that turns these tools from a slot machine into a power tool. And the trained eye that can look at a beautiful generated screen and say "the focus order is broken, this fails on a slow connection, and this auth pattern is a liability" is the thing standing between a prototype and a product.
So the tools didn't make expertise optional. They made expertise portable and fast for the people who have it — and a confidence trap for the people who don't.
How to actually use them well
We're not anti-vibe. We use these tools. Here's the posture that gets the speed without the debt:
Use them to think, not to ship. Treat the output as the fastest first draft ever invented — a thing to react to, learn from, and throw away — not as a foundation to build a business on. The prototype's job is to make the idea concrete and the requirements obvious. Once it's done that job, its work is finished.
Spec before you prompt. The quality of what comes back is capped by the clarity of what you ask. A vague prompt gets a confident guess; a precise spec gets an implementation of your design. The thinking still has to happen first — these tools just execute it faster.
Have someone who can read the output. The single biggest predictor of whether a vibe-built thing survives contact with reality is whether a real engineer reviewed it before it shipped. Not to gatekeep — to catch the silent decisions while they're still cheap to change.
Know which tool is which job. A UI scaffolder (v0) is not a full-stack app builder (Lovable) is not a developer's IDE (Cursor). Most disappointment comes from pointing a tool at a job it was never built for and concluding the whole category is fake. It isn't. It's just specific.
The bottom line
"Anyone can build an app" is true in exactly the way "anyone can write" is true. The tool removed the mechanical barrier. It did not install the judgment about what's worth building, what's actually correct, and what breaks the moment a real person shows up.
The vibe tools are the best prototyping technology we've ever had, and a genuinely bad way to ship a serious product unmediated. The teams that win with them won't be the ones who believed the marketing or the backlash. They'll be the ones who understood precisely where the seam is — and put their judgment exactly there.
Precision over decoration. Even when the decoration generates itself in two minutes.
