Bolt.new - VS Code in Your Browser That Actually Runs Code

I've used GitHub Copilot for two years. It's great at autocomplete but terrible when you actually need to run the code. Same with v0 - beautiful components that don't connect to databases or install packages.

Bolt.new is different. It actually executes the code it writes.

The Problem with Other AI Tools

Here's what happens with Copilot:

1. AI suggests a React component
2. Copy-paste into your editor
3. TypeScript errors because wrong imports
4. Spend hours fixing dependencies
5. Works on your machine, breaks everywhere else

v0 generates pretty React components but no backend logic, no databases, no additional packages. Basically fancy HTML.

What Bolt.new Actually Does

Bolt.new runs on WebContainers - basically Node.js compiled to WebAssembly that runs in your browser. When the AI says "let me install Express", it actually runs npm install express and it works.

No permission errors. No Docker containers. No local setup. Just works in the browser.

Last week I asked it to build a todo app with authentication. Here's what it did:

• Installed Next.js, TypeScript, Tailwind
• Set up Supabase auth with row-level security
• Generated API routes
• Started dev server
• Deployed to production

Took maybe 10 minutes. No dependencies on my machine.

Real Development Environment

The AI has access to everything you'd expect in a real dev environment:

• npm registry (install any package)
• Terminal with bash commands
• File system operations
• Network requests to external APIs
• Database connections via Prisma, Drizzle, etc.
• Git operations

I watched it debug a CORS issue by reading the error, installing the right middleware, and fixing it. Copilot would just suggest fixes you'd have to implement yourself.

The Cost Reality

It's expensive. Starts at $20/month but you'll burn through tokens fast. I hit my daily limit building an auth app with database connections. Budget at least $50/month if you're building real projects.

Worth it though. Beats spending 4 hours setting up Docker and fighting dependency conflicts. The GitHub repo has over 15k stars so I'm not alone in thinking this.

The WebContainers Magic That Actually Works

Bolt.new runs on WebContainers - a full Node.js runtime compiled to WebAssembly. Sounds crazy but it actually works.

What Actually Runs Without Breaking

I've tested a bunch of frameworks in Bolt.new. Here's what works reliably:

Frontend frameworks that work:

• React 18 + Next.js 14 - works perfectly, App Router and all
• Vue 3 + Nuxt 3 - solid, no issues with Composition API
• Svelte + SvelteKit - surprisingly fast builds
• Astro - great for content sites

Styling that doesn't break:

• Tailwind CSS - works flawlessly, JIT compilation and everything
• CSS Modules - no issues with scoping
• Styled Components - works but slows down builds
• Sass/SCSS - compiles fine, no Python dependencies needed

Build tools that work:

• Vite - lightning fast, HMR works perfectly
• Webpack - slower but works for complex configs
• Turbo - monorepo builds work great
• esbuild - blazing fast for simple projects

Database Connections (The Tricky Part)

Database stuff works but has limitations:

What works:

• Supabase - full auth + database + real-time subscriptions
• PlanetScale - MySQL with branching, solid performance
• Neon - serverless Postgres, works well for small apps
• Firebase - Firestore + Auth works fine
• MongoDB Atlas - via connection string, no issues

What doesn't work:

• Local Postgres/MySQL instances (obviously)
• Redis clusters (browser limitations)
• Any database requiring system-level drivers

Real Performance Numbers (From My Testing)

I built the same Next.js app locally vs Bolt.new. Here's what happened:

Cold start times:

• Local development: ~30 seconds (npm install + next dev)
• Bolt.new: ~8 seconds (WebContainer boot + package install)

Hot reload speeds:

• Local with Vite: ~200ms
• Bolt.new: ~350ms (still pretty snappy)

Build times for medium React app (~50 components):

• Local: ~45 seconds
• Bolt.new: ~60 seconds (acceptable for prototyping)

Memory usage:

• Local Node.js: ~800MB RAM
• Bolt.new WebContainer: ~400MB (browser handles garbage collection better)

What Breaks and When

WebContainer limitations I've hit:

• Can't run Docker containers (obviously)
• No Python, Rust, or other runtimes
• Some npm packages with native binaries fail (node-gyp dependencies)
• File uploads larger than 25MB timeout
• WebGL/Canvas apps consume massive memory

Token burn issues:

• Complex apps hit daily limits fast (learned this the hard way)
• AI refactoring entire codebases burns 100k+ tokens
• Each conversation continuation costs tokens, even for simple fixes

Browser crashes:

• Large Next.js apps (200+ components) sometimes freeze the tab
• Multiple projects open = browser memory hell
• Chrome works better than Safari or Firefox

The platform works great for JavaScript/TypeScript projects up to medium complexity. Once you need system-level stuff or non-JS runtimes, you're better off with local development.