Generative UI tool from Vercel that ships production-ready React + Tailwind components from a prompt.
Last updated
v0 is the tool in this category most often evaluated against the wrong competitors. It gets compared to Lovable and Bolt.new because all three turn prompts into working software, but those two are trying to produce an application and v0 is trying to produce a layer. The realistic v0 session does not end with a deployed product. It ends with a component you paste into a repository that already exists.
The output is React, styled with Tailwind, built on shadcn/ui primitives, and shaped to Next.js conventions. That is a specific and opinionated target, and how well v0 fits your team is mostly a question of how close your stack already sits to it. A team on Next.js and Tailwind is receiving code they can merge. A team on Vue, or on a CSS-in-JS system, or on a component library with its own primitives, is receiving a design to reimplement — still useful, but a different and slower kind of useful.
Worth noting that shadcn/ui is not a dependency you install and hide behind. Its components are copied into your project as source you own and edit. That property is why v0's output integrates as well as it does: it is generating code of the same kind you would already have in the repository, rather than configuration for a library only it understands.
Most of the value shows up in one narrow motion: you need a screen that is tedious rather than hard — a settings page, a data table with filters and empty states, a multi-step form, a dashboard shell — and you would rather not spend a day arranging it. You describe it, iterate in the chat or by manipulating elements directly, and move the result into your codebase. v0 provides a command-line path for dropping generated blocks into an existing project through the shadcn CLI as well as straightforward copying; check the current documentation for the exact invocation, since that surface has changed more than once.
Everything downstream of that paste is your normal process. Your router, your data fetching, your state management, your tests, your review. v0 does not want to own any of it, which is why it coexists comfortably with an editor-first tool like Cursor rather than competing with one.
This is the case where v0 is either excellent or actively annoying, with very little in between, and the deciding factor is how specific your system is.
If your design system is essentially Tailwind plus shadcn plus a theme, v0 lands close enough that adapting output is a matter of swapping tokens and tightening spacing. If your system has its own primitives, its own naming, and rules a reviewer will enforce, then generated code that ignores all of it creates a translation step that can cost more than writing the component would have. The mitigation is to show rather than describe: give v0 representative existing components as context so it can imitate concrete patterns instead of guessing from adjectives. It follows examples considerably better than it follows instructions.
There is also a quieter organisational risk. A generator that produces plausible, attractive, slightly-off components can erode a design system faster than it accelerates it, because the off-by-a-little version ships and becomes precedent. Teams that keep this under control tend to route v0 output through the same review that any component change would get, rather than treating it as already-approved because it looks finished.
v0 is credit-metered, and the thing that consumes credits is iteration. Getting a complex screen to the state you wanted is rarely one generation; it is a sequence of refinements, and each one costs. The practical consequence is that a precise first prompt is worth real money, and that a habit of nudging the output repeatedly toward a picture in your head is the expensive way to use the tool. Past a certain point it is cheaper to accept the structure and finish the details by hand.
Because plan names and credit allowances change, treat any figure you read as provisional and confirm the current terms on Vercel's pricing page before planning around them.
Stop at the point the work becomes behaviour rather than appearance. Authorisation rules, data consistency, background jobs, anything where the difficulty is in what happens rather than what it looks like — a UI generator has nothing distinctive to offer there, and asking it anyway produces confident code that has not considered your constraints.
Skip v0 entirely if you are not writing React, because the output is not portable in any meaningful sense. Skip it if you want something that builds and hosts an entire application for you, which is Lovable's job for non-developers and Bolt's for developers; our comparison of Bolt, v0, and Lovable separates those three cleanly, and v0 against Builder.io covers the design-tool angle. And be wary of reaching for it on components that are core to your product's identity. v0 is very good at the screens every product has and noticeably less interesting on the one screen yours is actually about.
Settings pages, tables with sorting and filtering and a decent empty state, onboarding forms, dashboard shells. Interfaces where the requirements are well understood and the work is arrangement rather than invention, which is precisely where a generator's weaknesses do not surface.
Designers on the paid tiers can bring Figma work in, and the output arrives as the same kind of Tailwind and shadcn source the repository already contains. The handoff stops being a document a developer interprets and becomes a component a developer edits, which is a shorter conversation.
v0 has five credit-based tiers: Free ($0, $5 monthly credits, up to 200 projects, Design Mode, GitHub sync), Premium ($20/mo, $20 monthly credits, Figma imports, v0 API, higher limits), Team ($30/user/mo), Business ($100/user/mo), and Enterprise (custom). All tiers access the three model tiers (Mini, Pro, Max) and differ in credits, daily limits, and collaboration. Purchased credits expire after one year. The pricing trap: generation cost scales with complexity, so heavy users on Premium can exhaust their $20 credit pool and need to buy more — budget by how much you actually generate, not by the flat sticker price.
You can export the code and host it anywhere, but you should be honest about how opinionated the output is. It is React with Tailwind and shadcn/ui, shaped to Next.js conventions. Outside that stack you are translating rather than integrating, and the further away you are, the less of v0's advantage survives the trip.
Components and pages as source code you own, not a hosted artefact you rent. Because shadcn/ui components are copied into a project rather than installed as an opaque dependency, what you receive is ordinary code in your repository that any developer on the team can read and change without learning anything v0-specific.
Either by copying it directly or through the shadcn command-line path v0 provides for adding a generated block to a project. The exact command has changed across releases, so take it from the current v0 documentation rather than from memory or an older tutorial.
Partially, and it depends on how far your system sits from Tailwind and shadcn. The approach that works is showing it real components from your codebase as context so it can copy concrete patterns; the approach that disappoints is describing your system in prose and hoping. If your primitives are genuinely custom, expect to adapt output rather than merge it.
They answer different questions. v0 produces UI for a codebase that already exists and assumes a developer will take it from there. Bolt.new builds a running full-stack project in the browser for developers who will steer it. Lovable builds an application for someone who does not intend to write code at all. If you already have a repository, v0 is the one designed for your situation.
Because iteration is what costs, not output size. Each refinement of a complex screen is another metered generation, so a long back-and-forth chasing an exact visual result is the expensive path. Writing a more specific first prompt, and finishing the last ten percent by hand instead of asking for it, is usually both cheaper and faster.
Full review coming soon.