Let’s admit it: you typed the prompt, waited forty seconds, and a dark-themed admin dashboard appeared. Charts in place, margins tidy, even the “no records yet” screen thought through. For a moment you felt like a genius. That feeling lasts about five minutes. In the sixth minute the question arrives – “so how do I get this into my own project?” – and the kitchen door creaks open.
In Chapter 3.1 (in Turkish) we moved the agent inside the editor and talked about multi-file edits, and I said the next step would be Mega-Prompting and .cursorrules. The handbook puts this chapter in between, and it is right to. Before we write a constitution for the agent – that is Chapters 4.1 and 4.2 – we need to know what is actually on the first plate the agent puts in front of us.
Because v0 and Bolt.new work exactly like the ready-meal aisle. Five minutes and you have a hot plate. Carry that plate into your own kitchen and the story changes. So let’s look at what these two tools really do, what they do not do, and the five things to check before a prototype enters your project.
Same Aisle, Two Very Different Plates
Both promise “describe it, run it”. But one builds the shop window while the other moves the entire kitchen into your browser. Pick without knowing the difference and you are working with the wrong tool.
v0: The Window Dresser
Vercel’s tool generates code inside a specific world: according to the official docs, Next.js, React, Tailwind CSS and shadcn/ui, plus Python, Pandas and Matplotlib on the data side. Design Mode lets you fix the generated interface by hand instead of by prompt, and you can deploy straight to Vercel and sync with GitHub.
Technical detail: v0 bills tokens, not messages. As Vercel explained in its announcement of 13 May 2025, input and output tokens convert into credits. The current pricing page lists a free plan with $5 of monthly credits and 7 messages per day, Plus at $30 per user per month ($30 in credits plus $2 of free credit daily), and Business at $100 per user per month.
The uncomfortable part: your prompt length is not the only thing burning credits. Chat history and any source files you attach go into the context too. The longer a single conversation runs, the more every new message costs. A clean new session is cheaper than a long argument.
Bolt.new: The Kitchen in Your Browser
Bolt.new pulls a different trick: using StackBlitz’s WebContainer technology it runs Node.js directly inside your browser. npm install really runs, the dev server really starts, the terminal is a real terminal. No server, no setup, no “but it worked on my machine”.
Technical detail: the price of that trick is a dependency on two browser features, SharedArrayBuffer and cross-origin isolation. The WebContainer documentation gives full support to Chromium-based browsers (Chrome, Brave, Edge), with Firefox and Safari 16.4 TP at beta level. The credentialless isolation mode that Chromium offers is missing in Firefox and Safari, and that is precisely the mode you need to test your own app inside the preview window.
The hidden treasure: the integration list is unusually serious for a prototyping tool. Supabase brings a hosted database, authentication and edge functions, and there are Netlify, GitHub, Stripe, Expo, Figma and MCP servers on top. On price, the free plan allows 300K tokens a day and 1M a month; Pro is $25 a month for 10M tokens with no daily cap. Since 1 July 2025, unused tokens on paid plans roll over for one extra month.
| Question | v0 | Bolt.new |
|---|---|---|
| Main job | Interfaces and components | Full-stack project in the browser |
| Default stack | Next.js, React, Tailwind, shadcn/ui | Anything Node.js based |
| Where it runs | Vercel infrastructure | WebContainer in the browser |
| Free limit | $5 credits monthly, 7 messages a day | 300K tokens daily, 1M monthly |
| First paid tier | Plus, $30 / user / month | Pro, $25 / month |
| Pick it when | You need to see and discuss a screen | You need to try a flow end to end |
A Five-Minute Plate, a Five-Week Kitchen
The speed of the prototype is not a lie. The lie is that the speed transfers to production. The gap comes down to four things.
Read the label before you eat
Underneath a v0 interface sits shadcn/ui, and shadcn/ui is not an npm dependency: the component source is copied straight into your project. Good for control, but here is what it means for maintenance – the generated code is now your code. When a bug shows up, npm update will not save you; you have to open the file and read it. Reading it is exactly what nobody does at the prototype stage.
Check the expiry date
Which versions did the generated project ship with? package.json is the first place to look. The current Next.js release is 16.3.5 (11 September 2026), and security support for Next.js 15 ends on 21 October 2026. If what landed in your lap was scaffolded on 15, you are starting day one with an upgrade already owed. Ignoring the date on a ready meal is the one mistake no kitchen forgives.
No gas ring in a browser kitchen
WebContainer’s boundary is explicit: only languages the web supports natively will run, meaning JavaScript and WebAssembly. Native addons are disabled by default via --no-addons, so a module written in C++ will not load. You cannot install your own service worker either, because WebContainer already uses one for its networking layer. Keep several projects open at once and the browser runs out of memory:
WebAssembly.instantiate(): Out of memory: wasm memorySo image processing, a native crypto library, a headless browser or any Docker step simply will not cook in this kitchen. Do not read “the prototype runs” as “the architecture holds”. What holds is the absence of your real dependencies.
Touch the schema and there is no way back
In Chapter 2.2 we called the schema sacred. Bolt gives that a very concrete meaning: its version history does not restore a Supabase database. Roll the project back to an earlier version and the code returns, the database stays exactly where it was. At prototype stage that is a footnote. The day customer data arrives, it stops being one.
Five Checks Before the Prototype Enters Your Kitchen
You have downloaded the generated project and you are about to move it into your own repo. Before that single npm install, run these five commands. Ten minutes now, a week saved later.
# 1. How old is the stack it shipped with?
npm ls next react tailwindcss --depth=0
# 2. Native dependencies that never cooked in a browser kitchen
npm ls --all --parseable 2>/dev/null | grep -Ei 'sharp|bcrypt|canvas|puppeteer|playwright'
# 3. Known vulnerabilities in what the prototype dragged in
npm audit --omit=dev
# 4. Any key leaking into the client bundle?
grep -rn "NEXT_PUBLIC_.*\(KEY\|SECRET\|TOKEN\)" app components lib 2>/dev/null
# 5. How many lines are you actually taking over?
find app components lib \( -name '*.ts' -o -name '*.tsx' \) | xargs wc -l | tail -1The fourth command produces the most surprises. The NEXT_PUBLIC_ prefix bakes that variable into the client bundle, and a service key dropped there to make the prototype work goes live without anyone noticing. The fifth keeps you honest: the “couple of screens” you thought you were adopting usually arrives with a four-digit line count, and every one of those lines is now yours.
Who Takes Over Once the Prototype Is Done?
Once the window is dressed, the prototype tool stops being the one doing the work. Splitting, growing and testing the code that lands in your repo belongs to a different category: terminal agents and agent-first platforms. Anthropic s Claude Code and OpenAI s Codex both sit here, and for both of them the unit of work is a task, not an open file. Ask either one to rewrite a form and add its tests and it reads the repository, not the tab you happen to have in front of you. Google s Antigravity does the same job by running several local agents in parallel, and it is offered to developers at no charge. If the code must never leave your machine, Cline, Aider or OpenCode will point the same workflow at a local model, which is where Chapter 3.3 picks up.
The line I draw is this: the prototype tool dresses the window, an agent runs the kitchen. You do not need a second tool to argue about the screen v0 produced. But the moment that screen is headed for production, the thing writing the migration, the tests and the restructuring is not your editor s autocomplete; it is an agent that takes a task. The full category comparison is in Chapter 3.1.
The Window Is Pretty, the Bill Comes from the Kitchen
None of this is written to belittle these tools. Discussing a screen in v0 beats three days of going in circles in Figma. Trying a flow end to end in Bolt.new is more convincing than describing it in a meeting. The right use is this: a prototype is a decision tool, not a deliverable. You see the screen, you pick a direction, and then you cook that direction in your own kitchen to your own standards.
Enjoy the plate that arrives in five minutes. Just read the label, check the date, and know whether your kitchen can handle that dish. A Vibe Coder is fast not because they like fast food, but because they know where every plate came from.
In the next chapter (3.3) we go off the cloud entirely: local models with Qwen-Coder and Llama, and what they cost in privacy, latency and GPU bills.
Stay with the tech, and code with responsibility rather than prompts.