Everything Claude Code (ECC) User Guide

1. Quick Start

Everything Claude Code (ECC) is a comprehensive collection of battle-tested configurations, skills, hooks, rules, commands, and agents for Claude Code and compatible AI-assisted coding tools. Evolved over 10+ months of intensive daily use by an Anthropic hackathon winner, ECC transforms Claude Code from a capable assistant into a fully governed, multi-agent development environment.

Key features:

• 130+ domain-specific skills covering languages, frameworks, security, DevOps, and business workflows
• 80+ slash commands for code review, TDD, deployment, and project management
• 19+ specialized agent definitions (planner, security-reviewer, e2e-runner, and more)
• Event-driven hook system with quality gates, formatting, and safety guardrails
• Language-specific rules for TypeScript, Python, Go, Rust, Swift, Kotlin, Java, C++, PHP, C#, Perl, and Dart
• Multi-IDE support (Claude Code, Cursor, Codex, Gemini, OpenCode, AntiGravity, CodeBuddy)
• Curated MCP server catalog with 20+ pre-configured integrations
• ECC 2.0 TUI dashboard for session orchestration and worktree management (Rust)

Prerequisites:

• Node.js >= 18
• Claude Code (or a compatible IDE target)
• Git

Install in one command:

npx ecc typescript

  ecc-universal installed!
  Run: npx ecc typescript

What to try next: Run /tdd to start a test-driven development workflow, /code-review for instant code review, or /plan to create an implementation plan.

Tip

If you already have an existing Claude Code setup, ECC merges its configuration non-destructively. Your existing rules and hooks are preserved.

2. Installation

System Requirements

Install Methods

npm (recommended)

npx ecc typescript

yarn

yarn dlx ecc-universal typescript

Manual (install script)

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

Windows (PowerShell)

git clone https://github.com/affaan-m/everything-claude-code.git
cd everything-claude-code
.\install.ps1 typescript

Important

When installing manually, copy entire rule directories — do not flatten with /*. The common/ and language-specific directories contain files with the same names, and flattening breaks the ../common/ relative references that language-specific files depend on.

Multiple Languages

Install support for multiple languages at once:

npx ecc typescript python golang

Or install individual language packs:

npx ecc python
npx ecc golang
npx ecc swift
npx ecc kotlin
npx ecc java
npx ecc cpp
npx ecc php
npx ecc csharp
npx ecc perl
npx ecc dart
npx ecc rust

Install Profiles

ECC supports profile-based installation for targeted setups:

# Install a named profile from ecc-install.json
npx ecc-install --profile web-fullstack

Profiles group components by use case. You can also use component-based selection:

# Include specific capability components
npx ecc-install --include baseline:rules --include lang:typescript --include capability:security

Multi-IDE Targets

ECC supports installation across different AI coding tools:

Post-Install Verification

After installation, verify the setup:

npx ecc --version

1.10.0

Check installed components:

node scripts/list-installed.js

Run the diagnostic tool:

node scripts/doctor.js

Tip

Use node scripts/doctor.js after installation to detect misconfigurations, missing hooks, or broken skill references.

Uninstalling

node scripts/uninstall.js

3. Configuration

Hook Profiles

ECC hooks enforce code quality and safety checks automatically. Control their behavior with environment variables:

# Set hook profile: minimal | standard | strict
export ECC_HOOK_PROFILE=standard

# Disable specific hooks by ID (comma-separated)
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

Package Manager

ECC detects your project's package manager automatically. Override it with:

export CLAUDE_PACKAGE_MANAGER=yarn

Or run the interactive setup:

node scripts/setup-package-manager.js

MCP Server Configuration

ECC includes a curated catalog of 20+ MCP server configurations in mcp-configs/mcp-servers.json. To use them, copy the servers you need to your ~/.claude.json mcpServers section:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT_HERE"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}

Warning

Keep under 10 MCP servers enabled at once to preserve your context window. Disable unused MCPs with ECC_DISABLED_MCPS=github,context7,... during install or sync.

For a full configuration reference, see the Admin Guide.

4. Core Usage

Skills

Skills are contextual knowledge modules that Claude Code loads automatically based on what you are working on. Each skill lives in skills/<name>/SKILL.md and contains domain-specific patterns, best practices, and code examples.

How skills activate: When you edit a Python file, python-patterns and python-testing load. Working on a Django project triggers django-patterns, django-security, and django-tdd. Running a TDD workflow activates tdd-workflow.

Skill Categories

Note

The full skill catalog includes 130+ skills. Run node scripts/catalog.js to see the current inventory with descriptions.

Slash Commands

Slash commands are quick-access workflows invoked with /<command-name> in Claude Code. ECC provides 80+ commands organized by purpose.

Development Commands

Language-Specific Commands

Workflow Commands

Session Management Commands

Agents

Agents are specialized AI personas with focused expertise. They are defined in AGENTS.md and the agents/ directory.

Language-specific agents are also available: go-reviewer, python-reviewer, typescript-reviewer, rust-reviewer, java-reviewer, kotlin-reviewer, cpp-reviewer, and database-reviewer.

Tip

Use /agent-sort to automatically select the best agent for your current task based on the code context.

Hooks

Hooks run automatically before or after Claude Code tool executions. They enforce quality, safety, and consistency without manual intervention.

PreToolUse Hooks (run before actions)

PostToolUse Hooks (run after actions)

Lifecycle Hooks

Warning

The GateGuard fact-force hook blocks the first Edit/Write/MultiEdit per file, requiring you to investigate the file's importers, data schemas, and user instructions before making changes. This prevents blind modifications. If this is too strict for your workflow, set ECC_HOOK_PROFILE=minimal or disable it with ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force".

Rules

Rules define broad coding standards and conventions. They are organized in a layered structure:

rules/
├── common/          # Language-independent (always installed)
│   ├── coding-style.md
│   ├── git-workflow.md
│   ├── testing.md
│   ├── performance.md
│   ├── patterns.md
│   ├── hooks.md
│   ├── agents.md
│   └── security.md
├── typescript/      # TypeScript/JavaScript
├── python/          # Python
├── golang/          # Go
├── swift/           # Swift
├── kotlin/          # Kotlin
├── java/            # Java
├── rust/            # Rust
├── cpp/             # C/C++
├── php/             # PHP
├── csharp/          # C#
├── perl/            # Perl
├── dart/            # Dart
└── web/             # Web-specific

Rule priority: When a language-specific rule conflicts with a common rule, the language-specific rule takes precedence — similar to CSS specificity.

Note

Rules tell you what to do; skills tell you how to do it. Language-specific rule files reference relevant skills for detailed implementation guidance.

5. Common Tasks

Start Test-Driven Development

Goal: Write a new feature using TDD methodology.

1. Run /tdd to start the TDD workflow
2. Claude will prompt you for the feature requirements
3. Write failing tests first
4. Implement the minimum code to pass
5. Refactor with confidence

Verify: Tests pass and coverage meets the 80% minimum threshold.

If it fails: Run /build-fix to resolve any build errors, then re-run tests.

Run a Code Review

Goal: Get a comprehensive code review before committing.

1. Run /code-review with your changes staged
2. Claude reviews for quality, security, patterns, and test coverage
3. Address any findings
4. Run /verify to confirm all checks pass

Set Up Multi-Agent Orchestration

Goal: Run parallel agent sessions across git worktrees.

1. Run /orchestrate to launch the orchestration template
2. Define worker tasks and agent types
3. Each agent works in an isolated worktree
4. Use node scripts/orchestration-status.js to monitor progress
5. Merge completed worktrees back to the main branch

Verify: Run node scripts/orchestration-status.js — all workers should show completed status.

Add a New Skill

Goal: Create a custom skill for your domain.

1. Create a directory skills/your-skill-name/
2. Add a SKILL.md file with YAML frontmatter:

---
name: your-skill-name
description: Brief description shown in skill list
---

# Your Skill Title

Brief overview.

## Core Concepts

Key patterns and guidelines.

## Code Examples

\`\`\`language
// Practical examples
\`\`\`

## Best Practices

- Actionable guideline 1
- Actionable guideline 2

3. Run npm run catalog:sync to update the catalog

Configure MCP Servers

Goal: Set up external tool integrations.

1. Open mcp-configs/mcp-servers.json for the full catalog
2. Copy desired server configurations to ~/.claude.json
3. Replace YOUR_*_HERE placeholders with actual API keys
4. Restart Claude Code to activate the new servers

Common MCP servers:

Write Custom Hooks

Goal: Add project-specific automation to Claude Code.

Hooks are shell commands that receive JSON via stdin and output JSON to stdout.

// my-hook.js
let data = '';
process.stdin.on('data', chunk => data += chunk);
process.stdin.on('end', () => {
  const input = JSON.parse(data);
  const toolName = input.tool_name;
  const toolInput = input.tool_input;

  // Warn (non-blocking): write to stderr
  console.error('[Hook] Warning message shown to Claude');

  // Block (PreToolUse only): exit with code 2
  // process.exit(2);

  // Always output the original data to stdout
  console.log(data);
});

Exit codes: 0 = success (continue), 2 = block tool call (PreToolUse only), other non-zero = error (logged, not blocked).

Use the Python GUI Dashboard

Goal: Browse ECC components visually.

python3 ecc_dashboard.py

The TkInter-based dashboard provides tabs for browsing agents, skills, commands, and rules with search and filtering capabilities.

Tip

The dashboard supports light and dark themes. Switch themes in the Settings tab.

Use the ECC 2.0 TUI

Goal: Use the Rust-based terminal dashboard for session management.

# Build the TUI (requires Rust toolchain)
cd ecc2
cargo build --release

# Launch the dashboard
./target/release/ecc-tui dashboard

The TUI provides real-time session monitoring, worktree management, merge queues, and coordination status. See the Admin Guide for the full ecc CLI reference.

6. Troubleshooting

Diagnostic Decision Tree

ECC not working?
├── Installation issues → Check Node.js version (>=18), run `node scripts/doctor.js`
├── Hooks not firing → Check `ECC_HOOK_PROFILE`, verify hooks.json is loaded
├── Skills not loading → Verify skill directory structure, check SKILL.md frontmatter
├── MCP servers offline → Check `ECC_MCP_HEALTH_STATE_PATH`, verify API keys
├── Windows-specific → Check path separators, ENOENT errors for spawn
└── Performance → Reduce enabled MCP servers (<10), check context window usage

Error: Failed to load hooks from hooks.json

Cause: Claude Code 2.1.x changed the hook schema to expect string commands, but ECC previously used argv arrays.

Solution:

1. Update ECC to the latest version: npx ecc typescript
2. If the issue persists, check that your hooks.json uses string "command" fields, not arrays

Prevention: Keep ECC updated. The hooks system validates against schemas/hooks.schema.json at CI time.

Error: ENOENT when spawning claude or npx on Windows

Cause: Windows cannot find the claude or npx binary in the system PATH, especially when spawned from hooks (GitHub issue #1469).

Solution:

1. Ensure Claude Code and Node.js are in your system PATH
2. For claw.js specifically, ensure the claude binary is accessible from the hook execution context
3. Set the BASH environment variable if hooks need a specific shell

Prevention: Run node scripts/doctor.js to verify all required binaries are discoverable.

Error: GateGuard blocks all tool calls in auto mode

Cause: The gateguard-fact-force hook can enter a state where it blocks all operations, including the commands needed to disable it (GitHub issue #1427).

Solution:

1. Set ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force" before starting Claude Code
2. On Windows, if fs.renameSync fails with EEXIST, update ECC to get the Windows-specific fix (GitHub issue #1435)
3. Clear the GateGuard state: delete files in the directory specified by GATEGUARD_STATE_DIR

Prevention: Use ECC_HOOK_PROFILE=minimal for autonomous/batch operations.

Caution

The GateGuard race condition (GitHub issue #1441) in the session state read-modify-write path can cause inconsistent state under concurrent access. Avoid running multiple Claude Code sessions with GateGuard enabled against the same state directory.

Error: PreToolUse+PostToolUse fork storm causes EAGAIN posix_spawn (macOS)

Cause: Dense Bash tool calls trigger too many hook processes simultaneously, exhausting system resources (GitHub issue #1423).

Solution:

1. Reduce the number of synchronous hooks — mark non-critical hooks as "async": true
2. Increase the process limit on macOS: ulimit -u 2048
3. Update ECC for consolidated dispatcher hooks that reduce fork count

Prevention: Use the consolidated pre-bash-dispatcher.js and post-bash-dispatcher.js (default in recent versions) instead of individual hook scripts.

Error: ECC breaks Claude Desktop / slash menu

Cause: getSupportedCommands validation failure when ECC is installed as a plugin (GitHub issue #1476).

Solution: This is a known open issue. As a workaround, install ECC directly via install.sh rather than as a Claude Desktop plugin.

Error: MCP health-check blocks all MCP calls on Windows

Cause: The MCP health-check hook spawns npx which fails with ENOENT on Windows (GitHub issue #1455).

Solution:

1. Disable the MCP health check: ECC_DISABLED_HOOKS="pre:mcp-health-check"
2. Or set ECC_MCP_HEALTH_FAIL_OPEN=1 to allow MCP calls even when health checks fail

Dashboard fails to launch on Windows

Cause: Terminal launch paths contain spaces or Windows-specific path issues (GitHub issue #1472).

Solution: Run the dashboard from a path without spaces, or update to the latest version which sanitizes cmd.exe command strings.

Warning

Several Windows-specific issues exist in hooks that use spawn. If you encounter ENOENT errors on Windows, check whether the hook is trying to spawn a command that requires the full path on Windows. Setting ECC_HOOK_PROFILE=minimal is a reliable workaround.

7. FAQ

Q: What is the difference between rules and skills?

Rules define broad standards and conventions (e.g., "80% test coverage", "no hardcoded secrets"). Skills provide detailed, actionable reference material for specific tasks (e.g., python-patterns shows you how to implement Python design patterns). Rules say what; skills say how.

Q: Do I need to install all skills?

No. Install only the components relevant to your technology stack. Use the component-based installer (--include lang:typescript --include capability:security) to pick exactly what you need.

Q: Can I use ECC with Cursor, Codex, or other AI tools?

Yes. ECC supports multiple IDE targets. Use npx ecc --target cursor typescript for Cursor, --target codex for Codex, and so on. Not all features are available on all targets — hooks and MCP configurations are Claude Code-specific.

Q: How do I disable a hook that is too aggressive?

Set ECC_DISABLED_HOOKS to a comma-separated list of hook IDs. For example: ECC_DISABLED_HOOKS="pre:edit-write:gateguard-fact-force,pre:bash:tmux-reminder". You can find hook IDs in hooks/hooks.json under the "id" field.

Q: How do I add support for a new programming language?

Create a rules/<language>/ directory with files that extend the common rules (coding-style.md, testing.md, patterns.md, hooks.md, security.md). Each file should start with > This file extends [common/xxx.md](../common/xxx.md) with <language>-specific content. Then create relevant skills under skills/.

Q: What is ECC 2.0 (ecc2)?

ECC 2.0 is a Rust-based TUI (Terminal User Interface) that acts as an agentic IDE control plane. It manages multi-agent sessions, git worktrees, merge queues, task delegation, and coordination — all from a terminal dashboard. It is a separate binary (ecc-tui) built with Rust and requires cargo build to compile. See the Admin Guide for the complete CLI reference.

Q: How do I update ECC?

Run npx ecc typescript again (or your chosen languages). The installer merges updates non-destructively. For git-cloned installs, git pull && ./install.sh typescript.

Q: What happens if I run multiple Claude Code sessions with the same hooks?

Most hooks are stateless and safe for concurrent use. However, GateGuard uses file-based state that has a known race condition under concurrent access (GitHub issue #1441). Use ECC_HOOK_PROFILE=minimal for parallel autonomous sessions.

Q: How do I contribute a new skill or command?

Create a skill directory with SKILL.md, or add a command markdown file under commands/. Run npm run catalog:sync to update the catalog. Run npm test to validate all manifests, schemas, and file references. Submit a PR to the repository.

Q: What is the plugin-hook-bootstrap.js that wraps all hooks?

Every hook command is wrapped by plugin-hook-bootstrap.js, which resolves the ECC installation root (whether installed globally, as a plugin, or from source). This bootstrap layer ensures hooks can locate their helper scripts regardless of installation method. You do not need to interact with it directly.