Everything Claude Code (ECC): Det öppna agentramverket för Claude Code

Everything Claude Code (ECC) är ett öppet ramverk som omsluter Claude Code med återanvändbara färdigheter, specialiserade agenter, beständigt minne och MCP-integrationer.

Uppdaterad 29 juni 2026 · 15 min läsa

Sedan kodningsagenter blev en grej – hur många gånger har du förklarat din stack, era konventioner, preferenser och granskningsstandarder på nytt i början av varje session?

Problemet är att varje ny konversation börjar från noll. Verktyg som Claude Code kan skriva kod, men de vet inte hur ditt team skriver kod. Det som skulle spara tid blir manuellt arbete med att klistra in samma projektkontext, rätta modellen när den glider iväg, trimma instruktioner och granska samma generiska förslag varenda gång.

Everything Claude Code (ECC) är ett öppet ramverk som vill lösa det. Trots namnet är det inte knutet till Anthropic. Det är ett agentsystem och ett arbetsflödeslager som sitter ovanpå Claude Code (inte en modell, inte en IDE) och förvandlar en allmän kodagent till en specialiserad ingenjörsplattform som redan kan dina standarder.

I den här artikeln går jag igenom vad ECC är, hur delarna hänger ihop, hur du installerar det, och vem som faktiskt bör använda det.

Men vad är Claude Code egentligen? Gå vår Claude Code 101-kurs för att lära dig använda det i dina dagliga utvecklingsarbetsflöden.

Vad är Everything Claude Code?

ECC är ett öppet repo som omsluter Claude Code med ett förbyggt operativt lager för ingenjörsarbete.

Du hittar projektet på affaan-m/ECC på GitHub. Det har MIT-licens, underhålls av Affaan Mustafa och bygger på 10+ månaders daglig användning av Claude Code i riktiga produkter. Det har ingen koppling till Anthropic, trots namnet.

Repostitoriet paketerar fyra saker i en installation:

Ett agentsele: en uppsättning specialiserade underagenter (planerare, arkitekt, kodgranskare, säkerhetsgranskare, byggfelslösare och ett dussin till) som Claude Code delegerar till i stället för att försöka göra allt i ett och samma kontextfönster.
Ett färdighets-ekosystem: några hundra små arbetsflödesdefinitioner som täcker TDD, säkerhetsgranskning, ramverksmönster (Django, Spring Boot, Next.js och andra), språkspecifika kodningsstandarder och ML-ingenjörsuppgifter.
Ett arbetsflödesramverk: krokar som körs vid verktygshändelser, regler som alltid gäller, MCP-serverkonfigurationer och sessionsminne som överlever mellan konversationer.
Ett kommandolager: underhållna snedstreckskommandon för vanliga arbetsflöden, plus en bakåtkompatibel shimmapp för äldre kommandonamn.

Det är viktigt att notera att Claude Code fortfarande är motorn. Det läser koden och kör verktygen.

ECC:s jobb är allt runtomkring: att tala om för Claude Code vilken underagent som ska hantera uppgiften, vilka arbetssteg som ska följas, vilka konventioner din stack använder och vilken kontext som ska tas med från gårdagens session.

I praktiken betyder det att du inte längre behöver konfigurera Claude Code från grunden för varje projekt. Du installerar ECC en gång, kopierar regelpaketen för din stack och får en specialiserad ingenjörsplattform som redan vet hur den ska gå vidare därifrån.

Varför Everything Claude Code har blivit så populärt

Tillväxten började med en tråd på X.

I början av 2026 publicerade Mustafa The Shorthand Guide to Everything Claude Code. Den fick över 10 000 bokmärken på några dagar. Sedan öppnade han källkoden, och ECC har nu passerat 200 000 stjärnor och 34+ forkar.

Här är varför det hände:

Agentisk kodning gick från experiment till vardag: När fler utvecklare började använda Claude Code blev begränsningarna i grundsystemet tydliga. Det som behövdes var ett förbyggt konfigurationslager som tar bort kallstartskontext, inkonsekventa kodgranskningsresultat och liknande.
Att skriva bra agentprompter är svårare än det ser ut: Ett stabilt TDD-arbetsflöde eller en kodgranskningsprompt som filtrerar på tillit kräver iteration för att bli rätt. Många team vill inte bygga och underhålla det från grunden i takt med att modeller ändras, så att återanvända någon annans testade version är den enklare vägen.
Bidrag ackumulerades: 270+ bidragsgivare har lagt till språkregelpaket (Java, Kotlin, Rust, Perl, PHP), ramverksstöd (Quarkus, Laravel), översättningar, IDE-integrationer utöver Claude Code (Cursor, OpenCode, Zed) och färdigheter.
ECC ger specialisering utan finjustering: Att finjustera en modell på teamkonventioner är inte praktiskt för de flesta team. En strukturerad uppsättning färdigheter och agenter vid körning kommer nära samma effekt, och ECC är ett av de mer kompletta försöken att paketera detta.

Så det började som en X-tråd, men blev en snöbollseffekt därifrån.

Hur Everything Claude Code fungerar

ECC är ett lagerindelat system.

Det finns fem komponenter mellan dig och din kodbas. Claude Code är runtime. Färdigheter, agenter, MCP och ett minneslager omsluter det. Varje del gör en sak, och de skickar arbete mellan varandra under en session.

Claude Code

Claude Code är det underliggande modellgränssnittet.

Det är Anthropics officiella CLI för att köra Claude som kodagent. Det läser filer, skriver diffar, kör shellkommandon, anropar verktyg och håller i konversationen. ECC ersätter inget av detta. Allt ECC lägger till laddas in i Claude Code vid sessionsstart och körs via dess befintliga plugin-, hook- och kommandosystem.

Färdigheter

Färdigheter är återanvändbara arbetsflödesinstruktioner lagrade som Markdown-filer.

Varje färdighet är en liten mapp med en SKILL.md som talar om för Claude Code hur en viss typ av uppgift ska hanteras. Färdigheten anger beskrivning, steg, förväntad utdata och begränsningar. ECC har runt 260 färdigheter som täcker språkmönster, testarbetsflöden, ramverkskonventioner, ML-ingenjörsarbete och operativa uppgifter.

Kom ihåg att du inte kör färdigheter manuellt. Claude Code väljer dem baserat på vad du gör, eller så refererar du till dem i en prompt.

Agenter

Agenter är specialiserade underagenter som Claude Code delegerar till.

Var och en definieras i Markdown med ett namn, en beskrivning, en verktygs-allowlist och en systemprompt som avgränsar beteendet. code-reviewer-agenten läser bara filer och rapporterar fynd. planner skriver implementeringsplaner innan någon kod rörs. Du fattar poängen.

Poängen med uppdelningen är kontextisolering. Varje underagent får ett rent kontextfönster för sin uppgift, så att huvudsessonen inte fylls upp. Huvudagenten koordinerar och underagenterna utför.

MCP-integrationer

MCP (Model Context Protocol) är hur Claude Code pratar med externa verktyg och datakällor.

ECC har konfigurationer för att koppla upp sig mot GitHub, Supabase, Vercel, Railway och andra via MCP-servrar. Varje server exponerar verktyg som Claude Code kan anropa mitt i en session. ECC paketerar bara fungerande konfigurationer och säkerhetsregler för dem.

Som standard aktiverar ECC en kontakt (chrome-devtools). Allt annat är opt-in, vilket undviker verktygsnamnskrockar och håller angreppsytan liten.

Minneslager

Minneslagret gör ECC tillståndsbevarande mellan sessioner.

Krokar körs vid Stop-händelsen i varje konversation och skriver en sessionssammanfattning till ~/.claude/sessions/. Nästa session laddar relevant kontext vid start via en SessionStart-krok. Färdigheter som modellen ”lär sig” från dina mönster extraheras till Continuous Learning v2-systemet, där de lagras som instinkter med förtroendepoäng och kan återanvändas senare.

Sessionsalias, inlärda färdigheter och mätvärden ligger alla under en gemensam agentdatarot (standard ~/.claude, konfigurerbar per sele om du kör ECC i både Claude Code och Cursor).

Hur delarna samverkar

En typisk session ser ut så här:

Session startar: En krok läser in kontext från föregående session, plus relevanta färdigheter och regler för aktuellt projekt.
Du ber om något: Säg, "lägg till OAuth-inloggning".
Planeraragenten körs först: Den skriver en plan, så ännu ingen kod.
TDD-färdigheten kommer in: Claude Code följer arbetsflödet med ett fallerande test, minimal implementation och refaktorering.
MCP-verktyg anropas: Kanske hämtar GitHub MCP relaterade PR:ar, eller så kollar Supabase MCP schemat.
Kodgranskaragenten körs på slutet: Den granskar diffen i sitt eget kontextfönster och rapporterar tillbaka.
Sessionen avslutas: En Stop-krok skriver en sammanfattning, extraherar nya mönster till instinkter och sparar dem till nästa gång.

Modellen är fortfarande Claude Code. ECC orkestrerar bara vilken färdighet, vilken agent och vilket verktyg som används i varje steg.

Färdigheter i Everything Claude Code

Färdigheter är det primära sättet ECC talar om för Claude Code vad som ska göras.

En färdighet är en mapp med en SKILL.md-fil. Markdownen definierar beskrivning, steg, begränsningar, förväntad utdata och i vilka sammanhang den gäller. Det är bara en enkel textfil som modellen läser vid körning.

Och det är avsiktligt. ECC ”tränar” inte om något, det laddar instruktioner som Claude läser och följer i stunden.

Färdigheter ligger i katalogen skills/ i repots rot. Efter installation kopieras de till ~/.claude/skills/. Claude Code laddar dem som direkta barn till den mappen.

Varje färdighetsmapp har samma grundlayout:

SKILL.md – arbetsflödesdefinitionen
Valfria stödjande filer (mallar, skript, exempel)
En valfri metadata.yaml för taggning och upptäckt

Färdigheter påverkar agentbeteende på två sätt. För det första läser Claude Code in dem vid sessionsstart och håller dem tillgängliga som referens. För det andra väljer modellen relevant färdighet baserat på vad du ber om. Säger du "skriv ett fallerande test först" aktiveras TDD-färdigheten. Säger du "granska detta för SQL-injektion" aktiveras säkerhetsgranskningsfärdigheten.

ECC levereras med runt 260 färdigheter. Här är några som visar spannet:

frontend-patterns: React- och Next.js-konventioner. Komponentstruktur, hook-användning, beslut om server vs. klientkomponenter, mönster för tillståndshantering.
django-patterns, django-tdd, django-security, django-verification: En fullständig Django-stack uppdelad i fyra färdigheter. En för arkitektur, en för testcykeln, en för OWASP-liknande granskningar, en för verifieringsslutloopen före leverans.
architect (parad med architect-agenten): Systemdesigngranskningar. Färdigheten definierar vad en arkitekturgranskning omfattar, vilka artefakter den producerar och vilka avvägningar som ska lyftas fram.
tdd-workflow: Red–green–refactor-cykeln. Skriv det fallerande testet, skriv minsta kod för att klara det, refaktorera, verifiera täckning. Färdigheten tvingar ordningen.
security-review: Checklista enligt OWASP Top 10, detektering av hårdkodade hemligheter, granskning av indatavalidering och kontroll av beroendesårbarheter. Färdigheten definierar vad som ska skannas och flaggas.

Agenter i Everything Claude Code

Agenter är specialiserade personas med egna kontextfönster.

Var och en är en Markdown-fil i mappen agents/ med ett namn, en beskrivning, en verktygs-allowlist och en systemprompt. Systemprompten definierar agentens uppdrag. Allowlisten styr vad den får göra (läsa filer, köra bash, anropa MCP-servrar, skriva kod). Claude Code delegerar automatiskt en uppgift till en agent åt dig.

ECC har 66 agenter. De grupperas i några kategorier.

Planeringsagenter körs innan någon kod skrivs.

Agenten planner bryter ner en funktionsförfrågan till en implementeringsplan: filer att ändra, gränssnitt att definiera, tester att skriva och edge cases att hantera. architect går på högre nivå: systemdesign, datamodellbeslut, tjänstegränser. Dessa agenter läser bara kod och skriver planer.

Kodningsagenter gör implementeringsarbetet.

tdd-guide tvingar test-först-cykeln. Språkspecifika felsökare som go-build-resolver, pytorch-build-resolver och kotlin-build-resolver fixar byggfel i respektive ekosystem. refactor-cleaner tar bort oanvänd kod.

Arkitekturagenter granskar strukturella beslut.

architect täcker design, database-reviewer täcker frågemönster och schemaval, och mle-reviewer granskar produktions-ML-pipelines (datakontrakt, evaltäckning, serving, övervakning).

QA-agenter verifierar det som byggts.

code-reviewer granskar diffar för kvalitet och säkerhet med en tröskel för tillit. security-reviewer kör en OWASP-liknande genomgång. e2e-runner hanterar end-to-end-tester i Playwright. Språkgranskare (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer och andra) hanterar språkspecifika kontroller.

Anledningen till uppdelningen i separata agenter är kontextisolering.

När code-reviewer körs får den ett nytt kontextfönster med bara diffen och granskningsfärdigheten inläst. Den ser inte planeringsanteckningar eller konversationshistoriken. Den bara granskar. Den fokuseringen ger bättre resultat än att be en allmän agent planera, koda, testa och granska i samma kontext, vilket är vad de flesta ad hoc-uppsättningar av Claude Code slutar med att göra.

Kontext- och minneshantering i ECC

ECC glömmer inte allt mellan sessioner som Claude Code gör.

Minne i ECC är ett system av krokar som skriver filer vid rätt tillfällen och laddar tillbaka dem vid rätt tillfällen. De är bara vanliga Markdown- och JSON-filer på disk.

Tre saker bevaras:

Sessionssammanfattningar skrivs när en session slutar: En Stop-krok körs efter sista meddelandet, tar hela utskriften och skriver en sammanfattning till ~/.claude/sessions/. Sammanfattningen täcker vad som arbetades med, vad som beslutades, vad som återstår. Nästa session läser den under en SessionStart-krok så att Claude vet var saker lämnades.
Instinkter är extraherade mönster från dina sessioner: Continuous Learning v2-systemet ser vad du gör och vad som fungerar, och skriver sedan enskilda instinkter med ett förtroendepoäng, en åtgärd, stödjande bevis och exempel. Kör /instinct-status för att se vad som lärts in. Kör /evolve för att klustra relaterade instinkter till en ny färdighet.
Loggfiler spårar det operativa lagret: Tänk hook-körningar, färdighetskörningar, MCP-anrop, kostnader, fel. Dessa ligger under ~/.claude/metrics/ och ~/.claude/session-data/. Användbart för felsökning och för dashboard-GUI:t som följer med repot.

Om du inte tycker att detta är så viktigt, här är ett par skäl som lär övertyga dig:

Långvariga projekt: En sexmånaders omstrukturering nollställs inte varje måndag. Förra veckans beslut, avvägningar och kända problem finns i sammanfattningen som laddas vid sessionsstart.
Inga upprepade förklaringar: Du behöver inte klistra in din stack, dina konventioner eller ”kom ihåg att vi valde Postgres, inte Oracle” varje gång.
Kringgår gränser i kontextfönster: Även med en miljon tokens får du inte in en sexmånaders projekthistorik. Sammanfattningar komprimerar det viktiga. Hela historiken stannar på disk, modellen får den relevanta delen.

Du kan trimma inläst kontext med miljövariabler. ECC_SESSION_START_MAX_CHARS begränsar hur mycket sammanfattning som laddas vid start (standard 8 000 tecken). ECC_SESSION_START_CONTEXT=off stänger av det för lågkontext-uppsättningar. ECC_SESSION_RETENTION_DAYS styr hur länge sessioner ligger kvar innan gallring.

Om du kör ECC i både Claude Code och Cursor på samma maskin, sätt ECC_AGENT_DATA_HOME för att hålla deras minne åtskilda. Annars skriver de över varandras sessionsfiler.

MCP-stöd i Everything Claude Code

MCP är hur Claude Code anropar allt som inte är en fil eller ett shellkommando.

Model Context Protocol är Anthropics standard för att koppla språkmodeller till externa verktyg. En MCP-server körs som en separat process och exponerar en typad uppsättning operationer: ”läs den här Notion-sidan” eller ”öppna en PR på GitHub”. Claude Code anropar de operationerna som funktionsanrop.

ECC kommer med MCP-konfigurationer i mcp-configs/mcp-servers.json för vanliga tjänster: GitHub, Supabase, Vercel, Railway, Linear och andra. Varje post innehåller kommandot för att starta servern, nödvändiga miljövariabler och de säkerhetsregler ECC tillämpar.

Det är värt att veta att ECC inte aktiverar dessa automatiskt.

MCP-kontaktpolicyn från juni 2026 minskade antalet förvalda servrar till en (chrome-devtools). Allt annat är opt-in. Du kopierar antingen posten till ditt projekts .mcp.json, eller aktiverar det via Claude Codes /mcp-kommando. Skälet är delvis praktiskt (långa MCP-verktygsnamn bryter vissa gateways) och delvis ett säkerhetsval (varje MCP-server är en potentiell angreppsyta).

Så här ser stödet ut i praktiken:

Externa integrationer: Släpp in GitHub-posten i .mcp.json, tillhandahåll en token och Claude Code kan läsa issues, öppna PR:ar och kolla CI-status utan att du behöver kopiera och klistra.
Verktygsanrop: Färdigheter och agenter refererar till MCP-verktyg vid namn. Till exempel kan en distributionsfärdighet anropa Vercel MCP, och en databasgranskningsagent kan anropa Supabase MCP.
Projektautomation: Du kan kombinera MCP-servrar med krokar för att få automation som består över sessioner. En PR-opened-krok kan starta en granskningsagent som använder GitHub MCP för att hämta diffen och Linear MCP för att uppdatera ärendet.

Om du redan kör egna kopior av MCP:er som ECC buntar, sätt ECC_DISABLED_MCPS till en kommaseparerad lista. ECC hoppar över dem under installation och synk, så du slipper dubbletter som slåss om samma servernamn.

AgentShield och säkerhetsfunktioner

Säkerhet är det som särskiljer ECC från konkurrenterna.

AgentShield är en fristående säkerhetsgranskare som följer med ECC. Den skannar Claude Code-konfigurationer efter sårbarheter, felkonfigurationer, misstag och injektionsrisker. Den körs som ett separat npm-paket (ecc-agentshield), men är kopplat till ECC via färdigheten /security-scan så att du kan köra det inifrån en Claude Code-session.

Skanningen täcker fem kategorier:

Upptäckt av hemligheter: 14 mönster för hårdkodade uppgifter, API-nycklar, token.
Behörighetsgranskning: vilka verktyg och sökvägar varje agent och färdighet har tillgång till, och om dessa rättigheter är för breda.
Hook-injektionsanalys: om krokar kan utnyttjas för att köra godtyckliga kommandon.
Riskprofilering för MCP-servrar: vad varje ansluten MCP-server kan läsa, skriva eller anropa, och var det skapar exponering.
Granskning av agentkonfiguration: promptinjektionsvektorer, övergenerösa allowlister, saknade begränsningar.

Du kan köra det med detta kommando, ingen installation behövs:

npx ecc-agentshield scan

Utdata är ett bokstavsbetyg (A till F) plus en lista med fynd, sorterade efter allvarlighetsgrad. Kritiska fynd avslutar med exit-kod 2.

Här är några flaggor att känna till:

-fix tillämpar autofixar för säkra problem (tar bort exponerade hemligheter, stramar åt alltför breda behörigheter…)
-opus kör skanningen genom tre Claude Opus 4.X-agenter i en röd team / blå team / revisor-pipeline. Angriparen försöker hitta exploit-kedjor. Försvararen utvärderar skydden. Revisorn sammanställer båda till en prioriterad riskrapport.
-stream strömmar analysen live, vilket är användbart på långsamma konfigurationer.

Opus-pipeline-upplägget är det som skiljer AgentShield från en generell linter. Adversariella agenter försöker kedja ihop var för sig ”okej” komponenter till något exploaterbart, vilket är var de flesta riktiga agentattacker kommer ifrån.

AgentShield rapporterar 102 statiska analysregler och 1 282 interna tester med 98% täckning, enligt repot. Siffrorna är värda att verifiera mot senaste versionen, men det syns tydligt att det inte är ett 50-raders skript.

Utdataformat inkluderar terminal (färggraderad), JSON (för CI), Markdown och HTML. Det finns också en GitHub Action och en separat ECC Tools GitHub-app som kör AgentShield på PR:ar.

För de flesta team som använder Claude Code i produktion är AgentShield den mest konkreta anledningen att installera ECC även om du inte använder resten av ramverket.

Installera Everything Claude Code

ECC har två installationsvägar.

Det vanligaste felet är att stapla plugin-installationen ovanpå den manuella. Båda kopierar samma filer till samma ställen, och du slutar med dubbletter. Så först av allt: välj bara en väg.

Innan du installerar, se till att du har Claude Code installerat i v2.1.0 eller senare:

claude --version

Claude-version

Installation via plugin-hanterare

Detta är den rekommenderade vägen för de flesta användare.

Inifrån Claude Code, kör:

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

Plugin-installation

Det första kommandot registrerar ECC-repot som en marknadsplats. Det andra installerar pluginet.

En brasklapp är att pluginsystemet inte distribuerar regler. Regler är riktlinjer som alltid ska följas (kodstil, git-arbetsflöde, teststandarder, språkspecifika mönster), och Claude Codes plugin-spec har dem inte. Du kopierar dem manuellt efter plugininstallationen.

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/

Kopiera rules/common plus ett språkpaket du faktiskt använder. I exemplet ovan har jag kopierat Python-regler. Kopiera inte allt – fler regler betyder mer kontext som laddas i varje session, och det mesta kommer inte att gälla ditt projekt.

Installation via konfigurationsfiler

Använd detta tillvägagångssätt om du vill ha full kontroll, eller om plugininstallationen inte fungerar i din miljö.

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

På Windows:

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

Detta kopierar agenter, färdigheter, kommandon, krokar och regler till din ~/.claude/-katalog. Inget pluginlager inblandat. Allt ligger som filer på disk som Claude Code läser vid sessionsstart.

Några profilalternativ att känna till:

-profile minimal: Regler, agenter, kommandon och kärnfärdigheter, utan krokar.
-profile core: Standardarbetsmängden. Inkluderar krokar.
-profile full: Allt i repot.

Du kan också installera specifika komponenter med --modules eller --with:

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

Om du är osäker på vilka komponenter som passar ditt arbete, fråga den medföljande rådgivaren:

npx ecc consult "security reviews" --target claude

Den returnerar matchande komponenter och exakta installationskommandon.

Verifiera installation

Kolla vad som installerats:

/plugin list ecc@ecc

Verifiering av plugin-installation

Det visar agenter, kommandon och färdigheter som finns tillgängliga från pluginet. För manuella installationer, använd livscykelomslaget:

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

doctor kontrollerar saknade filer, trasiga krokar och versionsmismatchar. Om något flaggas, kör:

node scripts/ecc.js repair

För att bekräfta att Claude Code ser det nya pluginet, öppna en session och testa ett snedstreckskommando:

/ecc:plan "Add user authentication"

Utdata från ECC-plan

För en plugin-installation krävs det namnområdesförsedda prefixet /ecc:. För en manuell installation fungerar kortformen (/plan).

Om något ser dubblerat eller trasigt ut, installera inte ovanpå igen. Kör först node scripts/uninstall.js --dry-run för att se vad som skulle tas bort, kör sedan node scripts/uninstall.js för att städa upp. ECC tar bara bort filer det själv installerat, så orelaterad konfig lämnas orörd.

Arbeta med färdigheter, kommandon och arbetsflöden

Det mesta du gör i ECC körs via färdigheter snarare än kommandon.

Anledningen är att mappen commands/ fortfarande underhålls för bakåtkompatibilitet, men ny utveckling av arbetsflöden sker i skills/ först.

Här är några användningsmönster som täcker det mesta av ditt dagliga arbete.

Färdighetsanrop är oftast implicita

Du anropar sällan en färdighet vid namn. Du beskriver vad du vill, och Claude Code väljer passande färdighet. Säger du ”skriv ett fallerande test först” aktiveras tdd-workflow-färdigheten. Färdighetsnamnen visas i svaret så att du ser vad som laddats.

När du vill vara explicit, referera till färdigheten i prompten: ”Använd django-tdd-färdigheten för att lägga till den nya endpointen.” Eller kör ett kommando som omsluter den:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

Prefixet /ecc: krävs för plugininstallationer. Manuella installationer använder kortformen (/plan, /code-review).

Utdata från ECC:s planeringsfas

Filinriktning är del av arbetsflödet

De flesta agenter och färdigheter arbetar på en viss scope: en fil, en katalog, en diff, en PR. Du anger scope genom att nämna filen i prompten, öppna den i editorn innan du anropar, eller peka agenten mot en sökväg:

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

Agenten plockar upp scopet, laddar bara de filer den behöver och kör i sitt eget kontextfönster.

Shellintegration körs via Claude Codes bash-verktyg

Färdigheter kan skala ut till shell för allt som kräver verklig körning, som att köra tester, bygga, lintra eller anropa en CLI. TDD-färdigheten kör pytest eller go test. Byggfixaragenten kör själva bygget för att se riktiga fel. Säkerhetsskanningsfärdigheten kör npx ecc-agentshield scan och tolkar utdata.

Färdigheten definierar vilka shellkommandon som körs och när. Krokar kan också köra shellkommandon vid verktygshändelser (kör en typkontroll efter varje editering, varna för console.log före en save).

MCP-hantering är mestadels opt-in

Efter installation aktiverar ECC exakt en MCP-server som standard (chrome-devtools). För att lägga till fler, kopiera poster från mcp-configs/mcp-servers.json till ditt projekts .mcp.json, aktivera sedan via Claude Codes /mcp-kommando. Gränssnittet /mcp hanterar aktivering, avaktivering och ominloggning.

Om du kör egna kopior av MCP-servrar som ECC buntar, sätt:

export ECC_DISABLED_MCPS="github,supabase"

ECC:s installer och synkflöden hoppar över dem, så du slipper två likadana servrar som slåss om samma verktygsnamn.

Arbetsflöden kedjas ihop

Du kör inte färdigheter en och en. Ett typiskt funktionsarbetsflöde ser ut så här:

/ecc:plan "Add OAuth login with Google"
# planner agent writes a blueprint

# tdd-workflow skill activates as you implement
# tests fail, code gets written, tests pass

/code-review
# code-reviewer agent audits the diff

/security-scan
# AgentShield checks the new code and config

Varje steg använder en annan agent i ett nytt kontextfönster. Huvudsessonen koordinerar, och sessionssammanfattningen fångar kedjan på slutet och gör den tillgänglig för nästa session.

Everything Claude Code vs konkurrerande konfigurationsramverk

ECC är inte det enda konfigurationslagret för Claude Code. Några andra gör liknande saker med olika avvägningar.

Det är värt att vara tydlig med kategorin först. ECC konkurrerar med andra konfigurationsramverk som ligger ovanpå Claude Code. Det konkurrerar inte med selar det körs tillsammans med (Cursor, Codex, OpenCode, Zed) eller med fristående agentplattformar (OpenHands, LangGraph, CrewAI), som är andra verktygskategorier.

Tre rivaler dyker upp oftast.

BMAD-Method är ett agilt SDLC-ramverk med specialistroller (Analyst, PM, Architect, Scrum Master, Developer, QA). Det körs över Claude Code, Cursor och Windsurf via npx bmad-method install. Det briljerar i den inledande planeringsfasen, då det förvandlar en vag idé till en PRD, arkitekturdokument och nedbrutna stories innan någon kod skrivs. Utförandeverktygen är lättare än i ECC. Det finns ingen säkerhetsskanner och ingen MCP-katalog. Det finns färre språkspecifika mönster.

SuperClaude är ett lättviktigt konfigramverk baserat på Markdown. Runt 30 snedstreckskommandon, 20 agenter och ett par beteendelägen. Installera med pip install SuperClaude. Det är enklare än ECC per design, då det saknas säkerhetsskanning och orkestreringsruntime. Men det finns heller inget inbyggt minneslager utöver vad Claude Code ger. Om du vill ha en fungerande CLAUDE.md plus en uppsättning vältestade prompter är SuperClaude ett bra val.

claude-flow / Ruflo (bytte namn från Claude Flow i början av 2026) är en multiagent-svärmorkestrerare. Den använder SPARC-metodiken (specifikation, pseudokod, arkitektur, förfining, färdigställande) och kör drottningsledda hierarkier med 60–100+ specialiserade agenter parallellt. Den har beständigt minne via AgentDB och fungerar över Claude, GPT, Gemini och Ollama. Infrastrukturen är tyngre än ECC:s och den är byggd för parallellt agentarbete snarare än produktivitet i enskilda sessioner.

Om du vill bläddra bland fler alternativ innan du bestämmer dig, awesome-claude-code är en kurerad katalog över Claude Code-resurser (agenter, färdigheter, plugins, MCP-servrar, konfigurationer). Det är där det mesta av communityns upptäckt sker.

Sammanfattningsvis: välj BMAD om du vill ha agil planering, SuperClaude om du vill ha ett lätt konfiglager, Ruflo om du behöver parallellt multiagentarbete och ECC om du vill ha en komplett ingenjörsplattform med säkerhetsverktyg och beständigt minne inbyggt.

Vem bör använda Everything Claude Code?

ECC är inte för alla. Om du bara använder Claude Code några gånger i veckan för småsaker kommer ramverket att kännas som mycket overhead för liten utdelning. En enda CLAUDE.md på 100 rader täcker det mesta du faktiskt behöver.

ECC lönar sig när du har passerat den punkten.

Här är scenarier där det passar bättre än vanilla Claude Code:

AI-ingenjörer som bygger agentsystem: Om du designar eller driftsätter agentarbetsflöden är ECC en fungerande referens. Läs agentprompterna, färdighetsdefinitionerna, hook-konfigurationerna och låna det som funkar.
Utvecklare som brinner för produktivitet: Om du lägger tid på dina verktyg, dotfiles, editorinställningar, shell – ECC är samma typ av investering för Claude Code. Du får ut mest om du använder det mycket.
Team som kör Claude Code som daglig infrastruktur: Om ert team använder Claude Code för kodgranskning, planering, refaktorering eller att skeppa funktioner varje dag, byggs tidsvinsterna på konsistens och onboarding upp. Nya teammedlemmar får samma agenter och samma arbetsflöden.
Alla som bygger komplexa agentarbetsflöden: Flerstegspipelines, underagent-orkestrering, MCP-kedjning, beständig kontext – för att nämna några. ECC har löst de flesta av dessa problem redan, och mönstren är återanvändbara även om du inte installerar allt.

Här är vem som inte bör välja ECC:

Sporadiska Claude Code-användare: Några sessioner i veckan av ”hjälp mig felsöka det här skriptet” behöver inte 60+ agenter, 260+ färdigheter och ett minneslager. Uppsättningskostnaden är helt enkelt inte värd det.
Enkla engångsuppgifter i kod: Snabba skript, små fixar, demoappar, engångsprototyper. Vanilla Claude Code hanterar dessa bra, och att lägga till ECC ger mest friktion utan mycket värde.
Team som redan har en fungerande uppsättning: Om din CLAUDE.md är vältrimmad och ert arbetsflöde stabilt, kräver byte till ECC migreringstid. Låna de delar du gillar, lämna resten.

Om du är osäker på var du landar är det säkra draget att läsa repot, kopiera två–tre agenter och färdigheter som verkar intressanta och hoppa över full installation tills vidare.

Fördelar och begränsningar med ECC

Jag går nu igenom några av ECC:s styrkor och svagheter. Båda är värda att känna till innan du bestämmer dig.

Fördelar

Stor färdighetsbank: Runt 260 färdigheter som täcker TDD, säkerhetsrevisioner, ramverksmönster, språkidiom, ML-ingenjörsarbete, driftsättning och mer. Även om du inte installerar något är repot en fungerande referens för hur man skriver bra färdighetsdefinitioner.
Återanvändbara arbetsflöden: Du får testade prompter för kodgranskning, planering, refaktorering och testning. Kodgranskaragenten nämns särskilt av folk som inte använder ECC alls men har lånat prompten.
Beständigt minne: Sådant som sessionssammanfattningar och kontext över sessioner fungerar direkt. De flesta andra Claude Code-konfigurationer adresserar inte minne alls.
Starkt MCP-stöd: Förbyggda konfigurationer för GitHub, Supabase, Vercel, Railway och andra.
AgentShield: Säkerhetsskannern ensam är en anledning att installera ECC även om du inte använder något annat. Bara några få andra Claude Code-konfigurationer har något i närheten.
Öppen källkod under MIT: Ingen betalvägg för kärnan. Den hostade GitHub-appen och ECC Pro-nivån är separata.
Plattformsoberoende: Fungerar med Claude Code, Cursor, Codex, OpenCode, Zed, Gemini och andra. Byter du eller kör flera kan du ändå använda samma agenter och färdigheter.

Begränsningar

Inlärningskurva: 60+ agenter, 260+ färdigheter, tre installationsvägar, fyra profiltyper och en bunt miljövariabler. Första veckan går mest åt till att förstå vad som är inläst och vad varje komponent gör.
Komplex uppsättning: Plugin vs. manuell installation, problemet med regler som inte distribueras via plugin, dubbla krokar i äldre versioner av Claude Code, MCP:s aktiverings-/avaktiveringsflöden, agentdatarot-variabeln för multi-sele-användning. Det mesta är dokumenterat, men ändå en hel del jobb.
Underhållsöverhäng: Repot uppdateras regelbundet. Katalogantal skiftar mellan releaser och färdighetsnamn ändras.
Beroende av Claude Code-ekosystemet: ECC är beroende av Claude Codes plugin-spec, hooksystem och MCP-stöd. När Claude Code ändrar dessa måste ECC följa efter.
Överingenjörat för många användningsfall: För de flesta team täcker en välskriven CLAUDE.md med 60–200 rader 80% av vad ECC erbjuder. De andra 20% är värdefulla, men bara om du använder dem.

Ramverket är det mest kompletta konfigurationslagret för Claude Code just nu. Men ”mest komplett” och ”nödvändigt för alla” är inte samma sak.

Slutsats

Om du använder Claude Code dagligen är ECC värt att titta på. Om inte, är repot ändå läsvärt som en fungerande referens för hur man bygger agentarbetsflöden som håller i praktiken.

Hur som helst är ECC en tydlig signal om att mjukvaruutveckling rör sig mot programmerbara agentpipelines i stället för enskilda chatsessioner. Ramverken för att göra detta bra är fortfarande nya, och ECC är ett av de mest kompletta försöken hittills. Det blir inte det sista – och det är poängen.

Om du är ny på generativ AI och agentisk kodning, gå vår kurs Generative AI Concepts. Den ger dig en stabil grund för framtiden.

Ämnen

Artificiell intelligens