v3.5.2 — Validator Wiring

Claude Code
Blueprint

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

55 Skills 29 Agents 10 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...
55 Skills
29 Agents
10 Hooks
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

19 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

55

Skills

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

29

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.

10

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

29 specialized agents organized into 6 groups

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 6
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
pattern-mapper Analog files for new code
Conditional Reviewers 5
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
doc-claim-verifier Doc claims vs live code
Synthesis 4
findings-synthesizer Merge review findings into P1/P2/P3
research-synthesizer Consolidate research into briefs
integration-verifier Cross-wave integration checks
findings-validator False-positive filter for findings
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 55 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 9
review-swarm requesting-code-review receiving-code-review systematic-debugging test-driven-development add-tests verification-before-completion iterative-refinement source-driven-development
Session Management 9
project-start project-status resume-session pause-checkpoint session-wrap session-continuity context-checkpoint backlog-triage health-check
Operations 12
pr-workflow codebase-mapping changelog-generation plugin-update migrate-to-plugin dependency-management deployment-verification migration-planning performance-profiling document-review browser-testing forensics
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

19 repos analyzed through direct source code inspection

Repo / ToolStarsVerdict
gstack123K15 patterns adopted
oh-my-claudecode37.9K3 patterns adopted
GSD64.8K4 patterns adopted
Superpowers257KPatterns adopted
Compound Eng.23.2KPatterns adopted
Everything CC231KReference
UI/UX Pro Max108KReference
claude-mem87.9KImport nothing
claude-squad8.1KImport nothing
Ralph21.2KPattern adopted
Ralphy2.9KPattern adopted

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

Platform Currency

Every sync cycle audits the Claude Code platform and adopts what fits — as guarded opt-ins, never core dependencies

Platform-sync cycle — Audit (68 CLI versions) → Gate 1 → Adopt + verify (Part 1, v3.4.0) → Delta sweep (Part 2, 4 repos) → Gate 2 → Import + close (v3.5.0), codified into the /cli-watch + /repo-watch watchers
Native platform features adopted as guarded opt-ins
Effort tiers across 29 agents — 2 low, 14 medium, 13 high; model: inherit stays default
Two CI consistency gates — drift gate derives counts from the filesystem; skill-collision gate flags near-duplicate descriptions
/ship completion guard — ship-loop.sh default guard plus native /goal opt-in complement
v3.5.2

What's New

Validator wiring & guide refresh — the last unreferenced agent gets a home, and the ecosystem guide gets a July 2026 data edition

Independent Fix Verification

bug-reproduction-validator is now wired into systematic-debugging: it independently establishes disputed repros before investigation, and re-verifies non-trivial fixes in a fresh context — no session assumptions.

July 2026 Guide Edition

The Claude Code Tools Guide refreshed with live GitHub data — stars, forks, and versions across all 14 profiled tools (950K+ combined stars). Corrupted cells gone.

Committed PDF Pipeline

New render-ebook.js joins render-diagrams.js and record-promo.js — every visual artifact now regenerates from source with one command. No more ad-hoc renders that drift.

v3.5.1

What's New

Verification sweep — post-release loops (three review agents + mechanical cross-checks) caught every stale surface, and each class is now drift-gated

Total Rename Purge

~35 surviving pre-v3.2 command names eliminated — install next-steps, scaffolded templates, 21 skill/agent prose refs, hook comments. The v3.2 rename is finally total.

Complete Rosters

The agents grid and README table now list all 29 agents; the skills grid all 55. The promo GIF re-renders with real stats instead of v2.x fossils.

Live Ecosystem Data

Star columns refreshed from the GitHub API across README + site — 19 repos, ~1.1M combined stars. Corrupted cells (GSD-2 "KB", OpenCLI "v1.3") fixed.

Gate Expansion

check-drift.sh now verifies grid completeness, badge-vs-rendered integrity, repo-count claims, the README agents table, and the promo source — every check negative-tested.

v3.5.0

What's New

Ecosystem delta sweep — source-level re-analysis of four external repos, 5 patterns imported, two repos yielded nothing (a documented outcome)

Blindspot Pass

brainstorming now maps the decision surface for users in unfamiliar territory — "I know nothing about X but need to…" — surfacing the blind spots before asking questions. Imported from compound-engineering.

Reversibility-Tiering

ideation sizes scrutiny by two-way vs one-way door: reversible calls decide fast, irreversible ones (migrations, public APIs) demand deeper grounding. From compound-engineering.

Skill-Collision Detector

New CI gate flags near-duplicate skill descriptions (warn ≥50% / fail ≥75%) that a single-skill trigger test can't catch. From agent-skills.

Doubt-Driven Review

review-swarm reviewers now get the artifact + contract with the author's correctness claim stripped, and are told to demand disproof, not confirmation. From agent-skills.

OWASP-LLM Lens

systematic-debugging gains an OWASP-LLM threat lens and the load-bearing rule that the system prompt is not a security boundary — enforce at permissions, validation, and isolation.

Ecosystem Table Refresh

New gsd-core row (import-nothing community fork, provenance-noted), refreshed pins for all four repos, and corrected star counts — 19 repos, 550K+ combined stars.

v3.4.0

What's New

Platform currency sync — the blueprint now tracks and adopts the latest Claude Code platform features as stability-guarded opt-ins

Effort Tiers

All 29 agents now carry an effort: tier (low/medium/high) by reasoning depth. model: inherit stays the default; an opt-in per-tier model mapping is documented for plans that support it.

Native /goal Opt-In

/ship can emit a copyable /goal prompt for platform-native condition completion. The ship-loop.sh Stop-hook guard stays the zero-config, headless-safe default — /goal complements, never replaces it.

Drift Gate

New check-drift.sh CI job derives skill/agent/hook counts from the filesystem and enforces exact-match version equality across every manifest, doc, and the website. Ends the count-drift that recurred three times.

Hooks Exec-Form

All 10 hook handlers converted to exec-form (args[]) spawning — no shell tokenization, robust to install paths with spaces, aligned with the plugin's execFile-over-exec convention.

Platform Currency

A new README table documents native /loop, dynamic workflows/ultracode, per-session caps, and Agent-tool injection hardening — each recorded as a gated opt-in so no core pipeline depends on an experimental feature.

Ecosystem Table Fix

The addyosmani/agent-skills row (7 imported patterns) is now present in the ecosystem table, and the learnings pointer resolves to the real per-cycle docs.

v3.3.0

What's New

GSD deep-analysis imports — 13 patterns across read-injection, debug persistence, plan-checker, doc verification, and more

Read-Injection Scanner

New PostToolUse hook scans content returned by Read for prompt-injection patterns + invisible Unicode + tag-block range. Catches file-content poisoning that survives context compression.

Persistent Debug Sessions

systematic-debugging now optionally writes .claude/debug/<slug>.md. Hypothesis log + eliminated branches survive context resets. Auto-trigger after 3rd cycle.

Doc-Claim Verifier

New agent extracts factual claims from docs (file paths, commands, endpoints, symbols, deps) and verifies each against the filesystem. PASS/FAIL/UNVERIFIABLE per claim. Catches doc drift after refactors.

Pattern Mapper

New agent finds 3–5 existing analogs for each new file in a plan, emits PATTERNS.md with line-numbered code excerpts. Stops new code from inventing structure that already exists.

/forensics Skill

New post-mortem skill diagnoses failed /ship runs against ship-logs and git state. Investigates 4 anomaly categories. Read-only. Redacts sensitive content.

Adversarial Stance

code-reviewer, security-sentinel, integration-checker, findings-synthesizer, plan-checker now lead with explicit "assume X is broken until evidence proves otherwise" framing.

Plan-Checker Refinements

Three new dimensions: scope-reduction detection ("v1" hedges against locked decisions), cross-plan data-contract compatibility, must_haves discipline (user-observable truths).

Subagent Return Contract

Long-running agents now return {DONE | BLOCKED | NEEDS_INPUT | INCONCLUSIVE} + ≤ 2K-token summary. Bounds handoff cost. Detail spilled to disk, not context.

v3.2.1

Previously

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.