Blueprint
Turn a one-line objective into a multi-PR construction plan with cold-start context briefs, dependency edges, parallel steps, and an adversarial review gate.
Overview
Blueprint is an agent skill most often used in Build (also Validate scope, Ship launch) that converts a complex objective into a dependency-aware, multi-PR construction plan with cold-start step briefs and an adversarial
Install
npx skills add https://github.com/affaan-m/everything-claude-code --skill blueprintWhat is this skill?
- 5-phase pipeline: Research, Design, adversarial review gate, plus dependency and parallel-step detection
- Steps sized as one-PR units (typically 3–12) with self-contained context briefs for cold agents
- Anti-pattern catalog and plan mutation protocol for evolving multi-session work
- Pre-flight checks: git, gh auth, remote, and default branch before planning
- Explicit DO NOT TRIGGER when task fits a single PR, fewer than 3 tool calls, or user says just do it
- 5-phase pipeline: Research through Design with adversarial review gate
- Typical plan contains 3–12 one-PR-sized steps
Adoption & trust: 4.3k installs on skills.sh; 210k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have a large objective but no ordered, PR-sized plan that survives context loss between agent sessions or parallel sub-agents.
Who is it for?
Solo builders running Claude Code or similar agents on refactors, migrations, or multi-PR features that need explicit handoff briefs.
Skip if: Single-PR tasks, fewer than three tool calls, or when the user explicitly says just do it without wanting a roadmap.
When should I use this skill?
User requests a plan, blueprint, or roadmap for a complex multi-PR task, or describes work needing multiple sessions; not for single-PR or sub-3-tool-call tasks or just do it.
What do I get? / Deliverables
You receive a step-by-step blueprint with dependencies, parallel steps, and review gates so the next session can invoke implementation skills against one step at a time.
- Step-by-step construction plan with dependency graph
- Per-step self-contained context briefs for cold agent execution
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build → pm because the primary artifact is a step-by-step engineering plan sized for PRs and multi-session agent execution. Subphase pm fits blueprint’s dependency graph, parallel step detection, and plan mutation protocol—planning infrastructure for implementation, not coding a single file.
Where it fits
Turn a vague migration idea into 3–12 PR steps with dependencies before committing engineering time.
Coordinate parallel sub-agents using detected parallel steps and per-step context briefs.
Order final launch-blocking PRs after adversarial review highlights gaps in the plan.
How it compares
Use instead of ad-hoc chat planning that omits gh pre-flight, parallel step detection, and adversarial review before coding starts.
Common Questions / FAQ
Who is blueprint for?
Indie developers and small teams using coding agents on multi-session work who need PR-sized steps and cold-start context for each step.
When should I use blueprint?
At Validate when scoping a large feature into PRs, at Build pm when coordinating parallel agent workstreams, or before Ship launch when ordering remaining hardening PRs.
Is blueprint safe to install?
It may instruct agents to inspect git remotes and GitHub auth; confirm repo access and review the Security Audits panel on this Prism page before enabling broad filesystem or network permissions.
SKILL.md
READMESKILL.md - Blueprint
# Blueprint — Construction Plan Generator Turn a one-line objective into a step-by-step construction plan that any coding agent can execute cold. ## When to Use - Breaking a large feature into multiple PRs with clear dependency order - Planning a refactor or migration that spans multiple sessions - Coordinating parallel workstreams across sub-agents - Any task where context loss between sessions would cause rework **Do not use** for tasks completable in a single PR, fewer than 3 tool calls, or when the user says "just do it." ## How It Works Blueprint runs a 5-phase pipeline: 1. **Research** — Pre-flight checks (git, gh auth, remote, default branch), then reads project structure, existing plans, and memory files to gather context. 2. **Design** — Breaks the objective into one-PR-sized steps (3–12 typical). Assigns dependency edges, parallel/serial ordering, model tier (strongest vs default), and rollback strategy per step. 3. **Draft** — Writes a self-contained Markdown plan file to `plans/`. Every step includes a context brief, task list, verification commands, and exit criteria — so a fresh agent can execute any step without reading prior steps. 4. **Review** — Delegates adversarial review to a strongest-model sub-agent (e.g., Opus) against a checklist and anti-pattern catalog. Fixes all critical findings before finalizing. 5. **Register** — Saves the plan, updates memory index, and presents the step count and parallelism summary to the user. Blueprint detects git/gh availability automatically. With git + GitHub CLI, it generates full branch/PR/CI workflow plans. Without them, it switches to direct mode (edit-in-place, no branches). ## Examples ### Basic usage ``` /blueprint myapp "migrate database to PostgreSQL" ``` Produces `plans/myapp-migrate-database-to-postgresql.md` with steps like: - Step 1: Add PostgreSQL driver and connection config - Step 2: Create migration scripts for each table - Step 3: Update repository layer to use new driver - Step 4: Add integration tests against PostgreSQL - Step 5: Remove old database code and config ### Multi-agent project ``` /blueprint chatbot "extract LLM providers into a plugin system" ``` Produces a plan with parallel steps where possible (e.g., "implement Anthropic plugin" and "implement OpenAI plugin" run in parallel after the plugin interface step is done), model tier assignments (strongest for the interface design step, default for implementation), and invariants verified after every step (e.g., "all existing tests pass", "no provider imports in core"). ## Key Features - **Cold-start execution** — Every step includes a self-contained context brief. No prior context needed. - **Adversarial review gate** — Every plan is reviewed by a strongest-model sub-agent against a checklist covering completeness, dependency correctness, and anti-pattern detection. - **Branch/PR/CI workflow** — Built into every step. Degrades gracefully to direct mode when git/gh is absent. - **Parallel step detection** — Dependency graph identifies steps with no shared files or output dependencies. - **Plan mutation protocol** — Steps can be split, inserted, skipped, reordered, or abandoned with formal protocols and audit trail. - **Zero runtime risk** — Pure Markdown skill. The entire repository contains only `.md` files — no hooks, no shell scripts, no