Everything Claude Code (ECC) on GitHub: What It Is

Everything Claude Code, now called ECC, is a large open source system for coding agents: 71 agents, 314 skills and 98 command shims, plus hooks, rules, memory, continuous learning and a security scanner. It is MIT licensed and works best with Claude Code. The GitHub repo is now affaan-m/ECC. We read its README on 31 October 2026.

Quick facts

The repo was renamed. Older links and blog posts say everything-claude-code; the current name is ECC, and the README lists its official sources: the GitHub repo, the npm packages ecc-universal and ecc-agentshield, a GitHub App, the plugin slug ecc@ecc and ecc.tools.

What it is

ECC bundles a working method, not a single tool. Its README describes the loop it wants an agent to follow:

plan -> test -> implement -> review -> verify -> remember -> improve

The idea is to install that process once instead of re-describing it in every prompt. The README's own contrast table makes the case: plans become editable artifacts, "please use TDD" becomes a gated red-green-refactor workflow, a fresh-context reviewer checks the work, sessions are distilled into summaries and reusable skills, hooks enforce checks outside the prompt, and the agent configuration itself is scanned as an attack surface.

What you get, from the README's table:

If you read our skills, subagents and plugins guides, you will recognise each part. ECC is those pieces, assembled and opinionated.

Install it

The guided setup

The README recommends one command for Claude Code plugin setup, updates, scope changes and hook-profile changes:

npx ecc-universal@2.2.3 setup

It names the version, which is a good habit: pin it. Release 2.2 also lists guided package setup for Claude Code, Codex and Kimi Code.

Native Claude Code plugin

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

This installs skills, agents, commands and plugin-managed hooks. The README says if you choose it, stop there. Do not also run a full manual install. Claude Code plugins cannot distribute rules, so you add rule packs separately and choose only the ones you want. After install, /ecc:configure-ecc reconfigures the setup.

Codex

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json

Both add commands are idempotent. To refresh: codex plugin marketplace upgrade ecc, then codex plugin add ecc@ecc. The older sync script is a deprecated compatibility path.

Other agents

The README lists adapters for Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen and others, with different levels of support. See the table below.

One rule: do not stack installs

The README is firm. Use one install method per harness. Installing ECC twice into the same harness can duplicate skills, commands, hooks or configuration. It lists combinations that work (Claude plugin plus Codex native plugin) and combinations to avoid (Claude plugin plus a full Claude manual install, or Codex sync plus the Codex marketplace plugin). If you layered installs, it has a reset and uninstall section.

A lighter install

If your concern is context or the hook runtime, there is a minimal profile that excludes it:

npx ecc-universal@2.2.3 install --profile minimal --target claude

And a core profile without hooks:

./install.sh --profile core --no-hooks --target claude

Any install that would add the hook runtime needs an explicit decision, --enable-hooks or --no-hooks.

Platform support, as the README states it

The README labels these as capability statements, not marketing tiers.

Operating systems: Linux and macOS are "supported core", Windows with WSL follows the Linux paths, and native Windows is "supported with limitations". The README lists open defects on native Windows and a macOS shell path issue, with issue numbers. That honesty is worth noting.

What the pieces do

Agents

Subagents specialised for a job. The README groups them as planning, review, build repair, security, architecture and domain agents. They work like any Claude Code subagent.

Skills

The largest part. The README says skills keep the context focused, since a skill's body loads only when it is used. Claude Code loads skills from direct children of ~/.claude/skills, and the installer places each skill there, not in a nested ecc folder.

Hooks and runtime

Hooks run shell commands at lifecycle points. ECC uses them for enforcement, session summaries and continuous learning. The README gives environment variables to tune them, such as ECC_HOOK_PROFILE (default standard), a list of hook IDs to disable, a cap on session-start context (default 8,000 characters), and options for the number and confidence of learned "instincts" injected at session start. A switch exists to turn off session-start context entirely for low-context or local-model setups.

Memory and instincts

ECC distils sessions into summaries and "instincts", and describes a shared memory vault that lets different harnesses hand work to each other. Treat this as a data store you should know the location of.

AgentShield

A scanner for the agent configuration itself: prompts, hooks, MCP config, permissions, secrets and agent files. The README presents it as part of the package and publishes it separately on npm as ecc-agentshield.

Real tasks with copy-ready prompts

The prompts below are generic; skill and command names depend on your install, so list them first with /skills or ask the agent.

List the ECC skills and agents installed here. Group them by job and
tell me which ones fire automatically versus on request.

Plan the change to the billing module before writing code. Show me the
plan as a numbered list and wait for my approval.

Implement the approved plan with a failing test first. After each
step, run the tests and show the result.

Review the diff as if you have not seen it before. List regressions
and gaps, with file and line for each.

Scan my Claude Code configuration for risky hooks, broad permissions
and secrets. Report only; do not change anything.

Safety and trust

This is a large package with a hook runtime. Treat it that way.

• Official sources only. The README's warning says third-party re-uploads and unofficial mirrors may contain malware. Install only from the sources it lists.
• Hooks run code. Anthropic's plugin docs say hooks run as shell commands with your user privileges, outside the sandbox. ECC's hook runtime is part of the package.
• Read before you enable. The README makes hook enablement an explicit decision on manual installs. Read the hooks.
• Pin the version. ecc-universal@2.2.3 rather than @latest.
• Scope the install. Claude Code plugins have user, project and local scope. Use project scope in a test repo first.
• Memory holds your work. Session summaries and instincts are written to disk. Know where.
• Auto-update. If you install through a marketplace with auto-update on, files can change after you reviewed them.
• Run the scanner on it. The package ships a scanner for exactly this problem; point it at your own setup and at the ECC install.

Adopting a package this size in stages

A single install that adds agents, skills, hooks and memory changes many behaviours at once. If something goes wrong, you will not know which part caused it. Adopt it in stages, and keep the stage you are on written down.

Stages 4 and 5 deserve the most caution, since hooks run code automatically and memory writes your work to disk. If you are not sure about either, skip it. The agents and skills give most of the visible value, and they are the part you can read as plain text.

The context bill

Every agent description, skill description and command in a package of this size competes for space in the model's context. A rough picture helps. These figures use example token counts, and your install will differ.

With those numbers, about 18,000 tokens of descriptions would load before you type a word, and at $2 per million input tokens that is about 3.6 cents for every 1,000 requests it is included in, before caching. The money is small. The cost that matters is attention: a model choosing between 150 skills picks the wrong one more often than one choosing between 15. Claude Code defers some definitions and loads skill bodies on demand, as the README notes, so the real load is lower, but check with /context after install and see what loaded. If the listing is large, uninstall the domains you do not work in, such as languages or frameworks outside your stack.

What to turn off first

You do not have to use the package whole. Items to trim, in order:

1. Languages and frameworks you do not use. A Rust agent in a PHP project only adds noise.
2. Duplicates of built-ins. Claude Code ships its own review and planning commands. If an ECC command does the same job, keep one.
3. Hooks that fire on every tool call. They add latency to everything. Keep the ones that enforce something you care about.
4. Auto-learning features until you have read what they record.
5. Anything you cannot explain to a teammate in one sentence.

A smaller install you understand beats a complete one you do not. Remove with the same tool you used to install, then confirm with git status and /context that nothing lingers.

How to tell whether it helped

After two weeks, compare against your own record, not the package's description.

• Rework. Did fewer changes bounce back from review?
• Prompt length. Do you type shorter prompts because a skill carries the routine?
• Surprises. Count the times a hook or agent did something you did not expect. More than one a week is a sign to trim.
• Speed. Did tool calls slow down? Hooks are the usual cause.
• Cost. Compare usage with the previous fortnight, from /usage.

If you cannot point to a gain, uninstall it. The idea behind it, small specialised agents and checked work, is available in a much lighter form: three or four subagents and a short CLAUDE.md that you wrote yourself. Our subagents and skills pages show how.

Limits and known issues

• Context footprint. 71 agents and 314 skills means a lot of descriptions. The README itself advises a selective profile when context footprint matters.
• Overlap. Many parts duplicate Claude Code built-ins such as /code-review and plan mode. Decide which source of truth you want.
• Complexity. The README is long and has many install paths. The "pick one path only" rule exists because layering causes duplicates.
• Parity. Outside Claude Code and Codex, features are partial.
• Windows. Native Windows has open defects for some memory features, per the README.
• Open issues. About 187 open issues and pull requests when we checked.
• Rapid change. Version 2.0 was described as "The Agent Harness Operating System" in June 2026, and the project moves quickly. Pin and re-read after updates.
• Name drift. The repo is ECC; the old name still shows in search results and tutorials.

Alternatives

Our take

We read the README and did not run ECC. We cannot say whether the workflow improves your results, and we will not guess.

It is the most complete single package of its kind that we know of, and it is unusually open about its limits: platform status by harness, install combinations to avoid, defects with issue numbers, a no-hooks path. That candour is a good sign.

It is also a lot. The core idea, plan first, test first, review in a fresh context, and remember what matters, can be had with a handful of files. If you like the method, copy the parts you understand. If you want the whole thing, install it in a scratch repo with the minimal profile, read the hooks, and add pieces back one at a time.

The question we would ask any large harness is the one the README itself implies: does your agent do better with it, measured on your own tasks? Run a week of normal work with and without, and keep a note.

Frequently asked questions

What is Everything Claude Code? A large MIT-licensed system of agents, skills, hooks and memory. The repo is now affaan-m/ECC.

How do I install it in Claude Code? npx ecc-universal@2.2.3 setup, or the native plugin commands.

Does it work with Codex and Cursor? Codex has a native plugin; Cursor has a beta adapter.

Is it safe to install? It includes hooks that run code. Use official sources, pin the version and read the hooks.

Should I install all of it? Probably not. Use a selective or minimal profile.

*Product names are used descriptively. We are not affiliated with the ECC project or Anthropic.*