ECC: A Framework for Code Agents to Avoid Prompt Dependence

Everything you need to know about affaan-m/ECC: a collection of agents, skills, rules, hooks, and utilities for structuring the work of coding agents across various environments.

---

What is ECC?

ECC presents itself as an environment runtime optimization system. Its goal isn’t to replace the model or the programming environment; instead, it installs a process layer that enables the agent to plan, test, deploy, review, verify, maintain context, and turn repeated results into reusable skills.

The current README lists 67 specialized agents, 281 skills, and 94 compatibility commands, along with rules, hooks, memory, continuous learning, and AgentShield. Its primary support is for Claude Code; it also provides configuration or adapters for Codex, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen, Hermes, OpenClaw, Kimi, and other environments. Not all receive the same level of automation: for example, the project itself states that Codex and Copilot do not have parity with Claude Code’s hooks.

Origin: From a Configuration Collection to a Multi-Environment System

The earliest recoverable confirmation is the initial commit by Affaan Mustafa on January 18, 2026, titled “Complete Claude Code configuration collection.” In that commit message, Mustafa describes configurations used for over ten months and states that he won first place in an Anthropic and Forum Ventures hackathon by creating zenith.chat; this is a claim made by the author himself, not an independent verification of the award.

The initial release contained nine agents, nine commands, eight rules, seven skills, hook configuration, and MCP servers. The problem it aimed to solve was straightforward: requesting tests or reviews within a conversation doesn’t guarantee that the agent will remember to do so. ECC turns part of this process into loadable artifacts and external hooks to the model’s context.

The author’s GitHub account identifies Mustafa as being associated with Itô, located in NYC, and describes ECC as his open-source environment for agents. The repository was created on January 18, 2026. The current version, 2.1.0, is now called “Agent Harness Operating System” and adds, among other changes, Plan Canvas, a destination for Kimi, and a documented path for self-hosted compute. No primary source was found that formally dates the name change from the initial title; therefore, a renaming date is not stated.

Philosophy and Principles

The guiding idea in the README is: optimize the context window and persist everything else. The architecture separates five roles to avoid loading everything at once:

• Skills are loaded for specific workflows, such as testing, research, or security review.
• Agents separate planning, implementation, and review contexts.
• Rules contain durable standards and should be installed selectively because they always consume context.
• Hooks execute checks outside the model in response to environment events.
• Instincts and memory store patterns and summaries for later sessions.

The proposed sequence is plan -> test -> implement -> review -> verify -> remember -> improve. This doesn’t guarantee quality: the repository recommends reviewing memories against authoritative sources and warns that unreviewed memory should not be treated as executable policy.

How it Works

For Claude Code, the recommended installation uses its plugin mechanism:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

For Codex, the guide prioritizes synchronization from a local clone that integrates AGENTS.md, skills, prompts, and configuration without replacing existing files:

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
bash scripts/sync-ecc-to-codex.sh

A function’s flow can start with /ecc:plan "description", continue with the tdd-workflow skill, proceed to /code-review in a new context, and end with compilation, type, style, and test verification. To finish or resume a session, use /save-session, /resume-session, and /learn-eval. Shared memory uses Markdown files under .ecc/memory/ for the project or ~/.ecc/memory/ for the user; its command-line interface includes ecc memory init, search, and doctor.

Version 2.1.0 also incorporates Plan Canvas: a local interface that allows annotating a plan and approving it or returning it for changes. The project states that its interface is a command-line utility that exchanges JSON, so it doesn’t depend on a specific model or environment.

Official and Semi-Official Status

There are three distinct statuses that should not be confused:

• Claude Code’s own marketplace: ECC publishes the identifier ecc@ecc and a manifest for Claude Code to install the plugin from the repository. This is distribution through an Anthropic native feature, but the retrieved source does not demonstrate that it is part of an official Anthropic editorial catalog or vendor certification.
• Codex’s plugin marketplace: The README indicates that Codex supports registering affaan-m/ECC in its marketplace, but marks it as experimental for ECC: the package may depend on shared content that doesn’t reach Codex’s cache. For reliable use, it recommends synchronization rather than the marketplace.
• GitHub Marketplace: The README links to the ECC Tools application in GitHub Marketplace and declares a free tier and plans for private repositories. This presence is an acceptance of distribution by GitHub Marketplace, not a technical approval of all skills by GitHub.

Visible adoption, numerous copies, and adaptations for different environments allow ECC to be described as a de facto reference in the pattern of configuration collections for agents. No formal standard designation or official recommendation from Anthropic, OpenAI, or GitHub regarding its methodology was found.

The Ecosystem

Author’s Repositories and Products

The author’s GitHub API returns these related projects, with their figures consulted on July 31, 2026:

• affaan-m/agentshield: security scanner for agent configurations, MCP servers, and permissions; 1,034 stars and 218 forks. ECC integrates it as ecc-agentshield and documents its use locally and in CI.
• affaan-m/claude-swarm: multi-agent coordination for Claude Code with a terminal interface; 306 stars and 77 forks.
• ECC Tools, the GitHub Marketplace application, analyzes repository history to generate skills, instinct collections, and pattern extraction. It is a hosted product from the same ecosystem, not a separate repository retrieved by the API.
• The packages published that the README identifies as official are ecc-universal and ecc-agentshield. The project explicitly warns against third-party republishing and unreviewed mirrors.

Community Translations, Ports, and Derivatives

The main repository maintains links to documentation in Brazilian Portuguese, Simplified Chinese, Traditional Chinese, Japanese, Korean, Turkish, Russian, Vietnamese, Thai, German, and Spanish. Additionally, a search of repositories by the project’s old name returned these community-derived or adapted versions; GitHub marks them as independent repositories, not official forks:

• xu-xiang/everything-claude-code-zh, Chinese translation: 1,791 stars and 300 forks.
• WorldFlowAI/everything-claude-code, Claude Code kit based on agents, commands, skills, rules, and hooks: 867 stars and 165 forks.
• tpavanipradeep/everything-claude-code, whose description calls it a copy of affaan-m/everything-claude-code: 86 stars and 39 forks.
• ahmed3elshaer/everything-claude-code-mobile, adaptation oriented towards mobile use: 61 stars and 17 forks.
• Luohaothu/everything-codex, described as a version for Codex: 24 stars and 5 forks.
• j7-dev/everything-github-copilot, rewrite for GitHub Copilot: 19 stars and 4 forks.

These figures do not prove compatibility, security, or author endorsement. In fact, ECC’s warning to install only from verified channels is particularly relevant given this volume of copies.

Repository Metrics

Measurement: July 31, 2026, GitHub API.

Metric	Value
Stars	236,598
Forks	35,984
Subscribers	1,225
Commits	2,336
Open issues reported by the API	110
Primary language	JavaScript
License	MIT
Creation	January 18, 2026
Last metadata update	July 31, 2026
Latest stable release	v2.1.0, July 27, 2026

The main contributors returned by the API are affaan-m with 1,517 contributions, dependabot[bot] with 51, pangerlkr with 47, gaurav0107 with 25, and Copilot with 22. The total number of commits was obtained from the last page of the API pagination. The open_issues_count field may include open change requests; it should not be read as an exclusive count of issues. The API replicates stars in watchers_count, so subscribers_count is reported as actual subscribers.

How to Contribute

The contribution guide asks you to fork and clone the repository, create a feat/... branch, test locally, and open a pull request. For a skill, it requires its own directory with SKILL.md, YAML metadata, a description that allows for automatic activation, examples, anti-patterns, tests in Claude Code, and no sensitive data.

Before submitting, document npm test as the same battery used by continuous integration. For public surface changes, it also asks you to update manifests, catalogs, command registries, and documentation; if the skill is intended for Codex or Cursor, you must synchronize the specific subsets of those environments. The pull request should explain the summary, type, tests, and a security checklist.

Community Reception

The retrieved evidence shows interest and collaboration, but not a massive verifiable external thread:

• On Hacker News, 48126691, doener submitted what was then called “Everything Claude Code” on May 13, 2026. The thread ended with 2 points and 0 comments. Another submission, 46676402, by bzGoRust, also had 2 points and 0 comments. These are specific references, but they do not allow us to claim widespread acceptance on that site.
• Pull request #730 by mecemis, about C# support, accumulated 99 comments. The maintainer, affaan-m, wrote “Approved — great C# support!”, an explicit positive assessment, although he asked to resolve merge conflicts. He then noted that C# coverage had already arrived through pull requests #704 and #747. This episode illustrates active review and also duplication of contributions.
• Pull request #2472 by girish-kanjiyani7 objects to a practical problem: according to his reproduction, a full installation silently omitted 79 of the 277 curated skills due to missing references in the manifest. This is a specific technical criticism of the installer, not a general assessment of the project.
• In #2634, samartomar proposed that automatic hooks require explicit authorization during installation. This objection relates to the cost of a layer that automates actions: productivity does not eliminate the need for human control and consent.

ECC vs. Other Proposals

Proposal	Verifiable Match	Verifiable Difference
affaan-m/agentshield	Both deal with agent configurations and connect within the ECC ecosystem.	AgentShield is a security scanner; ECC is the broader set of process, skills, rules, and adapters.
affaan-m/claude-swarm	Both organize the work of multiple agents for Claude Code.	Claude Swarm focuses on decomposing and visualizing multi-agent coordination; ECC also covers installation, rules, memory, and security across various environments.
WorldFlowAI/everything-claude-code	GitHub search describes it as a kit of agents, commands, skills, rules, and hooks for Claude Code.	It is an independent derivative focused on Claude Code; ECC documents adapters and distributions for a wider range of environments.
Luohaothu/everything-codex	Its description presents it as a version of Everything Claude Code for Codex.	It is a community adaptation for Codex; ECC maintains its own synchronization flow and states the limitations of its experimental plugin for Codex.

The important difference isn’t just the number of files: ECC aims to maintain a common source and adapters per environment. This coverage can save reconstruction of instructions, but it also increases the installation, compatibility, and security surface that needs to be reviewed.

Use Cases and Who Can Benefit from This Repository

• Teams using Claude Code and needing to distribute planning, implementation, and review can combine agents, skills, rules, and hooks to follow the plan -> test -> implement -> review -> verify cycle, save session transfers, and check results before closing work.
• Teams that want to bring the same set of instructions to Codex, Cursor, or other environments can use ECC’s synchronization to integrate AGENTS.md, skills, and prompts without replacing existing files. They should validate the result in each environment: the repository itself states that Codex and Copilot do not have parity with Claude Code’s hooks.
• Those creating research, articles, or materials for clients and investors can leverage the article-writing, content-engine, market-research, investor-materials, and investor-outreach skills, along with the Memory Vault, to maintain a reusable flow between sessions. Memories are still unreviewed context: important data and claims should be verified before publication.

Resources

• Repository: https://github.com/affaan-m/ECC
• Documentation and installation: https://github.com/affaan-m/ECC#install-ecc
• Official skills: https://github.com/affaan-m/ECC/tree/main/skills
• Codex guide: https://github.com/affaan-m/ECC/blob/main/docs/CODEX-NAVIGATION-GUIDE.md
• AgentShield: https://github.com/affaan-m/agentshield
• ECC Tools on GitHub Marketplace: https://github.com/marketplace/ecc-tools
• Discord community: https://discord.gg/36yGMHGFbR
• Conversations and reviews: https://news.ycombinator.com/item?id=48126691, https://news.ycombinator.com/item?id=46676402, https://github.com/affaan-m/ECC/pull/730, https://github.com/affaan-m/ECC/pull/2472, https://github.com/affaan-m/ECC/pull/2634

---

Note: This article combines the README and contribution guide of ECC, the GitHub API, its commit history, search results for repositories, and Hacker News, consulted on July 31, 2026. The figures change over time.