v3.2.1 — Claude Code Plugin

Claude Code
Blueprint

"Each unit of engineering work should make subsequent units easier — not harder."

53 Skills 26 Agents 6 Hooks — Stars
Get Started GitHub
claude
$ claude > /brainstorming add user authentication   Brainstorming 3 design options...   Writing implementation plan...   ✓ Plan ready — 6 tasks, 2 waves   > /orchestrate   Wave 1: 3 tasks in parallel...   Integration verified ✓   Wave 2: 3 tasks in parallel...   ✓ All tasks complete   > /review-swarm   Dispatching 8 reviewers...
53 Skills
26 Agents
16 Repos Analyzed
320K+ Ecosystem Stars
5 Quality Gates
4 Pipelines
2 Loop Mechanisms

Why Blueprint?

Stop reinventing the wheel every session

Most AI coding sessions start from scratch: no conventions, no memory, no workflow. Each session reinvents the wheel. Blueprint fixes that by giving Claude Code a structured operating system — a set of skills, agents, and documentation patterns that compound across sessions.
Each unit of engineering work should make subsequent units easier — not harder.

Structured

A complete operating system for Claude Code — skills, agents, and quality gates that activate automatically.

Compounding

Every solved problem becomes searchable institutional knowledge. Future plans consult past solutions automatically.

Battle-Tested

15+ repos analyzed through source code inspection. Best patterns absorbed, bad patterns documented and rejected.

What You Get

A full development lifecycle toolkit, installed as a single plugin

53

Skills

Workflow modules: TDD, systematic debugging, brainstorming, wave orchestration, swarm coordination, knowledge compounding, and more.

26

Agents

Specialized subprocesses for security audits, performance reviews, code review, research, architecture analysis. Each gets a fresh 200K context.

0

Commands

All commands merged into skills in v3.2. Every skill is a direct entry point — /brainstorming, /ship-pipeline, /review-swarm, and more.

6

Hooks

Session start bootstrap, context monitoring, prompt injection guard, ship loop exit guard, task completion, teammate idle detection.

Pipelines

Four execution modes for every situation

/build-pipeline

Supervised

Full-cycle pipeline with checkpoints between every stage. Human in the loop at every gate. Best for guided feature development.

/ship-pipeline

Autonomous

Zero checkpoints, fire-and-forget. Plans, executes via team-lead agent, iteratively reviews (3 cycles), and opens a PR automatically.

/quick-fix

Fast-Track

For small, well-understood changes under 3 files. Write a failing test, fix it, verify, commit. TDD in its purest form.

ship.sh

Ralph Loop

External bash loop that spawns a fresh 200K context per iteration. State persists via git. Handles context exhaustion gracefully.

Pipeline Checkpoints Review Best For
/build-pipelineBetween every stageSingle passHuman-guided features
/ship-pipelineNone3 iterative cyclesSingle-context fire-and-forget
ship.shNone3 iterative cyclesLarge features, context exhaustion
/quick-fixNoneNoneTrivial changes (< 3 files)

The Development Loop

Every feature follows a structured flow from idea to shipped code

1

Orient

Load context, review status, understand what's in flight

/project-status
2

Design

Brainstorm 3+ options, present tradeoffs, get human approval

/brainstorming
3

Plan

Break into bite-sized tasks with file paths and test strategies

/deepen-plan
4

Build

Execute with TDD. Verify with evidence. Dispatch review agents

/orchestrate
5

Ship

Merge, update docs, capture learnings for next session

/session-wrap

Not everything needs the full flow. Bug fixes, typos, and config changes use a lightweight workflow: write a failing test, fix it, verify, commit. The boundary is clear — if you're touching 4+ files or unsure of the approach, use the full workflow.

Multi-Agent Orchestration

Four coordination patterns — each designed for a specific type of work

/review-swarm

Review Swarm

6-10 specialized reviewers (security, performance, architecture, code quality, test coverage, data integrity) dispatched in parallel. A findings-synthesizer merges into a unified P1/P2/P3 report.

Review Swarm — parallel reviewers → findings-synthesizer → unified report
/deep-research

Research Swarm

5 agents research in parallel: best practices, git history, framework docs, codebase context, and past solutions. A research-synthesizer consolidates into one brief.

Research Swarm — 5 parallel researchers → research-synthesizer
/orchestrate

Wave Orchestration

Groups tasks by dependency into waves. Parallel within waves via worktree-isolated subagents. An integration-verifier validates between waves.

Wave Orchestration — dependency-ordered waves with integration verification
/team-execution

Agent Teams

Fully independent Claude Code instances with a shared task list and messaging. Unlike swarms (read-only), Agent Teams are peers that discuss, divide files, and coordinate.

Agent Teams — collaborative instances with shared task list and messaging

Agent Ecosystem

26 specialized agents organized into 4 teams

Review Team 6
code-reviewer General code quality and patterns
security-sentinel Security vulnerabilities and risks
performance-oracle Performance bottlenecks and scaling
code-simplicity-reviewer Complexity reduction and clarity
convention-enforcer Project conventions compliance
test-coverage-reviewer Test gaps and coverage analysis
Research Team 5
learnings-researcher Search past solutions and learnings
framework-docs-researcher Framework documentation lookup
best-practices-researcher Industry best practices analysis
git-history-analyzer Git log patterns and history mining
codebase-context-mapper Architecture and dependency mapping
Conditional Reviewers 4
architecture-strategist Structural patterns and design
frontend-reviewer UI/UX patterns and accessibility
data-integrity-guardian Data validation and consistency
schema-drift-detector Schema and API contract changes
Synthesis 3
findings-synthesizer Merge review findings into P1/P2/P3
research-synthesizer Consolidate research into briefs
integration-verifier Cross-wave integration checks
Execution 4
team-lead 200K-context orchestrator for workers
integration-checker Post-merge integration validation
deployment-verifier Deployment readiness checks
bug-reproduction-validator Reproduce and verify bug fixes
Specialist 4
codebase-mapper Full codebase structure mapping
pr-comment-resolver Resolve PR review comments
test-gap-analyzer Find untested code paths
plan-checker Validate plan quality and scope

Persistent Execution

Two-layer defense against context exhaustion and premature exit

Large features can exhaust Claude's 200K context window. When that happens, most setups just stop. Blueprint has two redundant loop mechanisms that keep work going — one inside the session, one outside — each solving a different failure mode.

OUTER LOOP — scripts/ship.sh

External Bash Loop

Runs outside Claude in your terminal. Spawns a fresh Claude process per iteration — each gets a clean 200K context window. State persists through git commits and plan files. Max 10 iterations (configurable with --max).

Spawn Fresh 200K
→
Execute /ship-pipeline
→
Commit State to git
→
Check <promise>DONE</promise>
→
Not done? Iterate
Loop until <promise>DONE</promise> or max iterations reached
INNER GUARD — ship-loop.sh (Stop Hook)

Session Exit Guard

Runs inside Claude's session as a Stop hook. When Claude tries to exit before work is complete, the hook blocks the exit and re-injects the original prompt. Same session, growing context. Max 5 internal retries.

Claude stops
→
Check promise
→
Block exit
→
Re-inject prompt
Promise-based unlock — exact match of <promise>DONE</promise> required

Outer Loop: Context Reset

scripts/ship.sh runs in your terminal as a bash loop. Each iteration runs claude --print as a completely fresh process. Work accumulates via git commits — the plan file stays on disk, changes are committed, and each new Claude instance picks up where the last left off. Includes a braille spinner with 8-stage detection showing what stage the pipeline is in.

Inner Guard: Exit Prevention

ship-loop.sh is a Stop hook that fires when Claude tries to end the session. It checks for <promise>DONE</promise> in the last output. If missing, it blocks the exit and re-injects the original prompt as a new message — Claude continues working in the same session. Session-isolated by branch name to prevent cross-contamination.

Completion Signal

Both loops gate on the same signal: <promise>DONE</promise>. This isn't a string Claude casually outputs — the /ship-pipeline skill only emits it after all 7 pipeline stages complete (requirements → plan → deepen → execute → review → compound → ship). No false positives.

State Persistence

Between iterations, state persists through multiple channels: git commits (code changes), plan files (task progress), progress tracking (.claude/ship-progress.local.md), and iteration logs (.claude/ship-logs/). Each new process reads the current state of the repo and continues from where the last one stopped.

Circuit Breakers — Knowing When to Stop

3 consecutive no-progress iterations
5 identical errors in a row
4+ tasks touching the same file
20% WTF-likelihood risk threshold
3Q Reflection Gate before every retry

Quality Gates

Five non-negotiable checkpoints enforced automatically

1

No code without design approval

brainstorming

2

No production code without failing test

test-driven-development

3

No fix without root cause

systematic-debugging

4

No completion claim without verification

verification-before-completion

5

No merge without code review

requesting-code-review

These aren't suggestions — they're hard gates. Claude will stop and course-correct if any gate is skipped.

Knowledge Compounding

Every solved problem makes the next one easier

Solve Problem
→
Capture /knowledge-compounding
→
Store docs/solutions/
→
Auto-Consult /brainstorming
→
Better Plans
→
Solve Faster
Cycle repeats — institutional memory grows with every session

Institutional Memory That Grows

Every solved problem becomes a structured, searchable document in docs/solutions/. Your project accumulates institutional knowledge over time.

Automatic Consultation

Planning skills like /brainstorming and /deep-research automatically search past solutions before starting new work. No manual lookup needed.

Zero Manual Effort

The /session-wrap skill captures learnings automatically at the end of every session. Knowledge compounds without extra work from you.

Session Continuity

Pick up exactly where you left off — every time

Without Blueprint
→ "What were we doing?"
→ Re-read everything from scratch
→ Lose track of previous decisions
→ Waste 10+ minutes orienting
→ Accidentally redo completed work
With Blueprint
→ CLAUDE.md Session Continuity auto-updated
→ /resume-session loads full context
→ Instant orientation in seconds
→ "Start here" tells you exactly what to do
→ Decisions preserved across sessions
CLAUDE.md — Session Continuity
## Session Continuity   Last session: 2026-04-13   What was done: - Implemented user auth with OAuth2 - Added JWT token refresh endpoint - Review swarm found 2 P2 issues, both fixed   What's remaining: - Add rate limiting to auth endpoints - Write integration tests for token flow   Start here: Add rate limiting middleware   to src/middleware/auth-limiter.ts

Get Started

Install once, available in every project

1 Plugin Marketplace

claude
/plugin marketplace add   Ninety2UA/claude-code-blueprint /plugin install   claude-code-blueprint

2 Or One-Line Install

terminal
curl -fsSL \   https://raw.githubusercontent.com/   Ninety2UA/claude-code-blueprint/   main/install.sh | bash

3 Set Up Your Project

claude
$ claude > /project-start # scaffold docs > /brainstorming # first feature ✓ Ready to build

Update to latest version

Run /plugin install claude-code-blueprint inside any Claude Code session to re-fetch the latest version from GitHub. Restart your session after updating.

All 53 Skills

Every skill in the Blueprint, organized by category

Pipelines 5
build-pipeline ship-pipeline quick-fix orchestrate team-execution
Design & Planning 8
brainstorming discuss writing-plans deepen-plan deep-research ideation scope-cutting spike-exploration
Quality & Review 8
review-swarm requesting-code-review receiving-code-review systematic-debugging test-driven-development add-tests verification-before-completion iterative-refinement
Session Management 9
project-start project-status resume-session pause-checkpoint session-wrap session-continuity context-checkpoint backlog-triage health-check
Operations 11
pr-workflow codebase-mapping changelog-generation plugin-update migrate-to-plugin dependency-management deployment-verification migration-planning performance-profiling document-review browser-testing
Orchestration & Meta 12
wave-orchestration swarm-orchestration agent-teams dispatching-parallel-agents resolve-in-parallel using-git-worktrees subagent-driven-development executing-plans autonomous-loop finishing-a-development-branch knowledge-compounding writing-skills

Ecosystem Analysis

16+ repos analyzed through direct source code inspection

Repo / ToolStarsVerdict
gstack22K15 patterns adopted
oh-my-claudecode21.9K3 patterns adopted
GSD24.7K4 patterns adopted
Superpowers71KPatterns adopted
Compound Eng.9.9KPatterns adopted
Everything CC50K+Reference
UI/UX Pro Max37KReference
claude-mem39.7KImport nothing
claude-squad6.5KImport nothing
Ralph13.5KPattern adopted
Ralphy2.5KPattern adopted

"Import nothing is a feature, not a failure. Sometimes the right answer after deep analysis is to change nothing."

v3.2.1

What's New

Framework audit — 18 fixes across hooks, skills, templates, and docs

Hook Quality Fixes

task-completed.js no longer false-positives on TypeScript files. Python syntax checks now use python3 (was silently skipped on macOS).

Stale References Purged

35 occurrences of old command names (/start, /wrap, /planning, etc.) updated across 13 files. Every new project now gets correct skill references.

Shell Scripts Hardened

render-graphs.js upgraded to execFileSync. find-polluter.sh word-splitting bug fixed for paths with spaces.

Version Chain Aligned

All manifests, installer, and docs now report consistent version numbers. README TOC anchor fixed. Team count corrected across website pages.

v3.2.0

Previously

Commands merged into skills — 53 skills, zero commands

Commands Merged Into Skills

All 27 commands are now skills. 53 total skills, zero commands. Skills are the direct entry point — no sandbox loading gap.

Anthropic Best Practices

Skill descriptions follow Anthropic's guidelines: pushy triggers (activate proactively) and negative triggers (avoid false matches).

Key Renames

/build → /build-pipeline, /ship → /ship-pipeline, /planning → /brainstorming, /quick → /quick-fix, /start → /project-start, /status → /project-status, /wrap → /session-wrap, /compound → /knowledge-compounding, /debug → /systematic-debugging, /update → /plugin-update, /team → /team-execution, /review → /requesting-code-review, /ideate → /ideation, /map → /codebase-mapping, /backlog → /backlog-triage, /health → /health-check, /pause → /pause-checkpoint, /resume → /resume-session, /pr → /pr-workflow, /changelog → /changelog-generation, /deepen → /deepen-plan

Direct Skill Entry

Every skill is a first-class entry point. No wrapper commands, no indirection. Type the skill name and go. Auto-creates MEMORY.md on first session start.

v3.1.0

Previously

Blueprint became a native Claude Code plugin

Plugin Architecture

Install once, available in every project. Zero engine files in your git history.

/project-start Scaffolding

Project files (CLAUDE.md, docs/, BACKLOG.md) created on demand per project.

/migrate-to-plugin

Transition v2.x in-project files to plugin mode. Removes engine files, keeps project state.

Sandbox Compatible

Cross-references use Skill tool instead of file paths. Required by Claude Code's plugin sandbox.

FAQ

Yes. The blueprint installs as a plugin — it adds zero files to your project. Run the plugin install steps, then /project-start to scaffold the docs structure. Your existing code is never touched.
No. Skills activate contextually. If you never do TDD, the test-driven-development skill won't activate. The template works with any subset — you can also configure which agents are active per project via blueprint.local.md.
Skills are instructions for the main Claude session — they guide Claude's behavior during your conversation. Agents are separate subprocesses dispatched via the Task tool, each with their own 200K context window. Use agents for focused analysis that benefits from isolation.
No. CLAUDE.md adds minimal context. Skills and agents are loaded on-demand, not upfront. Most of the intelligence is in skill files which are only read when triggered.
/ship-pipeline is the fully autonomous pipeline — zero checkpoints, fire-and-forget. It plans, researches, executes via a dedicated team-lead agent, iteratively reviews (3 cycles), and opens a PR. Use it for well-defined features. For large features that may exhaust context, use scripts/ship.sh from your terminal.
Two mechanisms at different layers. Inside a session, the ship-loop.sh Stop hook blocks premature exit (max 5 retries, same context). Outside a session, scripts/ship.sh spawns fresh Claude processes — each gets a clean 200K context, state persists via git.
After solving a non-trivial problem, /knowledge-compounding saves it as a structured document in docs/solutions/. Future /brainstorming and /deep-research skills automatically search this directory before starting new work. Your project builds institutional knowledge over time.