Everything Claude Code (ECC): Het open-source agentframework voor Claude Code

Sinds code-agents een ding zijn, hoe vaak heb je je stack, conventies, voorkeuren en review-standaarden opnieuw uitgelegd aan het begin van elke sessie?

Het probleem is dat elke nieuwe conversatie koud start. Tools als Claude Code weten hoe ze code moeten schrijven, maar niet hoe jouw team code schrijft. Wat begon als tijdbesparing eindigt als handwerk: steeds dezelfde projectcontext plakken, het model corrigeren als het afdwaalt, instructies aanscherpen en elke keer dezelfde generieke suggesties reviewen.

Everything Claude Code (ECC) is een open-sourceframework dat dat wil oplossen. Ondanks de naam is het niet gelieerd aan Anthropic. Het is een agentensysteem en workflowlaag bovenop Claude Code (geen model, geen IDE) die een generieke code-agent verandert in een gespecialiseerd engineeringplatform dat jouw standaarden al kent.

In dit artikel bespreek ik wat ECC is, hoe de onderdelen in elkaar grijpen, hoe je het installeert en voor wie het daadwerkelijk geschikt is.

Maar wat is Claude Code precies? Schrijf je in voor onze Claude Code 101-cursus om te leren hoe je het inzet in je dagelijkse ontwikkelworkflows.

Wat is Everything Claude Code?

ECC is een open-sourcerepo die Claude Code inwikkelt met een vooraf gebouwde operationele laag voor engineeringwerk.

Je vindt het project op affaan-m/ECC op GitHub.. Het is MIT-gelicentieerd, wordt onderhouden door Affaan Mustafa en is gebaseerd op meer dan 10 maanden dagelijks gebruik van Claude Code op echte producten. Het is, ondanks de naam, niet gelieerd aan Anthropic.

De repo verpakt vier dingen in één installatie:

• Een agent-harnas: een set gespecialiseerde subagents (planner, architect, code reviewer, security reviewer, build-error-oplosser en nog een dozijn meer) waarnaar Claude Code delegeert in plaats van alles in één contextvenster te proppen.
• Een skillecosysteem: een paar honderd kleine workflowdefinities voor TDD, security review, frameworkpatronen (Django, Spring Boot, Next.js en andere), taalspecifieke codestandaarden en ML-engineeringtaken.
• Een workflowframework: hooks die draaien op toolevents, regels die altijd gelden, MCP-serverconfigs en sessiegeheugen dat tussen conversaties blijft bestaan.
• Een command-laag: onderhouden slash-entries om veelgebruikte workflows te draaien, plus een backward-compatible shim-map voor oudere commandnamen.

Belangrijk om te benadrukken: Claude Code blijft de motor. Het leest de code en draait de tools.

ECC regelt alles eromheen: aangeven welke subagent dit moet oppakken, welke workflowstappen te volgen, welke conventies jouw stack gebruikt en welke context van gisteren moet worden meegenomen.

In de praktijk betekent dit dat je Claude Code niet meer voor elk project vanaf nul hoeft te configureren. Je installeert ECC één keer, kopieert de rule packs voor jouw stack en hebt een gespecialiseerd engineeringplatform dat al weet hoe het verder moet.

Waarom Everything Claude Code zo populair is geworden

De groei begon met één X-thread.

Begin 2026 postte Mustafa The Shorthand Guide to Everything Claude Code. Het kreeg binnen dagen meer dan 10K bookmarks. Daarna maakte hij de repo open-source en inmiddels is ECC de grens van 200K sterren en 34+ forks gepasseerd.

Dit is waarom:

• Agentisch coderen ging van experiment naar dagelijks gebruik: Naarmate meer developers Claude Code gebruikten, werden de beperkingen van het standaard­systeem zichtbaar. Wat ontwikkelaars nodig hadden was een vooraf gebouwde configuratielaag die cold-startcontext, inconsistente code-reviewresultaten en soortgelijke issues elimineert.
• Goede agentprompts schrijven is lastiger dan het lijkt: Een solide TDD-workflow of een code-reviewprompt die op confidence filtert, vergt iteratie. Veel teams willen dat niet from scratch bouwen en onderhouden terwijl modellen veranderen, dus een beproefde versie hergebruiken is de makkelijkere route.
• Bijdragen stapelden zich op: 270+ bijdragers voegden taal-rule packs toe (Java, Kotlin, Rust, Perl, PHP), frameworksupport (Quarkus, Laravel), vertalingen, IDE-integraties buiten Claude Code (Cursor, OpenCode, Zed) en skills.
• ECC geeft specialisatie zonder fine-tunen: Een model fine-tunen op teamconventies is voor de meeste teams niet praktisch. Een gestructureerde set skills en agents tijdens runtime komt in de buurt van hetzelfde effect, en ECC is een van de meer complete pogingen om dat te verpakken.

Het begon dus als een X-thread, maar kreeg daarna een sneeuwbaleffect.

Hoe Everything Claude Code werkt

ECC is een gelaagd systeem.

Er zijn vijf componenten tussen jou en je codebase. Claude Code is de runtime. Skills, agents, MCP en een geheugenlaag wikkelen het in. Elk onderdeel doet één taak en ze geven werk aan elkaar door tijdens een sessie.

Claude Code

Claude Code is de onderliggende modelinterface.

Het is Anthropic’s officiële CLI om Claude als code-agent te draaien. Het leest bestanden, schrijft diffs, voert shellcommando’s uit, roept tools aan en houdt de conversatie. ECC vervangt dat niet. Alles wat ECC toevoegt wordt bij sessiestart in Claude Code geladen en draait via het bestaande plugin-, hook- en commandsysteem.

Skills

Skills zijn herbruikbare workflowinstructies, opgeslagen als Markdown-bestanden.

Elke skill is een kleine map met een SKILL.md die Claude Code vertelt hoe een specifiek type taak af te handelen. De skill noemt de beschrijving, stappen, de verwachte output en de beperkingen. ECC heeft zo’n 260 skills die taalpatronen, testworkflows, frameworkconventies, ML-engineering en operationele taken dekken.

Belangrijk: je draait skills niet handmatig. Claude Code kiest ze op basis van wat je doet, of je verwijst ernaar in een prompt.

Agents

Agents zijn gespecialiseerde subagents waarnaar Claude Code delegeert.

Elke agent is gedefinieerd in Markdown met een naam, een beschrijving, een tool-allowlist en een systeemprompt die het gedrag afbakent. De code-reviewer-agent leest alleen bestanden en rapporteert bevindingen. De planner schrijft implementatieblauwdrukken voordat er code wordt aangeraakt. Je snapt het idee.

Het punt van deze splitsing is contextisolatie. Elke subagent krijgt een schoon contextvenster voor zijn taak, zodat de hoofdsessie niet volloopt. De hoofdagent coördineert en de subagents voeren uit.

MCP-integraties

MCP (Model Context Protocol) is hoe Claude Code met externe tools en databronnen praat.

ECC heeft configs om via MCP-servers te verbinden met GitHub, Supabase, Vercel, Railway en anderen. Elke server stelt tools bloot die Claude Code midden in een sessie kan aanroepen. ECC levert daarvoor werkende configs en securityregels mee.

Standaard schakelt ECC één connector in (chrome-devtools). De rest is opt-in, wat naamconflicten met tools voorkomt en het aanvalsoppervlak klein houdt.

Geheugenlaag

De geheugenlaag maakt ECC stateful tussen sessies.

Hooks draaien bij het Stop-event van elke conversatie en schrijven een sessiesamenvatting naar ~/.claude/sessions/. De volgende sessie laadt relevante context bij de start via een SessionStart-hook. Skills die het model uit jouw patronen "leert", worden geëxtraheerd naar het Continuous Learning v2-systeem, waar ze als instincten met confidencescores worden opgeslagen en later hergebruikt.

Sessiealiassen, geleerde skills en metrics leven allemaal onder één agent data root (standaard ~/.claude, per harnas configureerbaar als je ECC in zowel Claude Code als Cursor draait).

Hoe de onderdelen samenwerken

Een typische sessie ziet er zo uit:

1. Sessiestart: Een hook laadt context van de vorige sessie, plus relevante skills en regels voor het huidige project.
2. Je vraagt iets: Bijvoorbeeld: "voeg OAuth-login toe."
3. De planner-agent draait eerst: Die schrijft een blauwdruk, dus nog geen code.
4. De TDD-skill komt erin: Claude Code volgt de workflow van een falende test, minimale implementatie en refactor.
5. MCP-tools worden aangeroepen: Misschien haalt de GitHub MCP gerelateerde PR’s op, of checkt de Supabase MCP het schema.
6. De code-reviewer-agent draait aan het eind: Die auditeert de diff in een eigen contextvenster en rapporteert terug.
7. Sessie eindigt: Een Stop-hook schrijft een samenvatting, extraheert nieuwe patronen tot instincten en bewaart ze voor de volgende keer.

Het model is nog steeds Claude Code. ECC orkestreert alleen welke skill, welke agent en welke tool in elke stap wordt gebruikt.

Skills in Everything Claude Code

Skills zijn de primaire manier waarop ECC Claude Code vertelt wat te doen.

Een skill is een map met een SKILL.md-bestand. De Markdown definieert de beschrijving, stappen, beperkingen, de verwachte output en de contexten waarin het geldt. Gewoon platte tekst die het model op runtime leest.

En dat is bewust zo. ECC “traint” niets opnieuw; het laadt instructies die Claude op dat moment leest en volgt.

Skills staan in de map skills/ in de root van de repo. Na installatie worden ze gekopieerd naar ~/.claude/skills/. Claude Code laadt ze als directe kinderen van die map.

Elke skillmap heeft dezelfde basisopzet:

• SKILL.md - de workflowdefinitie
• Optionele ondersteunende bestanden (templates, scripts, voorbeelden)
• Een optionele metadata.yaml voor tagging en discovery

Skills beïnvloeden agentgedrag op twee manieren. Ten eerste leest Claude Code ze bij sessiestart en houdt ze beschikbaar voor referentie. Ten tweede kiest het model de relevante skill op basis van jouw vraag. Zeg je "schrijf eerst een falende test", dan activeert de TDD-skill. Zeg je "review dit op SQL-injection", dan activeert de security review-skill.

ECC levert ongeveer 260 skills mee. Hier zijn er een paar die de bandbreedte laten zien:

• frontend-patterns: React- en Next.js-conventies. Componentstructuur, hook-gebruik, beslissingen server- vs. clientcomponenten, state-managementpatronen.

• django-patterns, django-tdd, django-security, django-verification: Een volledige Djangostack opgesplitst in vier skills. Eén voor architectuur, één voor de testcyclus, één voor OWASP-achtige audits, één voor de verify-before-shipping-loop.

• architect (gekoppeld aan de architect-agent): System design-reviews. De skill definieert wat een architectuurreview dekt, welke artefacten het oplevert en welke trade-offs in beeld komen.

• tdd-workflow: De red-green-refactor-cyclus. Schrijf de falende test, schrijf de minimale code om te slagen, refactor, verifieer coverage. De skill dwingt de volgorde af.

• security-review: OWASP Top 10-auditchecklist, detectie van hardcoded credentials, review van inputvalidatie en afhankelijkheids­kwetsbaarheden. De skill definieert wat te scannen en wat te flaggen.

Agents in Everything Claude Code

Agents zijn gespecialiseerde persona’s met hun eigen contextvenster.

Elke agent is een Markdown-bestand in de map agents/ met een naam, beschrijving, tool-allowlist en systeemprompt. De systeemprompt definieert de taak van de agent. De tool-allowlist bepaalt wat hij kan (bestanden lezen, bash draaien, MCP-servers aanroepen, code schrijven). Claude Code delegeert automatisch een taak aan een agent voor je.

ECC heeft 66 agents. Ze vallen in enkele categorieën.

Planningsagents draaien voordat er code wordt geschreven.

De planner-agent breekt een featurerequest op in een implementatieblauwdruk: te wijzigen bestanden, te definiëren interfaces, te schrijven tests en te behandelen edgecases. De architect-agent gaat een niveau hoger: systeemontwerp, datamodelkeuzes, servicegrenzen. Deze agents lezen alleen code en schrijven plannen.

Codeeragents doen het implementatiewerk.

De tdd-guide dwingt de test-first-cyclus af. Taalspecifieke resolvers zoals go-build-resolver, pytorch-build-resolver en kotlin-build-resolver fixen builderrors in hun ecosystemen. De refactor-cleaner verwijdert ongebruikte code.

Architectuuragents beoordelen structurele keuzes.

De architect dekt ontwerp, de database-reviewer dekt querypatronen en schemakeuzes, en de mle-reviewer auditeert productiepijplijnen voor ML (datacontracten, eval coverage, serving, monitoring).

QA-agents verifiëren wat gebouwd is.

De code-reviewer auditeert diffs op kwaliteit en security met een confidedencedrempel. De security-reviewer draait een OWASP-achtige pass. De e2e-runner handelt Playwright end-to-endtests af. Taalreviewers (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer en anderen) doen taalspecifieke checks.

De reden om dit alles in aparte agents te splitsen is contextisolatie.

Als de code-reviewer draait, krijgt die een vers contextvenster met alleen de diff en de review-skill geladen. Hij ziet de planningsnotities of de conversatiegeschiedenis niet. Hij reviewt gewoon. Die focus levert betere output op dan één algemene agent vragen om te plannen, coderen, testen en reviewen in dezelfde context, wat is waar de meeste ad-hoc Claude Code-setups op uitkomen.

Context- en geheugbeheer in ECC

ECC vergeet niet alles tussen sessies zoals Claude Code doet.

Geheugen in ECC is een systeem van hooks die op de juiste momenten bestanden wegschrijven en ze op de juiste momenten weer laden. Het zijn gewoon Markdown- en JSON-bestanden op schijf.

Drie dingen blijven bewaard:

1. Sessiesamenvattingen worden geschreven bij het einde: Een Stop-hook draait na het laatste bericht, neemt het volledige transcript en schrijft een samenvatting naar ~/.claude/sessions/. De samenvatting dekt waaraan is gewerkt, wat is besloten en wat nog openstaat. De volgende sessie leest dit tijdens een SessionStart-hook, zodat Claude weet waar het gebleven was.
2. Instincten zijn geëxtraheerde patronen uit je sessies: Het Continuous Learning v2-systeem kijkt wat je doet en wat werkt, en schrijft vervolgens losse instincten met een confidencescore, een actie, ondersteunend bewijs en voorbeelden. Draai /instinct-status om te zien wat is geleerd. Draai /evolve om gerelateerde instincten te clusteren tot een nieuwe skill.
3. Logbestanden volgen de operationele laag: Denk aan hook-executies, skillruns, MCP-calls, kosten, fouten. Deze leven onder ~/.claude/metrics/ en ~/.claude/session-data/. Handig voor debugging en voor de dashboard-GUI die met de repo wordt meegeleverd.

Vind je dit geen groot ding, dan zijn hier een paar redenen die je van gedachten doen veranderen:

• Langlopende projecten: Een refactor van zes maanden reset niet elke maandag. De beslissingen, trade-offs en bekende issues van vorige week staan in de samenvatting die bij sessiestart laadt.
• Geen herhaalde uitleg: Je hoeft niet telkens je stack, je conventies of "onthoud dat we voor Postgres hebben gekozen, niet Oracle" opnieuw te plakken.
• Werken rond contextvensterlimieten: Zelfs met een window van een miljoen tokens past geen halfjaar projectgeschiedenis. Samenvattingen comprimeren wat ertoe doet. De volledige geschiedenis blijft op schijf, het model krijgt het relevante deel.

Je kunt de geladen context afstemmen met omgevingsvariabelen. ECC_SESSION_START_MAX_CHARS begrenst hoeveel samenvatting bij de start laadt (standaard 8.000 tekens). ECC_SESSION_START_CONTEXT=off schakelt het uit voor low-contextsetups. ECC_SESSION_RETENTION_DAYS bepaalt hoe lang sessies blijven staan voordat ze worden opgeschoond.

Als je ECC op dezelfde machine in zowel Claude Code als Cursor draait, stel dan ECC_AGENT_DATA_HOME in om hun geheugen te scheiden. Anders overschrijven ze elkaars sessiebestanden.

MCP-support in Everything Claude Code

MCP is hoe Claude Code alles aanroept wat geen bestand of shellcommando is.

Het Model Context Protocol is de standaard van Anthropic om taalmodellen te koppelen aan externe tools. Een MCP-server draait als apart proces en stelt een getypeerde set operaties bloot: "lees deze Notion-pagina" of "open een PR op GitHub." Claude Code roept die operaties aan als functiecalls.

ECC wordt geleverd met MCP-configs in mcp-configs/mcp-servers.json voor de gangbare services: GitHub, Supabase, Vercel, Railway, Linear en andere. Elke entry bevat het commando om de server te starten, de vereiste omgevingsvariabelen en de securityregels die ECC toepast.

Het is goed om te weten dat ECC deze niet automatisch inschakelt.

Het MCP-connectorbeleid van juni 2026 reduceerde de standaard ingeschakelde servers tot één (chrome-devtools). De rest is opt-in. Je kopieert de entry naar de .mcp.json van je project, of je schakelt ‘m in via het /mcp-commando van Claude Code. De reden is deels praktisch (lange MCP-toolnamen breken sommige gateways) en deels een securitykeuze (elke MCP-server is een potentieel aanvalsoppervlak).

Zo ziet die support er in de praktijk uit:

• Externe integraties: Zet de GitHub-entry in .mcp.json, geef een token en Claude Code kan issues lezen, PR’s openen en CI-status checken zonder copy-pastewerk.
• Toolaanroepen: Skills en agents verwijzen MCP-tools bij naam. Bijvoorbeeld, een deploymentskill kan de Vercel MCP aanroepen en een databasereviewagent kan de Supabase MCP aanroepen.
• Projectautomatisering: Je kunt MCP-servers combineren met hooks voor automatisering die sessieoverstijgend is. Een PR-opened-hook kan een reviewagent starten die de GitHub MCP gebruikt om de diff op te halen en de Linear MCP om het ticket bij te werken.

Als je al eigen kopieën draait van MCP’s die ECC bundelt, stel ECC_DISABLED_MCPS in op een kommagescheiden lijst. ECC slaat die dan over tijdens installatie en sync, zodat je niet met dubbele servers zit die om dezelfde naam strijden.

AgentShield en securityfeatures

Security is wat ECC onderscheidt van de concurrentie.

AgentShield is een standalone security-auditor die met ECC wordt meegeleverd. Het scant Claude Code-configuraties op kwetsbaarheden, misconfiguraties, fouten en injectierisico’s. Het draait als een apart npm-pakket (ecc-agentshield), maar is gekoppeld aan ECC via de /security-scan-skill, zodat je het vanuit een Claude Code-sessie kunt draaien.

De scan dekt vijf categorieën:

• Detectie van secrets: 14 patronen voor hardcoded credentials, API-keys, tokens.
• Permissie-auditing: welke tools en paden elke agent en skill kan benaderen en of die rechten te ruim zijn.
• Hook-injectieanalyse: of hooks kunnen worden misbruikt om willekeurige commando’s uit te voeren.
• MCP-serverrisicoprofielen: wat elke verbonden MCP-server kan lezen, schrijven of aanroepen en waar dat exposure creëert.
• Agentconfigreview: promptinjectievectoren, te brede tool-allowlists, ontbrekende beperkingen.

Je kunt het zo draaien, installeren is niet nodig:

npx ecc-agentshield scan

De output is een lettercijfer (A t/m F) plus een lijst bevindingen, gesorteerd op ernst. Kritieke bevindingen eindigen met exitcode 2.

Een paar flags om te kennen:

• -fix past autofixes toe voor veilige issues (exposed secrets verwijderen, te brede permissies aanscherpen…)
• -opus draait de scan via drie Claude Opus 4.X-agents in een red-team / blue-team / auditor-pijplijn. De aanvaller zoekt exploitketens. De verdediger evalueert de bescherming. De auditor synthetiseert beide tot een geprioriteerde risicorapportage.
• -stream streamt de analyse live, handig bij trage configs.

De Opus-pijplijnbenadering is wat AgentShield onderscheidt van een generieke linter. Adversarial agents proberen bekende-oké componenten te ketenen tot iets uitbuitbaars, waar de meeste echte agentaanvallen vandaan komen.

AgentShield rapporteert 102 statische-analyserregels en 1.282 interne tests met 98% dekking, volgens de repo. De cijfers zijn het waard om te verifiëren tegen de laatste release, maar duidelijk is dat het geen scriptje van 50 regels is.

Outputformaten zijn onder meer terminal (kleurgecodeerd), JSON (voor CI), Markdown en HTML. Er is ook een GitHub Action en een aparte ECC Tools GitHub App die AgentShield op PR’s draait.

Voor de meeste teams die Claude Code in productie gebruiken, is AgentShield de meest concrete reden om ECC te installeren, zelfs als je de rest van het framework niet gebruikt.

Everything Claude Code installeren

ECC heeft twee installatieroutes.

De meest voorkomende fout is de plugininstallatie bovenop de handmatige installatie stapelen. Beide kopiëren dezelfde bestanden naar dezelfde plekken en je eindigt met duplicaten. Dus eerst: kies één route.

Controleer vóór installatie of Claude Code v2.1.0 of later is geïnstalleerd:

claude --version

Claude-versie

Installatie via pluginmanager

Dit is het aanbevolen pad voor de meeste gebruikers.

Vanuit Claude Code, draai:

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

Plugininstallatie

Het eerste commando registreert de ECC-repo als marketplace. Het tweede installeert de plugin.

Eén kanttekening: het pluginsysteem distribueert geen rules. Rules zijn de altijd-te-volgen richtlijnen (coding style, gitworkflow, teststandaarden, taalspecifieke patronen), en de plugin-spec van Claude Code voorziet daar niet in. Die kopieer je handmatig na de plugininstallatie.

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/python ~/.claude/rules/ecc/

Kopieer rules/common plus één taalpakket dat je daadwerkelijk gebruikt. In het voorbeeld hierboven heb ik Pythonregels gekopieerd. Kopieer niet alles: meer rules betekent meer context die in elke sessie wordt geladen, en het meeste is niet relevant voor jouw project.

Installatie via configuratiebestanden

Gebruik deze aanpak als je volledige controle wilt, of als de plugininstallatie niet werkt op jouw setup.

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
./install.sh --profile full

Op Windows:

.\install.ps1 --profile full
# of
npx ecc-install --profile full

Dit kopieert agents, skills, commands, hooks en rules naar je ~/.claude/-map. Geen pluginlaag betrokken. Alles leeft als bestanden op schijf die Claude Code bij sessiestart leest.

Een paar profielopties om te kennen:

• -profile minimal: Alleen rules, agents, commands en core skills, zonder hooks.

• -profile core: De standaardwerkset. Inclusief hooks.

• -profile full: Alles in de repo.

Je kunt ook specifieke componenten installeren met --modules of --with:

./install.sh --target claude --modules hooks-runtime
npx ecc install --profile minimal --target claude --with capability:machine-learning

Weet je niet zeker welke componenten bij je werk passen, vraag het aan de meegeleverde adviseur:

npx ecc consult "security reviews" --target claude

Die retourneert bijpassende componenten en de exacte installatiecommando’s.

Installatie verifiëren

Controleer wat is geïnstalleerd:

/plugin list ecc@ecc

Plugininstallatie verifiëren

Dat toont de agents, commands en skills die via de plugin beschikbaar zijn. Voor handmatige installaties gebruik je de lifecycle-wrapper:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor

doctor checkt op ontbrekende bestanden, kapotte hooks en versie-mismatches. Als er iets wordt gevlagd, draai dan:

node scripts/ecc.js repair

Om te bevestigen dat Claude Code de nieuwe plugin ziet, open je een sessie en probeer je een slash-commando:

/ecc:plan "Add user authentication"

ECC-planoutput

Voor een plugininstallatie is het namespaced voorvoegsel /ecc: vereist. Voor een handmatige installatie werkt de korte vorm (/plan).

Als iets dubbel staat of stuk lijkt, installeer dan niet over jezelf heen. Draai eerst node scripts/uninstall.js --dry-run om te zien wat verwijderd zou worden, en daarna node scripts/uninstall.js om op te ruimen. ECC verwijdert alleen bestanden die het zelf heeft geïnstalleerd; ongerelateerde config blijft staan.

Werken met skills, commands en workflows

Het meeste wat je in ECC doet loopt via skills in plaats van via commands.

De reden is dat de map commands/ nog wordt onderhouden voor backward compatibility, maar nieuwe workflowontwikkeling eerst in skills/ plaatsvindt.

Hier zijn een paar gebruikspatronen die het gros van je dagelijkse werk dekken.

Skillaanroep is meestal impliciet

Je roept een skill doorgaans niet bij naam aan. Je beschrijft wat je wilt en Claude Code kiest de passende skill. Zeg je "schrijf eerst een falende test", dan activeert de tdd-workflow-skill. De skillnamen verschijnen in de response, zodat je ziet wat er is geladen.

Als je expliciet wilt zijn, verwijs dan in de prompt naar de skill: "Gebruik de django-tdd-skill om het nieuwe endpoint toe te voegen." Of draai een command dat ‘m wrapt:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

Het voorvoegsel /ecc: is vereist voor plugininstallaties. Handmatige installaties gebruiken de korte vorm (/plan, /code-review).

ECC-output planningsfase

Bestandstargeting is onderdeel van de workflow

De meeste agents en skills werken op een specifieke scope: een bestand, een map, een diff, een PR. Je scope door het bestand in de prompt te noemen, het in je editor te openen vóór je aanroept, of door het pad te mee te geven aan de agent:

/code-review src/auth/
/python-review services/billing/payment.py

De agent pikt de scope op, laadt alleen de benodigde bestanden en draait in een eigen contextvenster.

Shellintegratie loopt via Claude Code’s bash-tool

Skills kunnen shellen voor alles wat echte uitvoering vereist, zoals tests draaien, builden, linten of een CLI aanroepen. De TDD-skill draait pytest of go test. De build-fix-agent draait de echte build om echte fouten te zien. De security-scan-skill draait npx ecc-agentshield scan en parseert de output.

De skill definieert welke shellcommando’s wanneer draaien. Hooks kunnen ook shellcommando’s draaien op toolevents (na elke edit een typecheck, waarschuwen voor console.log vóór een save).

MCP-management is grotendeels opt-in

Na installatie schakelt ECC standaard precies één MCP-server in (chrome-devtools). Wil je er meer, kopieer dan entries uit mcp-configs/mcp-servers.json naar de .mcp.json van je project en schakel ze in via het /mcp-commando van Claude Code. De /mcp interface regelt inschakelen, uitschakelen en opnieuw authen­ticeren.

Draai je eigen kopieën van MCP-servers die ECC bundelt, stel dan in:

export ECC_DISABLED_MCPS="github,supabase"

De installer en syncflows van ECC slaan die over, zodat je niet twee keer dezelfde server hebt die om dezelfde toolnamen vecht.

Workflows schakelen in ketens

Je draait geen skills één voor één. Een typische featureworkflow ziet er zo uit:

/ecc:plan "Add OAuth login with Google"
# planner-agent schrijft een blauwdruk

# tdd-workflow-skill activeert tijdens implementatie
# tests falen, code wordt geschreven, tests slagen

/code-review
# code-reviewer-agent auditeert de diff

/security-scan
# AgentShield checkt de nieuwe code en config

Elke stap gebruikt een andere agent in een vers contextvenster. De hoofdsessie coördineert en de sessiesamenvatting legt de keten op het eind vast en maakt die beschikbaar voor de volgende sessie.

Everything Claude Code vs rivaliserende configuratieframeworks

ECC is niet het enige configuratielaagje voor Claude Code. Er zijn er meer die vergelijkbare taken doen met andere trade-offs.

Wees eerst helder over de categorie. ECC concurreert met andere configuratieframeworks die bovenop Claude Code zitten. Het concurreert niet met de harnassen waar het naast draait (Cursor, Codex, OpenCode, Zed) of met standalone agentplatformen (OpenHands, LangGraph, CrewAI), die andere soorten tools zijn.

Drie rivalen komen het vaakst terug.

BMAD-Method is een agile SDLC-framework met specialistische rolgebaseerde agents (Analyst, PM, Architect, Scrum Master, Developer, QA). Het draait over Claude Code, Cursor en Windsurf via npx bmad-method install. Het blinkt uit in de voorfase van planning, door een vaag idee om te zetten in een PRD, architectuurdocument en opgesplitste stories vóór er code wordt geschreven. De uitvoeringstooling is lichter dan die van ECC. Er is geen securityscanner en geen MCP-catalogus. Er zijn minder taalspecifieke patronen.

SuperClaude is een lichtgewicht, Markdown-gebaseerd configframework. Ongeveer 30 slashcommands, 20 agents en een paar gedragsmodi. Installeer met pip install SuperClaude. Het is bewust eenvoudiger dan ECC: er is geen securityscanning en geen orkestratieruntime. Maar er is ook geen ingebouwde geheugenlaag buiten wat Claude Code biedt. Wil je een werkende CLAUDE.md plus een set goed geteste prompts, dan is SuperClaude een goede keuze.

claude-flow / Ruflo (begin 2026 hernoemd van Claude Flow) is een multi-agent-swarmorkestrator. Het gebruikt de SPARC-methodologie (specification, pseudocode, architecture, refinement, completion) en draait koningin-geleide hiërarchieën van 60–100+ gespecialiseerde agents parallel. Het heeft persistent geheugen via AgentDB en werkt met Claude, GPT, Gemini en Ollama. De infrastructuur is zwaarder dan die van ECC en het is gebouwd voor parallel agentwerk, niet voor single-sessionproductiviteit.

Wil je meer opties bekijken voordat je kiest, dan is awesome-claude-code een gecureerde directory met Claude Code-resources (agents, skills, plugins, MCP-servers, configs). Daar vindt het meeste community-ontdekken plaats.

Kortom: kies BMAD als je agile-achtige planning wilt, SuperClaude als je een lichte configlaag wilt, Ruflo als je parallel multi-agentwerk nodig hebt, en ECC als je een compleet engineeringplatform met securitytooling en ingebouwde geheugenpersistente wilt.

Wie zou Everything Claude Code moeten gebruiken?

ECC is niet voor iedereen. Als je Claude Code maar een paar keer per week voor kleine taken gebruikt, voelt het framework als veel overhead voor weinig opbrengst. Een enkele CLAUDE.md van 100 regels dekt dan meestal wat je nodig hebt.

ECC loont zodra je dat punt voorbij bent.

Dit zijn scenario’s waarin het beter past dan vanilla Claude Code:

• AI-engineers die agentische systemen bouwen: Als je agentworkflows ontwerpt of uitrolt, is ECC een werkende referentie. Lees de agentprompts, de skilldefinities, de hookconfigs en leen wat werkt.
• Productiviteitsliefhebbers onder developers: Als je investeert in tooling, dotfiles, editor-setup, shell, is ECC dezelfde soort investering voor Claude Code. Je haalt er het meest uit als je het veel gebruikt.
• Teams die Claude Code dagelijks als infrastructuur draaien: Als je team Claude Code elke dag inzet voor code review, planning, refactoren of features shippen, tikt de tijdwinst op consistentie en onboarding aan. Nieuwe teamleden krijgen dezelfde agents en dezelfde workflows.
• Iedereen die complexe agentworkflows bouwt: Meertraps-pijplijnen, subagent-orkestratie, MCP-ketening, persistente context, noem maar op. ECC heeft de meeste van deze problemen al opgelost, en de patronen zijn herbruikbaar zelfs als je niet alles installeert.

Hier is wie beter niet voor ECC kiest:

• Casual Claude Code-gebruikers: Een paar sessies per week "help me deze script debuggen" heeft geen 60+ agents, 260+ skills en een geheugenlaag nodig. De setup-overhead is het niet waard.
• Eenvoudige, eenmalige codingtaken: Snelle scripts, kleine fixes, demo-apps, wegwerp-prototypes. Vanilla Claude Code kan dit prima aan en ECC toevoegen geeft vooral frictie zonder veel waarde.
• Teams met een al werkende setup: Als je CLAUDE.md goed is afgesteld en je workflow stabiel is, kost overstappen naar ECC migratietijd. Leen de stukken die je bevallen en laat de rest.

Als je twijfelt waar je valt, is de veilige zet: lees de repo, kopieer twee of drie agents en skills die je interessant vindt en sla de volledige installatie voorlopig over.

Voordelen en beperkingen van ECC

Ik loop nu door een paar sterke en zwakke punten van ECC. Beide zijn het weten waard vóór je beslist..

Voordelen

• Huge skill library: Zo’n 260 skills voor TDD, securityaudits, frameworkpatronen, taalidioom, ML-engineering, deployment en meer. Ook zonder installatie is de repo een werkende referentie voor hoe je goede skilldefinities schrijft.
• Workflowhergebruik: Je krijgt geteste prompts voor code review, planning, refactoren en testen. Vooral de code-reviewer-agent wordt vaak aangehaald door mensen die ECC niet gebruiken maar de prompt hebben geleend.
• Persistent geheugen: Dingen als sessiesamenvattingen en context over sessies heen werken out-of-the-box. De meeste andere Claude Code-configs negeren geheugen volledig.
• Sterke MCP-support: Vooraf gebouwde configs voor GitHub, Supabase, Vercel, Railway en andere.
• AgentShield: Alleen de securityscanner is al een reden om ECC te installeren, zelfs als je niets anders gebruikt. Slechts weinig andere Claude Code-configs komen in de buurt.
• Open source onder MIT: Geen paywall op de core. De gehoste GitHub App en ECC Pro-tier zijn apart.
• Cross-platform: Werkt met Claude Code, Cursor, Codex, OpenCode, Zed, Gemini en anderen. Als je wisselt of meerdere draait, kun je nog steeds dezelfde agents en skills gebruiken.

Beperkingen

• Leercurve: 60+ agents, 260+ skills, drie installeroutes, vier profieltypen en een stapel omgevingsvariabelen. De eerste week gaat vooral op aan uitzoeken wat er geladen is en wat elk onderdeel doet.
• Setupcomplexiteit: Plugin vs. handmatige installatie, het rules-niet-via-plugin-issue, het dubbele-hooks-probleem in oudere Claude Code-versies, MCP in-/uitschakelflows, de agent data home-variabele voor multi-harnasgebruik. Het meeste is gedocumenteerd, maar blijft veel werk.
• Onderhoudsoverhead: De repo wordt regelmatig bijgewerkt. Catalogusaantallen verschuiven tussen releases en skillnamen veranderen.
• Afhankelijk van het Claude Code-ecosysteem: ECC hangt af van de plugin-spec, het hooksysteem en MCP-support van Claude Code. Als Claude Code die verandert, moet ECC volgen.
• Over-engineering voor veel use-cases: Voor de meeste teams dekt een goed geschreven CLAUDE.md van 60–200 regels 80% van wat ECC biedt. De andere 20% is waardevol, maar alleen als je het gebruikt.

Het framework is momenteel de meest complete configuratielaag voor Claude Code. Maar “meest compleet” en “noodzakelijk voor iedereen” zijn niet hetzelfde.

Conclusie

Gebruik je Claude Code dagelijks, dan is ECC het bekijken waard. Zo niet, dan is de repo nog steeds de moeite als werkende referentie voor hoe je agentworkflows bouwt die in de praktijk niet instorten.

Hoe dan ook is ECC een duidelijk signaal dat softwareontwikkeling opschuift richting programmeerbare agentpijplijnen in plaats van single-shot chatsessies. De frameworks om dit goed te doen zijn nog nieuw, en ECC is een van de meest complete pogingen tot nu toe. Het zal niet de laatste zijn, en dat is precies de bedoeling.

Ben je nieuw in generatieve AI en agentisch coderen, schrijf je dan in voor onze cursus Generative AI Concepts. Die geeft je een stevige basis voor de toekomst.