Ecc Recipes
Map a described workflow to the right ECC command group with run-order and stop condition, or browse all command-group recipe families read live from the commands directory. Advisory only — never executes. Use when asked which commands run a workflow, the command sequence for a task, or to list ECC pipelines; not for executing the task (route to the command itself), single-command docs (use ecc-guide), or prompt rewrites (use prompt-optimizer).
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Ecc Recipes when an AI agent needs a reusable SKILL.md workflow for this job: Map a described workflow to the right ECC command group with run-order and stop condition, or browse all command-group recipe families read live from the commands directory. Advisory only — never executes. Use when asked which commands run a workflow, the command sequence for a task, or to list ECC pipelines; not for executing the task (route to the command itself), single-command docs (use ecc-guide), or prompt rewrites (use prompt-optimizer).
When not to use it
Skip Ecc Recipes when the task is outside the productivity category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/ecc-recipes # Save SKILL.md to ~/.claude/skills/ecc-recipes/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/ecc-recipes/SKILL.md. For a shared project, commit the folder at .claude/skills/ecc-recipes/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Ecc Recipes skill for this task: Use Ecc Recipes when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
70/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 70/100
Model compatibility evidence
- claudeinferred
The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# ECC Recipes
One entry point for "which group of ECC slash-commands runs my workflow, in what order, and when do I stop." Also browses every command-group recipe family.
Fills the gap between two existing skills:
- `ecc-guide` — lists commands and where to read docs, but as a flat catalog. - `prompt-optimizer` — matches a task to components, but outputs a single prompt, not a multi-command group with run-order and stop condition.
This skill adds: **family grouping + run-order + stop condition.**
## When to Activate
- "Which command group do I run for <workflow>?" - "What's the command sequence to build an MVP / fix a defect / refactor?" - "Show me all ECC command-group recipes" (catalog mode) - "How many workflow pipelines does ECC have?" - User invokes `/ecc-recipes` with or without a description.
### Do Not Use When
- User wants the task done now — route to the actual command, don't describe it. - User wants deep docs for ONE command — use `ecc-guide`. - User wants a draft prompt rewritten — use `prompt-optimizer`.
## Core Principle
**Answer from current files, not memory.** The command set changes; never hardcode counts or member lists. Read the live `commands/` directory each run, then classify into families.
### Live reads
Resolve the commands directory (first that exists), then list names:
```bash 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 "No ECC commands directory found."; return 1; } find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort ```
Optionally read `manifests/install-*.json` if present for richer grouping. Use the smallest set of reads needed.
## Family Classification (by prefix)
Group command names by leading prefix; map known singletons by hand. Families are derived live — the table below is the *classification rule*, not a frozen list.
| Family prefix | Recipe meaning | Typical run-order | |---|---|---| | `orch-*` | gated Research, Plan, TDD, Review, Commit per task type | pick one orch-* by task kind; it runs its own internal phases | | `multi-*` | multi-model workflow | `multi-plan` then `multi-execute` then review (or `multi-workflow` end-to-end) | | `prp-*` | PRD to plan to implement to PR pipeline | `prp-prd` then `prp-plan` then `prp-implement` then `prp-commit` then `prp-pr` | | `epic-*` | large multi-unit epic, parallel | `epic-decompose` then `epic-claim` then `epic-validate` then `epic-review` then `epic-unblock` then `epic-sync` then `epic-publish` | | `loop-*` | managed autonomous loop and monitor | `loop-start <pattern>` then watch with `loop-status` | | `gan-*` | generator and evaluator loop | `gan-build` (code) or `gan-design` (UI); self-looping | | `*-build` / `*-review` / `*-test` | per-language CI triad | `<lang>-test` (TDD) then `<lang>-build` (fix) then `<lang>-review` | | `hookify-*` | behavior-hook management | `hookify` then `hookify-list` then `hookify-configure` | | `learn` / `instinct-*` / `evolve` / `promote` / `prune` | continuous-learning | `learn` then `instinct-status` then `evolve` then `promote` | | singletons | `santa-loop`, `plan`, `plan-prd`, `pr`, `code-review`, `checkpoint`, etc. | standalone or glue between groups |
Any command not matching a prefix rule → list it under **singletons** with its one-line description.
## How It Works
``` 1. Live-read command names from CMD_DIR. 2. Classify into families by prefix and a singleton map. 3. If a workflow description was given -> MATCH MODE. If none -> CATALOG MODE. 4. Advisory only: print the plan. Never run the matched commands. ```
### Catalog mode (no description)
Output the family table: each family, member count, members, one-line meaning, typical run-order. End with the total command count and a prompt to describe a workflow for a matched recipe.
### Match mode (description given)
1. Restate the workflow in one sentence. 2. Pick the best 1-2 families; say WHY in one line each. 3. **Run-order block** — exact command sequence for the matched family. 4. **Stop condition** — always explicit (max-runs, completion-signal, review-passes, or single-shot). For autonomous loops, warn about subscription burn and recommend a backstop bound. 5. **Where to read** — the `commands/<name>.md` path plus `/ecc-guide <name>`.
## Output Template (match mode)
``` Workflow: <one-sentence restatement>
Best fit: <family> — <why> (Alt: <family> — <why>)
Run-order: /<cmd1> # job /<cmd2> # job /<cmd3> # job STOP when: <condition> WARNING (autonomous loops only): an unbounded loop burns subscription/credits — add a max-iteration or max-cost backstop alongside the completion signal.
Read full docs: commands/<cmd1>.md (or: /ecc-guide <cmd1>) ```
## Examples
**Catalog:** `/ecc-recipes` → prints the family table and total count.
**Match:** `/ecc-recipes plan a whole app upfront then auto-build with adversarial review until done` → Best fit: `loop-*` (autonomous) wrapping `gan-*` or `santa-loop` (adversarial). Run-order: `plan-prd` then `loop-start rfc-dag --mode safe` then monitor `loop-status`; STOP when all units pass review N consecutive times (add a max-iteration backstop to bound burn).
**Match:** `/ecc-recipes fix a bug in my Go service` → Best fit: `orch-fix-defect` (reproduce, fix, review, commit). Alt: `go-test` then `go-build` then `go-review`. STOP: regression test green and review pass.
## Non-Goals
- Not an executor — advisory only. - Not per-command deep docs — that's `ecc-guide`. - Not prompt rewriting — that's `prompt-optimizer`. - Never hardcode command counts or member lists — always live-read.
Intended uses
- Use Ecc Recipes when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.