ECC: AI Agent Optimization for Claude Code

Enhancing AI Coding Agents with ECC

ECC is a system installed into an AI coding agent harness such as Claude Code, Codex, Cursor, or OpenCode, layering on skills, agent instincts, memory, and security scanning around the model already running there. It replaces a plan-test-review routine you'd otherwise write into every prompt. Reach for it in Claude Code or Codex, where the README describes full support; treat other harnesses as partial until you check the support matrix.

Core Capabilities of the ECC System

• ✓68 agents built for jobs like planning, code review, fixing broken builds, security checks, architecture calls, and other domain-specific work, according to the README's own component table.
• ✓284 skills spread across categories such as TDD, security, research, documentation, frontend and data work, plus machine learning and day-to-day operations tasks.
• ✓94 legacy command shims stick around as ECC's command surface shifts toward being skills-first.
• ✓AgentShield scans more than the code an agent writes: it checks prompts, hooks, permission settings, secrets, MCP configuration, and the agent definition files themselves.
• ✓A hooks-and-memory runtime handles enforcement, session summaries, continuous learning, and context controls, separate from the always-loaded rule packs.
• ✓Rule packs are opt-in per language or project instead of one fixed bundle, so you load only the standards you actually use.
• ✓Routes through whatever model configuration the host harness already has, so a custom API endpoint or self-hosted model behind ANTHROPIC_BASE_URL works without changing ECC's own workflows.

Who Benefits from ECC?

Developers who already run Claude Code or Codex daily and want the plan, test, review, and verify loop enforced without re-explaining it every session get the most out of ECC; its 68 agents and 284 skills are built around that repeated workflow. Teams evaluating multiple harnesses at once should read the platform support matrix first, since ECC's own README describes Cursor, Zed, Gemini, OpenCode, GitHub Copilot, Antigravity, and Qwen support as capability-limited adapters rather than full parity with Claude Code.

Installing ECC into Your AI Coding Harness

For Claude Code, the README's recommended path is two plugin commands: /plugin marketplace add https://github.com/affaan-m/ECC followed by /plugin install ecc@ecc. That single install brings in ECC's skill library, agent definitions, commands, and the hooks the plugin manages itself, and the README says to stop there rather than layering a manual install on top. A guided ecc-universal setup flow is planned for npm version 2.2.0; the current release is 2.1.0 and doesn't include it yet, so the plugin commands are the documented route for now. Claude Code plugins can't ship rule packs, so rules are copied in separately: clone the repo, then copy rules/common plus one language pack (for example rules/typescript) into ~/.claude/rules/ecc. Codex users instead run codex plugin marketplace add affaan-m/ECC and codex plugin add ecc@ecc. Other harnesses, including Cursor, OpenCode, Gemini CLI, Zed, Antigravity, and Qwen, go through ./install.sh --profile minimal --target <harness> after cloning the repo, with OpenCode needing an extra npm install && npm run build:opencode step first. The README is explicit that legitimate installs only come from the GitHub repo itself, the ecc-universal and ecc-agentshield packages on npm, the GitHub App, the ecc@ecc plugin slug, and the ecc.tools site. It warns that third-party mirrors aren't reviewed and could carry malware.

Configuring ECC for Advanced Workflows

The /multi-plan, /multi-execute, /multi-backend, /multi-frontend, and /multi-workflow commands aren't part of the base plugin or rules install; they need the separate ccg-workflow runtime, started with npx ccg-workflow, which brings in dependencies like ~/.claude/bin/codeagent-wrapper. To route ECC through a custom model gateway or self-hosted model instead of Anthropic's hosted API, set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN before starting claude. The README says ECC doesn't hardcode Anthropic-hosted transport settings, and its hooks, skills, and rules don't care which provider is behind the claude CLI as long as the CLI itself is already working. MCP servers aren't auto-enabled on a plugin install either; pull the specific entries you need out of mcp-configs/mcp-servers.json and drop them into your own project-scoped .mcp.json, or use Claude Code's own /mcp command. ECC only bundles one default connector out of the box, chrome-devtools. If you're already running your own version of that connector, setting ECC_DISABLED_MCPS="chrome-devtools" tells ECC's install and sync flows to skip it rather than add a duplicate.

Exploring Alternatives for Agent Optimization

Common Questions About ECC

The problem it solves

An agent inside Claude Code or Codex can generate code on its own, but getting it to plan first, run tests, review its own diff from a clean context, and carry lessons into the next session usually means writing that scaffolding into your own CLAUDE.md or AGENTS.md file, project by project. ECC doesn't write code for you. It packages that plan-test-implement-review-verify-remember-improve sequence as an installable plugin, with 68 agents and 284 skills included, so a team doesn't rebuild the same rules and hooks in every repository it touches.

Best use cases

• •Standardizing a plan-test-review-verify loop across every Claude Code session instead of pasting the same instructions into CLAUDE.md each time.
• •Running the same agent workflow across both Claude Code and Codex, since ECC has a supported sync path for Codex alongside its native Claude Code plugin.
• •Auditing an existing agent setup for prompt, hook, MCP config, permission, and secret exposure with AgentShield before those files ship.
• •Picking a narrow slice of ECC, a handful of skills or one capability, through node scripts/ecc.js consult instead of installing the full 68-agent, 284-skill bundle.

Related repositories