For post-PMF engineering teams

You have traction.
 Now improve the code base.

You found product-market fit. But your codebase didn't keep up. BoilerPlateClau turns Claude Code into a senior architect that systematically rebuilds your foundation — without stopping shipping.

Get BoilerPlateClau — €9.99 See the problem ↓
~/my-startup — legacy codebase
$ cp -r boilerplate/. .
$ claude
✓ Reading CLAUDE.md...
✓ Detected stack: Symfony + Doctrine
⚠ Detected: no bounded contexts, fat controllers, no domain layer
✓ Refactor plan ready. Incremental. Zero downtime.
$ /ddd-review "src/Controller/OrderController.php"

// the problem

PMF is great.
But your code no scale.

Fast iteration during early growth leaves a trail. The same code that got you to traction is now slowing you down — and the team is too afraid to touch it.

🍝
Fat controllers, zero domain logic
Business logic scattered across controllers, services, and random helpers. No clear place to add a new rule without breaking three others.
→ DDD boundaries, aggregates enforced
🐢
Every new feature takes longer
The codebase grew without a plan. Now adding anything requires understanding a tangled web of side effects. Velocity drops every sprint.
→ CQRS + workflows restore speed
💥
Bugs in production, always
No test coverage, no clear ownership per module. Fixing one thing breaks two others. Deploys are stressful events, not routine operations.
→ 90% domain coverage from day one
😰
Scared to refactor
The tech debt is obvious, but the risk of touching it feels too high. So it compounds. Every new hire inherits the mess and slows down.
→ Incremental refactor workflow
🔁
Claude forgets everything
Every new Claude session starts from zero. You re-explain the architecture, the rules, the context — every single time. Productivity lost on repetition.
→ .context/ memory persists everything
🤷
No architecture standards
Everyone writes code differently. Reviews are arguments about style. Onboarding new engineers takes weeks. No shared mental model of how things should work.
→ Enforced conventions per stack

// what's inside

Everything Claude needs
to rebuild it right.

Drop these files into your existing project. Claude reads them on startup and applies your architecture automatically — refactoring incrementally while you keep shipping. See the files

🏛️
Architecture Core
DDD, CQRS, bounded contexts, layering rules, and a decision framework. Works on any existing stack — incrementally, not as a big bang rewrite.
⚡
5 Refactor Workflows
Step-by-step processes for refactoring features, extracting services, investigating bugs, and safely restructuring large codebases without downtime.
🧩
12 Design Patterns
Each pattern with a "should I apply this now?" decision guide. Knows the difference between patterns that help a growing codebase and premature abstraction.
📐
Language Conventions
Opinionated rules for Node.js/NestJS, PHP/Symfony, and Go/Gin — enforced consistently across the whole team with every Claude session.
🎨
Frontend System
React + Tailwind design tokens, component rules, and page structures. Eliminates frontend inconsistency as the product scales.
⌨️
5 Slash Commands
/ddd-review, /refactor, /bug-investigation, /new-feature, /search-context — one command kicks off a systematic, multi-step process.

// philosophy

Improve incrementally.
Keep shipping.

A big bang rewrite will kill your momentum. The boilerplate is built around a different approach: improve the codebase one bounded context at a time, while the rest of the system keeps running.

01 —
No big bang rewrites
Every refactor workflow is designed to be incremental. Extract one service, clean one module, migrate one layer — while everything else continues to work. Momentum is non-negotiable.
02 —
DDD as a migration path
Bounded contexts aren't just for greenfield projects. Claude uses them as a map to identify where your existing code belongs — and how to migrate it there, module by module.
03 —
Tests justify the change
Before any refactor, Claude writes characterisation tests to lock in current behaviour. Then it refactors. Then it checks the tests still pass. No refactor without a safety net.
04 —
Surface the real problem first
Claude never dives into fixing without understanding. Every workflow starts with a diagnostic — mapping the existing code, identifying the root issue, and proposing a path before writing a single line.

// supported stacks

Three stacks.
One architecture.

Core principles are language-agnostic. Language-specific files handle the conventions of your existing codebase.

TypeScript
frameworkNestJS
ormPrisma
testingVitest / Jest
lintESLint + Prettier
PHP
frameworkSymfony 6+
ormDoctrine
testingPHPUnit
lintPHP CS Fixer
Go
frameworkGin
dbsqlc
testingtesting + testify
lintgolangci-lint

// slash commands

One command.
Full audit or refactor.

Type a command in Claude Code. A structured, multi-step process runs — no half-measures, no skipped steps.

/ddd-review "path/to/module"Audits existing code for DDD/CQRS violations. Returns PASS, WARNINGS, or FAIL — with a concrete list of issues, root causes, and a prioritised fix plan.
/refactor "module or feature"Runs the full refactor workflow: characterisation tests → bounded context mapping → incremental extraction → verify nothing broke. Zero downtime by design.
/bug-investigation "description"Traces the bug through all layers, identifies the root cause (often architectural), writes the missing test first, then fixes it cleanly.
/new-feature "description"Adds new features using the correct architecture from the start — so you don't keep adding more debt on top of the existing mess.
/search-context "topic"Explores the codebase and stores structured findings in .context/topic.md — reused in every future session automatically. Claude never starts from zero again.

// file structure

34 files.
Every layer covered.

Drop the folder in your existing project root. Claude reads it on startup — no setup, no config, no onboarding call.

core/ 6 files
architecture.md
ddd-patterns.md
cqrs-guide.md
testing-strategy.md
api-design.md
error-handling.md
workflows/ 5 files
new-feature-workflow.md
new-service-workflow.md
bug-investigation-workflow.md
refactor-workflow.md
large-search-workflow.md
patterns/ 13 files
index.md ← decision tree
creational/
factory-method · builder · singleton
structural/
adapter · facade · proxy · decorator
behavioral/
strategy · observer · command · …
frontend/ 6 files
project-style.md ← per-project
tokens.md
components.md
pages/
landing · dashboard · auth
node-ts/ · php/ · go/
per stack, 3 files each:
CLAUDE.md
conventions.md
testing.md
entry + memory
CLAUDE.md ← reads first
.claude/commands/
5 slash commands
.context/
session memory · committed to git

// session memory

Claude knows your codebase.
Every session.

Legacy codebases are complex. Re-explaining your architecture to Claude every session is a tax you shouldn't pay. The .context/ folder is Claude's long-term memory — it accumulates knowledge about your system and loads it automatically on every startup.

how it works

01
You run /search-context "payments"
Claude reads your existing codebase — controllers, services, events, handlers — and builds a structured map of how payments work in your system, including the messy parts.
02
Claude writes .context/payments-searched.md
Findings are saved in structured markdown: bounded context analysis, key issues found, event flow, tech debt hotspots, and recommended refactor order.
03
You commit .context/ to git
The whole team shares the same knowledge base. New engineers onboard in minutes. Claude's understanding of your system compounds over time.
✓
Next session — Claude already knows everything
CLAUDE.md instructs Claude to read .context/ on startup. No re-explaining. No starting from zero. Just work.

example .context/ files

.ctx
payments-searched.md
Stripe integration map, fat service identified, suggested PaymentAggregate extraction, webhook debt documented.
.ctx
auth-searched.md
JWT + refresh token flow, UserAggregate candidate, 3 controllers doing auth logic that should be centralised.
.ctx
orders-searched.md
OrderController has 800 lines, 6 bounded context violations found, incremental extraction plan in 4 steps.
.md
CLAUDE.md reads .context/ on start
Entry point. Loads all context files before the first response — so every session starts with full knowledge of your system.
# in CLAUDE.md
## Session Memory
On startup, read all files in .context/.
These are your long-term memory across sessions.

// pricing

One price.
Yours forever.

No subscription. No per-seat. No tiers. Pay once, use on every project you need to fix.

one-time

BoilerPlateClau

€9.99
one-time payment
  • ✓ 34 markdown files, drop into any project
  • ✓ DDD + CQRS + incremental refactor workflows
  • ✓ Node.js, PHP, and Go conventions enforced
  • ✓ 12 design patterns with "apply now?" guidance
  • ✓ 5 slash commands for Claude Code
  • ✓ Frontend system (React + Tailwind)
  • ✓ Persistent .context/ session memory
  • ✓ Free updates forever
Start fixing the codebase →
stripe ·Secure checkout·Instant download

// get started

Your traction deserves
a codebase that scales.

Drop 34 files into your existing project. Claude reads them and starts fixing — incrementally, systematically, without stopping your team from shipping.

Start fixing the codebase — €9.99 →