iTranslated by AI

The content below is an AI-generated translation. This is an experimental feature, and may contain errors. View original article
🧩

A Practical Guide to Everything Claude Code (ECC): From Installation to Mastery

に公開
AI
生産性
Agent
開発効率化
Claude Code
tech

Introduction

Since my son started using Claude Code, I have compiled a guide on everything from setting up to using Everything Claude Code (ECC). This serves partly as a memo for myself, but I hope it might be useful for others who are also struggling with the setup.

ECC is an open-source extension system for Claude Code that adds specialized agents, slash commands, and skills (knowledge systems) to systematize the flow of planning, implementation, review, and testing. It was a winning project at the Anthropic hackathon and has surpassed 65,000 GitHub stars (as of March 2026).

This article is written as a reference you can revisit, covering everything from "getting it running" to "adjusting it to fit your own projects." I have prioritized practical information, including costs and cases where it might not be the best fit.

Prerequisite: What is Claude Code?

Before diving into ECC, let's briefly go over Claude Code itself for those who aren't familiar with it.

Claude Code is a terminal-based AI coding agent provided by Anthropic. It doesn't run as a VS Code extension or web chat; it operates directly in your terminal. It can autonomously handle file reading/writing, command execution, and Git operations.

# Installation
npm install -g @anthropic-ai/claude-code

# Launch
claude

Using it requires an Anthropic API key or a Claude Max plan. If using an API key, you are billed based on usage.

What is ECC?

It is an extension plugin that transforms Claude Code from "a single programmer" into a "team of experts."

Officially, it is positioned as an "agent harness performance optimization system." It works not only with Claude Code but also with multiple AI coding tools (harnesses) such as Codex, Cursor, and OpenCode.

Three Core Components

ECC consists of three layers: Agents, Commands, and Skills.

  • Agents (16 types): "Who" is in charge. Sub-agents with specialized domains such as planning, review, security, etc.
  • Commands (40 types): "What" to do. Actions invoked by slashes like /plan or /verify.
  • Skills (65 types): "How" to do it. Procedure manuals and knowledge systems for each domain such as TDD, API design, security review, etc.

For example, if you input /plan "implement user authentication", the /plan command calls the planner agent, which outputs an implementation plan including risk assessment, dependencies, and phase breakdown, while referencing skills like api-design and tdd-workflow.

Installation

There are two methods. Since both require cloning the repository, start with that.

git clone https://github.com/affaan-m/everything-claude-code.git
cd everything-claude-code

Method 1: Plugin Installation (Recommended)

Run the following inside Claude Code.

# Add marketplace
/plugin marketplace add affaan-m/everything-claude-code

# Install plugin
/plugin install everything-claude-code@everything-claude-code

This will enable the agents, commands, and skills. However, rules are not distributed via the plugin. Due to constraints in the Claude Code plugin system, rules must be copied manually.

# Install rules (specify the languages you use)
./install.sh typescript

# For multiple languages
./install.sh typescript python golang

Method 2: Manual Installation

Use this method if you want to use short command names without namespaces or if you only want to pick specific items.

# Agents
cp everything-claude-code/agents/*.md ~/.claude/agents/

# Rules (common + specific languages only)
mkdir -p ~/.claude/rules
cp -r everything-claude-code/rules/common/* ~/.claude/rules/
cp -r everything-claude-code/rules/typescript/* ~/.claude/rules/  # Only your stack

# Commands
cp everything-claude-code/commands/*.md ~/.claude/commands/

Regarding skills, you can copy all of them (cp -r everything-claude-code/skills/* ~/.claude/skills/), but including unused skills will crowd your context window. It is more practical to select only the ones that match your stack. The details of the 65 skills will be described later.

Operation Check

# Manual installation
/plan "Hello World"

# Plugin installation
/everything-claude-code:plan "Hello World"

If the planner agent starts and begins creating a plan, it is a success.

Three Commands You Should Use First

While there are 40 commands, you only need to learn three at first.

/plan — Use this before writing any code

/plan "add user authentication feature"

This launches the planner agent to create a plan that includes risk assessment, dependencies, and a phase breakdown. The important thing is that you should not start writing code until you have approved the plan. With raw Claude Code, coding starts immediately after saying "make an auth feature," but by interjecting /plan, the "plan → approve → implement" workflow is enforced.

This alone visibly reduces rework. In my experience, I have had many occasions in medium-to-large feature additions where starting without /plan led to realizing the initial design was wrong midway through, forcing me to start over.

/verify — Check after making changes

/verify quick       # build + type check + core tests (daily use)
/verify pre-commit  # pre-commit check
/verify pre-pr      # comprehensive check before creating a PR
/verify full        # all tests + security scans

This executes builds, type checks, tests, and security scans all at once. There are four modes; using quick for daily work and pre-pr before a PR is standard.

/code-review — Reduce noise from AI reviews

/code-review

The code-reviewer agent reviews the changed code. The key is its noise filter, which reports only issues with 80% or higher confidence. This helps you avoid common issues in AI code reviews, such as "getting 30 indentation suggestions that bury the actual bugs."

Once you are used to these three, you can add the following:

/orchestrate — Automatic coordination of multiple agents

/orchestrate feature "implement payment feature"

There are four workflow types (feature / bugfix / refactor / security), each of which automatically runs a different agent pipeline. For feature, the planner → tdd-guide → code-reviewer → security-reviewer sequence runs automatically, from planning to security audit.

However, because agents run in series, token consumption is high. It is not suitable for small fixes.

/tdd — Enforce test-driven development

This forces a TDD workflow where you write tests first. The tdd-guide agent manages the Red-Green-Refactor cycle and ensures test coverage of 80% or higher.

/build-fix — Automatic build error correction

This supports build error patterns for multiple languages such as npm, Cargo, Maven, Go, and Python. It has a safety criterion for fixes: a rule that "the number of changed lines must be less than 5% of the file," which prevents collateral damage from large-scale changes.

Agents — Who Should Handle the Tasks

ECC features 16 types of agents (according to the README claim; the agents/ directory in the repository contains 13 markdown files, and the rest operate via commands).

They can be broadly divided into four categories:

Planning & Design: planner (plan formulation & risk assessment), architect (system design), chief-of-staff (task management & priority judgment)

Quality & Review: code-reviewer (code quality), database-reviewer (PostgreSQL/Supabase optimization), doc-updater (documentation synchronization)

Testing & Security: tdd-guide (test-driven development), e2e-runner (Playwright E2E), security-reviewer (OWASP Top 10 & vulnerabilities)

Fixes & Specialization: build-error-resolver, refactor-cleaner, go-reviewer, go-build-resolver, python-reviewer, harness-optimizer, loop-operator

You do not need to be aware of all of them. If you use /plan or /orchestrate, the appropriate agent will be selected automatically.

Hooks — Mechanisms to Automatically Protect Quality

ECC hooks are scripts that automatically run in conjunction with Claude Code tool execution. They work in the background without you needing to think about them.

Things that run before execution (PreToolUse):

  • Blocks npm run dev outside of tmux (to prevent logs from becoming invisible)
  • Prompts for a change review before git push
  • Proposes /compact approximately every 50 tool calls

Things that run after execution (PostToolUse):

  • Automatically formats with Prettier after editing JS/TS files
  • Performs type checking with tsc --noEmit after editing .ts/.tsx files
  • Detects and warns about console.log mixed into production code

Session Lifecycle:

  • Reads the previous context at startup and detects the package manager
  • Automatically saves the important state before context compression
  • Extracts useful patterns upon exit

If you feel the hooks are too strict, you can adjust them via environment variables.

# minimal | standard | strict (default: standard)
export ECC_HOOK_PROFILE=standard

# Disable specific hooks
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

standard is usually sufficient. If you set it to strict, type checking and formatting run every time, which can sometimes slow down the pace of development.

Continuous Learning System

ECC includes a continual learning system based on instincts. It is a mechanism that becomes more optimized for your project as you use it more.

Here is the workflow:

Hooks automatically record daily work patterns and error resolutions (Observation). The recorded patterns are stored as "instincts" with confidence scores, managed separately for each project (Accumulation). High-confidence patterns can be promoted to skills using the /evolve command (Evolution). You can then export project-specific knowledge using /instinct-export to share with the team (Sharing).

/instinct-status        # Check accumulated instincts
/evolve                 # Cluster instincts into skills
/instinct-export        # Export
/instinct-import <file> # Import

It is an interesting mechanism, but honestly, it takes a few weeks of consistent use to feel the effects. You don't need to worry about this on the first day of installation.

The Reality of Costs

Using ECC increases API calls. This is unavoidable.

While /plan alone is not much different from normal Claude Code usage, running /orchestrate feature with four agents working in series can sometimes cost several dollars in a single execution. If you are on the Max plan, it is a flat rate so you won't need to worry, but if you are using an API key with pay-as-you-go, keep this in mind.

ECC also has mechanisms to reduce costs.

Switching Models: You can switch models for each agent. For example, use Opus for design decisions, Sonnet for daily tasks, and Haiku for documentation updates.

/model sonnet   # Use Sonnet for daily tasks
/model opus     # Use Opus only for complex designs

Context Window Management: Even a 200k token window can shrink to 70k when you register a large number of MCP servers or tools. It is recommended to keep MCPs under 10 and tools under 80.

When to use /compact: Execute it after research is finished or a milestone is reached. Be careful if you use it in the middle of implementation, as the context for variable names and file paths will be lost.

How to Choose Skills

You don't need all 65 skills. Choose the ones that match your stack.

Development Foundation (useful for almost everyone): tdd-workflow, api-design, coding-standards, verification-loop, search-first (forces research before implementation to prevent reinventing the wheel).

By Language/Framework:

  • TypeScript/React: frontend-patterns, e2e-testing
  • Python: python-patterns, python-testing, django-* (4 skills)
  • Go: golang-patterns, golang-testing
  • Java: springboot-* (4 skills), java-coding-standards, jpa-patterns
  • Swift: swift-* (3 skills)
  • C++: cpp-coding-standards, cpp-testing

Infrastructure/Operations: backend-patterns, postgres-patterns, docker-patterns, database-migrations, deployment-patterns

Business/Content: article-writing, content-engine, market-research, etc. (for non-coding tasks).

If you are doing individual development primarily in TypeScript, about 12 skills (5 foundational + 2 TypeScript-related + infrastructure-related) are sufficient.

Security: AgentShield

ECC has an integrated security scanning feature called "AgentShield."

# Quick scan (no installation required)
npx ecc-agentshield scan

# Automatic fix
npx ecc-agentshield scan --fix

# In-depth analysis by three Opus agents
npx ecc-agentshield scan --opus --stream

With --opus, three Claude Opus agents analyze in a red-team/blue-team approach: an attacker, a defender, and an auditor. It scans across 5 categories: CLAUDE.md, settings.json, MCP settings, hooks, agent definitions, and skills, using 102 static analysis rules.

If you are writing security settings yourself, it is worth running this at least once. However, --opus will naturally incur Opus usage charges.

Cross-Harness Support

ECC is not limited to Claude Code. You can install it for various harnesses using the --target option of the install.sh script.

  • Claude Code: Supports both plugin and manual installation
  • Codex (OpenAI): Runs based on AGENTS.md
  • Cursor: Installed with --target cursor
  • OpenCode: 12 agents / 24 commands / 16 skills
  • Antigravity: --target antigravity
  • Cowork: Supported

Cases Where ECC Is Not Suitable

You don't necessarily have to run everything through ECC.

  • One-liner fixes or small bug fixes — Standard Claude Code is sufficient; passing them through /plan might actually make it slower.
  • Quick questions or code explanations — There is no point in launching agents.
  • Prototypes or throwaway scripts — Quality gates will get in the way.
  • Environments where the context window is already strained — If you have many MCPs installed, ECC skills and rules will strain it further.

ECC is effective for "projects that involve repeated feature development of a certain scale." You don't need 16 agents to write a 10-line script.

Summary

At first, just using the three commands /plan → /verify → /code-review is enough. Once you get used to them, you can add /orchestrate or continuous learning.

Things to keep in mind when introducing it:

  • Don't forget to manually install the rules (due to plugin limitations).
  • Command names are long when using plugins (/everything-claude-code:plan). If that bothers you, use manual installation.
  • Don't install all the skills. Select only the ones that match your stack.
  • If you are using an API key with pay-as-you-go, get a feel for the cost of /orchestrate before using it in production.

I hope you can use this article as a reference whenever necessary.

References

Discussion