🧭 Decision Guide
Why trending now: The material shows 751 stars gained that day and 247,602 total stars. The latest ECC 2.2.0 release includes Guided Setup, Antigravity 2.0, and the Nasiko CLI Bridge, while the README highlights 68 agents, 286 skills, and multi-harness support for Claude Code and Codex. The material cannot prove causality, but these release and scale signals explain the current attention.
Try it if you
-
You use Claude Code 2.1+ and want TDD to become a RED→GREEN→REFACTOR workflowREADME section “Why Choose ECC?” says TDD becomes a gated RED -> GREEN -> REFACTOR workflow with evidence; installation requires Claude Code 2.1+
-
You need 68 agents for planning, code review, build repair, or security tasksREADME section “What's Inside” lists 68 specialized subagents, and the feature table names planning, review, repair, and security uses
-
You need to configure Claude Code, Codex, and Kimi Code togetherREADME section “Universal guided setup details” provides npx ecc-universal install --guided and says it supports selecting the three harnesses
-
You want to scan prompts, hooks, MCP configuration, permissions, and agent filesThe README feature table defines AgentShield as scanning these agent-runtime assets
Skip it if you
-
You use only GitHub Copilot and depend on hooks or agents/delegationREADME section “Feature coverage” explicitly says Copilot does not support hooks/automation or agents/delegation
-
Your environment lacks Node.js 18+, Git, or Claude Code 2.1+The README installation instructions require Node.js 18+, Git, and Claude Code 2.1+ on PATH
-
You cannot install from the official GitHub, npm, or GitHub App channelsThe README warns that unofficial re-uploads and mirrors are not maintained or reviewed and may contain malware
-
You require Cursor, OpenCode, or another harness to have full Claude Code feature parityThe README says Claude Code works best today, while other harnesses use capability-limited adapters, and directs users to the support status matrix
Requirements
- Universal setup requires Node.js 18 or newer
- Claude Code plugin installation requires Git
- Claude Code plugin installation requires Claude Code 2.1 or newer on PATH
- Package-runner commands require ecc-universal 2.2.0 or newer
- Use only github.com/affaan-m/ECC, ecc-universal, ecc-agentshield, the ecc-tools GitHub App, the ecc@ecc plugin, or ecc.tools
First step (verbatim from README)
npx ecc-universal setup
Watch out
-
Do not run npx ecc-universal setup and Claude native plugin installation together, or you will stack Claude installation pathsThe README explicitly requires choosing one path and says not to add a full manual installation
-
When npm reports a version or cache error, run npm view ecc-universal version to confirm the registry versionREADME section “Install with Claude Code” gives this troubleshooting command
-
Yarn Classic 1 does not provide yarn dlx, so the Yarn 2+ command cannot be copied directlyREADME section “Universal guided setup details” explicitly distinguishes Yarn 2+ from Yarn Classic 1
-
The README's total skill count is 286, while the directory description says 284 reusable workflowsThe README feature-count table and the “What's Inside” directory comment provide different numbers
Alternatives
-
Claude Code native plugin commands:Use this when you want to install ecc@ecc inside Claude Code instead of running the npx wizardInstall with Claude Code
-
GitHub Copilot:Use this when you only need copilot-instructions.md, a plan prompt, or a security-review prompt and do not need ECC hooks or subagentsFeature coverage
Not stated in the README
- The full support status matrix is not provided, so the exact missing features for Cursor, OpenCode, Zed, and other platforms are unknown
- The AgentShield scan command, result format, and false-positive handling are not provided
- The full names, version-pinning method, and per-component maintenance status of the 68 agents and 286 skills are not provided
- No quantitative impact is provided for hooks on build time, context usage, or agent success rate
- The practical isolation and conflict details among Codex, Kimi Code, and Claude Code in one project are not provided
- The excerpt does not provide complete test commands, coverage, or CI status
- The GitHub App permission scope and data-handling details for private repositories are not specified
💡 Deep Analysis
7
No for full adoption, because the README explicitly says Copilot does not support hooks/automation or agents/delegation and only receives limited mappings.
I use only GitHub Copilot. I can configure `copilot-instructions.md`, `plan`/`tdd` prompts, and external PR review, but I need ECC hooks, agent delegation, and fresh-context review. Is it suitable?
No for full adoption, because the two capabilities you need are explicitly listed as Copilot limitations.
- The README’s Copilot coverage table maps coding standards to
copilot-instructions.md, while security, testing/TDD, planning, and build repair are represented by always-on instructions or prompts. - Code review relies on external PR tools such as CodeRabbit and Greptile rather than ECC’s fresh-context reviewer.
- Copilot marks
Hooks / automationandAgents / delegationas not supported, so it cannot reproduce ECC’s runtime gates and specialized-agent collaboration from Claude Code. - If you only need shared rules, TDD prompts, and planning entry points, it can still provide partial value; it should not be treated as the full ECC harness.
- Feature coverage: Copilot mappings for coding standards, security checklist, testing/TDD, and implementation planning
- Feature coverage: `Code review | External PR review via CodeRabbit + Greptile`
- Feature coverage: `Hooks / automation | Not supported`
- Feature coverage: `Agents / delegation | Not supported`
It depends, because ECC unifies the workflow source tree, but hooks, plugin lifecycles, and subagent capabilities differ across harnesses.
I maintain Claude Code, Codex, Cursor, and GitHub Copilot at the same time. I want to reuse the same agents, skills, rules, and hooks across them. Can ECC provide a functionally equivalent unified solution?
It depends, because ECC reduces configuration drift but cannot give Cursor or Copilot all of Claude Code’s runtime capabilities.
- The README says the repository root is the source of truth, while platform adapters map or package the same workflows instead of maintaining separate copies.
- Claude Code has an official plugin and plugin-managed hooks; Codex has a supported sync path.
- The Copilot comparison explicitly says hooks/automation and agents/delegation are not supported. Cursor and Copilot may also lack hooks, subagent delegation, or plugin lifecycle support.
- Planning, TDD, and rules can therefore be partially reused, but each platform needs a fallback workflow rather than assumed feature parity.
- What's Inside: `The root is the source of truth. Platform adapters package or map these same workflows`
- README introduction: works best with Claude Code today, has a supported Codex sync path, and provides capability-limited adapters for other platforms
- Feature coverage: Copilot `Hooks / automation | Not supported`
- Feature coverage: Copilot `Agents / delegation | Not supported`
Yes, because Claude Code has ECC’s most complete support, including planning, TDD, independent review, hooks, and memory workflows.
We already develop with Node.js 18+, Git, and Claude Code 2.1+. We want the agent to follow planning, TDD, implementation, independent review, and verification, then install that workflow for our private repositories. Is ECC suitable?
Yes, because your environment meets the README’s Claude Code requirements and your goals directly match ECC’s engineering workflow.
- The README defines
plan -> test -> implement -> review -> verify -> remember -> improve, with plans turned into editable artifacts. - Its 68 agents cover planning, review, build repair, and security; 286 skills include TDD, research, and security workflows.
- The Claude plugin path installs skills, agents, commands, and plugin-managed hooks. Hooks can enforce deterministic checks outside the prompt.
- The private-repository option is compatible with the MIT-licensed core; the hosted GitHub App is listed at $19/seat/month for private repositories.
The README does not specify the integration effort for your existing CI, approval controls, and repository rules.
- Install with Claude Code: requires Node.js 18 or newer, Git, and Claude Code 2.1 or newer
- Why Choose ECC?: `plan -> test -> implement -> review -> verify -> remember -> improve`
- Access to 68 agents, 286 skills, and 94 legacy command shims
- Install with Claude Code: native path installs skills, agents, commands, and plugin-managed hooks
npx ecc-universal setup
Yes, but it cannot replace enterprise security review, because ECC scans agent configuration assets without claiming to eliminate all supply-chain or model risks.
I secure private repositories and review MCP, hooks, secrets, and agent permissions. I want to scan prompts and harness configuration risks beyond traditional code scanning. Can ECC cover these agent-security concerns?
Yes, because AgentShield directly covers the agent-runtime assets you care about, although it remains one part of a broader security process.
- The README lists AgentShield as included and explicitly scans prompts, hooks, MCP config, permissions, secrets, and agent files.
- It warns users to install only from verified channels such as the GitHub repository,
ecc-universal,ecc-agentshield, the GitHub App,ecc@ecc, and ecc.tools; unofficial mirrors may contain malware. - ECC treats agent configuration as an attack surface rather than trusted configuration by default, matching your MCP, hook, and permission review goals.
- However, the project insights state that ECC does not replace dependency security platforms, permission governance, CI/CD, or human architecture decisions, and cannot remove model errors.
- WARNING: `Official sources only`; third-party re-uploads and unofficial mirrors may contain malware
- What's Inside: AgentShield scans `prompts, hooks, MCP config, permissions, secrets, and agent files`
- Why Choose ECC?: `AgentShield scans the harness itself as an attack surface`
- Project insights usage_limitations: ECC cannot replace CI/CD, formal code review, dependency security platforms, permission governance, or human architecture decisions
npx ecc-universal setup
Yes, because ECC’s skills-first, on-demand loading design targets multi-domain work and avoids keeping every rule in the context permanently.
My repository includes frontend, data, machine learning, operations, and documentation work, and the team already follows TDD and code review. Is ECC more suitable than maintaining one large prompt if I want on-demand domain skills?
Yes, because your task breadth is large enough to benefit from ECC, while your existing engineering practices reduce its adoption cost.
- The README lists 286 skills covering TDD, research, security, docs, frontend, data, ML, and operations, directly matching your work areas.
- The project emphasizes
Skills keep the context focused; skills load on demand instead of placing every domain rule in the context at once. - Rules are selective and can be enabled by language or project, while 94 commands remain as compatibility entry points.
- The project insights say teams with existing TDD, code review, and CI practices have a more manageable learning curve; enabling too many rules, skills, or hooks can still create context noise and unpredictable behavior.
- Access to 68 agents, 286 skills, and 94 legacy command shims
- What's Inside: Skills include `TDD, research, security, docs, frontend, data, ML, operations`
- What's Inside: `rules/ # opt-in common and language standards`
- Project insights user_experience: teams with existing TDD, code review, and CI practices have a more manageable learning curve
No, because ECC’s workflow and component scale may exceed what simple script tasks require, making its configuration and learning costs disproportionate.
I maintain only one small JavaScript script repository and do not need multi-agent delegation, cross-harness synchronization, TDD gates, or long-term memory. Would ECC’s 68 agents and 286 skills exceed my actual needs?
No, because your constraints exclude the main value ECC provides: complex workflow coordination and multi-harness governance.
- ECC provides 68 agents, 286 skills, and 94 command shims covering planning, review, security, architecture, and multiple domains.
- Its target workflow includes planning, testing, implementation, independent review, verification, memory, and continuous improvement; it is not merely code completion or a prompt collection.
- The project insights explicitly state that small projects or simple scripts may lose value when workflow overhead becomes too large.
- Since you do not need cross-harness reuse, hooks, memory, or AgentShield, ECC’s unified source tree and runtime mechanisms are unlikely to provide proportional benefit; the README does not describe a lighter JavaScript-only distribution.
- README introduction: `Access to 68 agents, 286 skills, and 94 legacy command shims`
- README introduction: `plan -> test -> implement -> review -> verify -> remember -> improve`
- Project insights usage_limitations: `small projects or simple script tasks may lose value when workflow overhead becomes too large`
- Project insights user_experience: 68 agents and 286 skills create component-selection and workflow-design overhead
It depends, but it is generally suitable because ECC 2.2 provides guided setup for Codex and Kimi Code while requiring platform-specific capability checks.
I use Node.js 18+ and need to reuse ECC planning, skills, memory, and AgentShield between Codex and Kimi Code. I do not require every platform to have all Claude Code hook capabilities. Is ECC suitable?
It depends, but it is generally suitable because your goal is workflow reuse rather than identical capabilities across every harness.
- The README says ECC 2.2 includes guided package setup for Claude Code, Codex, and Kimi Code; the universal package requires Node.js 18 or newer.
- The project description explicitly targets Claude Code, Codex, OpenCode, Cursor, and other harnesses, and the README identifies a supported Codex sync path.
- The repository root is the source of truth, while platform adapters map or package the same workflows, which supports sharing skills, rules, and agent roles.
- However, the README says to check the support status matrix first. Other tools may lack hooks, subagent delegation, or plugin lifecycle support, so actual Memory, AgentShield, and runtime-automation coverage must be verified per platform.
- Install ECC: `ECC 2.2 includes guided package setup for Claude Code, Codex, and Kimi Code`
- Install ECC: `The universal package requires Node.js 18 or newer`
- Project description: `Skills, instincts, memory, security ... for Claude Code, Codex, Opencode, Cursor and beyond`
- README introduction: `has a supported Codex sync path`; other platforms have capability-limited adapters
- What's Inside: `The root is the source of truth`
npx ecc-universal setup
✨ Highlights
-
Provides 68 agents, 286 skills, and 94 commands
-
Structures agent work with a plan→test→implement→review flow
-
AgentShield scans prompts, hooks, MCP configuration, and secrets
-
Claude Code has the fullest support, while other platforms have capability gaps
🔧 Engineering
-
npx ecc-universal setup installs and manages the ecc@ecc plugin
-
Hooks, rules, and memory handle checks, standards, and session distillation
-
The 68 agents cover planning, review, repair, and security work
-
Supports multiple harnesses including Claude Code, Codex, and Cursor
⚠️ Risks
-
The official warning says third-party mirrors may contain malware; use only github.com/affaan-m/ECC and listed channels
-
Claude installation paths are mutually exclusive and must not be combined with manual installation
-
Universal setup requires Node.js 18+, Git, and Claude Code 2.1+
-
The README lists both 286 and 284 skills, creating a count inconsistency
👥 For who?
-
Development teams using Claude Code 2.1+ that want fixed TDD and review workflows
-
Users who need a unified installation flow across Claude Code, Codex, and Kimi Code
-
Engineers concerned with agent configuration security, MCP, and secrets scanning
-
Teams using only GitHub Copilot and requiring hooks or subagents are a poor match