Agent Tooling & Ecosystem · Blog Post
Everything Claude Code (ECC): what to take from a 327-skill bundle
ECC, short for Everything Claude Code, is one of the largest config bundles for coding agents: skills, subagents, commands, hooks, rules, and MCP configs in one repo. The real question isn't whether it's good. It's how much of it you should let into your agent, and which parts.
By Mehadi Hasan 8 min read
What it is
ECC is a single maintainer's (GitHub handle affaan-m) collection of Claude Code configuration. It started life as affaan-m/everything-claude-code; that URL now redirects to affaan-m/ECC. The repo describes itself as "the agent harness performance optimization system", and the README sums up the workflow it wants your agent to follow in one line: plan, test, implement, review, verify, remember, improve.
It is MIT-licensed. The current release is 2.2.3, dated October 1, 2026. As of November 17, 2026 the repo had about 305,000 GitHub stars and 45,000 forks. Stars measure attention, not fit, so the rest of this post is about fit.
Claude Code is the primary target and the only harness the README labels "stable". Codex and Qoder get native plugins. Cursor, OpenCode, and GitHub Copilot CLI get beta adapters. Gemini, Zed, Qwen, Kimi, and several others get experimental or minimal ones. The README is upfront that "full Claude feature parity is not claimed" outside Claude Code.
What's inside
Those counts come from the repo itself, not just the README: 327 folders with a SKILL.md under skills/, 72 agent files, 98 command files, and 28 hook entries across 8 lifecycle events in hooks/hooks.json. On top of that, rules/ holds 22 rule packs (a common pack plus languages and frameworks such as TypeScript, Python, Go, PHP, Rust, React, and Vue), and mcp-configs/mcp-servers.json lists 37 MCP server definitions.
The agents lean heavily toward review and build repair. There is a reviewer for most mainstream languages (go-reviewer, python-reviewer, rust-reviewer, php-reviewer and so on) and a matching build resolver for many of them. The skills range much wider: TDD, research, security, docs, frontend, data, ML, and operations, plus ECC's own systems for memory, "instincts" (patterns learned from your sessions), and orchestration.
How it works: six layers with different costs
The bundle mixes pieces that behave very differently once installed. Knowing which layer costs what is the whole game:
- Skills: Loaded on demand. Only the name and description sit in context until a task matches. ECC calls these its primary workflow surface; new work lands here first.
- Subagents: Run in their own context window with a limited tool list: planner, architect, code-reviewer, tdd-guide, build-error-resolver, security-reviewer, and dozens of language-specific reviewers.
- Commands: Entry points such as /ecc:plan, /code-review and /build-fix. The README describes them as shims kept during the move to a skills-first setup.
- Hooks: Shell commands that fire on tool events (PreToolUse, PostToolUse, Stop, SessionStart and others). They run whether or not the model remembers to.
- Rules: Always-loaded standards. A common pack plus language and framework packs. They cost context on every turn, so you pick them by hand.
- MCP configs: One default server (chrome-devtools) and an opt-in catalog. Plugin installs do not switch the catalog on for you.
Skills and agents are cheap until used. Rules are paid for on every turn. Hooks cost little context but they execute code. The README's own platform table makes the context point directly: the plugin "advertises the installed catalog to the model", so use a selective profile "when context footprint matters".
Hooks and rules run with your agent's access
This is the part to read before installing anything. A hook is a shell command that Claude Code runs on a tool event, with your user's permissions. A rule is text that goes into every prompt. Both change what your agent does without you seeing it happen. ECC's README says it plainly: hooks can run shell commands, MCP servers can hold credentials, and project instructions enter the agent's context, so "treat all three as executable configuration."
ECC's default hooks are mostly reasonable. They include a pre-commit quality check that blocks commits with detected secrets, a reminder before git push, Prettier and tsc --noEmit after edits, and session summaries on stop. The README also describes GateGuard, which gates destructive shell commands like rm before they run. But "reasonable" is a judgment you should make by reading hooks/hooks.json and its scripts yourself, not one you inherit from a star count.
Three practical points from the source. First, the README warns that third-party re-uploads and mirrors "may contain malware" and lists the only official channels: the GitHub repo, the ecc-universal and ecc-agentshield npm packages, the plugin ID ecc@ecc, and ecc.tools. Second, the installer refuses to write the hook runtime unless you pass --enable-hooks or --no-hooks, and hook profiles (minimal, standard, strict) can be switched with ECC_HOOK_PROFILE. Third, it ships AgentShield, a scanner for your own CLAUDE.md, settings, MCP configs, hooks, and agent files. For the wider set of controls I'd put around any coding agent, see AI coding agent guardrails.
Installation
The README asks for Node.js 18 or newer, and for the Claude plugin path, Git and Claude Code 2.1 or newer. The recommended route is a guided setup that asks for a scope (user, project, or local) and a hook profile before it writes anything:
Guided setup (Claude Code plugin)
npx [email protected] setup
Or use Claude Code's own plugin commands, which install the same ecc@ecc plugin with its skills, agents, commands, and hooks:
Claude Code: native plugin
/plugin marketplace add https://github.com/affaan-m/ECC /plugin install ecc@ecc
Pick one. The README is firm that stacking install methods in the same harness duplicates skills, commands, and hooks. Plugins also can't ship rules, so those are a manual copy. Start with common plus the one stack you use:
Rules: copy only what you need
git clone https://github.com/affaan-m/ECC.git cd ECC mkdir -p ~/.claude/rules/ecc cp -R rules/common ~/.claude/rules/ecc/ cp -R rules/typescript ~/.claude/rules/ecc/ # replace with your stack
If you want the workflows without any runtime hooks, the README documents a minimal profile that excludes the hook runtime entirely:
Low-context install, no hooks
npx [email protected] install --profile minimal --target claude
Two cautions from the README itself: "a version pin is not a security audit", so review the release before running package code, and npx [email protected] uninstall --dry-run shows what a removal would touch before you commit to it. Codex users have a separate native path (codex plugin marketplace add affaan-m/ECC), and Cursor, OpenCode, Gemini, and Copilot use ./install.sh --target … from a clone.
Using it day to day
The README's best advice is its first line on usage: "Start with the workflow you need, not the full catalog." Its own starting points:
- Building a feature: /ecc:plan "describe the feature", then the tdd-workflow skill
- Fixing a bug: Reproduce it with a failing test, then tdd-workflow
- Reviewing new code: /code-review for a fresh-context review
- Repairing a build: /build-fix
- Checking context pressure: /context-budget
- Ending or resuming a long session: /save-session, then /resume-session later
Plugin installs use the namespaced form (/ecc:plan); manual installs may expose the short form (/plan). Some commands need extra setup the base install doesn't provide: the /multi-* commands depend on a separate third-party runtime, and /astra-review sends your diff to OpenAI through the Codex CLI. Read those commands' docs before running them, because they move code outside Claude Code.
The README also recommends some cost settings in ~/.claude/settings.json: Sonnet as the default model, Haiku for subagents, and earlier auto-compaction. Those are opinions about your model budget, not part of ECC's code, so take them or leave them on their own merits.
Pricing
The repo is MIT-licensed and free, and the README says it will stay that way. The paid product is ECC Pro, a hosted GitHub App that adds private-repo analysis, PR-triggered audits, AgentShield-backed scanning, and pooled team usage. The README lists private repos "from $19/seat/mo"; check ecc.tools for current terms. Nothing in this post needs Pro.
My take
ECC is best read as a library, not a setup to adopt whole. Few people need 72 subagents and 327 skills, and nobody needs 22 rule packs loaded at once. The maintainers seem to know this. The README pushes selective installs, a consult command that suggests components for a task, and a minimal no-hooks profile. That's more restraint than most mega-bundles show.
If I were deciding what to take, I'd split it this way. Worth taking: the review and build-fix agents for your languages, tdd-workflow, search-first, strategic-compact, and rules/common plus one stack pack. Worth reading before enabling: the hook runtime, continuous learning, and memory. They're the most powerful parts and the hardest to see working. Skip unless you need them: the multi-model commands, orchestration families, and the MCP catalog.
Who it suits: a developer on Claude Code who wants a strong starting point and is willing to prune. Who it doesn't: a team that already has its own conventions, where 22 rule packs and 28 hooks can clash with the house style. The same goes for anyone who won't read hook scripts before running them. If you want one opinionated method rather than a toolbox, Superpowers is the smaller, tighter alternative.
Frequently asked questions
Is ECC the same project as everything-claude-code?
Yes. The repo was renamed from affaan-m/everything-claude-code to affaan-m/ECC, and the old GitHub URL redirects to the new one. The Claude Code plugin ID is ecc@ecc and the npm package is ecc-universal. The README lists those, plus ecc-agentshield and ecc.tools, as the only official sources and warns that unofficial mirrors may contain malware.
Do I have to install all 327 skills?
No. The README recommends starting with the workflow you need, not the full catalog. The installer supports a minimal profile, explicit skill lists (--skills tdd-workflow,security-review), and a consult command that suggests components for a task. Rules are never installed by the plugin; you copy rules/common plus one stack pack by hand.
Are ECC hooks safe to enable?
Hooks are shell commands that run on tool events with your user permissions, so treat them as code you are executing. ECC asks for an explicit --enable-hooks or --no-hooks choice before installing the hook runtime, offers minimal, standard, and strict profiles, and lets you disable individual hook IDs. Read hooks/hooks.json and its scripts before turning them on.
Does ECC work outside Claude Code?
Partly. Claude Code is the only harness the README marks stable. Codex and Qoder have native plugins, Cursor, OpenCode, and GitHub Copilot CLI have beta adapters, and Gemini, Zed, Qwen, Kimi, and others have experimental or minimal ones. The README says full Claude feature parity is not claimed on the other harnesses.