The affaan-m/ECC repository appeared on GitHub trending for week 47 of 2026 on November 17, 2026, on top of roughly 305,000 cumulative stars and packages ecc-universal 2.2.3 for Claude Code, Codex, Cursor, and a dozen other agent harnesses. ECC is not a single skill — it is a full agent operating system: 72 named agents, 327 skills, hook profiles, MCP templates, memory tooling, and the documented npx ecc-agentshield scan workflow for configuration review.
If you run Claude Code or Codex on a laptop with production credentials, the practical question is not whether ECC is popular. It is whether you can install once from an official surface, avoid duplicate plugin layers, and read hooks and MCP JSON before they execute on your machine. Runta FrontierHarness v1.1 is a useful reminder that default harness choice should change when you change models, not only when you install a bundle.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | Yes if you install trending harness bundles without review — ECC touches hooks, MCP, and hundreds of skills |
| Is there a fix? | Process: use official install paths only, pin [email protected], run AgentShield and a second scanner, avoid stacked installs |
| Does data leave my machine? | Default ECC content is local; you enable MCP servers and API keys in templates — those paths can egress once configured |
| What should I run first? | npm view ecc-universal version, then npx [email protected] setup or native ecc@ecc plugin — not both on Claude Code |
| How does this compare to last week’s skill trends? | Same pattern as ffmpeg-skill and Claude-BugHunter: star count ≠ safety review |
What ECC ships
The ECC README describes a repeatable engineering loop — plan, test, implement, review, verify, remember, improve — encoded as installable assets rather than one-off prompts. The maintainer documents:
- 72 agents for planning, security review, build repair, architecture, and domain work.
- 327 skills spanning TDD, research, security, DevOps, and language-specific patterns.
- Hook runtimes with multiple profiles (standard vs full) for Claude Code.
- Rule packs copied selectively from
rules/because Claude plugins cannot distribute rules automatically. - MCP configuration via
.mcp.jsonandmcp-configs/templates with placeholder secrets.
Version 2.2.3 is the pinned release named in the README install examples (npx [email protected] setup). The package.json on main matches that version string and requires Node.js 18+.
ECC’s own SECURITY.md is unusually explicit about supply chain: unofficial npm aliases, typosquats, and Go module metadata confusion are called out by name. That matters because trending repos attract re-uploads the project does not maintain — the README opens with a warning to install only from github.com/affaan-m/ECC, ecc-universal, ecc@ecc, ecc.tools, and the documented GitHub App.
explainx.ai covers the broader wave of harness and MCP tooling news; Beam focuses on the install mechanics and trust boundaries ECC changes on your workstation.
Why ECC hit trending the week of November 17
GitHub’s trending badge is a velocity signal, not a security review. The week-47 trending listing surfaced ECC beside much smaller repositories that already sit near 305,000 stars on the public counter — a combination that still predicts drive-by npx [email protected] setup installs in Slack threads where nobody read SECURITY.md first.
ECC’s maintainer frames the project as “optimize the context window, persist everything else.” That pitch lands when teams are tired of re-explaining TDD, review gates, and security checklists in every session. The trade is visibility: each installed skill and hook is another file your model may load as authoritative instruction. Snyk’s February 2026 ToxicSkills study (cited in ECC’s own security guide) found prompt injection patterns across a large fraction of public skills — ECC’s bundle is curated, but curated is not cryptographically signed.
The repository also ships continuous-learning and instinct workflows that write back into local memory stores. That is productive for engineering velocity and risky when untrusted repo content can steer what gets remembered — the same class of concern Microsoft documented as AI recommendation poisoning in enterprise agent memory.
ECC Pro and the ECC GitHub App (paid private-repo features on ecc.tools) are separate from the MIT open-source tree. Security reviewers should not conflate “I installed the free plugin” with “my org enrolled the hosted app” — different trust boundaries, tokens, and update channels.
Official install paths (and what not to stack)
ECC supports many harnesses, but the README’s “pick one path only (per harness)” rule is the security headline. Stacking methods duplicates skills, commands, hooks, or configuration.
Claude Code (recommended)
- Guided npm setup:
npx [email protected] setup— inventories marketplace state, picks user/project/local scope, and applies a hook profile. - Native plugin commands inside Claude Code:
/plugin marketplace add https://github.com/affaan-m/ECC/plugin install ecc@ecc
If you choose the native plugin path, do not also run ./install.sh --profile full into the same Claude scope.
Codex
Current Codex builds support a native marketplace plugin:
codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
The README marks scripts/sync-ecc-to-codex.sh as a deprecated compatibility path that copies merged configuration into ~/.codex. Do not combine native ecc@ecc with the legacy sync flow — that is the same duplication class the project warns about for Claude.
Multi-harness guided install
ECC 2.2 added a multi-harness wizard for teams that run Claude Code and Codex side by side:
npx [email protected] install --guided
The wizard lets you select any combination of Claude Code, Codex, and Kimi Code, shows destination paths, preflights selections, and asks for a single confirmation. Automation can pass explicit flags (--harness claude --harness codex, --claude-scope local, --claude-hooks standard, --profile core, --yes). Security reviewers should treat --yes as skipping the human confirmation ECC expects — fine in locked-down CI images, risky on a developer laptop with existing secrets on disk.
Hook profiles on Claude Code
ECC distinguishes hook profiles (for example standard vs heavier interception). More hooks mean more chances to block legitimate work — and more code that runs before you approve a tool call. Read the profile diff during setup the same way you would read a new .claude/settings.json committed to a repo. If a hook shell script curls remote content, that is egress you did not opt into explicitly.
Other harnesses
./install.sh --target <harness> adapts ECC into .cursor/, .gemini/, .zed/, Copilot .github/skills/, and more. Capability varies; the README’s support matrix notes feature parity is not guaranteed outside Claude Code and Codex native plugins. Cursor and Copilot installs land under project-local directories (.cursor/, .github/skills/), which is good for isolation but bad when you clone a random repo that already contains a malicious adapted ECC tree — scan before code ..
Verification commands
After install, ECC documents repair tooling:
node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
Those commands help when a local Claude setup was reset — they do not replace reading new hook JSON before you enable it.
AgentShield and the security guide
ECC bundles documentation for AgentShield (ecc-agentshield on npm):
npx ecc-agentshield scan
SECURITY.md scopes AgentShield to prompts, hooks, MCP config, permissions, secrets, and agent files shipped from ECC surfaces. Code vulnerabilities in AgentShield itself belong in AgentShield’s repository, not ECC’s issue tracker.
The maintainer’s the-security-guide.md is a long-form essay on agentic attack surfaces: poisoned repos, MCP tool poisoning, PR prompt injection, Check Point’s Claude Code CVE write-up, and Snyk’s ToxicSkills statistics. It argues for sandboxing, least agency, approval boundaries, and logging — aligned with Beam’s editorial stance on coding agents, even though ECC’s product goal is throughput rather than standalone observability.
NVIDIA SkillSpector (Beam’s earlier breakdown) and AgentShield occupy a similar lane: offline configuration scanning. Neither observes live tool calls after install the way a collector does.
Supply-chain traps to watch before you npx
Trending status amplifies three recurring failure modes ECC itself documents:
- Unofficial packages — SECURITY.md lists packages that reused ECC metadata without maintainer ownership. Run
npm view ecc-universal versionand compare to the README pin before executing package code. - Duplicate installs — marketplace plugin plus manual
install.shcan load two hook sets; symptoms include doubled slash commands and conflicting PreToolUse handlers (see Postman’s hook overwrite lesson). - Template secrets —
mcp-configs/mcp-servers.jsonusesYOUR_*_HEREplaceholders. Accidental commits of real tokens in~/.claude/settings.jsonare called out in SECURITY.md with grep one-liners — the same paths attackers target in GTIG SomberMeme-style settings backdoors.
ECC also runs supply-chain CI scripts (security:ioc-scan, security:advisory-sources) on its own repository. That protects upstream ECC releases, not your decision to paste a third-party fork into extraKnownMarketplaces.
Quick comparison: ECC vs a single trending skill
| Dimension | Single Agent Skill (e.g. ffmpeg-skill) | ECC full harness |
|---|---|---|
| Install footprint | One skill folder + optional MCP | Hundreds of skills, agents, hooks, rules |
| Update channel | Re-run skill installer | Plugin marketplace, npm setup, or git pull |
| Primary risk | Poisoned SKILL.md or MCP tool schema | Duplicated hooks, broad MCP templates, typosquat npm |
| Static scan time | Minutes | Hours unless you scope directories |
| Best for | One workflow (media, burp, etc.) | Team-wide engineering system |
Neither column is “safer” by default — ECC is more powerful and therefore more review work before you trust it on a machine that signs production commits.
What this means if you run AI coding agents
Treat ECC like onboarding a new vendor suite into your harness:
- Clone or install from official surfaces only — verify the GitHub org, npm package name, and plugin slug (
ecc@ecc). - Pick one install method per harness and run
doctorif behavior looks duplicated. - Run static scans before enabling hooks:
npx ecc-agentshield scanplusbeam scanon high-risk skills and.mcp.json(Beam scanning docs). - Scope MCP and tokens — start on a disposable project directory without production
.envfiles. - Log agent sessions when testing new hook profiles — ECC encourages structured logs in its security guide; Beam’s collector complements that with PreToolUse evidence on supported adapters (agent hooks overview).
- Pin versions — use
[email protected]or a commit SHA for team rollout;mainmoves faster than tagged releases.
ECC’s security skill (skills/agent-security-hardening/) and OWASP-oriented audits inside the bundle can accelerate review, but skills are still untrusted text until you read them — same lesson as MCP security basics.
How Beam handles this
Beam is local-first observability and policy for coding agents: heuristic scans on skills and MCP JSON (11 patterns plus MCP version-pin checks), optional hook-based deny on Claude Code and Codex PreToolUse, redaction before persistence, and Sentinel in the browser. It does not ship 327 workflow skills, repair ECC installs, or replace AgentShield’s bundled scanner.
Where Beam fits ECC-heavy setups:
- Before install:
beam scanon downloadedSKILL.mdfiles and MCP configs you are about to enable (/#how). - During daily use: record risky shell patterns, credential reads, and destructive commands on the laptop ECC configures (/#watches).
- Limits: scanning is heuristic, not semantic malware detection; enforce mode is hook-based, not a kernel sandbox; missing cached policy is fail-open on deny rules.
AgentShield and Beam overlap on pre-execution file review; Beam adds runtime evidence when hooks are wired. Using both is reasonable; using neither because ECC is MIT-licensed is not.
Related reading
- ffmpeg-skill trending MCP install hygiene
- Claude-BugHunter offensive skill bundle
- MCP security practical guide
- NVIDIA SkillSpector scanner limits
- What is AI agent monitoring
Frequently asked questions
What is affaan-m/ECC on GitHub?
ECC is an MIT-licensed agent operating system maintained by Affaan Mustafa. The repository ships skills, specialized agents, hook profiles, rule packs, MCP templates, and install tooling for Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, and other harnesses. The published npm package name is ecc-universal; the Claude marketplace plugin slug is ecc@ecc.
How do I install ECC for Claude Code safely?
The README recommends npx [email protected] setup for guided setup, or native /plugin marketplace add https://github.com/affaan-m/ECC followed by /plugin install ecc@ecc inside Claude Code. Pick one path per harness — the project warns against stacking a full manual install on top of the marketplace plugin because that can duplicate skills, commands, and hooks.
What is the difference between ecc-universal and ecc@ecc?
ecc-universal is the npm package that runs guided installers and repair scripts. ecc@ecc is Anthropic marketplace syntax for the same plugin content hosted from github.com/affaan-m/ECC. The SECURITY.md file lists both as official surfaces along with ecc.tools and the ECC GitHub App.
What does AgentShield check in ECC?
ECC documents AgentShield as npx ecc-agentshield scan, a separate npm package (ecc-agentshield) that scans prompts, hooks, MCP configs, permissions, secrets, and agent instruction files. It is heuristic pattern matching, not sandboxed execution or semantic malware analysis. AgentShield code issues are tracked in its own repository per SECURITY.md.
Which ECC packages are unofficial?
SECURITY.md names @chil_ntl/ecc-cli, ecc-100xprompt-plugin, opencode-ecc, everything-claude-code, and other ECC-like aliases as not maintained by the project unless explicitly documented. Treat npm packages that reuse ECC metadata without matching official surfaces as untrusted until you verify the publisher.
How many skills and agents does ECC ship?
The November 17, 2026 README counts 72 agents, 327 skills, and 98 legacy command shims, plus hooks, rules, memory tooling, and continuous-learning workflows. That count increases with releases; pin [email protected] or a commit hash if you need a fixed footprint for review.
Does ECC upload my code to the cloud?
The core install copies configuration, skills, and hooks locally under your harness paths (for example ~/.claude for Claude Code). Optional MCP servers in mcp-configs templates may call remote APIs once you paste real credentials into placeholders marked YOUR_*_HERE. Read .mcp.json and skill files before first run.
Is ECC the same as Beam?
No. ECC is a productivity and engineering workflow bundle with its own AgentShield scanner. Beam is local observability, heuristic skill/MCP scanning, and hook-based deny rules for Claude Code and Codex on your machine. They can coexist; neither replaces the other.
Install commands, star counts, and package versions reflect the ECC repository and npm registry as of November 17, 2026. Confirm current release tags on github.com/affaan-m/ECC before wide rollout.

