CHAPTERS
- 0:00 – 2:59
v0 adoption: users, deployments, and the “personal software” moment
Tom shares the scale and growth of v0, emphasizing that it’s being used not just for prototypes but for real deployed apps. He frames v0 as a catalyst for “personal software,” enabling non-engineers to build useful tools quickly.
- •~2M people have used v0 since launch; growth is accelerating
- •2.5M+ deployments to Vercel originated from v0
- •v0 is used by non-technical users, not just engineers
- •Focus is on customer value and Tom’s own daily use cases
- 2:59 – 4:23
Live build #1: prompting a “better LinkedIn newsfeed” (and using prompt enhancement)
Aakash asks for a better LinkedIn feed; Tom demonstrates starting from a rough prompt and letting v0 enhance it into a plan-like spec. They watch v0 generate a multi-file app with components and mock data, showing how quickly it expands a vague request into something substantial.
- •Using prompt enhancement to turn a weak idea into a structured plan
- •v0 generates a project structure, components, and mock content
- •The “plan/thinking” view functions like a lightweight PRD
- •Demonstrates rapid iteration without providing a screenshot
- 4:23 – 8:19
Live build #2: screenshot-to-UI clone with Apollo-style customization
Tom switches to a screenshot-driven workflow using Aakash’s Apollo.io homepage as reference. They prompt v0 to keep the design language while re-prioritizing the content around upcoming meetings, then iterate to better replicate navigation and styling.
- •Screenshot prompting for high-fidelity design replication
- •Customizing homepage modules based on which product a user uses
- •Iterating on UI details like the nav to match the source app
- •Discussion of doing changes atomically vs bundling multiple changes
- 8:19 – 11:58
Under the hood: multiple models, “online model,” and making code runnable
Aakash asks about model selection and how v0 compares to tools that expose model choices. Tom explains v0’s approach: hide complexity, route users through a “happy path,” and apply post-processing since raw LLM code often doesn’t run out of the box.
- •v0 uses multiple underlying models depending on the task
- •v0 adds a layer of iteration/fixes on top of LLM outputs
- •Goal is to avoid exposing sophistication; prioritize UX simplicity
- •Reality check: much LLM code still needs cleanup to run reliably
- 11:58 – 13:08
Debugging & iteration: exploring the generated app and “Fix with v0”
They return to the LinkedIn-style app, click through routes, and encounter runtime issues. Tom demonstrates an interactive build loop: explore the UI, hit an error, and ask v0 to implement missing routes or fix problems.
- •Generated app includes feed, notifications, composer, images, routes
- •Runtime errors become prompts: v0 diagnoses and implements missing pages
- •Interactive exploration guides what to build next
- •“Fix with v0” replaces manual searching and debugging workflows
- 13:08 – 14:04
Marketplace integrations: databases and AI providers in a couple clicks
Tom introduces v0 integrations from the Vercel Marketplace and describes the “out-of-the-box” setup experience. He highlights the ability to add databases and AI providers without heavy manual configuration, setting the stage for building real apps (not just UI prototypes).
- •Integrations are designed to be seamless: minimal setup friction
- •Support includes databases (e.g., Neon) and AI providers (e.g., Groq)
- •Goal: help users go from prototype to real, connected applications
- •Marketplace model expands capabilities without users wiring everything manually
- 14:04 – 15:40
Adding an AI post composer (Groq) and handling API key/runtime issues
They attempt to add a Groq-powered AI assist feature inside the LinkedIn-style composer flow. The demo hits typical real-world problems—invalid API keys, module exports, missing assets—leading to discussion of environment variables and using restore/versioning to recover from bad states.
- •Designing an AI assist interaction inside “Start a post” flow
- •Common integration failures: invalid API key, runtime/module issues
- •Environment variables configured via project settings
- •Restore/versioning workflow enables quick rollback to prior states
- 15:40 – 17:12
Tom’s personal v0 builds: changelog/filter tool, one-shot sneaker store, neighborhood button
Tom shares examples of personal software he’s built and actually uses, illustrating the “small prompts → real utility” promise. He demos a feed-driven internal tool, describes a one-shot e-commerce store with real-time filtering, and a simple location/neighborhood app his wife uses regularly.
- •Personal tooling: Atom feed reader + filters for blog/changelog analysis
- •One-shot e-commerce demo with real-time filtering as a ‘wow’ moment
- •Simple “what neighborhood am I in?” app deployed and used weekly
- •Theme: tailored software built to exact personal specs
- 17:12 – 22:27
From v0 to production workflow: export to IDE, Git-like iteration, and deployment scale
They discuss how teams move from v0 prototypes into real engineering workflows (Cursor/Windsurf/editors) and how v0 fits alongside Git and collaboration. Tom argues deployments are “real software” backed by Vercel infrastructure and can scale massively; choosing browser vs IDE depends on the builder.
- •Exporting v0-generated code into any editor for deeper work
- •Vision: seamless back-and-forth with atomic changes like commits/PRs
- •Non-devs may stay in-browser longer; devs may ‘eject’ earlier
- •Vercel-managed deployments can scale to very large traffic
- 22:27 – 27:22
Database + deployment closure: Neon meetings table, mock data, and live deploys
They return to the Apollo-style meetings app and wire it to Neon, generating schema and mock data for the next month. They test meeting creation, note missing screens, then deploy apps (including the sneaker store) publicly—demonstrating the full loop from UI to data to internet-accessible app.
- •Neon integration creates tables and populates mock data
- •App updated to fetch and display meetings from the database
- •Manual env var step (NEON_DATABASE_URL) highlighted as a friction point
- •Deploying produces a live, public URL; projects inherit Vercel capabilities
- 27:22 – 32:06
Team and org: v0’s lean crew, pillars of work, and leverage from Vercel foundations
Tom outlines how a small v0 team is structured and why it can move fast by building on Vercel’s existing systems (accounts, marketplace, deployments). He describes three pillars—model/research, core chat UX, and admin/billing/project settings—plus broader Vercel org size and leverage.
- •v0 team is <14 people across eng/product/design
- •Three pillars: model/research, core chat experience, periphery/admin
- •Vercel overall EPD around ~200
- •v0 benefits from existing Vercel infra: marketplace + deployments + accounts
- 32:06 – 34:14
Who is the “developer” now? Internal demo days and dev-adjacent builders
Tom explains how the definition of developer is expanding to anyone who wants to build. He shares how internal demo days evolved from engineers to designers/PMs to sales and other functions demoing real applications, like interactive TCO tools replacing spreadsheets.
- •Developer identity widening: builders beyond traditional engineers
- •Demo days now include PMs, designers, AEs, internal comms
- •Example: AE replaces spreadsheet with interactive app for prospects
- •v0 enables one-time-use, high-impact internal/external tools
- 34:14 – 43:44
Competition, React as substrate, and why frameworks are becoming implementation details
Aakash asks about competitors; Tom says he focuses on customers, not catching up feature-for-feature. They discuss React’s ubiquity in generated code and why LLMs default to it, plus a broader view that frameworks matter less as AI enables progressive disclosure and faster iteration.
- •Competitive stance: prioritize customer value over reacting to rivals
- •React appears often because training data includes abundant React code
- •v0 can generate other frameworks (e.g., SvelteKit) when asked
- •As AI lowers barriers, frameworks become more of an implementation detail
- 43:44 – 48:37
Vercel’s product operating system: product areas, frequent reviews, and lightweight planning
Tom details how Vercel organizes into product areas with cross-functional leads owning roadmaps. Planning is fluid: formal resets every ~6 months but frequent check-ins multiple times a week; they use Notion for planning and Linear for execution, and deliberately avoid heavy OKR overhead.
- •Org structure: 12–15 product areas with cross-functional leads teams
- •Review cadence: kickoff, execution check-ins, and pre-ship reviews weekly
- •Tooling: Notion → Linear; strong ‘Slack ops’ connective tissue
- •No formal OKRs; “lowercase-a agile” to avoid process drag
- 48:37 – 55:43
How v0 team uses v0 + the integrations feature story (demo-first, PRD optional)
Tom explains how the v0 team dogfoods and also uses v0 to generate individual UI pieces that get imported into the main app. He then shares how integrations were built: prototype the flow in v0, sequence features based on strategic value, and rely on demos/Looms rather than a traditional PRD.
- •Dogfooding plus targeted component generation for the main v0 codebase
- •Company-wide usage extends to slide decks and other non-app outputs
- •Integrations prioritized via ranked strategic feature list and demos
- •Integrations shipped with little/no PRD—mostly demos, Looms, discussions
- 55:43 – 1:15:15
AI-first product development: advice for slower companies, licensing, and the future of roles
Tom urges leaders to start tinkering because AI will become part of the fabric of products (not a separate ‘AI button’ roadmap). He gives pragmatic advice on starting small with seats for PMs/designers, building internal conviction via demos, and predicts hybrid roles (design engineer, PM engineer) as AI removes ‘job tax.’
- •AI will shift from bolt-on feature to embedded fabric of product work
- •Start small: a few seats, experiments, and internal demos to justify value
- •Iteration speed increases; strategy/ownership becomes even more critical
- •Future roles: more hybrid skill sets; AI complements what individuals lack
