affaan-m/ECC

Maintainer? Show your league in your README

Card: your league's emblem, from Copper to Legendary

[![bestofgithub](https://bestofgithub.dev/badge/affaan-m/ECC.svg?style=card)](https://bestofgithub.dev/repo/affaan-m/ECC)

Flat: fits beside your other badges

[![bestofgithub](https://bestofgithub.dev/badge/affaan-m/ECC.svg)](https://bestofgithub.dev/repo/affaan-m/ECC)

Loading README…

Included	Count	What it gives you
Agents	71 agents	Planning, review, build repair, security, architecture, and domain work
Skills	314 skills	TDD, research, security, docs, frontend, data, ML, operations, and more
Commands	98 commands	Convenient entry points while ECC moves to a skills-first surface
Hooks and memory	Runtime	Enforcement, session summaries, continuous learning, instincts, and context controls
Rules	Selective	Always-loaded standards you choose by language or project
AgentShield	Included	Scanning for prompts, hooks, MCP config, permissions, secrets, and agent files

Package runner	Guided setup command
npm / npx	`npx ecc-universal@2.2.3 setup`
pnpm	`pnpm dlx ecc-universal@2.2.3 setup`
Yarn 2+	`yarn dlx ecc-universal@2.2.3 setup`
Bun	`bunx ecc-universal@2.2.3 setup`

Harness	Guided install behavior
Claude Code	Native `ecc@ecc` plugin with one `user`, `project`, or `local` scope and an ECC hook profile
Codex	Native Codex marketplace/plugin lifecycle; hook review and trust remain Codex-owned
Kimi Code	Managed project files under `./.kimi-code`; ECC hooks, model/provider settings, and authentication are not configured

Harness	Install or setup	Notes
Cursor	`./install.sh --profile minimal --target cursor`	Project-local `.cursor/` adapter
OpenCode	`npm install && npm run build:opencode && ./install.sh --profile full --target opencode --enable-hooks`	Builds the plugin payload before the full install
Gemini CLI	`./install.sh --profile minimal --target gemini`	Project-local `.gemini/` config
Zed	`./install.sh --profile minimal --target zed`	Project-local `.zed/` adapter
Antigravity	`./install.sh --profile minimal --target antigravity`	See the Antigravity guide
Qwen CLI	`./install.sh --profile minimal --target qwen`	See the Qwen guide
Hermes	`./install.sh --profile minimal --target hermes`	See the Hermes setup guide
OpenClaw	`./install.sh --profile minimal --target openclaw`	Managed home-directory install
Kimi Code CLI	`./install.sh --profile minimal --target kimi`	Project-local `.kimi-code/` install · Get Kimi Code
CodeBuddy	`./install.sh --profile minimal --target codebuddy`	Project-local `.codebuddy/` install
JoyCode	`./install.sh --profile minimal --target joycode`	Project-local `.joycode/` install
GitHub Copilot	`./install.sh --profile full --target copilot`	Installs skills to `.github/skills/` and agents to `.github/agents/` for Copilot CLI

What you are doing	Start here
Building a feature	`/ecc:plan "describe the feature"`, then `tdd-workflow`
Fixing a bug	Reproduce it with a failing test, then use `tdd-workflow`
Reviewing new code	`/code-review` for a fresh-context review
Triaging a GitHub issue	`/ecc:issue-review <number>` (plugin) or `/issue-review <number>` (manual install) to verify it against the code and draft a reply
Repairing a build	`/build-fix`
Cleaning a codebase	`/refactor-clean`
Checking context pressure	`/context-budget`
Ending a long session	`/save-session` or `/learn-eval`
Resuming later	`/resume-session`
Auditing agent config	`/security-scan` with a reviewed scanner, or installed `agentshield scan --path .`

I want to...	Use this surface	Agent used
Plan a new feature	`/ecc:plan "Add auth"`	planner
Design system architecture	`/ecc:plan` + architect agent	architect
Write code with tests first	`tdd-workflow` skill	tdd-guide
Review code I just wrote	`/code-review`	code-reviewer
Review a GitHub issue	`/ecc:issue-review` (plugin), `/issue-review` (manual install)	— (issue-review skill)
Fix a failing build	`/build-fix`	build-error-resolver
Run end-to-end tests	`e2e-testing` skill	e2e-runner
Find security vulnerabilities	`/security-scan`	security-reviewer
Remove dead code	`/refactor-clean`	refactor-cleaner
Update documentation	`/update-docs`	doc-updater
Review Go code	`/go-review`	go-reviewer
Review Python code	`/python-review`	python-reviewer
Review F# code	(invoke `fsharp-reviewer` directly)	fsharp-reviewer
Review TypeScript/JavaScript code	(invoke `typescript-reviewer` directly)	typescript-reviewer
Develop HarmonyOS apps	(invoke `harmonyos-app-resolver` directly)	harmonyos-app-resolver
Audit database queries	(auto-delegated)	database-reviewer
Review production ML changes	`mle-workflow` skill + `mle-reviewer` agent	mle-reviewer

Topic	What You'll Learn
Token Optimization	Model selection, system prompt slimming, background processes
Memory Persistence	Hooks that save/load context across sessions automatically
Continuous Learning	Auto-extract patterns from sessions into reusable skills
Verification Loops	Checkpoint vs continuous evals, grader types, pass@k metrics
Parallelization	Git worktrees, cascade method, when to scale instances
Subagent Orchestration	The context problem, iterative retrieval pattern

Without a system	With ECC
Plans disappear into chat history	Plans become editable artifacts before implementation starts
"Please use TDD" is an instruction the model may forget	TDD becomes a gated RED -> GREEN -> REFACTOR workflow with evidence
The same context writes and reviews the code	A fresh-context reviewer looks for regressions and blind spots
Memory means saving an enormous transcript	Sessions are distilled into summaries, instincts, and reusable skills
Quality checks depend on reminders	Hooks can enforce deterministic checks outside the prompt
Agent configuration is trusted by default	AgentShield scans the harness itself as an attack surface

Concept	What it does	Context behavior
Skills	Reusable workflows such as TDD, security review, or deep research	Loaded when the task needs them
Agents	Scoped workers with their own context and tool permissions	Isolate planning, implementation, and review
Rules	Durable project or language standards	Always loaded, so install them selectively
Hooks	Scripts triggered by harness events	Run outside the model context
Instincts	Patterns learned from real sessions with confidence scores	Recalled when relevant

Platform	Status	Current limitation
Linux	Supported core	Optional features may require Bash, Python, or provider-specific tools.
macOS	Supported core	The standalone GAN shell path is not compatible with the system Bash 3.2 and currently has a score-parsing defect (#2674).
Windows + WSL	Supported core	WSL follows the Linux paths; Windows host integrations still vary by harness.
Windows native	Supported with limitations	Continuous-learning v2's observer daemon and memory-vault writes have open native-Windows defects (#2489, #2626). Shell-backed optional features require Git Bash/WSL or are unavailable.

Harness	Status	Recommended distribution	Important limitation
Claude Code	Stable primary	Plugin or selective installer	The plugin advertises the installed catalog to the model; use a selective/manual profile when context footprint matters. Optional shell-backed skills are not portable to every OS.
Codex	Supported native plugin	Codex marketplace plugin or repo config	Native hooks require an explicit trust decision and do not use Claude's hook profiles. The legacy sync is compatibility-only.
Qoder	Supported native plugin	Local plugin directory in Qoder CLI or ZIP upload in Qoder IDE	Loads the canonical skills, agents, commands, and MCP config; only the reviewed SessionStart hook is enabled, and Node.js 18+ must be on the non-interactive PATH.
Cursor	Beta project adapter	Selective installer into `.cursor/`	Agent discovery varies by Cursor build; hook events use profile-gated dispatchers, but full Claude feature parity is not claimed.
OpenCode	Beta built plugin	Build plugin, then selective installer	ECC ships a subset of the catalog; connect a provider and select a model in OpenCode (#2617).
GitHub Copilot Chat	Instruction-only	Checked-in instructions and prompt files	ECC hooks are not adapted.
GitHub Copilot CLI	Beta project adapter	`--target copilot` places skills, adapted agents, and converted rules in `.github/`	ECC hooks and command shims are not installed by this target.
Gemini, Zed, Antigravity, Qwen, Hermes, OpenClaw, Kimi, CodeBuddy, JoyCode	Experimental/minimal adapters	Harness-specific selective target	File placement and instruction portability are tested; full Claude feature parity is not claimed.

Capability	Claude Code	Codex	Cursor	OpenCode	GitHub Copilot
Instructions	Native	Native `AGENTS.md`	Project rules	Plugin instructions	Native instruction file
Skills	Native installed set	Native plugin set	Build-dependent/project set	Built subset	Native discovery (Copilot CLI) from `.github/skills/`, `.agents/skills/`, `.claude/skills/`
Agents/delegation	Native agents	Codex multi-agent roles; Claude agent files are not installed as roles	Build-dependent project agents	Plugin agents	Copilot CLI custom agents via `.github/agents/` and `--agent`
ECC hooks	Native plugin hooks	Native reviewed subset with explicit trust	Cursor hook adapter; install-path differences remain	Plugin events	Not ported; Copilot CLI has its own plugin hook system
MCP configuration	Available, explicit activation	Native plugin manifest; legacy sync can merge TOML	Explicit project/user config	Provider/plugin config	Not supplied by ECC
Parity with Claude Code	Primary reference	Partial	Partial	Partial	Partial

Component	Count	Details
Hook Events	15	sessionStart, beforeShellExecution, afterFileEdit, beforeMCPExecution, beforeSubmitPrompt, and 10 more
Hook Entrypoints	15	Thin Node.js event dispatchers delegating to `scripts/hooks/` via shared adapter
Rules	34	9 common (alwaysApply) + 25 language-specific (TypeScript, Python, Go, Swift, PHP)
Agents	48	`.cursor/agents/ecc-*.md` when installed; prefixed to avoid collisions with user or marketplace agents
Skills	Shared + Bundled	`.cursor/skills/` for translated additions
Commands	Shared	`.cursor/commands/` if installed
MCP Config	Shared	`.cursor/mcp.json` if installed

Component	Count	Details
Config	1	`.codex/config.toml`: top-level approvals/sandbox/web_search, MCP servers, notifications, profiles
AGENTS.md	2	Root (universal) + `.codex/AGENTS.md` (Codex-specific supplement)
Skills	32	`.agents/skills/`: SKILL.md + agents/openai.yaml per skill
MCP Servers	6 legacy reference entries	GitHub, Context7, Exa, Memory, Playwright, Sequential Thinking. Current managed sync recommends `chrome-devtools`; see the explicit refresh instructions above.
Profiles	2	`strict` (read-only sandbox) and `yolo` (full auto-approve)
Agent Roles	3	`.codex/agents/`: explorer, reviewer, docs-researcher

Role	Purpose
`explorer`	Read-only codebase evidence gathering before edits
`reviewer`	Correctness, security, and missing-test review
`docs_researcher`	Documentation and API verification before release/docs changes

Claude Code Hook	OpenCode Plugin Event
PreToolUse	`tool.execute.before`
PostToolUse	`tool.execute.after`
Stop	`session.idle`
SessionStart	`session.created`
SessionEnd	`session.deleted`

Component	File	Purpose
Core instructions	`.github/copilot-instructions.md`	Always-loaded rules: coding style, security, testing, git workflow
VS Code settings	`.vscode/settings.json`	Per-task instruction files for code gen, test gen, and commit messages
Plan prompt	`.github/prompts/plan.prompt.md`	Phased implementation planning
TDD prompt	`.github/prompts/tdd.prompt.md`	Red-Green-Improve cycle
Security review prompt	`.github/prompts/security-review.prompt.md`	Deep OWASP-aligned security analysis
Build fix prompt	`.github/prompts/build-fix.prompt.md`	Systematic build and CI error resolution
Refactor prompt	`.github/prompts/refactor.prompt.md`	Dead code cleanup and simplification

ECC Feature	Copilot equivalent
Coding standards	Always-on via `copilot-instructions.md`
Security checklist	Always-on + `security-review` prompt
Testing / TDD	Always-on + `tdd` prompt
Implementation planning	`plan` prompt
Code review	External PR review via CodeRabbit + Greptile
Build error resolution	`build-fix` prompt
Refactoring	`refactor` prompt
Commit message format	Per-task instruction in `settings.json`
Skills	Native discovery in Copilot CLI (`.github/skills/`, `.agents/skills/`)
Agents / delegation	Copilot CLI custom agents (`.github/agents/`, `--agent`)
Rules	Path-specific instructions (`.github/instructions/ecc/`, `applyTo:` globs)
Hooks / automation	ECC's hooks are not ported (Copilot CLI has its own plugin hook system)

Setting	Default	Recommended	Impact
`model`	opus	sonnet	~60% cost reduction; handles 80%+ of coding tasks
`CLAUDE_CODE_EFFORT_LEVEL`	Model-dependent	medium, if supported	Controls adaptive reasoning depth on models that support effort controls; lower effort trades reasoning depth for latency and cost
`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`	95	50	Compacts earlier, better quality in long sessions
`ECC_CONTEXT_MONITOR_COST_WARNINGS`	on	off for subscription users	Suppresses agent-facing API-rate estimate warnings while keeping context/scope/loop warnings

Command	When to Use
`/model sonnet`	Default for most tasks
`/model opus`	Complex architecture, debugging, deep reasoning
`/clear`	Between unrelated tasks (free, instant reset)
`/compact`	At logical task breakpoints (research done, milestone complete)
`/cost`	Monitor token spending during session

Install with Claude Code

ECC

Install ECC

Recommended: universal guided setup

Windows first-time walkthrough

Pick one path only (per harness)

Claude Code details

Codex App and CLI

Qoder CLI and IDE

Other agents and editors

Advanced Install Options

Low-context / no-hooks path

Find the right components first

Install hooks

Configure MCPs

Reset / Uninstall ECC

Start Using ECC

Self-Hosted Models and Custom Endpoints

Self-host Kimi with ECC + Itô compute

Itô compute CLI bridge

What's New

v2.0.0: The Agent Harness Operating System (Jun 2026)

What's Inside

Key Concepts

Agents

Skills

Hooks

Rules

Guides

Why Choose ECC?

TDD: Test-Driven Development

Skills keep the context focused

Share context between harnesses

Platform Support

Cross-tool capability map

What's included for Cursor

Cursor loading notes

Memory and data isolation (Cursor + Claude Code)

Hook architecture (DRY adapter pattern)

Rules format

What's included in the repo and legacy configuration layer

Key limitation

Multi-agent support

Hook support via plugins

Plugin installation

Documentation

What's included for GitHub Copilot

Copilot CLI: skills and agents

Installing with the copilot target

Feature coverage

Limitations

Token Optimization

Requirements

Claude Code CLI version

Important: hooks auto-loading behavior

Security

Ecosystem Tools

Option A: Local Analysis (Built-in)

Option B: GitHub App (Advanced)

Troubleshooting

Running Tests

Background

Community and Project

Links

License

Installing with the `copilot` target