Everything Claude Code (ECC): What the Repository Contains and How to Use It

The everything-claude-code repository, which its README now brands as ECC, is one of the largest single-author bundles for Claude Code: agents, skills, slash commands, coding rules and hooks in one MIT-licensed project. This guide explains what the repository ships, the install routes the README documents, how its skills show up in the directory, and what to check before you trust a collection this size.

Facts come from the README at github.com/affaan-m/ECC, which is where the old everything-claude-code address leads, and from the directory's records. The editorial team did not install or benchmark it, so there are no claims about results.

What the everything-claude-code repository contains

The README describes ECC as an "agent harness operating system" built on one idea: optimize the context window and persist everything else. Instead of rebuilding planning, testing, review and verification prompts every session, you install the pieces once. It states the intended loop as plan, test, implement, review, verify, remember, improve.

At the time of writing the README lists these component counts:

Other folders include docs/ for setup guides, mcp-configs/ for MCP server definitions and scripts/ for installers. The README says commands are being kept as maintained shims while workflows move to a skills-first layout. It also describes a Markdown-based memory vault for carrying context between harnesses.

These figures move with every release. Treat them as a snapshot and open the README for the current numbers.

How to install ECC

The README gives three routes and one firm rule: do not stack them. Installing into the same harness twice can duplicate skills, commands, hooks or configuration, so pick one.

Guided setup. This is the recommended path. It needs Node.js 18 or later, Git and Claude Code 2.1 or later, and walks through plugin install, updates, scope and hooks:

npx ecc-universal@2.2.3 setup

Claude Code plugin commands. If you would rather use the built-in plugin system:

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

How scopes, updates and trust prompts work for any plugin is covered in the guide to Claude Code plugins and marketplaces.

Manual, from a clone. For selective installs:

git clone https://github.com/affaan-m/ECC.git
cd ECC
./install.sh --profile minimal --target claude

Profiles run from minimal, which the README describes as rules and agents only, up to full, which adds hooks. Hooks need an explicit --enable-hooks or --no-hooks choice at install time.

One caveat matters if you take the plugin route. The README says Claude plugins cannot distribute rules, so you add rule packs yourself by copying the language folders you want into ~/.claude/rules/ecc/.

Which agents it supports

The README rates support by harness. Claude Code is the stable, primary target. Codex is listed as supported through a native marketplace plugin. Cursor and Kimi Code are beta, GitHub Copilot is instruction-only, and OpenCode, Gemini, Zed, Antigravity, Qwen and Hermes are experimental. Check the directory pages for Claude Code, Codex, Cursor and GitHub Copilot to see how each of those loads skills natively, since the README says full feature parity is only on Claude Code.

Hooks, profiles and tuning

Hooks are the part that changes behavior without you asking, so the README gives them the most knobs. The plugin loads hooks/hooks.json automatically on Claude Code 2.1 and later, and the README says not to copy that entry into your own settings.json, because the duplicate causes conflicts. Three environment variables are documented: ECC_HOOK_PROFILE to choose a profile such as standard, ECC_DISABLED_HOOKS to switch off named hooks, and ECC_SESSION_START_MAX_CHARS to cap what is injected at session start. You can also leave hooks out at install time with --no-hooks and add them later with --modules hooks-runtime.

The README is open about funding. It says development is supported by GitHub sponsors and by ECC Pro, a hosted GitHub App for private repositories, while the repository itself stays MIT licensed. That does not change what the skills do, but it is useful context when you weigh a project with a commercial side.

ECC skills in the directory

The directory indexes this repository as many separate skills. That number is far above the README's skill count, and the reason is where the files sit. Besides the root skills/ folder, the repository contains translated documentation folders such as docs/es/skills and docs/ja-JP/skills, plus adapter folders such as .kiro/skills and .agents/skills. Each copy gets its own listing, and repeated names pick up a numeric suffix.

That makes the bare slug unreliable. The listing named affaan-m/api-design, for example, comes from the Spanish documentation folder, while the root skills/api-design copy is affaan-m/api-design-5. When you want the canonical version, look at the folder path on the skill page.

A few listings that do come from the root skills/ folder, all MIT licensed with a pass result from the directory's static check:

• verification-loop runs a six-phase check of a session's work, covering build, types, lint, tests, a security grep and a diff review, and ends with a pass or fail report.
• strategic-compact suggests manual context compaction at logical points rather than waiting for automatic compaction.
• eval-harness sets up eval-driven development, with capability and regression evals and several grader types.
• context-budget audits how much of the context window agents, skills, MCP servers and rules consume.
• continuous-learning-v2 records small confidence-scored behaviors from hook data and can promote them into skills.
• search-first tells the agent to look for existing packages, MCP servers and skills before writing custom code.

For a sense of overlap, the debugging topic, the planning topic and the subagents topic show skills from smaller, single-purpose repositories that cover some of the same ground. The guide to Superpowers for Claude Code describes a more compact workflow set.

What to review before trusting a large collection

A repository this size is closer to a distribution than a skill. Several things deserve a read before you enable it.

• Hooks. The README says hooks run outside the model context, and Anthropic's documentation says command hooks run with your full user permissions and outside the sandbox. Read hooks/hooks.json and each script it calls. ECC offers --no-hooks at install and an ECC_DISABLED_HOOKS environment variable for turning off named hooks.
• Context cost. Every enabled skill, agent and command adds a name and description to each turn. The README advises installing selectively and mentions a /context-budget command for monitoring consumption. It also warns that enabling every MCP server at once can shrink a 200k window sharply.
• Rules. Rule packs are always-loaded standards. Copy only the languages you use.
• Install channel. The README states that ECC should be installed only from its GitHub repository, the ecc-universal and ecc-agentshield npm packages, its GitHub App, the plugin slug ecc@ecc and its website. It says third-party re-uploads and mirrors are not reviewed by the project and may contain malware. Pin versions as the README's commands do.
• Scanning. The README points to a separate scanner, ecc-agentshield, run as agentshield scan --path .. It is a separate install and a first filter, not proof of safety.
• Static checks. The directory's check marks most ECC listings pass, but some carry an info result and a few carry a warn result. Open a skill's page to see the reason before using it.

Taking a few skills instead of the whole thing

If the full harness is more than you want, copy individual skill folders. Each is a standard SKILL.md folder, so the install options on a skill page apply: a plugin install of everything, the skills CLI for one skill, or a manual copy into .claude/skills/. The Claude Code page lists each command. Reading a single folder takes minutes, and you keep the rest of your setup unchanged. For help writing your own versions, see how to create a Claude skill.