Turn Claude Code into a production team.
brew tap adrien-barret/claude-kit && brew install claude-kit
cd my-project && ck initThat's it. Your project now has agents, workflows, guardrails, and a team lead that parallelizes work across specialists.
"As soon as the meeting finished I was already installing it in my repo. It really worked to the point of solving some issues I haven't even spotted in my code." — Taina Martinez
Legend
Agents = Specialized AI personas (backend, security, PO...) with the right model, tools, and skills for their role. Skills = Reusable capabilities (code review, TDD, pentest...) that agents invoke. Rules = Guardrails enforced automatically (pattern-first coding, honest tests, IaC-only...). BMAD = Break → Model → Act → Deliver — the phased workflow from idea to production. Ralph = The autonomous team lead that orchestrates parallel agent teams. Roles = Working methods (dev, po, qa...) that adapt how the workflow behaves. Cowork = Claude Desktop's agentic mode — Claude Kit configures it, Cowork executes.
Claude Code is powerful but raw. Out of the box: no roles, no workflow, no quality gates. You babysit an agent that drifts off-scope.
Claude Kit adds three layers:
A team of 40+ specialists — backend, devops, security, finops, architect, PO, business analyst, project manager, QA, HR... Each activates in the right context with the right model and skills.
A structured workflow with quality gates — BMAD takes a project from idea to shipped feature through phases. TDD is enforced. Every story gets a readiness check before implementation and a done check after. No more "just start coding and hope for the best."
Role-based orchestration — Switch between working methods with ck user. A PO gets validation gates, product-language reports, and client challenge loops. A dev gets zero friction. A QA gets user journey verification. In all-roles mode, each BMAD phase activates the right perspective automatically.
> /ralph build a REST API for user management with auth, roles, and rate limiting
Ralph will:
- Break it into stories with acceptance criteria
- Design the architecture and shared contracts
- Spawn backend + security + devops agents in parallel
- Each agent implements following TDD — code without a failing test gets deleted
- Double review: spec conformity + code quality before acceptance
- Validate every story against acceptance criteria
- Run the full test suite and report results
You review the PR. That's your job now.
/bmad-break # Define the problem → problem.yaml
/bmad-model # Design architecture → architecture.yaml + backlog.yaml
/ralph # Implement everything with agent teams
/review # Code review with severity levels
/test-gen # Generate tests for your code
/security-check # OWASP audit
/pentest # Simulated penetration test
ck user po # Product owner — validation gates, product-language reports
ck user qa # QA — user journey verification, visual proof
ck user dev # Developer — fast cycles, zero friction (default)
ck user all # Full orchestration — right role at each BMAD phasebrew tap adrien-barret/claude-kit
brew install claude-kitgit clone https://github.com/adrien-barret/claude-kit
cd claude-kit && make installcd my-project
ck init # Interactive picker — choose your agents + security profile
# or
ck init --plan # Let Claude recommend components for your stackck add backend devops security # Add agents + their skills and rules
ck add business-analyst # Management agents too
ck list # See what's available vs installed
ck sync # Update everythingDev: backend, frontend, devops, SRE, security, pentester, DBA, data scientist, ML engineer, Go, Python, TypeScript, Rust, mobile (iOS/Android/RN/Flutter)...
Management: product owner, business analyst, project manager, scrum master, architect, tech lead, UX/UI designer, FinOps, change manager, HR/people ops, data governance, SOC2 compliance, access review...
Each has the right model, tools, and skills for its role.
Principles → Break → Clarify → UX Spec → Model → Analyze → Checklist → GSD Prep → Act → Deliver. Run the full pipeline with /bmad-run or pick individual phases.
| Role | What changes |
|---|---|
dev |
Fast cycles, no gates — current behavior (default) |
po |
Validation gates, product-language reports, client challenge loops, so_that proof |
qa |
User journey verification, visual evidence (screenshots/output), e2e readiness |
all |
Full orchestration: PO for Break, Architect+TL+SRE for Model, Dev+DevOps+Security for Act, QA+PO for Deliver |
- TDD enforced — code without a failing test gets deleted and restarted
- Double review — spec conformity + code quality review before acceptance
- Readiness check (DoR) — stories validated before implementation begins
- Done check (DoD) — business value proof required, not just passing tests
- Traceability — every task traces to a user story to a pain point to a persona
ck policy init # Pick a security profile (permissive / moderate / strict)
ck policy apply # Merge policy into settings.json with diff preview
ck audit view # See what agents did — structured JSONL log
ck audit export # Export to CSV/JSON for SIEM
ck sandbox create # Run Claude Code in an isolated containerProfiles are policy-as-code (.claude/policy.yaml) — committed, shareable, inheritable.
A native .app for non-technical users — POs, PMs, HR, and stakeholders.
Dashboard — project status, BMAD phase progress, recent files with click-to-read and edit
Stories — 3-column board (Todo / In Progress / Done) with filters, story detail modal, inline editing as markdown, Ralph status tracking, story locking during edits
File Manager — tree view with type icons, file preview, drag-and-drop
Profile Editor — form-based Cowork profile configuration, agent selector (management-first)
Workflow Launcher — visual BMAD phase diagram, artifact monitor, "Open in Cowork"
Claude Chat — embedded terminal (xterm.js + PTY) running claude directly in the app. Multi-session: one session per project, sessions persist when switching projects. Auto-starts when you open Chat.
WYSIWYG Editor — Tiptap-based markdown editor. Edit the rendered preview directly — no raw markdown. Toolbar for headings, bold, italic, lists, code, links.
Project Selector — top bar with fuzzy search, folder picker (native macOS dialog), recent projects list with remove button
Role Selector — sidebar dropdown with search, favorites (star system), grouped by Management/Dev/Special
| Shortcut | Action |
|---|---|
⌘K |
Fuzzy find and switch project |
⌘← ⌘→ |
Previous / next project |
⌘J |
Open Claude Chat |
⌘S |
Open Stories board |
⌘F |
Open File Manager |
⌘D |
Open Dashboard |
⌘E |
Edit selected story |
Escape |
Close any modal |
# Build from source
make app
# Install to /Applications
make app-install
# Or download from GitHub releases, unzip, then:
xattr -cr "Claude Kit.app" # Required — app is not signed
open "Claude Kit.app"- Pattern-first coding — agents scan existing code before implementing
- Honest test pairing — tests never weakened to hide failures
- IaC-only infrastructure — no manual cloud CLI mutations
- Pre-commit scope check — surfaces file leaks before commit
| You type | What happens |
|---|---|
/ralph <description> |
Full implementation with agent teams |
/bmad-run |
Complete workflow from idea to delivery |
/review |
Code review on current changes |
/test-gen |
Generate tests |
/security-check |
Security audit |
/pentest |
Penetration test simulation |
/quick-spec |
Lightweight tech spec |
/quick-dev |
Quick implementation from spec |
/brainstorm |
Creative ideation |
/party |
Multi-agent debate |
- BMAD Method — the phased workflow approach
- Superpowers — TDD enforcement and structured development
- spec-kit — structured specification engineering
Full CLI Reference
| Command | Description |
|---|---|
ck init |
Interactive setup — agents + security profile |
ck init --plan |
AI-guided setup via Claude session |
ck add [names...] |
Add agents by name (auto-installs deps) |
ck remove [names...] |
Remove components |
ck list |
Available vs installed |
ck sync |
Update + refresh docs-index |
ck docs |
Generate stack-aware docs-index.md |
ck user [role] |
View/set working method (dev, po, qa, all...) |
ck user <role> --global |
Set role globally |
ck policy init |
Pick a security profile |
ck policy apply |
Merge policy into settings.json |
ck policy show |
Show resolved policy |
ck audit view |
View agent activity log |
ck audit export |
Export log to CSV/JSON |
ck sandbox create |
Generate container config from policy |
ck sandbox run |
Launch sandboxed Claude Code |
ck sandbox stop |
Stop container |
ck dep install |
Install recommended dependencies |
ck profile list|use|add|remove |
Manage Claude profiles |
ck version |
Print version |
| Command | Description |
|---|---|
ck skill eval <skill-dir> |
Test trigger accuracy |
ck skill optimize <skill-dir> |
Eval-improve loop |
ck skill grade <skill-dir> |
Grade output against assertions |
ck skill benchmark <results-dir> |
Compare grading stats |
ck skill validate <skill-dir> |
Validate structure |
ck skill report <results.json> |
HTML report |
| Command | Description |
|---|---|
ck skill package <skill-dir> |
Package as .skill |
ck agent validate <agent.md> |
Validate agent |
ck agent package <agent.md> |
Package as .agent |
ck agents registry |
Generate registry |
ck package <template-dir> |
Bundle as .claude-kit |
ck install <archive> |
Install archive |
All slash commands
BMAD Workflow:
/bmad-run, /bmad-break, /bmad-model, /bmad-act, /bmad-deliver
Spec & Quality Gates:
/principles, /clarify, /analyze, /checklist, /ux-spec
Implementation:
/ralph, /ralph-loop, /ralph-cancel, /gsd-prep
Dev Skills:
/review, /pr-review, /test-gen, /test-check, /docs-gen, /commit-msg, /code-only
Security & FinOps:
/security-check, /pentest, /cost-review
Quick track:
/quick-spec (/qs), /quick-dev (/qd)
Ideation:
/brainstorm, /party
Utilities:
/ck-sync, /shard, /create-component, /bmad-help (/h)
Skills reference
| Skill | What it does |
|---|---|
code-reviewer |
Code review with severity levels |
test-generator |
Test generation with framework detection |
test-check |
Per-function coverage — never weakens assertions |
tdd-enforced |
RED → GREEN → REFACTOR cycle enforcement |
api-documenter |
OpenAPI/Swagger generation |
git-commit-helper |
Conventional commit messages |
dependency-auditor |
Vulnerability scanning |
performance-audit |
N+1 queries, bundle size, caching |
accessibility-audit |
WCAG 2.1 AA compliance |
database-review |
Schema, indexing, query optimization |
| Skill | What it does |
|---|---|
readiness-check |
Definition of Ready — validates before implementation |
done-check |
Definition of Done — requires business value proof |
traceability-check |
Task → story → pain point matrix |
spec-reviewer |
Spec conformity review (subagent) |
plan-writer |
Granular implementation plans for complex stories |
| Skill | What it does |
|---|---|
code-security-audit |
OWASP Top 10, injection, XSS, secrets |
infra-security-audit |
Cloud config, permissions, encryption |
auth-review |
OAuth/JWT, RBAC, token policies |
secret-rotation |
Secret storage and rotation |
pentest-web |
Auth bypass, IDOR, SSRF, JWT attacks |
threat-model |
STRIDE threat modeling |
| Skill | What it does |
|---|---|
cost-optimization |
Rightsizing, auto-scaling, reserved instances |
tagging-audit |
Cost allocation tag compliance |
waste-detection |
Idle resources, orphaned volumes |
budget-forecast |
Cost estimation from IaC |
| Skill | What it does |
|---|---|
requirements-elicitation |
Structured requirements discovery |
process-mapping |
As-is/to-be business process flows |
gap-analysis |
Current vs desired state comparison |
risk-assessment |
Risk identification and scoring |
milestone-tracking |
Timeline tracking and forecasting |
sprint-planning |
Sprint capacity and story selection |
retrospective |
Structured retro facilitation |
policy-drafting |
Organizational policy documents |
impact-assessment |
Change impact across people/process/tech |
communication-planning |
Stakeholder communication plans |
Guardrails detail
RED → GREEN → REFACTOR. Code written before a failing test exists gets deleted. No exceptions for code stories. Anti-rationalization table handles 12 common excuses.
After a teammate reports done: spec-reviewer (conformity) + code-quality-reviewer (quality) run in parallel as fresh subagents. Both must PASS before acceptance-validator runs. Skipped in dev mode.
Before implementing, agents scan the codebase for similar features and follow existing patterns. Before creating a file, they find where similar files live — never inventing directories.
Every function has a test. When a function changes, the test updates if the contract changed — but never weakens assertions to hide failures.
Cloud CLI is read-only (describe, get, list). All mutations go through Terraform/Helm.
A hook fires before git commit, printing staged files to catch scope leaks.
Build from source
- Go 1.21+
- Make
- Wails v2 (for desktop app only)
make build # Compile CLI binary
make install # Build + install to /usr/local/bin + templates
make clean # Remove build artifacts
make uninstall # Remove everythingcd cmd/claude-kit-ui
wails build # Produces .app bundle$BMAD_TEMPLATE_DIRenvironment variable~/.bmad/templates/- Adjacent
project-template/.claude/(development)
Supported stacks
ck docs auto-detects your stack and generates framework-specific notes.
Languages: JavaScript, TypeScript, Python, Go, Ruby, Rust, Java, Kotlin, PHP
Frameworks: Next.js, React, Vue, Nuxt, Svelte, Angular, Express, Fastify, NestJS, Hono, Django, Flask, FastAPI, Rails, Sinatra, Laravel, Symfony
Tools: Docker, Terraform, Kubernetes, Helm, GitHub Actions, Prisma, Drizzle, Tailwind
Claude Kit vs Superpowers
Both enhance Claude Code with structured workflows. Here's how they differ:
| Claude Kit | Superpowers | |
|---|---|---|
| Scope | Full project lifecycle — idea to delivery | Code-focused — spec to implementation |
| Workflow | 11-phase BMAD (Brainstorm → Principles → Break → Clarify → UX Spec → Model → Analyze → Checklist → GSD Prep → Act → Deliver) with quality gates between each | 7-phase (Brainstorm → Spec → Plan → TDD → Subagent → Review → Finalize) |
| Agents | 40+ persistent agents with defined roles, skills, and interfaces — survive across sessions | Fresh disposable subagents per task — no memory between tasks |
| Roles | Role-based working methods — ck user po/qa/dev/all adapts the entire workflow |
Single workflow, same for everyone |
| Non-dev users | PO, PM, HR, QA get their own agents, profiles, and desktop app | Developer-only |
| Desktop app | macOS .app with dashboard, file manager, profile editor | No GUI |
| TDD | Enforced via skill + rule + Ralph integration | Enforced — deletes code written before tests |
| Review | Double review (spec + quality) as parallel subagents | Single review phase |
| Architecture | Full architecture design phase (ADRs, data model, API surface) | No architecture phase |
| Security | Dedicated agents + skills (pentest, threat model, secret rotation) + policy profiles + container sandbox | Basic security in review |
| FinOps | Dedicated agent + 4 skills (cost optimization, tagging, waste, budget) | None |
| Quality gates | DoR (readiness) + DoD (business value proof) + traceability matrix | Spec validation |
| Client engagement | Challenge loops at every milestone, visual round reviews | None |
| Cowork integration | Profile editor + push to Cowork + launch from app | None |
| Distribution | CLI (ck) + desktop app + Homebrew |
CLAUDE.md configuration |
| Packaging | .skill, .agent, .claude-kit archives |
None |
| Eval framework | ck skill eval/grade/benchmark/optimize |
None |
Bottom line: Claude Kit covers everything Superpowers does (TDD enforcement, subagent development, structured review) and extends it with architecture design, role-based workflows, security policies, quality gates (DoR/DoD), management agents, a desktop app, and team orchestration. A solo dev using ck init + ck user dev gets the same TDD-first experience as Superpowers — plus 40+ agents, policy-as-code, and the option to scale to multi-role workflows when the project grows.
Claude Kit's TDD enforcement was inspired by Superpowers. Both can coexist in the same project.