ECC Teardown: The Agent Harness That Won Anthropic’s Hackathon
One repo, 268,000 GitHub stars: ECC turns Claude Code into an engineering team — planner, writer, reviewer, security — with 68 specialist subagents, 292 skills, and a memory vault that never forgets a lesson. Here’s how the harness works, and the two patterns worth stealing for your own setup.
Explain it like I’m five
Imagine you ask one very smart friend to build you a treehouse. If you just say “build a treehouse” and walk away, you’ll get something — but the ladder might be on the wrong side and nobody checked whether the wood is rotten. Now imagine instead you hire a tiny construction crew: one person draws the plan, one person builds, a second person inspects the work with fresh eyes, and a safety officer checks everything before anyone climbs up. Same smart friend doing the work — but organized like a team, with a notebook where they write down every lesson so next week’s treehouse is better.
ECC — Everything Claude Code — is that crew, for Claude. It is not a new AI model. It is a harness: a layer of organization around Claude Code that splits coding work into specialist roles, gives each role reusable playbooks called skills, and keeps a memory vault of markdown notes so lessons survive between sessions. The open-source repo (by affaan-m, MIT licensed) has collected over 268,000 GitHub stars and was reported as a winner of the Anthropic × Cerebral Valley hackathon — which tells you something about how hungry developers are for exactly this pattern.
Why it matters: the context problem
Every agent harness is really an answer to one question: what do you do when the task is bigger than one prompt? The naive answer — one giant prompt with all the instructions — burns through the context window before the real work starts, and the model ends the session knowing exactly as much as it started with.
ECC’s answer has three parts, and they map directly onto the three ways agents fail in practice. First, roles instead of one blob. A single agent asked to plan, write, review, and secure its own code does all four badly — it falls in love with its own draft and its “review” is a rubber stamp. ECC splits the work across specialist subagents: the planner sketches the approach, the writer builds, a reviewer reads the code with genuinely fresh context, and a security pass runs before anything ships. The repo’s own summary of the loop: plan → test → implement → review → verify → remember → improve.
Second, skills instead of instructions. Repeating “write tests first” in every prompt is how context windows go to die. A skill is a reusable playbook — TDD, security review, database migrations — that gets loaded only when the task needs it. ECC ships 292 of them, but the key insight is selective loading: Claude doesn’t read all 292, it reads the one relevant skill for this task.
Third, memory instead of amnesia. Sessions end; lessons shouldn’t. Hooks save a markdown session summary every time you stop — what worked, what broke, notes for tomorrow — so Monday’s debugging war story is still there on Friday. The repo’s motto: “Optimize the context window. Persist everything else.”
ECC is an agent harness, not a model: it organizes Claude Code into specialist subagents with selective skills and persistent markdown memory, so big tasks get a pipeline instead of one giant prompt.
Architecture deep dive
ECC is a big repo — 68 agents, 292 skills, 94 commands — but the architecture is three ideas composed well. Understand the three and the size stops being intimidating.
Skills: reusable playbooks, loaded on demand
A skill is a markdown playbook for one job: how to do TDD, how to run a security review, how to write a database migration. Think of it as the difference between telling every new hire the whole company handbook versus handing them the one runbook for today’s task. When a task arrives, the relevant skill is loaded into context; the other 291 stay on disk. That selectiveness is the whole trick — it’s what keeps the context window full of signal instead of handbook.
In practice this means the marginal cost of a new capability is one markdown file, not a prompt rewrite. Teams using the pattern end up with skills like tdd, security-review, docs, research, testing, and migrations — each one a checklist the agent follows the same way every time, which is exactly what makes agent behavior boring in the good way: predictable.
Skills don’t make the model smarter; they make its behavior repeatable. The win is consistency across sessions, not capability — and consistency is what you actually need from a teammate.
Subagents: fresh context per specialist
The 68 subagents are the crew roster. Each one is a Claude instance launched with a narrow role, its own system prompt, and — critically — a fresh context window. That last part is doing more work than it looks: the reviewer who reads your code genuinely hasn’t seen the writer’s reasoning, so it can’t be charmed by it. It’s the difference between proofreading your own essay and handing it to a colleague.
The pipeline for a feature looks like this: the planner sketches the approach (files to touch, edge cases, test plan), the writer implements it, the reviewer reads the diff cold and hunts for bugs, and a security specialist scans for the vulnerability classes the writer was too focused to see. Then the loop the repo describes — plan, test, implement, review, verify, remember, improve — runs again on the next task, with the memory vault (below) carrying lessons forward.
One giant prompt burns context because everything — instructions, history, the task, the review criteria — competes for the same window. Specialists sidestep this: each agent’s window holds one job description and one job.
Memory vault and hooks: lessons that survive the session
When a Claude Code session ends, its context evaporates. ECC fights this with two mechanisms. Hooks fire on session events — when you stop, a hook writes a markdown session summary: what worked, what broke, notes for tomorrow. And the memory vault is where those summaries live, as plain markdown files organized by date, plus a longer-lived lessons file the agents consult at the start of new work.
The repo also describes continuous learning — agents that update the vault as they work — and AgentShield security scanning over the harness itself. Plain markdown is the deliberate choice: it’s human-readable, grep-able, version-controllable, and it never needs a migration. Your agent’s memory is a folder of text files, and that’s a feature.
Source: affaan-m/ECC on GitHub — check the repo for current counts, which move fast ↗Walkthrough: build a login form
The abstract version is nice; the concrete version is convincing. Here’s the ECC pipeline handling the most ordinary task in web development — and catching the two things a solo prompt would have shipped.
You type: build me a login form. The planner sketches first — fields, validation rules, where the auth call goes, what the error states look like — before a line of code exists. Planning is cheap; rewriting is expensive.
The writer implements the form from the plan. It works. The fields submit, the happy path is happy. Left alone, this is where the story would end — and where the bugs would ship.
The reviewer reads the code cold, with no memory of the writer’s intentions — and catches it: no rate limiting on the login endpoint. Without it, the form is a credential-stuffing target. (This is the exact vulnerability class in our rate limiter guide — the reviewer is enforcing it as a checklist item, not a flash of insight.)
The security pass scans deeper and flags raw SQL string concatenation in the auth query — a SQL injection waiting for its first quote character. The fix is parameterized queries, applied before anything ships.
The hook fires at session end and writes the lesson to the vault: sanitize login inputs. Next month, when someone asks for a signup form, the planner reads that lesson first. Monday’s war story is Friday’s checklist.
The pipeline didn’t make the model smarter — it made the failure modes structural instead of accidental. Review and security aren’t vibes; they’re steps that always run.
Steal this setup: two patterns for your own harness
You don’t need all 292 skills — and you shouldn’t install them all (more on that in the FAQ). What’s worth copying is the shape: fresh-context specialists and a markdown memory convention. Both fit in an afternoon.
Pattern 1: the specialist pipeline
Four roles, each with one job and a clean window. The sketch below is tool-agnostic — implement it with Claude Code subagents, separate chat sessions, or any agent framework. The load-bearing details: the reviewer never sees the writer’s reasoning, and the security pass has a fixed checklist rather than a vibe.
# One clean task per agent. Each agent gets a FRESH context window.
planner => "Sketch the approach ONLY. No code.
Files to touch, edge cases, test plan.
Output: plan.md"
writer => "Implement plan.md. Follow repo conventions.
Output: diff + test results."
reviewer => "You have NOT seen the plan or the writer's reasoning.
Read the diff cold. Hunt for: logic bugs, missing
edge cases, no rate limiting on auth endpoints.
Output: findings.md (empty = approved)."
security => "Scan the diff against this checklist ONLY:
- raw SQL / string-concatenated queries
- unsanitized user input rendered to HTML
- secrets or keys in code
- missing auth checks on new routes
Output: vulnerabilities.md (empty = clean)."
# Rule: reviewer + security run on EVERY diff.
# They are steps in the pipeline, not optional extras.Pattern 2: the markdown memory vault
A folder of dated session notes plus one long-lived lessons file. The convention matters more than the tooling: every session ends by writing down what worked, what broke, and what tomorrow should know — and every session starts by reading the lessons file.
memory/
sessions/
2026-09-27.md # one file per session, written by a hook on stop
2026-09-26.md
lessons.md # distilled, long-lived: read at session start
# --- sessions/2026-09-27.md ---
## what worked
- reviewer caught missing rate limit on /login (again)
## what broke
- raw SQL in auth query; fixed with parameterized queries
## notes for tomorrow
- signup form next: apply the login lessons first
# --- lessons.md (distilled, survives forever) ---
- sanitize login inputs — learned 2026-09-27, login form
- every auth endpoint gets a rate limit — no exceptions
- parameterized queries only; never concatenate SQLTry it this weekend: pick one boring chore — triaging CI failures, writing release notes, reviewing dependabot PRs — and run it through the four-role pipeline with a memory folder. You’ll feel the difference the reviewer makes by the second run.
FAQ
No — and that’s the most common misunderstanding. ECC is a harness: organization, roles, playbooks, and memory wrapped around Claude Code, which is itself built on Anthropic’s Claude models. It doesn’t make the model smarter; it makes the model’s working conditions better. All the intelligence is still Claude’s; ECC is the management layer.
No — and the repo’s own documentation warns against it. Skills are code that runs with your permissions: they can include hooks, scripts, and MCP server configurations. Installing hundreds of them indiscriminately means running hundreds of strangers’ automation against your machine and your accounts. The safe approach: read the skill’s source first, check what permissions, hooks, and MCP config it asks for, install only the handful you actually need for your workflow, and prefer skills from authors you trust. Treat a skill install like adding a dependency — because that’s what it is.
A skill is a reusable playbook — markdown instructions for one job (TDD, security review) that get loaded into an agent’s context when relevant. A subagent is a worker — a Claude instance with a role, its own system prompt, and a fresh context window. Skills are what the worker knows; subagents are who does the work. The pipeline assigns skills to subagents: the reviewer subagent loads the review skill, the security subagent loads the security-review skill.
Because the failure mode of a database is “the schema migrated and the agent can’t read its own past,” while the failure mode of markdown is “it’s a text file.” Markdown is human-readable (you can audit what your agent “remembers”), grep-able, diff-able in git, and needs no infrastructure. For personal and team harnesses, that beats a vector store on every axis except semantic search — and dated session files plus a distilled lessons file turn out to cover most of the need.
The mechanism is real even if any single catch is anecdotal: the reviewer works from a fresh context window, so it can’t rationalize the writer’s choices — it only sees the diff. That’s the same reason human code review works: unfamiliar eyes notice what familiar eyes skip. The checklist matters too — “check for rate limiting on auth endpoints” as a written step catches more than “review carefully” as a vibe.
The memory vault convention. The pipeline is powerful but needs real setup; the vault is a folder, a template, and a habit — write down what worked, what broke, and what tomorrow should know, every session. It compounds: after a month you have a personalized engineering handbook written by your own past self. That’s the highest ROI-per-minute idea in the whole repo.
Key takeaways
- ECC is a harness, not a model: it organizes Claude Code into specialist subagents — planner, writer, reviewer, security — instead of relying on one giant prompt.
- Skills are reusable playbooks loaded selectively: Claude reads the one skill the task needs, not all 292 — selectiveness is what protects the context window.
- Fresh context per specialist is the load-bearing detail: the reviewer catches bugs because it never saw the writer’s reasoning.
- The memory vault turns sessions into compounding lessons: hooks write markdown summaries on stop, and a distilled lessons file is read at every session start.
- Don’t install all 292 skills: review each skill’s source, permissions, hooks, and MCP config first — treat it like adding a dependency.
- Steal the shape, not the repo: a four-role pipeline plus a markdown memory folder is an afternoon’s work and most of the value.