The Vibe Coding
Stack That Ships

A compounding stack isn't about picking the "best" individual tools. It's about picking tools that make each other more powerful over time.

Shared conventions. AI-readability. Composability. When your auth system, your database, and your payment layer all share the same user identity — set up once — every new feature you build gets easier because the foundation already knows who's logged in, what they've paid for, and what they can access.

When your AI editor has read your entire codebase — your conventions, your component library, your database schema — it doesn't just write code. It orchestrates across layers. One conversation can build a landing page, set up the database, wire the payment flow, and deploy it live.

Here's what we'll do together.

We'll walk through 7 layers of a vibe coding stack. For each layer, you'll make a choice between three paths — a simpler option, my recommendation, and a more advanced alternative. You can also write in your own.

After each choice, you'll see what other builders picked. At the end, you'll have a complete, personalized stack config — ready to copy-paste into any AI and start building.

This is the same Stack Builder we walk through in the Builder Lab — every decision, together, in real time.

Your AI development environment. This is where you write, debug, and orchestrate everything. The quality of everything else in your stack depends on how well your AI understands your project.

Three types of tools compete for this layer:

Chat-based AI builders like Lovable, Bolt, and v0. You describe what you want, they generate a full app. Great for prototypes and landing pages. The ceiling shows up when you need real debugging, custom integrations, or the kind of post-payment logic that turns a prototype into a business.

AI-powered code editors like Cursor, Windsurf, and Google Antigravity. These sit inside a full development environment. They read your entire codebase, understand your conventions, and connect to external tools through MCP servers. More to learn upfront, but the compounding is real — every file you add, every convention you establish makes the AI more capable.

Terminal-based AI tools like Claude Code, Codex CLI, and Gemini CLI. Pure command line. Fast, scriptable, composable with other CLI tools. The most powerful option for developers who already think in terminals.

For vibe coders without a development background, we recommend starting with Cursor. It's visual, it has the most mature MCP server ecosystem, and it reads your entire project — every rule you write, every component you build makes it smarter. That's the compounding that chat-based builders can't match.

If you have development experience and feel at home in the terminal, Claude Code gives you the most direct control. Think of it as the difference between a graphical interface and the command line — same power, different comfort zone.

One thing that's explicitly not a stack decision: the AI model. Claude, GPT, Gemini — they change every few months, and you'll switch between them constantly. Most of these tools work with all of them. The choice that compounds is your environment, not which model powers it.

How your code becomes a live product. This is the modern equivalent of choosing a CMS — like deciding between WordPress and Webflow in the old days. Except now the decision shapes how well AI can help you, how fast you can iterate, and whether you can collaborate with others.

Three approaches compete here:

Built-in deployment from your AI builder — Lovable, Bolt, or Replit ship for you. No Git, no terminal. Great for getting live fast.

Managed framework stacks like Next.js + Vercel or SvelteKit + Vercel. These are bundles — framework, hosting, and Git designed to work together. The result: git push = live product. Preview deployments on every change. Rollback in seconds. This is where the shipping cadence from Ship Every Week becomes physically possible.

Custom framework stacks for developers who want to choose every piece — TanStack Start, Astro, or Docker-based deployments. More flexibility, more infrastructure work.

How your product looks and feels. This isn't just about aesthetics — it's about how well your AI can generate UI code.

If you're using a chat-based builder, the built-in UI is automatic — Lovable, Bolt, and v0 all generate polished components for you. The tradeoff is less customization after generation.

Managed component libraries like shadcn/ui + Tailwind CSS have massive representation in AI training data. That matters more than you think. When you ask Cursor to build a settings page, a pricing table, or a dashboard — it generates consistently high-quality code because it has seen these components thousands of times. Professional results. Fast iteration. No fighting the framework. I asked Cursor to build a pricing table last week — because it knows shadcn/ui, it generated a production-ready component in one prompt.

Headless primitives like Radix or Base UI give you total pixel control. If you have strong design opinions and want a unique look, this is your path — but you'll build more from scratch.

Where your users' data lives. This is the layer where the difference between ownership and convenience matters most.

With built-in databases, your builder manages data automatically — Lovable provisions Supabase for you, Firebase handles everything through Google. Convenient, but you don't always have direct access.

Managed Backend-as-a-Service tools like Supabase and Convex give you full ownership with managed hosting. Supabase provides PostgreSQL with real-time subscriptions, row-level security, and edge functions. And here's the compounding: Supabase has an MCP server, which means your AI can query and manage your database directly. No context-switching. No copy-pasting SQL.

Serverless databases with ORMs like Neon + Drizzle or PlanetScale + Prisma are for developers who want full schema control and type-safe migrations. Less batteries-included, more flexibility.

Who your users are. Authentication touches everything — it protects routes, gates content, manages user state, connects to payments, and provides identity for analytics.

Built-in auth from Supabase or Firebase gives you email, password, and social logins automatically. Good enough for basic needs, but limited when you need organizations or webhooks.

Managed auth services like Clerk provide the shared identity that Supabase, Stripe, and PostHog all need. Set it up once: every layer knows who's logged in, what they've paid for, and what they can access. When someone signs up, a webhook creates their user record in Supabase. When they pay, Stripe's webhook updates their access level. One identity, shared across your entire stack.

Open-source auth like Better Auth or Auth.js gives you full control with no vendor dependency. More flexible, more complex — the right choice if you know exactly what you want.

Where demos become businesses. This is where many vibe coding projects stall — not because payments are impossible, but because the flows after checkout get complicated fast.

Quick checkout through your builder gets you live fast — Stripe via Lovable or Gumroad can have you accepting payments in minutes. The tradeoff is limited post-payment logic.

Managed payment platforms like Stripe, LemonSqueezy, or Paddle handle the full infrastructure. With Stripe, you get webhooks feeding into Supabase, user access gated by Clerk, and the whole flow trackable in PostHog. Not just "add a payment link" — a connected revenue system where a single checkout creates a customer, updates their access, sends a confirmation email, and logs the conversion.

Developer-first billing via Polar or Stripe's direct API gives you maximum control — custom billing logic, usage-based pricing, and the lowest fees.

From shipping a product to running a business. The first six layers get your product live and charging money. This layer is what turns it into something you can actually operate.

Not everyone needs operations tools on day one. If you're still building your MVP, skip this layer for now — you can always add it later.

But if you're ready, there are four categories to consider:

Together, these form the operating system that turns a shipped product into a business you can run. Pick one tool per category — or skip the ones you don't need yet.