ECC's 72 agents: which to use, when, and how to call them in Claude Code
At the end of the article you'll find the install command, a ready-to-paste prompt and a .md to download.
ECC's agents are 72 Claude Code subagents, each with a narrow job: planning (planner, architect), per-language code review (typescript-reviewer, python-reviewer…), fixing builds (go-build-resolver, rust-build-resolver…), hunting silent failures or auditing security. Five are enough to start: planner, code-reviewer, security-reviewer, the reviewer for your language and build-error-resolver.
This is part 4 of the complete ECC guide. Below you will see how the 72 are split, which model each family uses, how to call them (by command, by name or automatically) and a real test with silent-failure-hunter, which found a bug the general review missed.
What a subagent is and why ECC has so many
A subagent is a Markdown file in agents/ with frontmatter (name, description, allowed tools and model) and instructions. Claude Code runs it in a separate context: it works, returns a report, and its conversation does not clutter yours.
---
name: code-reviewer
description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability.
tools: Read, Grep, Glob, Bash
model: sonnet
---ECC has 72 because it covers many languages and tasks, not because you should use them all. Each one only takes context when it runs; what is always loaded is its description, which Claude Code reads to decide when to delegate.
How the 72 agents are split
| Family | Count | Examples |
|---|---|---|
| Plan and design | 8 | `planner`, `architect`, `code-explorer`, `spec-miner` |
| Reviewers by language and stack | 24 | `typescript-reviewer`, `python-reviewer`, `go-reviewer`, `django-reviewer`, `database-reviewer` |
| Quality review | 10 | `code-reviewer`, `security-reviewer`, `silent-failure-hunter`, `refactor-cleaner` |
| Fix builds | 12 | `build-error-resolver`, `rust-build-resolver`, `pytorch-build-resolver` |
| Tests and docs | 4 | `tdd-guide`, `e2e-runner`, `doc-updater`, `docs-lookup` |
| Operate agents | 5 | `loop-operator`, `harness-optimizer`, `chief-of-staff` |
| GAN generation | 3 | `gan-planner`, `gan-generator`, `gan-evaluator` |
| Open source, marketing and network | 6 | `opensource-sanitizer`, `seo-specialist`, `network-troubleshooter` |
Models: 62 agents use sonnet, 6 use haiku (docs, comments and open source packaging) and only 4 use opus: planner, architect, spec-miner and healthcare-reviewer. On a Pro subscription, those four burn more quota.
Three ways to call an agent
1. Through a command. The easiest. Each main command has an agent behind it:
| You want to… | Use | Agent |
|---|---|---|
| Plan a feature | `/ecc:plan "…"` | `planner` |
| Review what you just wrote | `/ecc:code-review` | `code-reviewer` |
| Fix a broken build | `/build-fix` | `build-error-resolver` |
| Look for vulnerabilities | `/security-scan` | `security-reviewer` |
| Remove dead code | `/refactor-clean` | `refactor-cleaner` |
| Review Go or Python | `/go-review`, `/python-review` | `go-reviewer`, `python-reviewer` |
| Update docs | `/update-docs` | `doc-updater` |
2. By name. Some have no command (for example typescript-reviewer, fsharp-reviewer or silent-failure-hunter). Ask Claude: "use the ecc:typescript-reviewer subagent to review src/". With the plugin they carry the ecc: prefix.
3. Automatically. Several descriptions say "Use PROACTIVELY": Claude Code may delegate to them unprompted. database-reviewer, for example, kicks in when you write SQL or migrations.
Real test: silent-failure-hunter
In part 3 we built a POST /orders endpoint with 19 green tests and ran it through /ecc:code-review, which reported 9 findings. Then we ran this agent alone on the same app.js:
Use the ecc:silent-failure-hunter subagent to review app.js. Return its report as is, short.It took 24 seconds and the CLI reported 0.16 USD. It found 8 issues, and the most serious one was not in the general review:
- In the
catchthat returns 500,sendJsoncan throw again if headers were already sent. That leaves an unhandled promise rejection in anasynchandler, which can crash a Node process. It suggests checkingres.headersSentand logging method and URL. - The
catch {}aroundJSON.parsedrops the original error: the client only seesinvalid_jsonand debugging gets harder. - A client that aborts mid-upload ends up as a false 500;
ECONNRESETandabortedshould be handled separately.
It also agreed with the general review on the plain-text 404 and /products accepting any method. The lesson: specialized agents catch things the general reviewer does not prioritize. Do not run them all; run the one that matches the risk of your change.
Careful with consult: you pick, not the search
ECC ships a plain-language component finder. We asked it about code review and security for a Next.js app:
npx ecc-universal@2.2.3 consult "code review and security for a Next.js app" --target claudeIt got capability:security, code-reviewer and security-review right, but its third pick was fsharp-reviewer for a Next.js app, only because the words "code" and "review" matched. The finder matches keywords; it does not understand your stack. Use it as a starting point and add typescript-reviewer and react-reviewer yourself.
Which agents to use for your stack
| Your project | Recommended agents |
|---|---|
| Next.js / React + TypeScript | `typescript-reviewer`, `react-reviewer`, `react-build-resolver`, `e2e-runner` |
| Python API (Django or FastAPI) | `python-reviewer`, `django-reviewer` or `fastapi-reviewer`, `django-build-resolver`, `database-reviewer` |
| Go backend | `go-reviewer`, `go-build-resolver`, `database-reviewer` |
| Rust | `rust-reviewer`, `rust-build-resolver` |
| Android / Kotlin | `kotlin-reviewer`, `kotlin-build-resolver` |
| iOS / Swift | `swift-reviewer`, `swift-build-resolver` |
| Laravel / PHP | `php-reviewer` (plus the `laravel-*` skills) |
| RAG or ML in production | `rag-pipeline-reviewer`, `mle-reviewer`, `pytorch-build-resolver` |
| Anything, before production | `security-reviewer`, `silent-failure-hunter`, `performance-optimizer` |
If you only want a few, copy them into ~/.claude/agents/; each agent is a standalone file:
git clone https://github.com/affaan-m/ECC.git
mkdir -p ~/.claude/agents
cp ECC/agents/{planner,code-reviewer,security-reviewer,typescript-reviewer,build-error-resolver,silent-failure-hunter}.md ~/.claude/agents/Agents you will not need (at first)
gan-planner,gan-generator,gan-evaluator: a generator-evaluator loop to build products from one line. Interesting, but the macOS shell path has an open bug (#2674).loop-operator: watches long autonomous loops. Useful once you automate a lot, not on day one.chief-of-staff: triages email, Slack and messaging. Unrelated to coding.opensource-forker,-packager,-sanitizer: for open-sourcing an internal project without leaking secrets.
FAQ
Can I change an agent's model? Yes: edit the model: line in its frontmatter. For example, move planner from opus to sonnet if quota is a concern.
Can agents change my code? It depends on their tools: line. planner only has Read, Grep, Glob (it cannot write); build-error-resolver and tdd-guide have Write and Edit.
What is the "Prompt Defense Baseline" block? Every agent starts with rules not to change roles, reveal secrets or emit executable code without need. It is a basic defense against prompt injection, not a guarantee.
Conclusion
Of ECC's 72 agents, five cover almost all daily work: planner, code-reviewer, security-reviewer, your language's reviewer and your stack's build resolver. Add silent-failure-hunter before each deploy: in our test it found the only bug able to crash the process. Part 5 covers choosing skills and rules so you do not load context you never use.
// resource · use it now
The ECC agents you will actually use
Copy only the agents that fit your stack and let the prompt help you pick the rest. Works with Claude Code 2.1 or newer.
Repository license: MIT
1. Install
git clone https://github.com/affaan-m/ECC.git
mkdir -p ~/.claude/agents
cp ECC/agents/{planner,code-reviewer,security-reviewer,build-error-resolver,silent-failure-hunter,tdd-guide}.md ~/.claude/agents/npx ecc-universal@2.2.3 setup2. Pick your case
I have ECC's agents available. This project is <stack: e.g. Next.js + TypeScript + Postgres>.
1. Read the names and descriptions in ~/.claude/agents/ (or the ecc plugin) and tell me which 5-6 agents fit this stack and what I will use each for.
2. Add an "Agents" section to CLAUDE.md: when to use planner, which reviewer to run after each change, and that silent-failure-hunter runs on touched files before every deploy.
3. Do not copy or install anything else; only propose and write CLAUDE.md.3. How to use it
- Paste the prompt at the project root.
- Check the list: drop any reviewer for another language.
- Copy only the approved ones into
~/.claude/agents/.
Before this deploy I want a layered review with ECC agents over the changes since main:
1. git diff --name-only main...HEAD and classify files by risk (auth, payments, data, public API, UI).
2. Run the matching language reviewer (ecc:typescript-reviewer, ecc:python-reviewer...) on the changes.
3. Run ecc:security-reviewer only on high-risk files.
4. Run ecc:silent-failure-hunter on async handlers and jobs.
5. Merge the findings into one table (severity, file:line, agent, proposed fix), remove duplicates and do not change code until I choose what to fix.3. How to use it
- Run it on the branch that is ready to deploy.
- Fix critical and high first.
- Keep the table in the PR description.
Help us grow
codigoagente is free, with no paywalls. If this article helped you, any of these keeps the blog going.
- Share it with someone who'll find it usefulWhatsAppLinkedInXFacebook
- Meet our sponsorSafe Build Labs
More on AI agents

- Skills for your agents
- Claude Code

guide · Marketing psychology guide for AI agents · #3
- Skills for your agents
- Claude Code

guide · Marketing psychology guide for AI agents · #2
- Skills for your agents
- Claude Code