blueprint
affaan-m/ECC
Générer un plan de construction étape par étape à partir d'un objectif succinct, avec des graphiques de dépendances, la détection des étapes parallèles et une révision contradictoire pour les projets d'ingénierie en plusieurs sessions.
...Développer toutBlueprint — Générateur de plans de construction
Transformez un objectif d'une ligne en un plan de construction étape par étape que n'importe quel développeur peut exécuter sans préparation.
Quand l’utiliser
- Pour décomposer une fonctionnalité volumineuse en plusieurs pull requests avec un ordre de dépendance clair
- Planifier une refactorisation ou une migration s’étalant sur plusieurs sessions
- Coordonner des flux de travail parallèles entre sous-agents
- Toute tâche pour laquelle une perte de contexte entre les sessions entraînerait un surcroît de travail
À ne pas utiliser pour les tâches pouvant être réalisées dans une seule pull request, nécessitant moins de 3 appels d'outils, ou lorsque l'utilisateur dit « fais-le, c'est tout ».
Fonctionnement
Blueprint Exécute un pipeline en 5 phases :
- Recherche — Vérifications préalables (git, authentification GitHub, distant, branche par défaut), puis lecture de la structure du projet, des plans existants et des fichiers en mémoire pour recueillir le contexte.
- Conception — Décompose l’objectif en étapes de la taille d’une pull request (généralement entre 3 et 12). Attribue les liaisons de dépendance, l’ordre parallèle/série, le niveau de modélisation (le plus strict ou par défaut) et la stratégie de restauration pour chaque étape.
- Ébauche — Rédige un fichier de plan Markdown autonome dans
plans/. Chaque étape comprend un résumé du contexte, une liste de tâches, des commandes de vérification et des critères de sortie — ce qui permet à un nouvel agent d’exécuter n’importe quelle étape sans avoir à lire les étapes précédentes. - Révision — Délègue la révision critique à un sous-agent utilisant le modèle le plus performant (par exemple, Opus) à l’aide d’une liste de contrôle et d’un catalogue d’anti-modèles. Corrige tous les problèmes critiques avant la finalisation.
- Enregistrement — Enregistre le plan, met à jour l’index en mémoire et présente à l’utilisateur le nombre d’étapes et un résumé du parallélisme.
Blueprint Détecte automatiquement la disponibilité de git/gh. Avec git + GitHub CLI, il génère des plans complets de workflow pour les branches, les PR et la CI. En leur absence, il passe en mode direct (édition sur place, sans branches).
Exemples
Utilisation de base
/blueprint myapp "migrate database to PostgreSQL"
Génère plans/myapp-migrate-database-to-postgresql.md avec des étapes telles que :
- Étape 1 : Ajouter le pilote PostgreSQL et la configuration de connexion
- Étape 2 : Créer des scripts de migration pour chaque table
- Étape 3 : Mettre à jour la couche de référentiel pour utiliser le nouveau pilote
- Étape 4 : Ajouter des tests d'intégration pour PostgreSQL
- Étape 5 : Supprimer l'ancien code et la configuration de la base de données
Projet multi-agents
/blueprint chatbot "extract LLM providers into a plugin system"
Génère un plan comportant des étapes parallèles lorsque cela est possible (par exemple, les étapes « implémenter le plugin Anthropic » et « implémenter le plugin OpenAI » s’exécutent en parallèle une fois l’étape d’interface des plugins terminée), des affectations au niveau du modèle (prioritaires pour l'étape de conception de l'interface, par défaut pour la mise en œuvre), et des invariants vérifiés après chaque étape (par exemple, « tous les tests existants réussissent », « aucune importation de fournisseur dans le cœur »).
Fonctionnalités clés
- Exécution à froid — Chaque étape comprend un résumé contextuel autonome. Aucun contexte préalable n’est nécessaire.
- Contrôle de révision antagoniste — Chaque plan est examiné par un sous-agent utilisant le modèle le plus performant, à l’aide d’une liste de contrôle portant sur l’exhaustivité, l’exactitude des dépendances et la détection des anti-modèles.
- Workflow de branche/PR/CI — Intégré à chaque étape. Passe en douceur en mode direct en l’absence de git/gh.
- Détection des étapes parallèles — Le graphe de dépendances identifie les étapes ne comportant ni fichiers partagés ni dépendances de sortie.
- Protocole de modification des plans — Les étapes peuvent être divisées, insérées, ignorées, réorganisées ou abandonnées selon des protocoles formels et avec une piste d’audit.
- Risque d’exécution nul — Compétence Markdown pure. L’ensemble du dépôt ne contient que
.mddes fichiers — pas de hooks, pas de scripts shell, pas de code exécutable, pas depackage.json, aucune étape de compilation. Rien ne s’exécute lors de l’installation ou de l’invocation, hormis le chargeur natif de compétences Markdown de Claude Code.
Installation
Cette compétence est fournie avec Everything Claude Code. Aucune installation distincte n’est nécessaire lorsque ECC est installé.
Installation complète d’ECC
Si vous travaillez à partir du dépôt ECC, vérifiez que la compétence est bien présente à l’aide de la commande suivante :
test -f skills/blueprint/SKILL.md
Pour effectuer une mise à jour ultérieure, consultez le diff ECC avant de procéder :
cd /path/to/everything-claude-code
git fetch origin main
git log --oneline HEAD..origin/main # review new commits before updating
git checkout # pin to a specific reviewed commit
Installation autonome via le « vendoring »
Si vous installez uniquement cette compétence en dehors de l’installation complète d’ECC, copiez le fichier validé depuis le dépôt ECC vers ~/.claude/skills/blueprint/SKILL.md. Les copies « vendored » ne disposent pas de git remote ; mettez-les donc à jour en recopiant le fichier à partir d’un commit ECC validé plutôt qu’en exécutant git pull.
Prérequis
- Claude Code (pour la
/blueprintcommande « / ») - Git + GitHub CLI (facultatif — permet un workflow complet de branches/PR/CI ; Blueprint détecte l’absence de l’outil et bascule automatiquement en mode direct)
Source
Inspiré de antbotlab/blueprint — projet en amont et conception de référence.
---
name: blueprint
description: Generate a step-by-step construction plan from a one-line objective, with dependency graphs, parallel step detection, and adversarial review for multi-session engineering projects.
---
# 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 executable code, no `package.json`, no build step. Nothing runs on install or invocation beyond Claude Code's native Markdown skill loader.
## Installation
This skill ships with Everything Claude Code. No separate installation is needed when ECC is installed.
### Full ECC install
If you are working from the ECC repository checkout, verify the skill is present with:
```bash
test -f skills/blueprint/SKILL.md
```
To update later, review the ECC diff before updating:
```bash
cd /path/to/everything-claude-code
git fetch origin main
git log --oneline HEAD..origin/main # review new commits before updating
git checkout <reviewed-full-sha> # pin to a specific reviewed commit
```
### Vendored standalone install
If you are vendoring only this skill outside the full ECC install, copy the reviewed file from the ECC repository into `~/.claude/skills/blueprint/SKILL.md`. Vendored copies do not have a git remote, so update them by re-copying the file from a reviewed ECC commit rather than running `git pull`.
## Requirements
- Claude Code (for `/blueprint` slash command)
- Git + GitHub CLI (optional — enables full branch/PR/CI workflow; Blueprint detects absence and auto-switches to direct mode)
## Source
Inspired by antbotlab/blueprint — upstream project and reference design.
Tous les fichiers
1 fichiersInstaller blueprint
Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.
Télécharger le ZIPClonez le dépôt et copiez les fichiers de compétence dans votre projet.
git clone https://github.com/affaan-m/ECC/tree/main/skills/blueprint # Copy SKILL.md to your .claude/skills/ directory
Copier





Maison
