ecc-recipes
Helps your agent map workflows to specific commands. It suggests execution order and conditions. Useful for planning and understanding task sequences.
What it does
This agent helps you figure out which sequence of commands to use for a specific task. It groups commands into families and suggests the execution order and when to stop.
When to use it
- ✓When you don't know which commands to use for a workflow.
- ✓To understand the correct command order for a task.
- ✓To see all available recipes (command sequences).
Example of what to ask your AI
“What command sequence should I use to refactor my code?”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
It reads available commands in real-time, groups them by task type, and based on your description, suggests the best sequence and stopping condition.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add affaan-m/ECC --skill ecc-recipesOr download just the file:
curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/ecc-recipes/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
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-recipeswith 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:
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)
- Restate the workflow in one sentence.
- Pick the best 1-2 families; say WHY in one line each.
- Run-order block — exact command sequence for the matched family.
- 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.
- Where to read — the
commands/<name>.mdpath plus/ecc-guide <name>.
Output Template (match mode)
…
FAQ
Does this agent execute the commands?
No, it only suggests which commands to use and in what order. It does not perform any actions.
What are command 'families'?
These are groups of related commands that together perform a specific type of task, like building a project or fixing a bug.
What happens if I ask it to do something it doesn't know?
It will list commands that don't fit any known family as 'singletons' (individual ones) and suggest the best way to use them.
Details
Original description by the author
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-gu
repo: affaan-m/ECC
Popularity
- GitHub stars
- 280k
- Ranking position
- #180
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
accessibility
Helps your agent create interfaces that everyone can use. Ensures websites and apps work well for people with disabilities, like those who are blind or have reduced mobility.
affaan-m/ECC
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC
Similar skills
template-skill
This is a generic template for new skills. It needs a specific description to be useful.
anthropics/skills
shipping-and-launch
Prepares your code to be safely launched into production. Helps ensure everything is ready, monitored, and has a rollback plan.
addyosmani/agent-skills
using-agent-skills
Has your agent discover and use other skills. It's useful for deciding which tool or workflow to use for a specific task.
addyosmani/agent-skills