ECC – Open-Source Cross-Platform AI Agent Performance Optimization System

1. What Is ECC

ECC (Everything Claude Code) is an open-source cross-platform AI Agent performance optimization system designed to enhance AI coding assistant collaboration efficiency and security audit capabilities. The system provides 63 professional Agents, 249 on-demand loaded Skills, cross-session memory persistence, and the AgentShield security audit tool for 7+ AI coding tools including Claude Code, Codex, and Cursor. Through a Hook event system, ECC transforms a single AI coding assistant into a clearly divided "AI team," enabling full-chain automated workflows from architecture design and code review to security auditing—significantly reducing developer context management costs across multiple tools and sessions.

Image source: Official article

Technical positioning and domain: ECC belongs to AI Agent orchestration and performance optimization, focused on providing system-level Agent management, on-demand Skill loading, context budget control, and security auditing for LLM-based coding assistants (Harness). It doesn't directly generate code but serves as a middleware layer enhancing existing AI coding tools' collaboration and security—positioned as an "AI Agent Harness performance optimization system."

Development background: ECC was created by developer affaan-m, inspired by winning a hackathon through carefully designed Agent and Skill combinations—completing full-chain construction from customer research to product prototype in hours. The project aims to solve AI coding assistants' "solo operation" problem in complex projects, enabling AI to collaborate like professional teams through systematic Agent division and cross-session memory.

Core value: ECC's core value integrates scattered AI coding capabilities into reusable, orchestratable Agent systems while protecting limited context windows (such as Claude Code's 200K tokens) through on-demand loading—avoiding token overflow from excessive Skills and MCP tools. AgentShield security auditing addresses production-grade security issues in AI-generated code such as credential leakage and configuration errors, making ECC ideal infrastructure for enterprise AI development workflows.

Technical characteristics: ECC uses Manifest-driven on-demand loading architecture—injecting relevant Skills only when corresponding tech stacks are detected, greatly reducing context pollution. Its Hook event system supports 8 lifecycle events (SessionStart, PreToolUse, PostToolUse, Stop, etc.) enabling automated workflows. Additionally, ECC provides minimal, core, full, and other installation profiles—users selectively copy rules, Agents, and Skills based on project needs, flexibly adapting to different team sizes.

2. Key Features

• 63 professional Agents: Cover full development chain roles including architecture design, code review, security auditing, test-driven development (TDD), build error fixing, and documentation updates. Each Agent contains specific system prompts and Skill combinations, executing complex tasks independently or collaboratively—e.g., "Security Auditor Agent" automatically scans code for vulnerabilities and generates fix recommendations.

• 249 on-demand loaded Skills: Dynamically match skills based on project tech stack—TypeScript projects automatically load TS review Skills, Python test scenarios trigger TDD Skills, avoiding unrelated Skills consuming context. Manifest-driven loading effectively protects 200K token context windows, letting AI focus on current tasks.

• Cross-session memory persistence: Automatically stores and retrieves context across sessions via Hook mechanism, maintaining uninterrupted continuous workflows. For example, architecture design decisions from morning sessions automatically referenced in afternoon coding sessions without manual information transfer—greatly improving long-cycle project development efficiency.

• AgentShield security auditing: Built-in 1,282 tests and 102 static analysis rules, millisecond scanning for credential leakage, misconfiguration, and injection risks. Supports --fix auto-repair mode and --opus deep adversarial auditing (red team Agent finds vulnerabilities, blue team Agent fixes, auditor Agent summarizes)—providing 98% coverage static analysis capability.

• Continuous learning v2: Intuition-based learning system automatically extracts reusable patterns from real development sessions, generating Instincts and clustering them into Skills. As usage increases, ECC configuration increasingly fits personal workflows—achieving self-evolving "smarter with use" effect.

• Verification loops and checkpoints: Supports /checkpoint for saving verification state, /quality-gate quality gates, and /eval evaluation framework—allowing developers to set automated tests and code quality checkpoints ensuring every Agent operation meets predefined standards.

• Multi-Agent collaboration: Supports /multi-plan, /multi-execute, and other multi-model collaborative workflow commands—simultaneously invoking multiple Agents for parallel tasks (e.g., one Agent refactoring code while another updates documentation) with conflict detection avoiding duplicate work.

• Dashboard GUI: Provides Tkinter desktop application supporting theme switching, font customization, and component visualization browsing—helping developers unfamiliar with command lines manage Agent, Skill, and command configurations, lowering usage barriers.

3. How to Use

1. Environment requirements and prerequisites: Requires Claude Code v2.1+ (latest stable recommended) or other Harness supporting Hook mechanism (Codex, Cursor). Supports macOS, Linux, Windows (WSL recommended). Node.js 18+ and Git optional for plugin installation and repository cloning.

2. Plugin installation (recommended): In Claude Code, run /plugin marketplace add https://github.com/affaan-m/ECC to add marketplace source, then /plugin install ecc@ecc to install plugin. After installation, Skills, commands, and Hooks auto-load, but manually copy rules/ directory to ~/.claude/rules/ecc/ (plugins don't auto-distribute rules). Suitable for quick experience.

3. Manual installation (advanced users): Clone repository git clone https://github.com/affaan-m/ECC.git, then selectively copy agents/, skills/, commands/ to corresponding ~/.claude/ directories. Run ./install.sh --profile minimal --target claude to install Hook runtime. Allows selective installation avoiding unnecessary components consuming space.

4. Key configuration: Control context budget via environment variables—e.g., set ECC_SESSION_START_MAX_CHARS=50000 to limit maximum characters at session start, preventing token overflow. For non-Claude Code platforms like Cursor, use adapter.js to convert Hook events ensuring script logic reuse. Recommend ≤10 MCP tools per project to protect context window.

5. Notes and best practices: After initial installation, run /ecc status to verify component loading. For large projects, recommend full profile installing all Agents and Skills, but watch context budget. Regularly run /ecc learn to trigger continuous learning extracting patterns from latest sessions. For security audit scenarios, recommend --opus mode but consumes more tokens.

4. Pros and Cons

5. Comparison with Similar Tools

Selection advice: For developers seeking maximum Agent count and full-stack coverage, ECC is the best choice—63 Agents and 249 Skills cover complete development chain from architecture design to security auditing, especially suitable for teams needing cross-platform collaboration (simultaneously using Claude Code and Cursor). claude-skills excels in domain breadth (16 domains) with most Skills (338), suitable for teams needing cross-domain knowledge (marketing, product, compliance)—but fewer Agents, less depth in collaborative work than ECC.

For teams emphasizing enterprise discipline and standardization, Superpowers' "development discipline framework" positioning is more suitable—fewer but higher-quality Skills focused on engineering discipline execution (test coverage, code style checks)—but weaker cross-platform support, primarily Claude Code-oriented. If teams simultaneously need security auditing and continuous learning, ECC's AgentShield and continuous learning v2 are unique advantages—neither claude-skills nor Superpowers provides similar functionality.

6. Editor's Take

ECC excels in technical innovation—its on-demand loading architecture and Hook event system provide reusable infrastructure for AI Agent orchestration. Compared to similar projects, ECC's "cross-session memory persistence" and "continuous learning v2" solve AI development's core pain point—AI cannot remember long-term context. ECC automatically stores and retrieves context via Hooks, enabling AI to maintain understanding of large codebases across multiple sessions—a capability most AI coding plugins currently lack. Additionally, AgentShield security auditing (1,282 tests, 102 rules) reaches production-grade standards; especially --opus mode red-blue team adversarial auditing is extremely rare in open-source projects, reflecting the author's deep security understanding.

In practical value, ECC suits medium-to-large teams and complex projects. For full-stack engineers, 63 professional Agents can replace multiple development roles (architect, reviewer, tester), reducing communication costs. For security-sensitive enterprises, AgentShield prevents AI-generated code from leaking keys or containing vulnerabilities, reducing release risk. But ECC has a steep learning curve—newcomers need time familiarizing with Agent systems and commands, and insufficient documentation examples may slow adoption.

Target audience: Experienced AI coding users (familiar with Claude Code or Cursor), full-stack developers, DevOps engineers, security engineers. Beginners should start with minimal configuration, gradually adding Agents and Skills.

Future potential: As AI coding tools evolve from "single assistant" to "multi-Agent teams," ECC's orchestration philosophy will become mainstream. The author plans to support more Harnesses and custom Agent development frameworks—potentially becoming standard middleware for AI development workflows. Note: ECC's continuous learning system depends on user session data—privacy protection needs further clarification (no local offline mode currently provided).

Recommended rating: ★★★★☆ (4.5/5) Deductions for incomplete documentation, cumbersome manual rules copy, and cross-platform compatibility issues. But core functionality is powerful—security auditing and continuous learning are highly innovative and worth recommending.

7. Use Cases

• Full-stack project development: Complete AI-assisted development pipeline from requirements planning, architecture design, TDD coding to code review and E2E testing. Use "Architecture Agent" to generate module design diagrams, then "TDD Agent" to automatically write test cases, finally "Code Review Agent" to review code quality—all without manual tool switching.

• Multi-tech-stack teams: When simultaneously maintaining TypeScript, Python, Go, Java, Rust, Swift, PHP, and other multi-language projects, ECC automatically matches corresponding review Agents. Detecting package.json auto-loads TypeScript review Skills; detecting requirements.txt loads Python test Skills—avoiding manual configuration.

• Security-compliant development: In finance and enterprise projects, use AgentShield to prevent key leakage, configuration errors, and injection attacks. Developers run --opus deep audit before submitting code—red team Agent simulates attackers finding vulnerabilities, blue team Agent auto-fixes, auditor Agent generates security reports meeting compliance requirements.

• Long-cycle maintenance: Use cross-session memory and continuous learning so AI maintains understanding of large codebases across multiple sessions. In three-month refactoring projects, ECC automatically records each session's decisions and patterns—subsequent sessions directly reference without repeating historical context.

• Hackathons and rapid prototyping: Drawing on the author's winning experience, complete full-chain construction from customer research to product prototype in hours. Use /multi-plan to simultaneously launch "Research Agent," "Design Agent," and "Coding Agent" working in parallel—quickly outputting demonstrable MVPs.

8. FAQ

Q: Does ECC support Chinese projects?
A: ECC Agents and Skills are primarily designed with English prompts, but theoretically can handle Chinese code comments and documentation. For Chinese projects, recommend adding Chinese support instructions in Agent system prompts, or using --lang zh parameter (if future versions support). No dedicated Chinese optimization currently provided officially.

Q: How do I verify ECC works after installation?
A: Run /ecc status in Claude Code—if it returns Agent count, Skill count, and Hook status, installation succeeded. Also run a simple test Agent like /agent run "code-review" --file src/index.ts and observe whether review workflow triggers.

Q: Does ECC's continuous learning feature leak privacy?
A: Continuous learning v2 extracts patterns from sessions generating Instincts—all data stored locally in ~/.claude/ecc/ directory, not uploaded to cloud. But recommend regularly reviewing generated Instinct files ensuring no sensitive information (passwords, API keys). AgentShield audit logs also saved locally only.

Q: How do I use ECC in Cursor?
A: Cursor supports Hook event system but format differs slightly from Claude Code. ECC provides adapter.js—manually copy to Cursor extension directory and configure event mapping per project documentation. Cursor compatibility is weaker than Claude Code—some advanced commands (like /multi-plan) may not run normally.

Q: Does ECC conflict with existing MCP tools?
A: ECC recommends ≤10 MCP tools per project to avoid context window overflow. ECC Skills and Agents don't consume MCP tool slots but interact with MCP tools via Hook events. If conflicts occur, use environment variable ECC_MCP_BLACKLIST to exclude specific MCP tools.

Q: How do I update ECC to the latest version?
A: For plugin installation, run /plugin update ecc@ecc. For manual installation, re-clone repository and overwrite corresponding folders in ~/.claude/, then re-run ./install.sh. Recommend backing up custom configurations (such as custom rules in rules/ directory) before updating.

9. Project Links

• Official website: https://ecc.tools/
• GitHub repository: https://github.com/affaan-m/ECC
• Plugin marketplace: Add source in Claude Code via /plugin marketplace add https://github.com/affaan-m/ECC