Inside Vercel’s Rebuilt v0: From Vibe-Coded Prototypes to Governed Production Apps

AI-assisted coding tools have made it easy to generate impressive demos, but much harder to safely ship and maintain real software. Vercel’s v0 launched into that gap in 2024 as a “version 0” prototyper. Millions of people used it to turn prompts into attractive UI scaffolds—then hit a wall when they tried to move that code into production.

Vercel has now rebuilt v0 with a different target: not greenfield prototypes, but the 90% of real work that happens inside existing applications and infrastructure. The new v0 is designed to plug directly into GitHub repositories, Vercel deployments, and enterprise data sources, while enforcing the same workflows and controls that govern hand-written code.

For enterprise software teams, this is less about prompting out another demo and more about containing the shadow IT that has emerged around AI coding tools, without shutting that productivity down.

From disposable demos to the 90% real-work problem

The original v0 focused squarely on what Vercel calls the “blank canvas” problem. Developers (and non-developers) could describe an interface in natural language and quickly get a working UI scaffold. For early exploration, this worked: more than 4 million people used v0 to build millions of prototypes.

But in practice, those prototypes were largely disposable. The generated code lived in v0’s own environment, separate from production repositories and pipelines. Moving anything into a real product typically meant copying files out, rewriting imports, wiring up data sources by hand, and reimplementing security and deployment patterns.

This pattern is not unique to v0. Across what Vercel and others describe as “vibe coding” tools, a consistent gap exists between what the tools generate and what enterprise teams can safely deploy. Tools like Claude Code generate backend logic and scripts effectively, but they do not drop their output into an organization’s existing design systems, repositories, or security regime. They tend to create new artifacts and environments that live off to the side.

Tom Occhino, Vercel’s Chief Product Officer, frames the consequence of this as “the world’s largest shadow IT problem.” AI-powered software creation is already happening across enterprises: staff paste credentials into prompts, feed sensitive data to unmanaged tools, and deploy apps outside approved infrastructure. Little to none of this is visible through existing audit and governance mechanisms.

With the rebuilt v0, Vercel is deliberately aiming at that 90% of software work: iterative changes to existing codebases and systems. The central design question is no longer how fast you can produce a demo, but how cleanly AI-generated changes can land inside the same repositories, environments, and controls that teams already use.

How the new sandbox runtime keeps AI code inside your repo

In its first incarnation, v0’s generation loop was essentially a self-contained playground. You prompted, it generated UI code, and you iterated via a conversational interface. The isolation made experimentation easy—but it also meant a translation step before anything could touch production.

The rebuilt v0 inverts that model. Instead of living apart from your stack, it now starts from your existing GitHub repositories. Teams connect v0 to a repo; from there, v0 imports that codebase and automatically pulls relevant environment variables, deployments, and configuration from Vercel.

Under the hood, a sandbox-based runtime mirrors how those applications actually run on Vercel. When you prompt v0 to add a feature, modify a view, or connect to a data source, it generates code directly into the repository context. The sandbox “understands” the project’s configuration and infrastructure, so generated changes align with how the app is really deployed.

Several workflow changes follow from this:

• Code lives where engineers already work. The output is stored in the GitHub repo rather than in a proprietary prototyping environment. Existing tooling around code review, CI, and monitoring can apply without special handling.
• VS Code in the interface. v0 now includes a full VS Code experience in the browser, allowing developers to hand-edit generated code, inspect files, and make manual adjustments without context-switching between tools.
• First-class git workflows. A built-in git panel lets any authorized team member create branches, open pull requests against the main branch, and deploy on merge. Pull requests are not an afterthought; previews map directly to real Vercel deployments rather than isolated demos.

The impact for non-engineering roles is substantial. Product managers and marketers no longer need local development setups or a handoff phase where engineers re-implement AI-generated snippets. They can work within v0 to propose changes that surface as standard pull requests, subject to the same review and deployment rules as any other change.

Vercel has also wired v0 into data sources via direct integrations with Snowflake and AWS databases. Instead of copying credentials into prompts or writing ad hoc connectors, teams can attach applications to production data with controlled access, defined through the same infrastructure that governs other services.

Occhino characterizes the outcome as moving collaboration to the product itself: “Teams end up collaborating on the product, not on PRDs and stuff.” The code remains visible, reviewable, and governed within the usual tools of record.

Why Vercel’s React and Next.js heritage matters for production readiness

Vercel’s claim is not only that v0 can write code into your repo, but that the code it writes is deployable on infrastructure that has already been battle-tested at large scale. The company’s history is central to this argument.

Occhino spent more than a decade as an engineer at Meta, helping to lead the development of React, the JavaScript framework that underpins much of today’s web. Vercel’s founder, Guillermo Rauch, created Next.js, a full-stack framework built on top of React that has become a popular choice in the current AI-assisted, “vibe coding” era.

Vercel operates what is effectively a managed, opinionated stack for React and Next.js applications, and it has codified many of those opinions into published React best practices tailored for AI agents and large language models. The rebuilt v0 sits on top of that same platform.

As a result, when v0 generates or modifies an app, it is targeting an environment with:

• Framework-defined infrastructure aligned with React/Next.js best practices
• Agentic workflow support and MCP (Model Context Protocol) integration
• Security layers such as a web application firewall, SSO, and deployment protections
• Cloud development environments that can open any project and push changes to preview or production in a click

Competing tools in the vibe coding category—such as Replit, Lovable, and Cursor—offer powerful editing and generation experiences. Vercel’s argument is that its differentiator is not primarily the in-editor experience but the underlying managed infrastructure, evolved over roughly a decade of running millions of deployments.

Occhino describes this evolution as moving from managed infrastructure to framework-defined infrastructure and now toward what Vercel calls “self-driving” infrastructure. v0’s integration with that stack is meant to ensure that AI-generated code is not fighting the environment it’s deployed into, but instead inherits established patterns.

The shadow IT problem: Why security depends on infrastructure, not memos

Most enterprises are already experiencing the side effects of AI-assisted development, even if they have not formally endorsed specific tools. When developers or domain experts use external AI coding services in an ad hoc way, three patterns tend to emerge:

• Credentials get pasted into prompts because there is no secure, sanctioned way to connect to enterprise databases.
• Apps and demos spin up on public infrastructure unrelated to official pipelines.
• Data flows into tools with no visibility or audit trail for IT or security teams.

Policy alone cannot address this. Even if organizations publish guidelines about what not to share with AI tools, the underlying platforms often lack the hooks to enforce those guidelines. As long as the tools run on separate infrastructure, IT faces a blunt choice: block them or tolerate a degree of unmanaged risk.

Vercel’s approach with v0 is to bring AI-assisted coding onto the same infrastructure that already governs production. Because v0 runs on Vercel’s platform and writes into sanctioned repositories, the same deployment protections, access controls, and visibility rules apply to AI-generated code as to any other change.

Direct integrations with Snowflake and AWS databases are part of this strategy. Instead of exposing raw credentials in prompt text, teams define controlled access via infrastructure configurations. The AI-generated app connects through those defined paths, inheriting existing restrictions and observability.

According to Occhino, this alignment is what makes IT teams more comfortable: they can manage who is allowed to build and what those applications can touch, instead of trying to police usage of disconnected tools. The goal is not to eliminate AI-powered development, but to ensure it happens where governance mechanisms already exist.

Generative UI vs. generative software: Where v0 fits

Alongside the new v0, Vercel has introduced another AI-centric technology: a framework called json-render. The two address related but distinct layers of the stack.

v0 is positioned as “generative software.” It builds and modifies full-stack applications and agents—structures that live in a codebase, go through version control, and are deployed through standard pipelines. Its output is code that teams own and maintain.

json-render, by contrast, is targeted at “generative UI.” Instead of having the AI write UI code, the framework lets AI generate JSON that directly drives the rendering layer at runtime. Vercel engineer Chris Tate describes it this way: the AI doesn’t write software; it connects into the rendering layer to produce on-demand, personalized interfaces.

For enterprises, the distinction maps to different use cases:

• Use v0 when you need complete applications, custom components, or production software that should live in a repository and evolve over time.
• Use json-render when you want dynamic, personalized UI elements inside existing apps—dashboards that adapt per user, contextual widgets, or interfaces that respond to changing data without code changes.

Both sit on top of Vercel’s AI SDK infrastructure for streaming and structured outputs. In effect, v0 shapes the long-lived code surface of an application, while json-render orchestrates real-time presentation for end users.

What enterprises have actually learned from vibe coding adoption

As organizations have experimented with vibe coding tools over the last two years, three consistent lessons have emerged around AI-generated code in production environments.

Lesson 1: Prototypes without a production path create false progress. Teams can quickly build compelling demos—something the early v0 supported well—but they then encounter friction when trying to integrate those demos into live systems. The core issue is less code quality and more environment disconnect: prototypes exist in isolated sandboxes that do not reflect production infrastructure.

Occhino points out that most real work is not net-new builds: “90% of what we need to do is make changes to an existing code base.” Tools that do not start from that reality risk generating artifacts that look impressive but do not move the production roadmap forward.

Lesson 2: The development lifecycle has changed, whether planned or not. Domain experts no longer just write product requirement documents and wait for implementation. They are using AI tools to modify applications directly. Product managers and marketers are shipping features without always going through traditional sprint cycles.

This shift doesn’t eliminate the need for governance; it changes where control has to be applied. Enterprises require ways to maintain code visibility, review, and compliance while still enabling non-engineers to contribute meaningful changes. Forcing all AI-generated work back into classic, engineer-only workflows tends to recreate bottlenecks and push people toward unsanctioned paths.

Lesson 3: Blocking tools doesn’t stop their use—it hides it. Attempts to outright ban vibe coding tools tend to drive usage underground. Staff turn to personal accounts or unmanaged services, expanding the very shadow IT surface organizations are trying to shrink.

The practical implication is to focus less on “if” employees will use AI to build software, and more on “where” that activity happens. Bringing AI-assisted development into governed infrastructure—with repositories, access controls, and deployment protections already in place—offers a more realistic way to manage risk while capturing productivity gains.

What engineering leaders should watch as v0 rolls out

For enterprise engineering leaders evaluating AI-assisted development tools, Vercel’s rebuilt v0 illustrates a set of design choices worth interrogating in any platform:

• Repository-first or sandbox-first? Does the tool operate directly in your existing repos, or does it require copying code and artifacts in and out of a separate environment?
• Alignment with current infrastructure. Can it deploy through the same pipelines and platforms that handle production today, with identical security controls and observability?
• Non-engineer contribution paths. How can product managers, marketers, or domain experts propose and ship changes while keeping code review, approvals, and audit trails intact?
• Data access model. Are database and API connections defined through infrastructure with controlled access, or improvised via credentials in prompts?
• Scope: UI vs. full-stack. Is the tool meant to control presentation only (generative UI), or to generate and modify the underlying software (generative software) that teams own?

v0’s new incarnation is Vercel’s answer to these questions: a repository-first, infrastructure-aligned tool that tries to bring AI-driven changes inside existing governance rather than around it. How well that approach works in practice will depend on how tightly it integrates with the particular stacks and processes of each enterprise.

What is clear from early adoption of vibe coding is that AI is already part of the software development lifecycle. The challenge for engineering leaders is not whether to allow it, but how to ensure it operates within the same boundaries that protect the rest of their systems. Vercel’s rebuilt v0 is one of the first major attempts to design an AI coding tool around that reality from the ground up.