And how I finally built the boilerplate I wish I had when we started.

The Origin Story

Late 2019. My co-founders and I were racing to build our MVP. I handled the frontend, one of my co-founder tackled the backend (as a junior dev, no less). We moved fast. Too fast, as it turned out.

But here’s the thing: speed mattered. We launched, got clients, gained traction. Things got serious. And that’s when I rolled up my sleeves and started what would become a multi-year journey into architectural refinement.

Fast forward through years of production battles, a successful acquisition, a small tech team onboarded and countless lessons learned. I finally had the chance to build what I’d always wanted: a TypeScript-first, production-ready boilerplate that embodied everything we’d learned the hard way.

That became my 2025 boilerplate. And now, after a year of building real projects on top of it, I’m sharing the evolved version: Clean Boilerplate '26.

What Changed Everything: Agentic Coding

The biggest shift in my development life this year wasn’t a framework or a library—it was coding with AI agents.

I’ve been building extensively with LLM-powered coding assistants using this architecture, and it works remarkably well. Clean Architecture’s clear separation of concerns, explicit dependencies, and well-defined boundaries make it almost perfect for AI-assisted development. The agents understand the structure, respect the patterns quite well, and can navigate the codebase with confidence.

The base Claude.mds files I use are included in the repository. They give Claude clear insights on how things work.

The Architecture

This is Uncle Bob’s Clean Architecture principles implemented: domain isolation, dependency inversion, separation of concerns. It’s not theoretical ; every pattern here has survived production.

Many patterns of this boilerplate were born and refined during the life of my latest startup, where it evolved under real business pressure (others were born in an Elixir implementation that turned out to be way too hard, but that’s another story). My team and I never had time to add TypeScript during that phase (the business came first), but the architectural bones were solid.

After the acquisition, I finally got to build what I’d always envisioned: that same battle-tested foundation, but in TypeScript (some patterns really benefit of what’s the language has to offer), with many improvements I’d been mentally cataloging for years.

Backend:

• Clean Architecture with proper dependency injection (via TSyringe)
• GraphQL (via Yoga)
• BullMQ / Redis for async job processing in separate workers
• MongoDB with proper migrations and schemas
• LangChain integration ready to go (because let’s be honest, most new projects touch LLMs)
• Testing infrastructure (Mocha + Sinon)
• Custom logger and error handling for debugging sanity

Frontend:

• React 19 + Next.js 16 (it has some great MCP tools built-in)
• Shadcn for the design system foundation (I’m betting on this one’s future)
• Apollo Client + GraphQL Codegen

The Pragmatic Choices

Not everything is perfect, and that’s okay.

I stuck with Stack Auth instead of migrating to https://next-auth.js.org/. Why? Because a few days of auth migration work wouldn’t move the needle for anyone using this boilerplate, and Stack Auth works. It has facilities I appreciate, even if it’s not my platonic ideal. Pragmatism over perfection.

I switched to pnpm after discovering its catalog feature for monorepos. Sometimes the small improvements compound into something significant.

I added LangChain examples because I genuinely believe LLM integration is table stakes for new projects in 2025 and beyond. Your boilerplate should have opinions about this.

Who This Is For

If you’re starting a SaaS, an ambitious side project, or your next venture, and you want to start with architectural foundations that have survived real production environments, this could be for you (or at least, the perfect time for you to discover some patterns).

It’s not minimal, the idea is to give concrete implementation example. Clean architecture is about principles, but examples are always very welcome.

I particularly encourage you to use your AI coding agents to explore this codebase. Let them learn the patterns, understand the boundaries, explain the principles. (Boris Cherny is obviously right about this approach)

I built this for myself, but I’m not keeping it to myself.

Early in my career, other developers’ boilerplates taught me patterns I wouldn’t have discovered for years. They saved me time and shaped how I think about code.

If you’re early in your journey, this could save you countless hours of architectural experimentation. If you’re experienced with this kind of architecture, maybe it offers a different perspective on Clean Architecture principles.

With AI coding agents accelerating how fast we write code, the architecture guiding that code matters more than ever. Good foundations protect your business rules and scale with you.

Take what resonates. Ignore what doesn’t. That’s how I learned from others, now it’s my turn to share.

Check it out: github.com/elieteyssedou/clean-boilerplate-26

Remember:

It’s always easier to straighten a sapling than a grown tree