Everything Claude Code (ECC): il framework di agenti open source per Claude Code

Da quando gli agenti per il coding sono diventati una realtà, quante volte hai dovuto rispiegare stack, convenzioni, preferenze e standard di review all’inizio di ogni sessione?

Il problema è che ogni nuova conversazione parte a freddo. Strumenti come Claude Code sanno scrivere codice, ma non sanno come il tuo team scrive codice. Quello che nasce come un risparmio di tempo finisce per diventare lavoro manuale: incollare sempre lo stesso contesto di progetto, correggere il modello quando deraglia, ottimizzare le istruzioni e rivedere ogni volta gli stessi suggerimenti generici.

Everything Claude Code (ECC) è un framework open source che punta a risolvere proprio questo. Nonostante il nome, non è affiliato ad Anthropic. È un sistema di agenti e uno strato di workflow che si appoggia a Claude Code (non è un modello, non è un IDE) e trasforma un agente generico per il coding in una piattaforma di ingegneria specializzata che conosce già i tuoi standard.

In questo articolo vedremo cos’è ECC, come si incastrano i suoi pezzi, come installarlo e a chi conviene davvero usarlo.

Ma che cos’è esattamente Claude Code? Iscriviti al corso Claude Code 101 per imparare a usarlo nei tuoi workflow di sviluppo quotidiani.

Cos’è Everything Claude Code?

ECC è una repo open source che avvolge Claude Code con uno strato operativo predefinito per il lavoro di ingegneria.

Puoi trovare il progetto su affaan-m/ECC su GitHub. È distribuito con licenza MIT, mantenuto da Affaan Mustafa e nasce da oltre 10 mesi di uso quotidiano di Claude Code su prodotti reali. Non è affiliato ad Anthropic, nonostante il nome.

La repo impacchetta quattro elementi in un’unica installazione:

• Un “harness” per agenti: un set di sub-agenti specializzati (planner, architect, code reviewer, security reviewer, risolutore di errori di build e una dozzina di altri) a cui Claude Code delega invece di provare a fare tutto in un’unica finestra di contesto.
• Un ecosistema di skill: qualche centinaio di piccole definizioni di workflow che coprono TDD, security review, pattern di framework (Django, Spring Boot, Next.js e altri), standard di codice specifici per linguaggio e task di ML engineering.
• Un framework di workflow: hook che si attivano su eventi degli strumenti, regole sempre valide, configurazioni di server MCP e memoria di sessione che sopravvive tra conversazioni.
• Uno strato di comandi: voci “slash” mantenute per eseguire i workflow comuni, più una cartella di compatibilità retroattiva per i nomi di comandi più vecchi.

È importante notare che Claude Code resta il motore. Legge il codice ed esegue gli strumenti.

Il lavoro di ECC è tutto ciò che sta intorno: dire a Claude Code quale sub-agente deve gestire un compito, quali step di workflow seguire, quali convenzioni usa il tuo stack e quale contesto portare dalla sessione di ieri.

In pratica, significa che non devi più configurare Claude Code da zero per ogni progetto. Installi ECC una volta, copi i pacchetti di regole per il tuo stack e hai una piattaforma di ingegneria specializzata che sa già come procedere.

Perché Everything Claude Code è diventato così popolare

La crescita è partita da un thread su X.

All’inizio del 2026, Mustafa ha pubblicato The Shorthand Guide to Everything Claude Code. Ha superato i 10K bookmark in pochi giorni. Poi ha open-sourcizzato la repo, ed ECC ha superato 200K stelle e 34+ fork.

Ecco perché è successo:

• Il coding “agentic” è passato dall’esperimento all’uso quotidiano: Con l’aumentare degli sviluppatori che usano Claude Code, sono emersi i limiti del sistema “stock”. Quello di cui avevano bisogno era uno strato di configurazione predefinito che eliminasse il contesto di cold start, gli output incoerenti delle code review e simili.
• Scrivere buoni prompt per agenti è più difficile di quanto sembri: Un solido workflow TDD o un prompt per code reviewer che filtra per confidenza richiede iterazioni. Molti team non vogliono costruire e mantenere tutto da zero mentre i modelli cambiano, quindi riusare la versione testata di qualcun altro è la via più semplice.
• Le contribuzioni si sono accumulate: 270+ contributor hanno aggiunto pacchetti di regole per linguaggi (Java, Kotlin, Rust, Perl, PHP), supporto per framework (Quarkus, Laravel), traduzioni, integrazioni IDE oltre Claude Code (Cursor, OpenCode, Zed) e skill.
• ECC offre specializzazione senza fine-tuning: Il fine-tuning di un modello sulle convenzioni del team non è praticabile per la maggior parte dei team. Un set strutturato di skill e agenti a runtime ci si avvicina molto, ed ECC è uno dei tentativi più completi di impacchettarlo.

È partito da un thread su X ed è diventato una palla di neve da lì in poi.

Come funziona Everything Claude Code

ECC è un sistema a strati.

Tra te e la tua codebase ci sono cinque componenti. Claude Code è il runtime. Skill, agenti, MCP e uno strato di memoria lo avvolgono. Ogni pezzo fa un lavoro e durante una sessione si passano il testimone.

Claude Code

Claude Code è l’interfaccia al modello sottostante.

È la CLI ufficiale di Anthropic per eseguire Claude come agente di coding. Legge file, scrive diff, esegue comandi shell, chiama strumenti e gestisce la conversazione. ECC non sostituisce nulla di tutto ciò. Tutto ciò che ECC aggiunge viene caricato in Claude Code all’avvio della sessione e gira tramite il suo sistema di plugin, hook e comandi esistente.

Skill

Le skill sono istruzioni di workflow riutilizzabili archiviate come file Markdown.

Ogni skill è una piccola cartella con un SKILL.md che dice a Claude Code come gestire un tipo specifico di task. La skill nomina descrizione, step, output atteso e vincoli. ECC ha circa 260 skill che coprono pattern di linguaggio, workflow di testing, convenzioni di framework, ML engineering e task operativi.

Ricorda che non esegui le skill manualmente. Claude Code le sceglie in base a quello che stai facendo, oppure le citi nel prompt.

Agenti

Gli agenti sono sub-agenti specializzati a cui Claude Code delega.

Ognuno è definito in Markdown con nome, descrizione, allowlist degli strumenti e un system prompt che delimita il suo comportamento. L’agente code-reviewer legge solo file e riporta le evidenze. Il planner scrive i blueprint di implementazione prima di toccare il codice. L’idea è chiara.

Il punto di questa separazione è l’isolamento del contesto. Ogni sub-agente ottiene una finestra di contesto pulita per il suo compito, così la sessione principale non si riempie. L’agente principale coordina e i sub-agenti eseguono.

Integrazioni MCP

MCP (Model Context Protocol) è il modo in cui Claude Code parla con strumenti e fonti dati esterni.

ECC include configurazioni per connettersi a GitHub, Supabase, Vercel, Railway e altri tramite server MCP. Ogni server espone strumenti che Claude Code può chiamare a metà sessione. ECC si limita a fornire configurazioni funzionanti e regole di sicurezza per questi.

Di default ECC abilita un solo connettore (chrome-devtools). Tutto il resto è opt-in, il che evita collisioni di nomi degli strumenti e riduce la superficie d’attacco.

Strato di memoria

Lo strato di memoria rende ECC “stateful” tra sessioni.

Gli hook si attivano all’evento Stop di ogni conversazione e scrivono un riepilogo di sessione in ~/.claude/sessions/. La sessione successiva carica il contesto rilevante all’avvio tramite un hook SessionStart. Le skill che il modello “impara” dai tuoi pattern vengono estratte nel sistema Continuous Learning v2, dove sono archiviate come “instinct” con punteggi di confidenza e possono essere riusate in seguito.

Alias di sessione, skill apprese e metriche vivono tutte sotto un’unica radice di dati dell’agente (default ~/.claude, configurabile per harness se esegui ECC sia in Claude Code che in Cursor).

Come lavorano insieme i pezzi

Una sessione tipica si presenta così:

1. Avvio sessione: Un hook carica il contesto dalla sessione precedente, più le skill e le regole rilevanti per il progetto corrente.
2. Chiedi qualcosa: per esempio, “aggiungi il login OAuth”.
3. Parte prima l’agente planner: scrive un blueprint, quindi niente codice per ora.
4. Entra in gioco la skill TDD: Claude Code segue il workflow test fallito, implementazione minima e refactor.
5. Vengono chiamati gli strumenti MCP: magari il MCP di GitHub recupera PR correlate o quello di Supabase verifica lo schema.
6. Alla fine gira l’agente code-reviewer: controlla il diff nella sua finestra di contesto e riporta i risultati.
7. Fine sessione: uno Stop hook scrive un riepilogo, estrae eventuali nuovi pattern in “instinct” e li archivia per la prossima volta.

Il modello resta Claude Code. ECC orchestra solo quale skill, quale agente e quale strumento usare a ogni passo.

Le skill in Everything Claude Code

Le skill sono il principale modo con cui ECC dice a Claude Code cosa fare.

Una skill è una cartella con un file SKILL.md. Il Markdown definisce descrizione, step, vincoli, output atteso e contesti a cui si applica. È solo un file di testo che il modello legge a runtime.

Ed è voluto. ECC non “ri-addestra” nulla, carica istruzioni che Claude legge e segue al momento.

Le skill vivono nella directory skills/ alla radice della repo. Dopo l’installazione, vengono copiate in ~/.claude/skills/. Claude Code le carica come figli diretti di quella cartella.

Ogni cartella di skill ha la stessa struttura di base:

• SKILL.md - la definizione del workflow
• File di supporto opzionali (template, script, esempi)
• Un metadata.yaml opzionale per tag e discovery

Le skill influenzano il comportamento degli agenti in due modi. Primo, Claude Code le legge all’avvio della sessione e le tiene disponibili come riferimento. Secondo, il modello sceglie la skill rilevante in base a ciò che chiedi. Se dici “scrivi prima un test che fallisce”, si attiva la skill TDD. Se dici “rivedi questo per SQL injection”, si attiva la skill di security review.

ECC include circa 260 skill. Eccone alcune per dare l’idea del range:

• frontend-patterns: convenzioni per React e Next.js. Struttura dei componenti, uso degli hook, decisioni server vs client component, pattern di gestione dello stato.

• django-patterns, django-tdd, django-security, django-verification: uno stack Django completo suddiviso in quattro skill. Una per l’architettura, una per il ciclo di test, una per gli audit in stile OWASP, una per il ciclo di verifica prima del rilascio.

• architect (abbinata all’agente architect): revisioni di system design. La skill definisce cosa copre una review architetturale, quali artefatti produce e quali trade-off evidenziare.

• tdd-workflow: il ciclo rosso-verde-refactor. Scrivi il test che fallisce, scrivi il minimo codice per farlo passare, fai refactor, verifica la copertura. La skill impone l’ordine.

• security-review: checklist di audit OWASP Top 10, rilevamento di credenziali hardcoded, revisione della validazione dell’input e verifiche delle vulnerabilità nelle dipendenze. La skill definisce cosa scansionare e cosa segnalare.

Gli agenti in Everything Claude Code

Gli agenti sono “personas” specializzate con la propria finestra di contesto.

Ognuno è un file Markdown nella cartella agents/ con nome, descrizione, allowlist degli strumenti e un system prompt. Il system prompt definisce il lavoro dell’agente. L’allowlist controlla cosa può fare (leggere file, eseguire bash, chiamare server MCP, scrivere codice). Claude Code delega automaticamente un task a un agente per te.

ECC ha 66 agenti. Si raggruppano in alcune categorie.

Agenti di pianificazione eseguono prima che venga scritto qualsiasi codice.

L’agente planner suddivide una feature request in un blueprint di implementazione: file da cambiare, interfacce da definire, test da scrivere e edge case da gestire. L’agente architect va a un livello più alto: system design, decisioni di data model, confini dei servizi. Questi agenti leggono solo codice e scrivono piani.

Agenti di coding fanno il lavoro di implementazione.

Il tdd-guide impone il ciclo test-first. I risolutori di build specifici per linguaggio come go-build-resolver, pytorch-build-resolver e kotlin-build-resolver correggono gli errori di build nei rispettivi ecosistemi. Il refactor-cleaner rimuove codice inutilizzato.

Agenti di architettura rivedono le decisioni strutturali.

L’architect copre il design, il database-reviewer copre pattern di query e scelte di schema e il mle-reviewer esegue audit delle pipeline ML in produzione (data contract, copertura delle valutazioni, serving, monitoraggio).

Agenti QA verificano ciò che è stato costruito.

Il code-reviewer controlla i diff per qualità e sicurezza con una soglia di confidenza. Il security-reviewer esegue un passaggio in stile OWASP. L’e2e-runner gestisce i test end-to-end con Playwright. I reviewer di linguaggio (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer e altri) gestiscono i controlli specifici per linguaggio.

Il motivo per cui si suddivide tutto in agenti separati è l’isolamento del contesto.

Quando gira il code-reviewer, ottiene una finestra di contesto fresca con solo il diff e la skill di review caricati. Non vede le note di pianificazione né la cronologia della conversazione. Fa solo la review. Questa concentrazione produce output migliori rispetto a chiedere a un unico agente generale di pianificare, codare, testare e rivedere nello stesso contesto, che è ciò che fanno la maggior parte delle configurazioni ad hoc di Claude Code.

Gestione di contesto e memoria in ECC

ECC non dimentica tutto tra una sessione e l’altra come fa Claude Code.

La memoria in ECC è un sistema di hook che scrivono file nei momenti giusti e li ricaricano nei momenti giusti. Sono semplici file Markdown e JSON su disco.

Persistono tre cose:

1. I riepiloghi di sessione vengono scritti quando la sessione termina: uno Stop hook gira dopo l’ultimo messaggio, prende l’intera trascrizione e scrive un riepilogo in ~/.claude/sessions/. Il riepilogo copre su cosa si è lavorato, cosa si è deciso, cosa è ancora aperto. La sessione successiva lo legge durante un hook SessionStart così Claude sa dove si era rimasti.
2. Gli “instinct” sono pattern estratti dalle tue sessioni: il sistema Continuous Learning v2 osserva cosa fai e cosa funziona, quindi scrive singoli instinct con un punteggio di confidenza, un’azione, evidenze di supporto ed esempi. Esegui /instinct-status per vedere cosa è stato appreso. Esegui /evolve per raggruppare instinct correlati in una nuova skill.
3. I file di log tracciano lo strato operativo: esecuzioni di hook, esecuzioni di skill, chiamate MCP, costi, errori. Vivono sotto ~/.claude/metrics/ e ~/.claude/session-data/. Utili per il debug e per la dashboard GUI inclusa nella repo.

Se non ti sembra così importante, ecco un paio di motivi che ti faranno cambiare idea:

• Progetti di lunga durata: un refactor di sei mesi non si azzera ogni lunedì. Le decisioni della settimana scorsa, i trade-off e i problemi noti sono nel riepilogo che si carica all’avvio della sessione.
• Niente spiegazioni ripetute: non devi reincollare ogni volta il tuo stack, le tue convenzioni o “ricorda che abbiamo deciso di usare Postgres, non Oracle”.
• Aggirare i limiti della finestra di contesto: anche con una finestra da un milione di token, non ci sta la storia di un progetto di sei mesi. I riepiloghi comprimono ciò che conta. La storia completa resta su disco, al modello va la parte rilevante.

Puoi regolare il contesto caricato con variabili d’ambiente. ECC_SESSION_START_MAX_CHARS limita quanta parte del riepilogo viene caricata all’avvio (default 8.000 caratteri). ECC_SESSION_START_CONTEXT=off lo disabilita per setup a basso contesto. ECC_SESSION_RETENTION_DAYS controlla per quanto tempo le sessioni restano prima della pulizia.

Se esegui ECC sia in Claude Code che in Cursor sulla stessa macchina, imposta ECC_AGENT_DATA_HOME per mantenere separate le loro memorie. Altrimenti si sovrascrivono i file di sessione a vicenda.

Supporto MCP in Everything Claude Code

MCP è il modo con cui Claude Code chiama qualsiasi cosa non sia un file o un comando shell.

Il Model Context Protocol è lo standard di Anthropic per collegare i modelli linguistici a strumenti esterni. Un server MCP gira come processo separato ed espone un set tipizzato di operazioni: “leggi questa pagina Notion” o “apri una PR su GitHub”. Claude Code chiama queste operazioni come fossero chiamate di funzione.

ECC include configurazioni MCP in mcp-configs/mcp-servers.json per i servizi comuni: GitHub, Supabase, Vercel, Railway, Linear e altri. Ogni voce include il comando per avviare il server, le variabili d’ambiente richieste e le regole di sicurezza che ECC applica.

Vale la pena sapere che ECC non li abilita automaticamente.

La policy dei connettori MCP del giugno 2026 ha ridotto i server abilitati di default a uno (chrome-devtools). Tutto il resto è opt-in. O copi la voce nel .mcp.json del tuo progetto, oppure lo abiliti tramite il comando /mcp di Claude Code. Il motivo è in parte pratico (nomi lunghi degli strumenti MCP rompono alcuni gateway) e in parte una scelta di sicurezza (ogni server MCP è una potenziale superficie d’attacco).

Ecco come si presenta questo supporto nella pratica:

• Integrazioni esterne: inserisci la voce di GitHub in .mcp.json, fornisci un token e Claude Code può leggere issue, aprire PR e controllare lo stato della CI senza copia-incolla.
• Chiamata di strumenti: le skill e gli agenti si riferiscono agli strumenti MCP per nome. Per esempio, una skill di deploy può chiamare il MCP di Vercel e un agente di review del database può chiamare il MCP di Supabase.
• Automazione di progetto: puoi combinare server MCP con hook per ottenere automazioni persistenti tra sessioni. Un hook su PR aperta può avviare un agente di review che usa il MCP di GitHub per recuperare il diff e il MCP di Linear per aggiornare il ticket.

Se esegui già copie tue di MCP inclusi da ECC, imposta ECC_DISABLED_MCPS con un elenco separato da virgole. ECC salterà quelli durante install e sync, così non avrai duplicati che si contendono lo stesso nome di server.

AgentShield e funzionalità di sicurezza

La sicurezza è ciò che distingue ECC dalla concorrenza.

AgentShield è un auditor di sicurezza standalone fornito con ECC. Scansiona le configurazioni di Claude Code alla ricerca di vulnerabilità, misconfigurazioni, errori e rischi di injection. Gira come pacchetto npm separato (ecc-agentshield), ma è collegato a ECC tramite la skill /security-scan così puoi eseguirlo dall’interno di una sessione Claude Code.

La scansione copre cinque categorie:

• Rilevamento di secret: 14 pattern per credenziali hardcoded, chiavi API, token.
• Audit dei permessi: quali strumenti e percorsi ogni agente e skill può accedere e se tali concessioni sono troppo ampie.
• Analisi di injection negli hook: se gli hook possono essere sfruttati per eseguire comandi arbitrari.
• Profilazione del rischio dei server MCP: cosa ogni server MCP connesso può leggere, scrivere o chiamare e dove si crea esposizione.
• Revisione delle configurazioni degli agenti: vettori di prompt injection, over-grant nell’allowlist degli strumenti, vincoli mancanti.

Puoi eseguirlo con questo comando, senza installazione:

npx ecc-agentshield scan

L’output è un voto in lettere (da A a F) più un elenco di rilievi ordinati per gravità. I rilievi critici escono con codice 2.

Ecco alcune flag utili da conoscere:

• -fix applica correzioni automatiche per problemi sicuri (rimozione di secret esposti, restringimento di permessi eccessivamente ampi…)
• -opus esegue la scansione tramite tre agenti Claude Opus 4.X in una pipeline red-team / blue-team / auditor. L’attaccante cerca catene di exploit. Il difensore valuta le protezioni. L’auditor sintetizza entrambi in un report di rischio prioritizzato.
• -stream trasmette l’analisi in tempo reale, utile su configurazioni lente.

L’approccio con pipeline Opus è ciò che separa AgentShield da un semplice linter. Agenti avversari provano a concatenare componenti considerati “OK” in qualcosa di sfruttabile, che è dove originano la maggior parte degli attacchi reali agli agenti.

Secondo la repo, AgentShield riporta 102 regole di analisi statica e 1.282 test interni al 98% di copertura. Vale la pena verificare i numeri sull’ultima release, ma è chiaro che non è uno script da 50 righe.

I formati di output includono terminale (con color grading), JSON (per la CI), Markdown e HTML. C’è anche una GitHub Action e una GitHub App separata, ECC Tools, che esegue AgentShield sulle PR.

Per la maggior parte dei team che usano Claude Code in produzione, AgentShield è il motivo più concreto per installare ECC anche se non si usa il resto del framework.

Installare Everything Claude Code

ECC ha due percorsi di installazione.

L’errore più comune è sovrapporre l’installazione via plugin a quella manuale. Entrambe copiano gli stessi file negli stessi posti e finisci con duplicati. Quindi prima di tutto: scegli un solo percorso.

Prima di installare, assicurati di avere Claude Code installato in versione v2.1.0 o successiva:

claude --version

Versione di Claude

Installazione tramite plugin manager

Questo è il percorso consigliato per la maggior parte degli utenti.

Dall’interno di Claude Code, esegui:

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

Installazione del plugin

Il primo comando registra la repo ECC come marketplace. Il secondo installa il plugin.

Una nota: il sistema di plugin non distribuisce le regole. Le regole sono le linee guida sempre valide (stile di codice, workflow git, standard di testing, pattern specifici per linguaggio) e lo spec dei plugin di Claude Code non le include. Devi copiarle manualmente dopo l’installazione del plugin.

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/

Copia rules/common più un pacchetto di linguaggio che usi davvero. Nell’esempio sopra ho copiato le regole per Python. Non copiare tutto: più regole significano più contesto caricato in ogni sessione e la maggior parte non si applicherà al tuo progetto.

Installazione tramite file di configurazione

Usa questo approccio se vuoi il pieno controllo o se l’installazione via plugin non funziona nel tuo setup.

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

Su Windows:

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

Questo copia agenti, skill, comandi, hook e regole nella tua directory ~/.claude/. Nessun layer di plugin coinvolto. Tutto vive come file su disco che Claude Code legge all’avvio della sessione.

Alcune opzioni di profilo utili da conoscere:

• -profile minimal: solo regole, agenti, comandi e skill core, senza hook.

• -profile core: il set predefinito funzionante. Hook inclusi.

• -profile full: tutto ciò che c’è nella repo.

Puoi anche installare componenti specifici con --modules o --with:

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

Se non sei sicuro di quali componenti si adattino al tuo lavoro, chiedi al consulente incluso:

npx ecc consult "security reviews" --target claude

Restituisce i componenti corrispondenti e i comandi di installazione esatti.

Verifica dell’installazione

Controlla cosa è stato installato:

/plugin list ecc@ecc

Verifica installazione plugin

Mostra gli agenti, i comandi e le skill disponibili dal plugin. Per le installazioni manuali, usa il wrapper di lifecycle:

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

doctor controlla file mancanti, hook rotti e mismatch di versione. Se segnala qualcosa, esegui:

node scripts/ecc.js repair

Per confermare che Claude Code veda il nuovo plugin, apri una sessione e prova un comando slash:

/ecc:plan "Add user authentication"

Output del piano ECC

Per un’installazione via plugin è richiesto il prefisso con namespace /ecc:. Per un’installazione manuale funziona la forma breve (/plan).

Se qualcosa appare duplicato o rotto, non reinstallare sopra. Esegui prima node scripts/uninstall.js --dry-run per vedere cosa verrebbe rimosso, poi node scripts/uninstall.js per pulire. ECC rimuove solo i file che ha installato, quindi la configurazione non correlata resta invariata.

Lavorare con skill, comandi e workflow

La maggior parte di ciò che fai in ECC passa tramite le skill, non i comandi.

Il motivo è che la cartella commands/ è ancora mantenuta per compatibilità all’indietro, ma lo sviluppo di nuovi workflow si trova prima in skills/.

Ecco alcuni pattern d’uso che copriranno gran parte del tuo lavoro quotidiano.

L’invocazione delle skill è per lo più implicita

Di solito non chiami una skill per nome. Descrivi cosa vuoi e Claude Code sceglie la skill adatta. Se dici “scrivi prima un test che fallisce”, si attiva la skill tdd-workflow. I nomi delle skill compaiono nella risposta così puoi vedere cosa è stato caricato.

Quando vuoi essere esplicito, cita la skill nel prompt: “Usa la skill django-tdd per aggiungere il nuovo endpoint.” Oppure esegui un comando che la incapsula:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

Il prefisso /ecc: è richiesto per le installazioni via plugin. Le installazioni manuali usano la forma breve (/plan, /code-review).

Output della fase di pianificazione ECC

Il targeting dei file fa parte del workflow

La maggior parte di agenti e skill lavora su uno scope specifico: un file, una directory, un diff, una PR. Definisci lo scope menzionando il file nel prompt, aprendolo nell’editor prima di invocare, o indicando all’agente un percorso:

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

L’agente raccoglie lo scope, carica solo i file necessari ed esegue nella propria finestra di contesto.

L’integrazione con la shell passa dallo strumento bash di Claude Code

Le skill possono eseguire comandi shell per tutto ciò che richiede esecuzione reale, come avviare test, build, lint o chiamare una CLI. La skill TDD esegue pytest o go test. L’agente di fix della build esegue la build reale per vedere errori reali. La skill di security scan esegue npx ecc-agentshield scan e analizza l’output.

La skill definisce quali comandi shell eseguire e quando. Gli hook possono anche eseguire comandi shell sugli eventi degli strumenti (avviare un typecheck dopo ogni edit, avvisare dei console.log prima di un salvataggio).

La gestione dei MCP è per lo più opt-in

Dopo l’installazione, ECC abilita di default esattamente un server MCP (chrome-devtools). Per aggiungerne altri, copia le voci da mcp-configs/mcp-servers.json nel .mcp.json del tuo progetto, poi abilitali tramite il comando /mcp di Claude Code. L’interfaccia /mcp gestisce abilitazione, disabilitazione e nuova autenticazione.

Se esegui copie tue dei server MCP inclusi da ECC, imposta:

export ECC_DISABLED_MCPS="github,supabase"

L’installer e i flussi di sync di ECC li salteranno, così non ti ritrovi con due server identici che si contendono gli stessi nomi di strumenti.

I workflow si concatenano

Non esegui le skill una alla volta. Un workflow tipico per una feature è così:

/ecc:plan "Add OAuth login with Google"
# l'agente planner scrive un blueprint

# la skill tdd-workflow si attiva durante l'implementazione
# i test falliscono, si scrive il codice, i test passano

/code-review
# l'agente code-reviewer controlla il diff

/security-scan
# AgentShield controlla il nuovo codice e la config

Ogni step usa un agente diverso in una finestra di contesto pulita. La sessione principale coordina e il riepilogo di sessione cattura la catena finale rendendola disponibile alla sessione successiva.

Everything Claude Code vs framework rivali di configurazione

ECC non è l’unico strato di configurazione per Claude Code. Ce ne sono altri che svolgono compiti simili con trade-off diversi.

È utile chiarire la categoria. ECC compete con altri framework di configurazione che si appoggiano a Claude Code. Non compete con gli harness con cui gira affiancato (Cursor, Codex, OpenCode, Zed) o con le piattaforme di agenti standalone (OpenHands, LangGraph, CrewAI), che sono categorie diverse.

Tre rivali ricorrono più spesso.

BMAD-Method è un framework agile SDLC con agenti specializzati per ruolo (Analyst, PM, Architect, Scrum Master, Developer, QA). Gira su Claude Code, Cursor e Windsurf via npx bmad-method install. Brilla nella fase di pianificazione iniziale, trasformando un’idea vaga in un PRD, un documento di architettura e storie scomposte prima che venga scritto codice. Il tooling di esecuzione è più leggero rispetto a ECC. Non c’è scanner di sicurezza né catalogo MCP. Ci sono meno pattern specifici per linguaggio.

SuperClaude è un framework di configurazione leggero basato su Markdown. Circa 30 comandi slash, 20 agenti e un paio di modalità comportamentali. Si installa con pip install SuperClaude. È più semplice di ECC per scelta: niente scansione di sicurezza e nessun runtime di orchestrazione. Ma non c’è nemmeno uno strato di memoria integrato oltre a quello fornito da Claude Code. Se vuoi un CLAUDE.md funzionante più un set di prompt ben testati, SuperClaude è una buona scelta.

claude-flow / Ruflo (rinominato da Claude Flow all’inizio del 2026) è un orchestratore di swarm multi-agente. Usa la metodologia SPARC (specification, pseudocode, architecture, refinement, completion) ed esegue gerarchie guidate da “queen” di 60-100+ agenti specializzati in parallelo. Ha memoria persistente tramite AgentDB e funziona con Claude, GPT, Gemini e Ollama. L’infrastruttura è più pesante rispetto a ECC, ed è pensato per lavoro parallelo tra agenti più che per produttività in singola sessione.

Se vuoi esplorare altre opzioni prima di decidere, awesome-claude-code è una directory curata di risorse per Claude Code (agenti, skill, plugin, server MCP, configurazioni). È dove avviene gran parte della scoperta nella community.

In sintesi, scegli BMAD se vuoi pianificazione in stile agile, SuperClaude se ti serve uno strato di configurazione leggero, Ruflo se ti serve lavoro multi-agente in parallelo ed ECC se vuoi una piattaforma di ingegneria completa con tooling di sicurezza e memoria persistente integrati.

Chi dovrebbe usare Everything Claude Code?

ECC non è per tutti. Se usi Claude Code solo qualche volta a settimana per task piccoli, il framework ti sembrerà un sacco di overhead per poco ritorno. Un singolo CLAUDE.md da 100 righe coprirà la maggior parte di ciò che ti serve davvero.

ECC ripaga quando superi quel punto.

Ecco gli scenari in cui è una scelta migliore del Claude Code “vanilla”:

• AI engineer che costruiscono sistemi agentici: se progetti o distribuisci workflow di agenti, ECC è un riferimento funzionante. Leggi i prompt degli agenti, le definizioni delle skill, le configurazioni degli hook e prendi ciò che funziona.
• Appassionati di produttività per sviluppatori: se investi tempo su tool, dotfile, setup dell’editor e shell, ECC è lo stesso tipo di investimento per Claude Code. Ne trarrai il massimo se lo usi molto.
• Team che usano Claude Code come infrastruttura quotidiana: se il tuo team usa Claude Code ogni giorno per code review, pianificazione, refactor o rilascio di feature, il tempo risparmiato in coerenza e onboarding si somma. I nuovi membri ottengono gli stessi agenti e gli stessi workflow.
• Chiunque costruisca workflow di agenti complessi: pipeline multi-step, orchestrazione di sub-agenti, concatenazione MCP, contesto persistente, e altro. ECC ha già risolto la maggior parte di questi problemi e i pattern sono riutilizzabili anche senza installare tutto.

Ecco chi non dovrebbe scegliere ECC:

• Utenti occasionali di Claude Code: qualche sessione a settimana di “aiutami a fare debug di questo script” non ha bisogno di 60+ agenti, 260+ skill e uno strato di memoria. L’overhead di setup non vale la pena.
• Task di coding semplici e una tantum: script veloci, piccole fix, app demo, prototipi “usa e getta”. Claude Code “vanilla” li gestisce bene e aggiungere ECC aggiunge solo attrito senza molto valore.
• Team che hanno già un setup funzionante: se il tuo CLAUDE.md è ben calibrato e il tuo workflow è stabile, passare a ECC richiede tempo di migrazione. Prendi i pezzi che ti piacciono, lascia il resto.

Se non sei sicuro di dove collocarti, la mossa sicura è leggere la repo, copiare due o tre agenti e skill che trovi interessanti e saltare per ora l’installazione completa.

Vantaggi e limiti di ECC

Ora ti guido tra alcuni punti di forza e debolezze di ECC. Entrambi da conoscere prima di decidere.

Vantaggi

• Enorme libreria di skill: circa 260 skill che coprono TDD, audit di sicurezza, pattern di framework, idiomi di linguaggio, ML engineering, deploy e altro. Anche senza installare nulla, la repo è un riferimento pratico su come scrivere buone definizioni di skill.
• Riuso dei workflow: ottieni prompt testati per code review, pianificazione, refactor e testing. L’agente di code review in particolare è citato da persone che non usano affatto ECC ma hanno preso in prestito il prompt.
• Memoria persistente: elementi come riepiloghi di sessione e contesto cross-session funzionano out of the box. La maggior parte delle configurazioni di Claude Code non affronta affatto la memoria.
• Solido supporto MCP: configurazioni predefinite per GitHub, Supabase, Vercel, Railway e altri.
• AgentShield: lo scanner di sicurezza da solo è un motivo per installare ECC anche se non usi nient’altro. Solo poche altre configurazioni di Claude Code offrono qualcosa di paragonabile.
• Open source sotto MIT: nessun paywall sul core. La GitHub App hosted e il tier ECC Pro sono separati.
• Cross-platform: funziona con Claude Code, Cursor, Codex, OpenCode, Zed, Gemini e altri. Se cambi o ne usi diversi, puoi comunque usare gli stessi agenti e skill.

Limiti

• Curva di apprendimento: 60+ agenti, 260+ skill, tre percorsi di installazione, quattro tipi di profilo e un mucchio di variabili d’ambiente. La prima settimana sarà soprattutto capire cosa è caricato e cosa fa ogni componente.
• Complessità di setup: installazione via plugin vs manuale, il problema delle regole non distribuite via plugin, il problema degli hook duplicati nelle versioni più vecchie di Claude Code, flussi di abilitazione/disabilitazione MCP, la variabile della radice dei dati dell’agente per uso multi-harness. Quasi tutto documentato, ma è comunque tanto lavoro.
• Overhead di manutenzione: la repo si aggiorna regolarmente. I conteggi del catalogo cambiano tra release e i nomi delle skill cambiano.
• Dipendenza dall’ecosistema di Claude Code: ECC dipende dallo spec dei plugin, dal sistema di hook e dal supporto MCP di Claude Code. Quando Claude Code li cambia, ECC deve adeguarsi.
• Over-engineering per molti casi d’uso: per la maggior parte dei team, un CLAUDE.md scritto bene con 60-200 righe copre l’80% di ciò che offre ECC. Il restante 20% è prezioso, ma solo se lo usi.

Il framework è lo strato di configurazione per Claude Code più completo disponibile oggi. Ma “più completo” e “necessario per tutti” non sono la stessa cosa.

Conclusione

Se usi Claude Code ogni giorno, vale la pena dare un’occhiata a ECC. Se non lo fai, la repo resta comunque una lettura utile come riferimento pratico per costruire workflow di agenti che non si sfaldano nella pratica.

In ogni caso, ECC è un chiaro segnale che lo sviluppo software si sta muovendo verso pipeline di agenti programmabili invece che sessioni di chat “one shot”. I framework per farlo bene sono ancora nuovi, ed ECC è uno dei tentativi più completi finora. Non sarà l’ultimo, ed è questo il punto.

Se sei alle prime armi con l’AI generativa e il coding con agenti, iscriviti al nostro corso Generative AI Concepts. Ti darà basi solide per il futuro.