Home / Blog

From Frameworks to Agents: Building the Generative Web on Vercel

What v0, agentic DX, and self-driving infrastructure mean for the next wave of builders

8/10/2025by Diego de Miguel

6 min read

Unlike typical interviews that begin with personal backstories, this conversation dives directly into the technical frontier. Sequoia Capital's Training Data podcast, hosted by Sequoia partners Sonya Huang, Pat Grady (among others), provides a focused platform for deep discussions with AI innovators. In this episode featuring Guillermo Rauch, CEO of Vercel, the conversation explores how generative AI is fundamentally transforming software creation — from leveraging ChatGPT as a customer acquisition tool to Rauch's vision of a "generative web" that empowers anyone with a keyboard to build.

Here are some key insights from the conversation:

From frameworks to agents

Frameworks were pits of success: guardrails for humans. Next.js made it trivial to go from file to route, to stream data, and to deploy globally without learning the guts of a CDN. But frameworks assume a human at the keyboard. Agents flip the interface: your first user isn't always a developer—it's an LLM that speaks for your developer, designer, or marketer. That changes how we design APIs and runtime constraints. More explicit, deterministic, and documented often beats "short," because it helps models produce the right call the first time.

v0 made this tangible. It's text-to-front-end, but under the hood it behaves like an opinionated teammate. It encodes years of taste from Next.js and the Vercel platform: where to stream, what to render on the server, how to manage state, and how to keep secrets server-side by default. That encoded taste matters when the model is doing the typing. Little things—like matching Safari's theme bar color to your page background—sound trivial, but they compound into perceived quality. We used to rely on documentation or linters to nudge builders toward these patterns. Now we teach the agent once and let it apply the pattern for millions.

Reliability is the new DX

We've always obsessed over DX because it correlates with business outcomes: faster iteration, fewer defects, and happier users. AI products added something we've wanted for decades—tight, intrinsic metrics. Copilot had acceptance rate. v0 has render and deploy success rates, post-deploy engagement, and a simple binary: did the generation work? Those feedback loops let us tune reliability the way we used to tune bundle size.

Reliability isn't just uptime. It's secure by construction, fast by default, and repairable when reality breaks. LLMs are astonishing, but they will happily ship a client-side fetch with a database secret if you let them. v0 blocks that class of mistake thousands of times a day and routes sensitive logic to the server where it belongs. The same goes for performance. The web is a generator, not a pure function—you perceive it over time. That demands models that know when to stream, which parts to cache, and how to keep the main thread unblocked so the UI stays crisp on jittery networks and tired phones.

The generative web: from static to agentic

Static got us reliability. Dynamic got us personalization. Generative gets us both—if we treat tokens as a streaming resource and the edge as a first-class runtime. Vercel's fluid compute was built to stream database-backed pages; streaming LLM responses isn't that different. You still care about first byte, about interleaving shell UI and content, and about handling partial results gracefully. The difference is the source: sometimes your data comes from a model, not a table.

Caching doesn't go away; it changes shape. You cache scaffolds, not sentences. You stabilize prompts, version behaviors, and memoize expensive subcomputations so users don't pay the same token tax on every click. And you make your site legible to agents. The web used to be for humans with browsers; now it's for humans with assistants. Protocols like llms.txt are the beginning—simple, static signals that announce how to talk to you. MCP pushes further: agents can expose capabilities and call each other over well-defined channels. That's what an agentic platform looks like: not a single UI, but a contract for collaboration.

For end users, this will feel like speed. You won't download heavyweight clients. You'll visit a URL and the app will be generated for you—layout, data, and hints tuned to your task. For builders, it means accepting that many of your users never see your marketing site. They ask an assistant how to deploy a React app and get "Use Vercel" in response. That flips marketing. You still write for people, but you also write for models. Short, crisp answers map to the questions agents ask. Longform still matters, but you'll see outsized returns on content that looks like an internal playbook: how to pick a runtime, how to stream responses, how to handle secrets and auth when the agent—not a human—makes the call.

Shipping advantage: how teams win now

This all sounds heady until you try it and feel the loop collapse. A founder used v0 to build a Series B demo—the prototype replaced the deck. That isn't a parlor trick; it's the new baseline. You'll still need product taste and constraints, but the distance from idea to online is now measured in prompts, not sprints. That's why ChatGPT has become an unexpected lead gen channel for Vercel. When assistants synthesize the internet's consensus on "best way to deploy Next.js," they keep landing on the same answer. We shipped docs and code that models learned to trust, then exposed a playground that compares model outputs side-by-side so we can tune to those vibes.

If you're leading a team, point that energy where it compounds. Make your platform agent-friendly: explicit APIs, deterministic responses, and error messages that a model can act on without guessing. Put evals in the loop. Treat generation as a testable surface—write checks for "does it render," "is it fast," "did we leak secrets," and "does the UI feel right on an old iPhone." Instrument your critical paths—sign-up, sign-in, buy, deploy—and let an agent click through them constantly. When something breaks, have the agent file the issue with reproduction steps and a patch. When it's safe, let it merge.

Adopt LLM-first distribution. Keep writing for people, but add the pieces assistants pick up: structured answers, crisp how-tos, and pages that load fast in a headless fetch. If you're building a new product, start in v0 to find the feel, eject to your editor when needed, then ship on Vercel with streaming turned on and observability wired in. The final mile is where taste lives. You'll still make calls about spacing, motion, and rhythm. The difference is you can now spend your time on what your users feel rather than what your servers do. The agent will keep the lights on; your job is to make the room worth entering.

Useful Links

• Training Data interview on Sequoia's site — Vercel CEO Guillermo Rauch: Building the Generative Web with AI.
• Watch the full interview — vercel-insights-hub.com/video/YoxeOS60qBc.
• About the author — Diego de Miguel (Solutions Engineer at Vercel) — LinkedIn | @DiegodeMiguel87
• Sonya Huang — @sonyatweetybird
• Pat Grady — @gradypb
• Sequoia — @Sequoia