Skill

Generate Executable Code Project Plans

Generates cold-start-executable plans for multi-session, multi-agent projects - each step runnable by a fresh agent with no prior context.

Works with githubpostgres

91
Spark score
out of 100
Updated last month
Source checked Aug 21, 2026
Version 15.16.0
Models
claude

Add to Favorites

Why it matters

Transform a high-level objective into a detailed, step-by-step execution plan for coding agents. Ensures each step is independently executable, even by agents without conversation history.

Outcomes

What it gets done

01

Break down complex objectives into single-PR-sized, executable steps.

02

Incorporate branch workflow rules, CI policies, and rollback strategies.

03

Facilitate adversarial review of the plan by a strong-model sub-agent.

04

Generate plans with cold-start execution context for each step.

Install

Add it to your toolbox

Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-blueprint | bash

After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.

Reports

Agent outcome reports

No reports yet

Overview

Blueprint - Construction Plan Generator

Generates multi-step project plans as Markdown files where every step is self-contained enough for a fresh agent, with no prior conversation context, to execute it cold. Includes a dependency graph for parallel steps, an adversarial review pass by a strongest-model sub-agent, and a progress log for resuming across sessions. Use it for coding projects too large for a single agent session - multi-step refactors, migrations, phased rollouts - where steps need to be picked up by different agents in different sessions. Not the right tool for single-session, quick, or exploratory tasks, where Claude Code's built-in /plan is simpler.

What it does

Blueprint generates plans for large coding projects - multi-step refactors, plugin extractions, architecture migrations, phased feature rollouts - as plain Markdown files where every step carries enough context to be executed cold, by a different agent in a different session. Each step is one-PR sized, with a task list, rollback strategy, verification commands, and exit criteria; the plan also includes a dependency graph (which steps can run in parallel vs. serially), locked design decisions, invariants checked after every step, a progress log as the single source of truth for execution state, and a review log from an independent adversarial review.

When to use - and when NOT to

Use it for projects too large for a single agent session, where steps need to be picked up cold by a fresh agent that hasn't read the conversation history or prior steps. It's explicitly a different tool than Claude Code's built-in /plan (good for single-session, quick, exploratory work) or persistent-planning tools that solve context loss with session-catchup scripts - Blueprint targets multi-session, multi-agent projects specifically, with cold-start context briefs, an adversarial review gate, and a branch/PR/CI workflow built into every step.

Inputs and outputs

Run /blueprint myapp "migrate database to PostgreSQL" to scan the codebase, design a step-by-step plan, review it with a strongest-model sub-agent (falling back to the default model if unavailable), and save it to plans/myapp-migrate-database-to-postgresql.md. Each step's Context field is a cold-start brief describing exactly what state the codebase is in and what the step does; tasks are marked [exact] (run this command verbatim), [guided] (agent decides the approach), or [open] (goal only, full autonomy). Plans are living documents: steps can be split, inserted, skipped, reordered, or abandoned through formal protocols with an audit trail, and a new session reads the Progress Log plus branch/file state to resume exactly where the last session stopped.

Integrations

Installed into Claude Code by cloning into ~/.claude/skills/blueprint, after which /blueprint is discovered automatically; since generated plans are standard Markdown, any agent that can read files can execute one by treating SKILL.md as a system prompt. Git and the GitHub CLI unlock the full branch/PR/CI workflow, but Blueprint detects their absence and falls back to a direct mode instead of failing - the same graceful-degradation pattern applies if the strongest review model or project memory is unavailable.

Who it's for

Developers running large, multi-session projects across multiple agent instances who need each step independently executable without shared conversation context, plus an adversarial review pass and a real dependency graph for parallelizable work - beyond what a single-session plan or a simple persisted-context tool provides.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.