Communitygithub.com

ecc-recipes

Transformez une description de workflow en la bonne famille de commandes ECC, avec ordre d'exécution et condition d'arrêt, et parcourez toutes les familles de recettes de groupes de commandes.

Qu'est-ce que ecc-recipes ?

Ce skill, `ecc-recipes`, sert de point d'entrée unique pour identifier quel groupe de slash-commandes ECC exécute un workflow donné, dans quel ordre, et quand s'arrêter. Il comble le fossé entre `ecc-guide`, qui liste les commandes sans structure, et `prompt-optimizer`, qui produit un prompt unique plutôt qu'un groupe de commandes avec ordre et condition d'arrêt. En lisant en direct le répertoire des commandes, il classe les commandes en familles par préfixe (ex: `orch-*`, `multi-*`, `prp-*`) et produit soit un catalogue de toutes les recettes, soit un plan sur mesure pour le workflow de l'utilisateur, incluant l'ordre d'exécution, la condition d'arrêt (comme un nombre maximal d'itérations ou un signal de complétion), et un avertissement pour les boucles autonomes. Il est purement consultatif et ne déclenche pas d'exécution. Il s'active lorsque l'utilisateur demande le groupe de commandes adapté à son workflow ou souhaite parcourir les pipelines, mais ne doit pas s'activer pour une exécution directe, une documentation profonde d'une seule commande (utiliser `ecc-guide`), ou la réécriture d'un prompt (utiliser `prompt-optimizer`).

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/ecc-recipes

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Recettes ECC

Point d'entrée unique pour « quel groupe de slash-commandes ECC exécute mon workflow, dans quel ordre, et quand m'arrêter ? ». Permet également de parcourir toutes les familles de recettes de groupes de commandes.

Comble le fossé entre deux skills existants :

  • ecc-guide — liste les commandes et où lire la documentation, mais sous forme de catalogue plat.
  • prompt-optimizer — associe une tâche à des composants, mais produit un seul prompt, pas un groupe de commandes avec ordre et condition d'arrêt.

Ce skill ajoute : regroupement par famille + ordre d'exécution + condition d'arrêt.

Quand l'activer

  • « Quel groupe de commandes dois-je exécuter pour ? »
  • « Quelle est la séquence de commandes pour construire un MVP / corriger un défaut / refactoriser ? »
  • « Montre-moi toutes les recettes de groupes de commandes ECC » (mode catalogue)
  • « Combien de pipelines de workflow ECC existe-t-il ? »
  • L'utilisateur invoque /ecc-recipes avec ou sans description.

Ne pas utiliser quand

  • L'utilisateur veut que la tâche soit exécutée maintenant — redirigez vers la commande réelle, ne la décrivez pas.
  • L'utilisateur veut une documentation approfondie pour UNE commande — utilisez ecc-guide.
  • L'utilisateur veut qu'un brouillon de prompt soit réécrit — utilisez prompt-optimizer.

Principe fondamental

Répondez à partir des fichiers actuels, pas de la mémoire. L'ensemble des commandes change ; ne codez jamais en dur les comptes ni les listes de membres. Lisez le répertoire commands/ en direct à chaque exécution, puis classez-les en familles.

Lectures en direct

Résolvez le répertoire des commandes (le premier qui existe), puis listez les noms :

for D in \
  "$HOME"/.claude/plugins/marketplaces/ecc/commands \
  "$HOME"/.claude/plugins/cache/ecc/ecc/*/commands \
  ./commands \
  ./.claude/commands \
  "$HOME"/.claude/commands; do
  [ -d "$D" ] && CMD_DIR="$D" && break
done
[ -z "${CMD_DIR:-}" ] && { echo "Répertoire de commandes ECC introuvable."; return 1; }
find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort

Optionnellement, lisez manifests/install-*.json s'il existe pour un regroupement plus riche. Utilisez le plus petit ensemble de lectures nécessaire.

Classification en familles (par préfixe)

Regroupez les noms de commandes par préfixe principal ; mappez les singletons connus manuellement. Les familles sont dérivées en direct — le tableau ci-dessous est la règle de classification, pas une liste figée.

Préfixe de familleSignification de la recetteOrdre d'exécution typique
orch-*Recherche, Planification, TDD, Revue, Commit par type de tâchechoisir un orch-* selon le type de tâche ; il exécute ses propres phases internes
multi-*Workflow multi-modèlemulti-plan puis multi-execute puis revue (ou multi-workflow de bout en bout)
prp-*Pipeline PRD → plan → implémentation → PRprp-prd puis prp-plan puis prp-implement puis prp-commit puis prp-pr
epic-*Grande épique multi-unités, parallèleepic-decompose puis epic-claim puis epic-validate puis epic-review puis epic-unblock puis epic-sync puis epic-publish
loop-*Boucle autonome gérée et surveillanceloop-start <modèle> puis surveiller avec loop-status
gan-*Boucle générateur et évaluateurgan-build (code) ou gan-design (UI) ; auto-bouclage
*-build / *-review / *-testTriade CI par langage<lang>-test (TDD) puis <lang>-build (correction) puis <lang>-review
hookify-*Gestion des hooks de comportementhookify puis hookify-list puis hookify-configure
learn / instinct-* / evolve / promote / pruneApprentissage continulearn puis instinct-status puis evolve puis promote
singletonssanta-loop, plan, plan-prd, pr, code-review, checkpoint, etc.autonome ou colle entre groupes

Toute commande ne correspondant pas à une règle de préfixe → listez-la sous singletons avec sa description d'une ligne.

Comment ça fonctionne

1. Lecture en direct des noms de commandes depuis CMD_DIR.
2. Classification en familles par préfixe et une carte des singletons.
3. Si une description de workflow a été fournie -> MODE CORRESPONDANCE.
   Sinon -> MODE CATALOGUE.
4. Uniquement consultatif : affichez le plan. N'exécutez jamais les commandes correspondantes.

Mode catalogue (aucune description)

Affichez le tableau des familles : chaque famille, nombre de membres, membres, signification en une ligne, ordre d'exécution typique. Terminez par le nombre total de commandes et une invite à décrire un workflow pour obtenir une recette correspondante.

Mode correspondance (description fournie)

  1. Reformulez le workflow en une phrase.
  2. Choisissez la ou les 2 meilleures familles ; expliquez POURQUOI en une ligne chacune.
  3. Bloc d'ordre d'exécution — séquence exacte de commandes pour la famille correspondante.
  4. Condition d'arrêt — toujours explicite (nombre maximal d'exécutions, signal de complétion, passages en revue, ou tir unique). Pour les boucles autonomes, avertissez de la consommation d'abonnement et recommandez une limite de sécurité.
  5. Où lire — le chemin commands/<nom>.md plus /ecc-guide <nom>.

Modèle de sortie (mode correspondance)

Workflow : <reformulation en une phrase>

Meilleure correspondance : <famille> — <pourquoi>
(Alternative : <famille> — <pourquoi>)

Ordre d'exécution :
  /<cmd1>   # tâche
  /<cmd2>   # tâche
  /<cmd3>   # tâche
  STOP quand : <condition>
  ATTENTION (boucles autonomes uniquement) : une boucle sans limite consomme abonnement/crédits —
  ajoutez une limite de nombre d'itérations ou de coût maximal en complément du signal de complétion.

Lire la documentation complète :
  commands/<cmd1>.md   (ou : /ecc-guide <cmd1>)

Exemples

Catalogue : /ecc-recipes → affiche le tableau des familles et le nombre total.

Correspondance : /ecc-recipes planifier toute une application d'abord puis construire automatiquement avec revue contradictoire jusqu'à terminaison → Meilleure correspondance : loop-* (autonome) enveloppant gan-* ou santa-loop (contradictoire). Ordre d'exécution : plan-prd puis loop-start rfc-dag --mode safe puis surveiller loop-status ; STOP quand toutes les unités passent la revue N fois consécutives (ajouter une limite de nombre d'itérations pour borner la consommation).

Correspondance : /ecc-recipes corriger un bogue dans mon service Go → Meilleure correspondance : orch-fix-defect (reproduire, corriger, revoir, commit). Alternative : go-test puis go-build puis go-review. STOP : test de régression vert et revue approuvée.

Non-objectifs

  • Pas un exécuteur — uniquement consultatif.
  • Pas de documentation approfondie par commande — c'est le rôle de ecc-guide.
  • Pas de réécriture de prompt — c'est le rôle de prompt-optimizer.
  • Ne jamais coder en dur les comptes ou les listes de commandes — toujours lire en direct.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Skills associés