Everything Claude Code (ECC) plugin: a practical setup

Deciding whether to add Everything Claude Code, now published as ECC, to a Claude Code setup you already use comes down to four things: what the plugin installs, the install path that avoids duplicate hooks, which parts to keep on and which to switch off, and how its rules sit next to your own CLAUDE.md. Each is covered below.

I run ECC in my own Claude Code setup. Everything below was checked against the ECC repository and Anthropic’s Claude Code documentation in November 2026. If you are setting up Claude Code from scratch, read the Claude Code setup guide first and come back.

What ECC is

ECC began as everything-claude-code, a public collection of Claude Code configuration. The old GitHub URL now redirects to affaan-m/ECC, which is MIT-licensed and, according to its README, maintained by a single maintainer funded by sponsors and a paid hosted GitHub App. It had over 300,000 GitHub stars in November 2026.

The README calls it an agent harness system: agents, skills, hooks and rules that push the agent through a plan, test, implement, review, verify loop instead of you re-typing that process into every prompt. It works best with Claude Code, has native plugin paths for Codex and Qoder, and lighter adapters for Cursor, OpenCode, Gemini, Zed and others. The README asks you to check its support matrix before assuming feature parity outside Claude Code.

Popularity attracts imitations, and the README is blunt about it: install only from the official channels. They are not interchangeable names, so it helps to know all of them.

Where	Official identifier
Source repository	github.com/affaan-m/ECC
Claude Code plugin	ecc@ecc
npm package	ecc-universal (plus ecc-agentshield)
Website	ecc.tools

Older blog posts show a longer marketplace name. The project treats that as a legacy alias, so if claude plugin marketplace list shows two ECC marketplaces, keep one.

What is in the box

The README for release 2.2.3 (1 October 2026) lists these components:

Component	Count	What it does
Agents	71	Subagents for planning, review, build repair, security, architecture and language-specific review
Skills	314	Workflows loaded on demand: TDD, research, security, docs, frontend, data, operations
Commands	98	Slash-command shims kept while ECC moves to a skills-first surface
Hooks	Runtime	Shell commands on tool and session events: safety gates, formatting, session memory, learning
Rules	Opt-in	Always-loaded standards by language, copied by you
AgentShield	Included	Scanner for secrets, permissions, hooks and MCP config in agent files

A few notes on what those mean in practice.

Agents are Markdown files with frontmatter that names their tools and model. Installed as a plugin they are namespaced, so you call ecc:code-reviewer, ecc:security-reviewer or ecc:build-error-resolver. The value is a fresh context: a reviewer that did not write the code reads the diff without the author’s assumptions.

Skills are the main surface. Claude Code keeps each skill’s description in context and loads the body only when the skill is used, so 314 skills cost far less than 314 documents. The listing is not free, though, and it grows with every plugin you add.

Commands use the namespaced form, for example /ecc:plan "Add authentication". Retired short names such as /tdd sit in legacy-command-shims/ for explicit opt-in.

Hooks are the most opinionated part. GateGuard denies the first Edit or Write of each file until the agent states facts about it, such as who calls the code, the data schema and the user’s instruction. Config protection blocks edits to linter and formatter configs so the agent fixes the code instead of weakening the check. Stop hooks batch-format and type-check edited JavaScript and TypeScript, look for leftover console.log, persist session state and look for patterns worth learning.

Install it as a Claude Code plugin

ECC 2.2 needs Node.js 18 or newer, Git, and Claude Code 2.1 or newer on your PATH. There are two supported routes. Choose one.

Guided setup. This is the README’s recommended path:

npx [email protected] setup

The wizard inventories the official marketplace and every Claude Code install scope before writing anything, then installs, updates or moves ecc@ecc to the scope you pick, with a hook profile. Rerun it to update ECC or change scope or profile. The README also points out that pinning a version is not an integrity check, so review the release before running package code.

Native plugin commands. Inside a Claude Code session:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

In a session, /plugin install opens the plugin’s details pane first. Read the Will install list, then choose a scope:

Scope	Recorded in	Who gets it
User	~/.claude/settings.json	You, in every project
Project	.claude/settings.json (committed)	Everyone on the repository, after each runs the install once
Local	.claude/settings.local.json	You, in this repository only

When the same plugin is set at several scopes, local overrides project and project overrides user. Confirm the result with claude plugin list in your shell, which prints version, scope and status, or with the Installed tab in /plugin.

Two mistakes cause most broken ECC installs:

1. Stacking install methods. The plugin plus a full manual install into the same harness duplicates skills, commands and hooks. If you have already done it, ECC’s README gives the clean-up order: remove the plugin, run the ECC uninstall from the project that holds the install state, delete extra rule folders, reinstall once.
2. Copying hooks/hooks.json into settings.json. Claude Code 2.1 and later loads plugin hooks automatically. A second copy makes every hook fire twice.

Updates are your call. Claude Code turns auto-update off by default for third-party marketplaces, which ECC’s is, so the files you reviewed do not change underneath you. Update deliberately with the guided setup or claude plugin update ecc@ecc.

Rules are a separate, manual step

Claude Code plugins cannot distribute rules, so ECC asks you to copy the packs you want:

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

Copy whole directories. The common and language packs contain files with the same names, and language files link to ../common/, so flattening them with /* overwrites rules and breaks the links. Start with common plus one language. The common pack covers agents, code review, coding style, development workflow, git workflow, hooks, patterns, performance, security and testing.

What to keep on and what to switch off

ECC’s defaults suit a team that wants the full harness. Most individual engineers want a lighter version. The controls are environment variables, so you can change them without editing plugin files.

Hook profiles and individual hooks

ECC_HOOK_PROFILE takes minimal, standard (the default) or strict. The guided setup also offers off, which turns off ECC’s hook work through setup rather than acting as a runtime profile. One detail worth checking: in the current hooks.json, GateGuard and config protection are registered for the standard and strict profiles only. Choosing minimal removes them, so it is lighter than its “essential safety hooks” label suggests.

For finer control, ECC_DISABLED_HOOKS takes a comma-separated list of hook IDs. These IDs come from ECC’s hooks.json:

Hook ID	What it does	My recommendation
pre:config-protection	Blocks edits to linter and formatter configs	Keep
pre:edit-write:gateguard-fact-force	Fact-forcing gate on the first edit of each file	Keep on production repositories; expect one extra round trip per new file
stop:format-typecheck	Batch format and tsc on edited JS/TS files	Keep on JS/TS projects
stop:session-end, pre:compact	Persist state after responses and before compaction	Keep if you resume sessions
pre:edit-write:suggest-compact	Suggests /compact at intervals	Off if you compact by habit
pre:write:doc-file-warning	Warns about non-standard .md and .txt files	Off in docs or content repositories
pre:observe, stop:evaluate-session	Capture tool use and extract patterns for continuous learning	Off until you choose ECC’s learning system as your memory
stop:desktop-notify, stop:cost-tracker	Desktop notification and cost markers	Personal preference

The Bash checks run through one dispatcher, and the README shows sub-checks such as pre:bash:tmux-reminder being disabled the same way.

GateGuard is the hook people notice first, because it refuses the first write to every new file and asks questions. That friction is the point: it makes the agent read before it edits. If a large tool call is blocked during setup or recovery, ECC_GATEGUARD=off disables only GateGuard. Turn it back on afterwards.

Session-start context and MCP servers

ECC’s SessionStart hook injects previous context, capped at 8,000 characters by default. ECC_SESSION_START_MAX_CHARS=4000 halves it, and ECC_SESSION_START_CONTEXT=off removes it entirely. ECC_MAX_INJECTED_INSTINCTS (default 6) caps how many learned instincts are added.

The plugin does not auto-enable ECC’s bundled MCP server definitions, and the project now ships one default connector, chrome-devtools. ECC’s own guidance is to keep fewer than 10 MCP servers and 80 tools active per project, and to switch off unused servers with /mcp.

Measure before and after

Do not guess what ECC costs you. In your shell:

claude plugin details ecc@ecc

The Always-on line is the number of tokens the plugin adds to every session where it is enabled, and the per-component rows show which skill or agent contributes most. Run it before and after trimming.

ECC’s README also recommends cost settings: Sonnet as the default model, CLAUDE_AUTOCOMPACT_PCT_OVERRIDE at 50, and Haiku as CLAUDE_CODE_SUBAGENT_MODEL. Those trade reasoning depth for cost. Apply them deliberately, and keep the strongest model for security review and architecture work.

How ECC’s rules interact with your CLAUDE.md

This is where most confusion comes from, and the Claude Code documentation is clear about the mechanics.

Claude Code reads instruction files from several places: a managed policy file, your user ~/.claude/CLAUDE.md, the project’s CLAUDE.md or .claude/CLAUDE.md, and a personal CLAUDE.local.md. Rules in ~/.claude/rules/ apply to every project and load before project rules. The documentation then says: “Neither set overrides the other: if a user rule and a project rule conflict, Claude may follow either one.”

It also says Claude treats all of these as context, not enforced configuration. So ECC’s copied rules carry the same weight as the lines you wrote yourself. Nothing makes your CLAUDE.md win automatically. ECC’s own rule that language packs override the common pack is a convention written into the rule text, not something Claude Code enforces.

The practical consequences:

1. The copied rules are your files. Edit them. ECC’s common performance rule has its own model-selection advice, its testing rule sets an 80% coverage bar and its git rule sets a commit format. If your CLAUDE.md says something different, change one side. Two contradictory instructions leave the choice to chance.
2. State a tie-breaker, but do not rely on it. A line in your CLAUDE.md saying that it wins over anything in ~/.claude/rules/ helps, but it is still guidance. Removing the conflict is the real fix.
3. Scope language packs with paths: frontmatter. A rule with a paths field loads only when Claude reads or edits a matching file, so a Python pack need not sit in context during a TypeScript session. For user-level rules, the patterns are relative to the session’s primary working directory.
4. Audit regularly. /doctor prompt-audit looks for contradictions and stale references across your instruction files and rules, and proposes edits without changing anything until you approve.
5. Put hard limits in hooks, not rules. If something must never happen, such as weakening a lint config or running a destructive command, a PreToolUse hook is the place. That is exactly why ECC’s config protection and GateGuard are hooks.

Pros and cons

Strengths	Costs
Broad, maintained catalogue of reviewers, planners and language specialists	Hundreds of skill descriptions and several hooks per tool call add context and latency
Safety hooks catch real failure modes: weakened configs, destructive commands, unread files	Opinionated defaults (coverage bars, model routing, doc warnings) may contradict your policy
Install-state tracking with doctor, repair and a dry-run uninstall	Hooks run as shell commands with your user privileges, outside Claude Code’s sandbox
MIT licence and support for several coding agents	Fast release pace and a past rename, so old guides go stale quickly
Fresh-context review agents for diffs	/multi-* commands need a separate ccg-workflow runtime, and /astra-review sends diffs to OpenAI through the Codex CLI

The privilege point deserves care. Anthropic’s plugin security page says an installed plugin “can execute arbitrary code on your machine with your user privileges”, and that hooks and MCP servers run outside the sandbox. Read hooks/hooks.json before installing ECC or any other plugin. The security review skills guide covers how to review agent tooling in general.

A practical setup

This is the setup I would recommend to most engineers working alone or in a small team.

1. Install once at user scope, with npx [email protected] setup or the two /plugin commands.

2. Copy rules/common and one language pack into ~/.claude/rules/ecc/, then read them line by line against your CLAUDE.md.

3. Trim hooks in your shell profile or the env block of ~/.claude/settings.json:

   {
     "env": {
       "ECC_HOOK_PROFILE": "standard",
       "ECC_SESSION_START_MAX_CHARS": "4000",
       "ECC_DISABLED_HOOKS": "stop:desktop-notify,stop:cost-tracker,pre:edit-write:suggest-compact,pre:observe,stop:evaluate-session"
     }
   }

   Add pre:write:doc-file-warning for documentation or content repositories.

4. Run /doctor prompt-audit and resolve every conflict it reports.

5. Measure with claude plugin details ecc@ecc, before and after.

6. Use a small loop: /ecc:plan for anything non-trivial, the tdd-workflow skill for the change, then a fresh-context ecc:code-reviewer pass, and ecc:security-reviewer when the change touches auth, money or personal data.

7. Update on purpose, then run npx [email protected] doctor if anything looks duplicated.

If you also want multi-agent orchestration, the oh-my-claudecode guide covers running OMC next to ECC without the two fighting over hooks and instructions. For third-party skills beyond ECC’s catalogue, see the skills.sh guide.

ECC in five points

• ECC is the ecc@ecc plugin from affaan-m/ECC. Install it from official sources only, and by one method only.
• The plugin brings agents, skills, commands and hooks. Rules are a manual copy, and once copied they are yours to edit.
• Claude Code gives user rules and your CLAUDE.md equal standing, so resolve conflicts rather than hoping one wins.
• Keep config protection and GateGuard. Trim the reminder, notification and learning hooks you do not use.
• Measure the always-on cost with claude plugin details ecc@ecc, and read the hooks before you trust them.