Someone asked on r/ClaudeCode whether everything-claude-code is really that good. The thread got one reply saying the token cost of skill descriptions is "minimal". Nobody had counted.
So I cloned it, version 2.2.1, and counted. It has 250,000 stars, 68 agents, 286 skills, 94 slash commands, 122 rule files and 23 hooks. The README that describes all of it is 2,200 lines long.
The question I wanted answered: what does a full install cost you before you type a word, and which parts are worth taking?
The part the repo tours skip
A skill's body only loads when the skill fires. Its name and description do not. They sit in your context from the first token of every session, and the same is true of every subagent.
That metadata is the price of admission, so I measured it on the fresh clone:
286 skill names + descriptions 85,000 chars ~21,000 tokens
68 subagent descriptions 20,000 chars ~5,000 tokens
the repo's own instruction file ~1,000 tokens
------------------------------------------------------------
standing context, full install ~27,000 tokens
Against a 200,000 token window that is 14% gone every session. It sounds survivable until you remember what shares that window: your files, your diffs, your tool results and the conversation itself. Every skill you will never call competes with the code you are working on.
The repo's own README says "optimize the context window, persist everything else". Then it ships 286 skills.
Two caveats before anyone quotes this. Tokens are estimated at four characters each, so the real number moves with the tokenizer. And none of this says the skills are bad. It says they are not free, and most of them are for stacks you don't write in.
What I kept
Five things. The first two don't need the repo installed at all.
1. AgentShield
A security auditor for agent configurations. It ships inside ECC and also lives on npm as its own package, ecc-agentshield (5,500 downloads last week).
npx ecc-agentshield scan --path .
It audits your agent files, hooks, MCP servers, permissions and secrets, with flags for output format, severity floor and safe auto-fixes. Its README justifies itself with numbers from January: 12% of one skill marketplace was malicious, 341 skills out of 2,800. Those are the package's claims, not mine.
The catch is a date. AgentShield was last published in March. The repo it ships with was updated yesterday, and the scanner's README still describes the ecosystem at 42,000 stars. Six months behind the thing it audits.
2. The settings block
The README publishes four changes to .claude/settings.json: default model to Sonnet, thinking budget from 32,000 down to 10,000, compaction threshold from 95% down to 50%, subagents on the cheapest model. It claims about 60% off model cost and 70% off hidden thinking cost. Its figures, not mine, and they are a trade. A smaller default model will cost you on the hard reviews.
3. Instincts
This is the one idea in the repo I have not seen anywhere else. An instinct is a small learned behaviour with a confidence score between 0.3 and 0.9. Not a rule you wrote. A pattern the system noticed you repeating and wrote down for you.
It watches before and after every tool call, runs the analysis in a background agent on the cheap model, and scopes instincts per project so your React habits stay in the React project. When the same instinct shows up in two projects it gets promoted to global. The system decides what is universal by watching instead of asking.
The tool behind it is 2,200 lines with six commands, and instinct libraries are exportable. Hand yours to a teammate and they import it, which is the first sane onboarding story I've seen for an agent setup.
String attached: all of it rides on the hook runtime, which is the exact part of the repo you are asked to opt into on purpose. No hooks, no instincts.
4. The three context skills
A context budget, a compaction adviser, a token budget adviser. The repo that costs you 14% also ships the tools to see it. The compaction rule alone is worth copying: compact after research and before you implement, after a milestone, after debugging, after an approach fails, and never in the middle of an implementation where you lose the file paths and the half-finished state.
5. The installer, used one skill at a time
Seven profiles, and the smallest says in its own description that it leaves the hook runtime out. You can skip profiles entirely and name skills one by one, and an adviser takes a plain sentence about your work and returns matching components with a preview before anything is written. Any install that would put hooks on your machine stops and waits for a yes.
Install that way and the bill stops being 14%. I'm not giving a figure for the fraction because I did not measure every combination. Even the smallest profile still carries the agents and the rules, so naming skills by hand is the only way to pay for exactly what you use.
What stays in the repo
The 68 agents as a set: about 5,000 tokens of standing context, mostly language reviewers and build fixers for C++, C#, Django and Kotlin. Take the two that match your work.
The 94 slash commands: the README itself calls them temporary entry points while the repo moves to skills, and commands are the easiest thing here to write yourself.
The hooks file: 23 hooks, 291 lines, 40 KB, every hook squeezed onto a single line, the longest at 2,000 characters. The descriptions beside them are readable and some are good (one blocks the agent from editing your linter config and says why). The description is the only part you can read.
The ballast: config for 19 harnesses and 15 MB of docs in 22 languages, for a tool you run in one language, in one place.
What this doesn't measure
Whether the skills make the answers better. I measured what they cost you to have. Those are different questions. Also, version 2.2.1 had 110 open pull requests the day I cloned it, so the counts above are already old.
Takeaways
- A full install of ECC parks about 27,000 tokens in context before you type, 14% of a 200k window.
- Skill bodies are lazy. Skill metadata is not.
- The licence is MIT. Copying five directories out is the intended use, not a workaround.
- AgentShield is worth running once, and worth checking the publish date of.
- Instincts are the only new idea; they need the hook runtime.
Full write-up with the tables and chapter timestamps: https://aidive.dev/videos/ecc-what-to-steal/
Are you running the full install, a profile, or hand-picked skills? And what does your context sit at when a session starts?
I use AI tools to help edit my writing. The counts, the install and the opinions are mine.
Top comments (1)
Nobody counting is the saddest part of this — the one-reply thread you mention is exactly how these decisions get made, on vibes. The 27k figure passes my sniff test too: skill metadata eats a similar share of standing context in my own agent setups, and the sting is that you pay it in every session, including the ones where you touch none of the 286 skills.
One thing I'd add from running long-lived agents where the API bill is real: the 14% understates the damage. Standing metadata doesn't just cost tokens, it costs selection quality — every skill name the model sees is something it can wrongly reach for, and with 286 candidates the wrong pulls are non-trivial. Cutting down to a hand-picked dozen didn't just save tokens for me, it made routing visibly more reliable. Did you observe whether the curated install changed behavior, or only cost?
The compaction rule you quoted deserves restating because it's earned the hard way: never mid-implementation. A compaction that fires between writing a migration and running it loses exactly the state you need, and the agent rebuilds from a summary that confidently omits the half-applied step. Compact-after-debugging is the other underrated one — debug sessions accumulate the most junk context of anything I run.
On instincts: the confidence-score idea is genuinely new to me, but the hook-runtime dependency is where I'd hesitate. Hooks are shell execution on every tool call, and an auto-generated "learned behaviour" riding on that is a supply-chain surface, not just a feature flag. Does the repo let you run instincts as read-only suggestions before wiring them in?