Skip to content
Skillpedia
Misc280k · #180

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

https://github.com/affaan-m/ECC/blob/main/skills/ecc-recipes/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/skills/ecc-recipes/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
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-recipes

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/ecc-recipes/SKILL.md -o SKILL.md
Technical 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-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:

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)

…

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

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills