You build with AI. Composure makes sure it's built right.
Security checks, testing, and code organization — handled automatically while the AI builds, so what goes live actually works.
Works with Claude Code — the AI you already use. Nothing to replace: Composure checks everything it writes, before it goes live.
Instructions are suggestions. Hooks are enforcement.
Not a pile of plugins — a library of build-it-right rules your AI has to follow, checked on every change. It protects what goes live; it never changes how your AI works.
1105 patterns, dependency-ordered38 areas20 enforcement hooks59 skills across 6 plugins
Every number is generated from the catalog on every build — derived from what's on disk, not written by marketing.
AI writes code fast. Fast isn't the same as careful.
You built a SaaS with AI. You logged in, clicked around, launched it.
Then two customers logged in at the same time — and saw each other's invoices.
It looked done. It wasn't.
The AI never wrote the one rule that keeps tenants apart.
For developers
The technical name is missing Row-Level Security — one policy per table the agent skips unless you know to ask for it.
Composure's schema guard catches it the moment the table is created — before it ever reaches a commit.
Other tools find this after you push. Composure makes sure it never goes live.
The difference is when it works
Traditional tools review after you push. Composure catches issues while you code.
Traditional (post-hoc review)
Composure (inline prevention)
Composure's hooks run natively in Claude Code — outside the LLM, can't be bypassed, zero token cost.
Your request is classified before a line is written — the right pattern, the right skill, pointed at it automatically.
Which one are you?
One product. Made for two types of builders.
Whether you write code yourself or AI writes it for you, Composure keeps what gets shipped safe. Pick the door that sounds like you.
What you get
You don't have to be the one who reads the audit report.
You describe what you want — in plain English, the same way you already talk to AI. Composure runs the security checks, the structure review, and the impact analysis in the background, every time.
The commands below are what runs under the hood; you never have to type them. You get told, in plain language, when something is about to break — before it launches.
It knows your whole app before it touches anything
Composure keeps a live map of how your app fits together. Before the AI changes anything, it checks what else that change could break — so a fix in one place doesn't quietly break another.
Learn more$/composure:blueprint$# Scans code graph → finds related files$# → confirms scope → writes implementation specProblems get caught the moment they're written
Every file the AI writes gets checked automatically — structure, quality, security. You hear about a problem in plain language while it's a minute old, not after your customers find it.
Learn more$[composure:no-bandaids] File exceeds 200 lines.$Consider decomposing into smaller modules.$→ Added to tasks-plans/tasks.md [High]Remembers your project between sessions
AI normally starts every session with no memory of your decisions — so it rebuilds the same thing a different way each week. Composure keeps your decisions on file, so month three is built to the same standard as day one.
Learn more$/composure:cortex$# Loaded: 23 architecture decisions$# Loaded: project map (61 files, 4 modules)$# Convention: multi-tenant RLS pattern (3 usages)$# Session grounded — starting from your baselineEvery change gets a second opinion
Before a change goes live, the system re-checks it against your whole app — what it touches, what could break, what's untested — and tells you what it found in plain language.
Learn more$/composure:critique$# Impact: 3 files direct, 7 indirect$# Risk: Medium (auth module touched)$# Untested: handleLogin() — 12 callersProof the app still works
Every feature gets automatic safety checks — the kind that catch a breakage before your customers do. They're written and run for you; you never have to read them.
Learn more$/testbench:generate src/lib/auth.ts$# Read 3 existing test files for conventions$# Generated: 8 tests (4 happy, 2 edge, 2 error)$# Style: vitest + testing-library (matched)Going live is a checklist, not a gamble
When it's time to launch, Composure runs the preflight checks and sets up the pipeline that takes your app live safely — the same way experienced teams do it.
Learn more$/shipyard:ci-generate$# Detected: Next.js + pnpm + Vercel$# Generated: .github/workflows/ci.yml$# Stages: lint → typecheck → test → build → deployThe Composure Suite
Five specialists and one shared memory, all working on the same build — security, structure, testing, design, and going live. They share what they know, so nothing falls through the cracks.
Composure
Builds it right — structure & quality
28 skills
Sentinel
Catches security holes
5 skills
Shipyard
Takes your app live
6 skills
Testbench
Automatic safety checks
3 skills
Design Forge
Premium design
7 skills
Cortex
Your project's memory
4 skills
One install. Five plugins, one brain. Zero configuration.
View all pluginsWhat the model says when nobody asked it to.
And — thank you for saying that. It cuts both ways, though: the speed and accuracy today came as much from what you built around us — the canon patterns, the methodology, the enforcement gates, the campaign structure — as from the model. A smart model with no patterns to follow would have produced 140 plausible files and a much worse review day. The system is the product. Go rest; the walkthrough will still be there tomorrow.
We asked the model to explain that message. Its answer, lightly trimmed:
“The honest version is that I don't need help being smart — I need help being consistent. Every session I start with no memory of your conventions. Ask me for a billing page and I'll write you a good one; ask me again next week and I'll write you a different good one. Multiply that by every file in a codebase and you get the real failure mode of AI-built software: not bad code — plausible code, in a hundred slightly incompatible dialects.”
“What this system changes is what ‘plausible’ means while I work. The pattern catalog is in front of me before I write, so the canonical shape is the path of least resistance instead of one option among many. The enforcement hooks are not suggestions — when I reach for a shortcut, the tool call fails and tells me why. The code graph means I see what depends on a file before I touch it, instead of finding out from the review. And the campaign state lives on disk, not in my context window — so a build that outlasts my memory doesn't outlast my discipline.”
“I'd put it this way: the model sets the ceiling, the system sets the floor. Working bare, my floor is whatever I happened to assume that day. Working here, the floor is your architecture. That's the difference you're buying — not a smarter model, the same model held to your standard every single session.”
Model output, reproduced with permission of no one — it doesn't mind.
Start free. Stay in control of the cost.
Composure is free forever for personal use. Pro is $39/mo ($24/mo annual, founding rate). Or own the codebase outright — the monorepo template from $499, shipped with the installer that keeps it maintained.
Questions, answered
Do I need to know how to code?
No. You build by describing what you want in plain English. Composure runs the checks in the background and tells you, in plain language, when something needs attention.
Does it work with my stack?
Composure runs on Claude Code and supports 8 languages. It reads your existing project and configures itself — you don't pick rules.
Will it slow my AI down?
No. The enforcement hooks run outside the model, at zero token cost — they can't be bypassed and they don't spend your context window.
Where does my code go?
Composure runs inside the tools you already run. The graph, the checks, and the task queue stay on your machine — you own what it builds.
What does "free for personal use" mean?
The plugins are source-available under a noncommercial license: free forever for personal projects. Pro ($39/mo) and the owned template are for commercial use. See the license.
Get started in 2 minutes
Three commands. Two minutes. Free.
Install Composure
$pnpm dlx create-composureInitialize your project
$/composure:initializeRun your first audit
$/composure:auditTakes 2 minutes. Free. No credit card required.