Bolt.new

Overview

Bolt.new is StackBlitz's browser-based AI app builder — a WebContainer-powered environment where you type "build me a Next.js app with auth and Stripe checkout" into a prompt box and watch a working codebase materialize in real time, running in your browser without you installing anything. It launched in October 2024 as a repositioning of StackBlitz's technical bet (WebContainers — Node.js running in-browser via WebAssembly), went viral on the strength of its first-prompt-to-deployed-app demo, and by 2026 is one of the anchor tools in the "AI does the whole thing" category alongside Lovable, v0, and Replit Agent.

The one-line positioning: Bolt.new is what happens when you take a real Node.js runtime, put it in a browser tab, and hand the keys to an AI agent that can install packages, run migrations, and hit npm run dev on your behalf. No local setup. No git clone. No "does this work on Windows?" No stubbed sandbox pretending to be a real environment. What you see running in the preview pane is the actual code, actually executing, and you can pull the whole thing down as a real project any time you want.

Under the hood, Bolt.new runs Claude Sonnet 4.5 as its default model (with GPT-5 available on paid tiers), executes generated code inside StackBlitz's WebContainer, and one-click-deploys to Netlify. The stack it produces is opinionated — Vite, React, TypeScript, Tailwind, sometimes Next.js — and the app scaffolding it generates is closer to production-ready than most of the "prompt to app" competition. Real environment variables. Real database connections (Supabase is the default). Real deploy pipeline.

Bolt.new's audience is unambiguous: founders and PMs who want to see their idea running as a real app before writing a spec, designers who want prototypes stakeholders can actually click through, and developers who use it as a scaffolding tool to skip the boring first two hours of any new project. It is not where senior engineers do their day-to-day work — that seat is Cursor or Claude Code — but as the "0 to running app in 30 seconds" tool, Bolt.new is the tool most likely to earn its $20/month invoice the first time you show a working prototype in a meeting.

Key Features

Bolt.new's features cluster around a coherent premise: an AI agent should be able to bring up an entire working app in a real runtime environment inside your browser, no local setup required.

• Full-stack app generation from a single prompt. Type "build a task app with drag-and-drop and Supabase auth" and Bolt scaffolds the whole thing — components, routing, database schema, auth flow, styling — in a working state you can immediately click through.
• WebContainer runtime. The killer technical bet. Real Node.js running in your browser via WebAssembly, meaning npm install, npm run dev, and every real command actually work — not simulated, not sandboxed to a subset, actually running.
• Live preview with hot reload. Every edit the AI makes updates the running app in the preview pane in real time. You can see the app change as the agent works, and you can interact with it while the agent is still typing.
• One-click deploy to Netlify. From a Bolt project to a live URL is a single button. No CLI, no config, no build setup — the whole pipeline is wired for you.
• Supabase integration. Databases, auth, and file storage are provisioned through Supabase's Bolt integration. Ask the AI to add auth and it wires up email/password, magic links, and RLS policies without you touching the Supabase dashboard.
• Stripe integration. Payment flows are a first-class concern. Ask Bolt to add "checkout for a $10 product" and it generates the Stripe integration, webhook handlers, and success/cancel pages.
• Full project download. Every Bolt project can be downloaded as a ZIP — real code, real package.json, real everything — and taken to Cursor, VS Code, or wherever you actually ship from.
• GitHub push. For teams that want to move a Bolt prototype into their real repo, push-to-GitHub is one click.
• Discussion and iteration. After the first generation, keep iterating. "Add a dark mode toggle." "Make the landing page use the Vercel-style hero section." Each turn edits the running app in place.
• Token-based usage model. All Bolt tiers use a monthly token allowance. Simpler apps burn few tokens; complex apps or long iterative sessions burn many. The pricing works out well for hobby use and gets expensive at intense professional use — a fact worth knowing before committing.

Pricing

Bolt.new is freemium with token-based paid tiers scaling into what StackBlitz calls "prosumer" ranges:

Plan	Price	What you get
Free	$0	1M tokens/month, public projects, community support
Pro	$20/month	10M tokens, private projects, priority in queue
Pro 50	$50/month	26M tokens, private projects, priority processing
Pro 100	$100/month	55M tokens, private projects, priority processing
Pro 200	$200/month	120M tokens, private projects, priority processing
Teams	$30/user/month	Teams features, shared projects, admin controls
Enterprise	Custom	SSO, dedicated support, custom token allocations

The Free tier is enough to build one or two small apps and feel out whether the flow clicks — a single working prototype is achievable, but you'll hit the ceiling before shipping anything real. Pro at $20 is the tier most individual users start on and where the value case is easiest to make: 10M tokens is roughly ten to twenty full app builds per month depending on iteration depth, which is generally enough for a founder or PM building prototypes and pitching.

Pro 50, 100, and 200 exist because serious users blow through 10M tokens fast — a single complex app with 30 rounds of iteration can consume 5M tokens by itself. Heavy users tend to end up on Pro 50 or Pro 100; the Pro 200 tier is aimed at agencies and product studios building client work. Teams at $30/seat is a team-management wrapper on top; Enterprise is a custom conversation. The token model is honest but front-loads the cost surprise — worth budgeting for.

Pros and Cons

Pros

• WebContainer runtime is a genuine technical differentiator — real Node.js in the browser, not a stub
• First-prompt-to-working-app is the fastest in the category for full-stack applications
• Live preview with hot reload turns the "did it work?" question into an immediate answer
• Supabase and Stripe integrations are wired up rather than hand-waved
• One-click Netlify deploy makes it trivial to share a working demo with stakeholders
• Full project download means you can eject to Cursor or VS Code any time
• Backed by StackBlitz, whose WebContainer tech is genuinely hard to replicate

Cons

• Token pricing gets expensive fast on iterative work — a serious founder will end up on $50 or $100 tier quickly
• The generated code quality is good for prototypes but requires meaningful cleanup for production
• Limited to the JavaScript/TypeScript ecosystem; Python, Go, Rust, and other backend stacks are effectively out of scope
• Struggles on very large apps once the codebase exceeds what fits in a single agent-window context
• No local runtime equivalent — everything runs in the browser tab, which occasionally chokes on complex apps
• Debug loop still requires developer intuition; non-technical users hit walls when the app breaks in non-obvious ways

Best Use Cases

• Founders validating an idea before writing a spec. Type the pitch, get a clickable prototype in a meeting. This is where Bolt.new is unquestionably the fastest tool in the category.
• Product managers prototyping for engineering handoff. A working Bolt prototype communicates intent better than any Figma flow, and engineers can eject the code as a starting point.
• Designers who want stakeholder demos beyond static mockups. Real interactivity, real state, real hover effects, real everything — without a dev in the loop.
• Developers scaffolding the first hour of a new project. Skip the setup, dependencies, boilerplate, and initial routing decisions. Eject to Cursor for the real work.
• Hackathon teams shipping on a deadline. From idea to deployed app in an hour is the sweet spot — Bolt.new plus Supabase plus Netlify is a genuinely fast stack for time-constrained builds.

Alternatives

Bolt.new competes with a handful of tools spanning "prompt to app" and traditional AI coding:

• Lovable — the closest direct competitor. Similar positioning, similar prompt-to-app flow, different opinions on the generated stack (React + Supabase focus, higher-touch UI polish out of the gate).
• Emergent — the "full stack from a prompt, including backend logic" pick. Bolt is faster to first-preview; Emergent tends to produce more architecturally-sound outputs on complex apps.
• Replit Agent — browser-based like Bolt but with a broader language footprint and a slightly different iteration model. Worth trying if you want Python or Go in the mix.
• v0 by Vercel — component and page generation rather than full-app generation. Better for embedding into an existing project than starting fresh.
• Cursor — not a direct competitor. Once a Bolt prototype grows past the "clickable demo" stage, you eject to Cursor for real development.
• Claude Code — the terminal-first alternative for developers who want the AI to build a full app but prefer to stay in a real dev environment.

For the head-to-head across mainstream AI coding tools, read Cursor vs Claude Code vs GitHub Copilot: The Solo Developer Stack 2026.

Getting Started

1. Go to bolt.new. No signup required to try — you can type a prompt on the landing page and watch a project scaffold immediately.
2. Sign up to save your work. Free tier is enough for one or two real prototypes. GitHub, Google, or email — takes ten seconds.
3. Type a real idea, not a toy one. "Build a landing page" is too vague and will produce a generic result. "Build a Next.js landing page for a task management app called Beacon, with a hero, three-column feature grid, testimonial section, and Supabase-backed email signup form" is the kind of prompt that shows what the tool actually does.
4. Iterate in chat. Once the first version is running, treat the chat as a code review — "make the hero image full-bleed," "add a footer with social links," "wire up the signup to actually save to Supabase." Each turn edits the running app.
5. Deploy or eject. One-click deploy to Netlify for a shareable URL, or download the project as a ZIP to move it into Cursor for serious work.

Skip Pro until you've felt the Free tier ceiling — you'll know when it's time.

FAQ

Does Bolt.new produce real code or a sandbox? Real code. The project is a genuine Node.js app running in a WebContainer (Node.js compiled to WebAssembly running in your browser). You can download the ZIP, run it locally, and it will behave exactly the same way.

How does token pricing work? Every action — generation, edit, chat turn — consumes tokens from your monthly allowance. A simple app might use 200K tokens end-to-end; a complex iterative build can use 5M or more. Serious users tend to end up on Pro 50 or higher.

Can I use a stack other than React/Next.js? Vue, Svelte, Astro, and other JavaScript frameworks work but are less optimized. Non-JS backends (Python, Go, Rust) are effectively out of scope — Bolt is built around the JS ecosystem.

Is the generated code production-ready? For prototypes and MVPs, yes. For production apps at scale, expect to do meaningful cleanup — refactor components, tighten types, add tests, review security. Bolt is a starting point, not a finishing tool.

How does Bolt.new compare to Lovable? Both are prompt-to-app tools with similar workflows. Bolt is slightly faster on initial generation and better on the runtime story (WebContainer). Lovable tends to produce higher-fidelity UI on the first pass and is more opinionated about design. Try both — they diverge more than they overlap.

Verdict

Bolt.new is the AI app builder for anyone who needs to see an idea running as a real app in under two minutes. The WebContainer runtime is a genuine technical bet that pays off — you get a real environment, not a simulation. The prompt-to-working-app loop is the fastest in the category, the Supabase and Stripe integrations are wired for real use, and the ability to eject to a real project any time removes the "will I be locked in?" worry that kills adoption of other tools in the space.

Where Bolt.new stops being the right pick is on production work. Once your app grows past prototype scale, the token pricing gets expensive fast, the generated code needs cleanup, and the AI's ability to reason across a large codebase falls off. Real engineering work on real products still belongs in Cursor or Claude Code, not in a browser tab.

The honest recommendation: use Bolt.new for the first two hours of every new project, then eject. Free tier is enough to feel it out; Pro at $20 is the tier most individual users end up on for regular prototyping. Skip Pro 50 and above unless you're doing serious agency-style work where the token throughput actually pays off. For real product development, pair Bolt's prototyping with Cursor for the daily editor and Claude Code for autonomous long-horizon work.

Explore more in the Coding category, or read the full solo-dev stack comparison before committing a paid subscription.