Everything Claude Code hit 249K stars. Install almost none of it

Everything Claude Code, now abbreviated to ECC, went from first commit to roughly 249,000 GitHub stars in under eight months. That puts a config framework, a pile of Markdown files and hooks with no model weights and no runtime of its own, in the same star territory as VS Code. Affaan Mustafa's project bills itself as "the agent harness performance optimization system," and it ships an enormous amount of stuff: 284 skills, 68 specialized subagents, per-language rule packs, hook-based automations, a cross-session memory vault, and a security scanner called AgentShield. It installs into Claude Code, Codex, Cursor, OpenCode, and a half dozen other harnesses.

The star count is real signal. The install decision is where most developers will get it wrong.

Why a parts bin got famous

ECC exists because every team using coding agents has been rebuilding the same scaffolding by hand: plan before you write, run the tests, review the diff from a fresh context, write down what you learned so tomorrow's session doesn't start from zero. Anthropic gave Claude Code the primitives for this (skills, subagents, hooks, CLAUDE.md), but primitives aren't a workflow. ECC is what happens when someone commits their entire working workflow to a repo and keeps refining it in public. Judging by 37,500 forks, that answered a question a lot of people were asking.

The more interesting move is that ECC stopped being a Claude Code project. The same skills, rules, and memory format now target nine-plus harnesses through a single npx ecc-universal setup. That's a quiet bet: if your prompts, learned patterns, and review workflows live in portable Markdown, the agent CLI underneath becomes swappable. The vendors are competing on models and harness ergonomics. ECC is a wager that the durable asset is the layer you accumulate on top, and that developers would rather own that layer in a git repo than have it locked inside any one vendor's product.

The memory design is the one part I'd call novel. Session summaries get written at conversation end, recurring patterns get extracted into "instincts" with confidence scores, and all of it lands in plain Markdown you can read, edit, or delete. Most agent-memory schemes are opaque databases. This one you can code-review. If cross-harness portable memory becomes a real category, this repo is the prior art.

The physics problem

Here's the case against installing all of it. Context windows are a budget, and Claude Code spends heavily before you type anything: one widely discussed measurement put its pre-prompt overhead around 33,000 tokens, versus about 7,000 for OpenCode. Every always-loaded rule pack ECC adds comes out of what's left. Load the full suite and independent write-ups estimate your usable working context can collapse to well under half the nominal window. ECC's own documentation concedes the point, warning that an oversized CLAUDE.md means the model ignores half your rules, and advising you to copy rules/common plus one language pack rather than everything.

So the project's docs and its marketing pull in opposite directions. The README sells a coordinated engineering system; the fine print tells you to install a sliver of it. The fine print is right. Skills load on demand and cost little on the shelf. Always-on rules are the expensive part, and they're expensive on every single turn. Developers on $20/month plans already report burning through usage limits in a handful of complex prompts; a maximal ECC install makes that strictly worse while degrading instruction-following at the same time.

There's also a supply-chain angle that deserves more attention than it gets. Installing ECC means adopting thousands of lines of third-party prompt text, hooks that execute on your machine, and pre-configured MCP servers. Prompt files are code now. They steer an agent that holds your credentials and writes to your repos. ECC shipping AgentShield, a scanner that audits prompts, hooks, and MCP configs, is both a useful tool and a tacit admission of how large this attack surface has become. Read what you install. All of it.

How to adopt it without regret

Treat ECC as a reference library with an optional installer, in that order.

Start by reading, not installing. The skills and agent files are well-organized Markdown; an afternoon in the repo will teach you more about structuring agent workflows than most paid courses. Steal the two or three skills that map to your actual work, a TDD loop, a security-review pass, a planning gate, and put them in your own project config where you control every line.

If you do install, take the minimal or core profile, never full, and pick one install method (the maintainer explicitly warns against stacking them). Add exactly one language rule pack. Then watch your token burn for a week before adding anything else. The memory vault and instincts system is the piece I'd enable early, because it compounds: it's the only part of ECC that gets more valuable the longer you run it, and it's inspectable enough to audit as it grows.

The business model, MIT-licensed core with a hosted ECC Pro GitHub App for private repos, means the free tier isn't going anywhere, so there's no urgency premium on adopting today.

The verdict

ECC's growth is evidence for a real shift: the harness layer above the agent CLI is now where practitioners are competing and sharing, and it's consolidating fast around portable, vendor-neutral formats. That layer mattering is not hype. But the maximalist framing, one system, hundreds of components, install it everywhere, runs into the hard constraint that context is the scarcest resource an agent has. The repo's real value is that a quarter million people can now read one obsessive practitioner's working notes. Strip it for parts. Leave the operating system on the shelf.