ShipFast JS vs BoiledPlate: Which Starter Wins?

Search "shipfast js" and you'll find Marc Lou's ShipFast at the top of every result: a Next.js boilerplate that promises to launch your startup in days, not weeks. It's earned that ranking. Thousands of solo builders have shipped real products on it. But if you're building with a coding agent in the loop — Claude interviewing you, patching your codebase, provisioning your services — the framework underneath matters less than how readable and stable that codebase is. This is where BoiledPlate, an AI-native Nuxt + Supabase starter, takes a different bet.

The Real Problem Both Solve

Nobody ships slowly because they picked the wrong framework. As we've argued before, the stack picks itself in an afternoon — the weeks disappear into the plumbing between services. Webhook idempotency. Row-level security. Transactional email that sends exactly once. Auth that doesn't leak. Both ShipFast and BoiledPlate exist to kill that plumbing tax.

ShipFast dominates search because it got there first and it works. BoiledPlate is the better choice if you're agent-native — if your default workflow is describing what you want and letting Claude build it.

Why ShipFast Works (And What It Assumes)

ShipFast rides Next.js momentum. Massive community, endless tutorials, pre-built components, and a Vercel deployment path so well-trodden you can't get lost on it. Stripe is wired, login is there, the UI is battle-tested.

Its core assumption: you'll clone it, read the docs, and wire the last mile by hand. That's a good fit for a solo builder who won't touch the internals much and just wants to ship. ShipFast is genuinely batteries-included Next.js, and for that audience it's hard to beat.

The Hidden Cost of Next.js Boilerplates

The trouble is that Next.js is a moving target. App Router churn means boilerplates age fast — patterns that were idiomatic 18 months ago now generate warnings. That churn is invisible until your agent tries to modify code written against an older mental model.

There's also gravitational pull toward Vercel: deployment, logging, analytics all nudge you into one ecosystem. And Next's client-first defaults make it easy to trust the browser for things the browser should never decide — like whether a user actually paid.

Why Nuxt Stays Stable (And Agents Love It)

Nuxt offers a smaller, more predictable surface area for code generation. File-based routing is deterministic: an agent knows that pages/dashboard.vue becomes /dashboard, no config archaeology required. Vue's template syntax reads cleanly, so an agent modifying a component isn't untangling JSX branching logic mixed into markup.

Crucially, Supabase RLS is first-class here, not an afterthought bolted onto a client-heavy app. That combination — what it actually takes to wire Nuxt, Supabase and Stripe — is exactly the plumbing BoiledPlate ships pre-built.

Agent-Native Architecture: AGENTS.md

Here's the sharpest difference. ShipFast has no documented contract for how an agent should behave in its codebase. Consistency is manual — you hope Claude infers your conventions from context.

BoiledPlate ships AGENTS.md: one documented way to do data access and secrets, so your conventions are written for the agent, not the next hire. Deterministic patches work precisely because the codebase follows conventions an agent can parse. ShipFast says "use as-is." BoiledPlate says "customize via interview" — the agent asks questions, then reshapes the code to your answers.

Billing Done Right: Where Both Differ

Both integrate Stripe. The difference is architectural rigor. BoiledPlate's webhooks are idempotent by design, and subscription state lives in Stripe — your checkout success page should never touch your billing state. The webhook is the source of truth; the success page is just a redirect.

That discipline shows up in the edge cases: refund flows, multi-plan logic, and EU consent like the German withdrawal waiver encoded into the pay button. ShipFast gives you an admin UI to manage subscriptions; BoiledPlate takes a programmatic approach where the correctness lives in code your agent can extend.

Database Security: RLS as Default

ShipFast uses Supabase, but guides often treat it as "just a database." That's how privilege-escalation bugs sneak in — a client query that returns rows it shouldn't.

BoiledPlate enforces row-level security from row one. Deterministic patches keep RLS logic consistent as the agent customizes tables, so you never end up with one protected table and three that quietly aren't. The real-world lesson: a client-side success page can happily tell a user they're subscribed while the database and Stripe disagree. RLS plus webhook-as-truth closes that gap.

The Agent Interview Pattern

With ShipFast, the flow is: clone, read docs, wire manually. With BoiledPlate, the agent runs an interview — name, languages, theme, billing model — then patches the codebase and provisions Stripe products, webhooks, Supabase, and Google sign-in in a single session.

Why does this matter? Setup isn't a one-time tax. Your first agent run shapes every run after it. A codebase built around deterministic patches stays coherent as you keep asking the agent for changes; a manually-wired one drifts.

Multi-Language Out of the Box

ShipFast is English-first; i18n is an add-on decision you make later, when retrofitting is painful. BoiledPlate ships four languages from the starter. Because language additions run through deterministic patches, adding locales doesn't break existing routes or components — the friction that usually kills i18n plans disappears.

SEO and Blog Infrastructure

Both include a blog. BoiledPlate's is prerendered Markdown — no ISR complexity, and pages that rank because they're static HTML at request time. JSON-LD and canonical URLs matter here, and Next.js defaults don't guarantee correctness. We learned that the hard way twice: our blog once told Google its canonical URL was localhost:3000, and a dynamic JSON-LD block returned 200 from curl but 500 in Chrome. Those bugs are exactly the kind of thing a boilerplate should have already solved for you.

Transactional Email: Resend vs Custom

BoiledPlate ships a Resend integration with verified templates. ShipFast assumes you'll wire email yourself. The subtle requirement: email templates need to survive agent customization. If Claude reshapes your onboarding flow, the confirmation email and consent copy have to follow — deterministic patches keep those in sync instead of leaving a stale template in a folder nobody remembers.

Deployment and Delivery Mechanics

ShipFast: clone the GitHub repo, deploy to Vercel. BoiledPlate Pro delivers differently — the GitHub invite is the product, granted instantly via a Stripe webhook where some failures must throw and some must never. That's not a gimmick: webhook-driven delivery is how you scale a paid, customized boilerplate without a manual handoff for every sale.

TypeScript Strict Mode: Rigor Where It Counts

Both include TypeScript. BoiledPlate enforces strict mode, which matters more than usual when an agent is writing code. Strict typing catches the class of mistakes Claude occasionally makes — a possibly-null value passed where a string is required — at compile time instead of in production. The trade-off is slightly more verbose type coverage. Worth it when a machine is patching your codebase weekly.

Pricing and Long-Term Value

ShipFast is a paid Next.js kit; BoiledPlate offers a free, MIT-licensed Lite version you clone and wire by hand, plus Pro at €159 one-time with lifetime updates and instant GitHub delivery. What you pay for in Pro is the AI tooling: idempotent webhooks, AGENTS.md discipline, and deterministic patch stability. Lite proves the app works; Pro makes it set itself up.

Real-World Workflows: The Agent Scenario

Picture prototyping a SaaS MVP with Claude. On ShipFast, the agent reads Next.js conventions and makes steady but manual progress — every customization is a fresh negotiation with an undocumented codebase. On BoiledPlate, the agent runs the interview, provisions Stripe and Supabase, applies patches, and ships. When agents are in the loop, consistency beats feature count. A predictable codebase compounds; a clever-but-opaque one fights you.

When to Pick Each

Pick ShipFast if you want batteries-included Next.js, prefer wiring the last mile yourself, and you're a solo builder comfortable in the App Router. The Next.js inertia is real and valuable.

Pick BoiledPlate if you're building with agents, value Supabase RLS as structural rather than optional, plan to customize heavily, and want deterministic updates instead of merge conflicts. It's the solo-plus-agent workflow made explicit.

Gaps ShipFast Leaves Open

The honest list: no documented agent contract, so consistency stays manual. Billing logic is present but not architecturally proven idempotent. RLS is available but guides rarely make it structural. And there's no clean story for keeping your customized code in sync with upstream — that gap is the whole reason BoiledPlate exists.

The Future: Boilerplates as Agent Infrastructure

Next-generation SaaS starters will be judged by agent-readability, not feature count. AGENTS.md is an emerging pattern, and deterministic patches beat manual merge conflicts every time your agent touches the code. The boilerplate that wins the "shipfast js" era won't be the one with the most components — it'll be the one an agent can reason about without breaking things.

ShipFast is safe, proven, and excellent at what it does. BoiledPlate is the better bet if you're shipping with Claude — Nuxt + Supabase + deterministic patches is an underrated stack, and it's built for exactly the workflow the rest of the industry is only now waking up to.