How I AI: Guillermo Rauch (Vercel CEO) on how to vibe code to production with v0

In this episode of How I AI, Vercel CEO Guillermo Rauch demonstrates how v0 fits into branch, preview, pull-request, and review workflows for production software.

Guillermo gave us a behind-the-scenes look at how Vercel is using v0 internally. We walked through two very different workflows that together show the full range of the product. First, the Vercel team showed how they built and maintain Skills by Vercel, a viral hub for AI skills, using a git-based workflow directly inside v0. Then we switched gears into something much more playful: an AI-powered 3D chess game that pushed the platform into streaming, workflows, and custom debugging tools.

These aren't just polished demos. They point to a real shift in who gets to contribute to software. Designers, marketers, PMs, and operators can now move from idea to pull request without needing to become full-time engineers first. The important part is that the workflow still keeps the guardrails: branches, previews, reviews, rollback paths. That combination of speed and structure feels genuinely different.

shipping production features with v0 and Git

Build and Ship Production Features Using a Git-Based AI Workflow with v0: Use v0 as a production branch workspace: import the real repository, build a bounded feature with production constraints, iterate against the running app, and hand engineers a reviewable PR and preview.

The first workflow focused on something much harder than a greenfield demo: safely changing a live, high-traffic app. Guillermo walked through how the Vercel team iterates on skills.sh, which has over 34,000 community-submitted skills and hundreds more arriving every hour. At that scale, you need real engineering process, not just good prompts, and v0 now builds that workflow directly into the product.

branching directly in v0

The entire process starts with a familiar concept for any engineering team: creating a branch. Instead of using a terminal or a separate Git client, Guillermo showed how you can create a new branch directly from the v0 interface for an existing project. He even followed a common naming convention, g/root-g, which I loved seeing because it makes v0 feel like a true teammate in an established engineering culture.

Once the branch is created, v0 spins up a full development environment. You get a VS Code editor, a live preview of the app, and all the dependencies installed automatically. For less technical teammates, this removes one of the biggest barriers to contributing: no local setup, no homebrew installs, no dependency debugging rabbit holes.

prompting a new feature

With the branch ready, Guillermo started building. The team had heard consistent feedback that users needed a better way to judge quality across so many skills, so he prompted v0 to add a rating system. What stood out to me was that the prompt already included production concerns like abuse prevention and rate limiting, not just UI instructions.

"Let's add a five star based rating system for the skills. uh, put it on the sidebar. be mindful that, uh, we should rate limit or prevent abuse on the scores that we receive... and make it make sense within the style of this skills website."

v0 picked up the project context correctly. It recognized the app was already using Redis, generated a rating system that matched the existing "terminal core" aesthetic, and handled both the frontend and backend logic. It also incorporated the security considerations directly from the prompt instead of treating them like an afterthought.

iterating on the details

After the first pass, Guillermo noticed a tiny flicker during page load before the rating data arrived. That kind of layout shift is exactly the difference between a prototype and something production-ready. Instead of opening the code manually, he gave v0 one more natural-language instruction:

"Hey, when we don't have data, make sure there's no layout shift"

v0 fixed the issue by stabilizing the skeleton loader so the sidebar no longer jumped around during loading. The iteration loop here was the interesting part: spot a UI issue, describe it in plain language, immediately test the result.

creating a pull request

Once he was happy with the feature, Guillermo clicked a button in v0 to create a pull request on GitHub. v0 didn't just push the code. It also generated a detailed PR description explaining the changes, including UI updates and data-fetching logic. That alone removes a surprising amount of tedious work from the review process.

reviewing with preview deployments

As soon as the PR was created, Vercel automatically deployed the branch to its own preview URL. This is where the workflow started feeling very real to me. The team can test changes in a production-like environment before merging anything into main, and non-engineers can review the actual experience instead of reading code diffs. The result is a much tighter path from idea to shippable feature.

creative AI development with the v0 chess match

After all the production workflow demos, Guillermo showed us something completely different: an AI chess match he built over the holidays. My kids are obsessed with this one. You can try it yourself at v0-chess-match.app. Underneath the fun presentation is a surprisingly sophisticated example of building a complex interactive app from scratch with v0.

from idea to 3D render

Guillermo imagined an ESPN-style broadcast of a chess match between two AIs, complete with a 3D board. He was curious if v0 could handle it. He prompted v0 to generate 3D code using Three.js and was able to get a live, interactive chess match running where two AI models battle each other.

streaming AI "thoughts"

One of the most interesting parts of the project is that you can watch the models reason through their moves in real time. Guillermo used streaming to surface the thinking tokens as the AIs debated strategy and evaluated positions. It runs on the Vercel AI SDK and makes the game feel oddly alive while also exposing how the models approach decision-making.

It's a combination of all the Vercel AI infrastructure. It's using a workflow so the game could run forever. The game could literally run forever or until I run out of tokens.

building for durability

To keep the game running indefinitely, Guillermo used Vercel Workflows. If a provider goes down or a function times out, the system retries automatically instead of collapsing. That durability layer matters a lot once you move from toy agents to long-running applications, and it's one of the clearest examples in the episode of where human engineering judgment still matters.

debugging with AI

The most relatable part of the chess demo was the debugging process. Guillermo discovered that the 3D chess model had all the pieces fused into a single mesh, which made animation impossible. To untangle it, he first used other AI models to learn more about the 3D file structure, then asked v0 to generate a custom debugging tool directly inside the app so he could inspect meshes and textures visually. It was a very meta workflow: AI helping him debug code and assets generated with AI.

Two modes of building

The skills.sh demonstration showed a branch, a generated change, a pull request, and a preview deployment. The chess project showed exploratory 3D work, streaming model output, durable workflows, and a custom visual debugger.

Build a Complex Interactive 3D Application with an AI-Powered Debugging Loop: Build and debug an ambitious 3D AI application by combining v0's code generation with streaming model output, durable execution, outside technical research, and custom visual diagnostics inside the app.

Both examples reduce the distance between an idea and something a team can inspect. They do not remove code review, validation, access controls, or rollout decisions.

The branch, preview, and review loop is the reusable part: isolate the change, test the running result, and give the team a clear artifact to approve before merging.