my-skills/skills/ecc.md

ecc (Everything Claude Code)

• Autore: Affaan Mustafa (affaan-m)
• Repository: affaan-m/everything-claude-code (il nome canonico indicato dal progetto è affaan-m/ECC; licenza MIT, versione 2.2.3 del 1 ottobre 2026)
• Sorgenti: README, AGENTS.md, cartelle agents/, skills/, hooks/, rules/
• Pagina su skills.sh: affaan-m/ecc
• Diffusione (ottobre 2026): circa 1,4 milioni di installazioni complessive su skills.sh, che elenca 330 skill; il repository ha circa 292.900 stelle e 43.300 fork su GitHub
• Controlli di sicurezza su skills.sh: la pagina del repository non riporta esiti
• Canali ufficiali (indicati dal progetto): il repository GitHub, i pacchetti npm ecc-universal e ecc-agentshield, la GitHub App, il plugin ecc@ecc e il sito ecc.tools. Il progetto avverte che copie non ufficiali possono contenere malware.

Non è una skill ma un sistema di ottimizzazione per agenti di sviluppo: 71 agenti, 314 skill, 98 comandi, hook, regole e uno scanner di sicurezza. I numeri sono quelli della pagina GitHub alla versione 2.2.3; skills.sh ne conta 330 e altre fonti, di versioni diverse, ne danno altri. Esistono molti fork (per esempio unju-ai/ecc o ysyecust/everything-claude-code, quest'ultimo adattato al C++20); questa scheda riguarda solo il repository di affaan-m.

A cosa serve

Dà all'agente un flusso di lavoro di ingegneria software strutturato: pianificare prima di costruire, scrivere i test per primi, farsi rivedere il codice da un agente con contesto pulito, verificare, e ricordare quanto imparato tra le sessioni. Invece di aggiungere una sola metodologia, offre un catalogo molto ampio di specialisti (revisori e risolutori di errori di build per ogni linguaggio) e di automazioni, da cui scegliere ciò che serve. È un'alternativa più grande e più invasiva di superpowers.

Cosa fa

Quando si attiva

I componenti partono in modi diversi:

• agenti: l'agente principale li delega quando il compito corrisponde (per esempio un revisore di Go dopo una modifica a codice Go);
• skill: si attivano quando la richiesta corrisponde alla loro descrizione;
• comandi: li lanci tu (/ecc:plan, /code-review...);
• hook: scattano da soli prima e dopo gli strumenti dell'agente e a inizio e fine sessione;
• regole: sono sempre caricate, se le copi nella cartella delle regole.

Come lavora

Il flusso di sviluppo indicato dal progetto:

1. Pianifica le funzioni complesse prima di scrivere codice (/ecc:plan "...", agente planner).
2. Test per primi: prima un test che fallisce, poi il codice minimo per farlo passare, poi il rifacimento; obiettivo di copertura dell'80% o più con test unitari, di integrazione ed E2E (agente tdd-guide).
3. Revisione con contesto pulito (/code-review), più revisori per linguaggio e per sicurezza (security-reviewer) prima dei commit.
4. Documentazione aggiornata nel posto giusto (doc-updater), poi commit con messaggi in stile conventional commits.

Principi dichiarati: delegare i compiti di dominio ad agenti specializzati e lanciare in parallelo quelli indipendenti; sicurezza prima di tutto (convalida degli ingressi, niente segreti scritti nel codice, query parametrizzate); immutabilità (creare nuovi oggetti invece di modificare quelli esistenti).

Comandi principali:

/ecc:plan "..."                 # pianificazione
/code-review                    # revisione con contesto pulito
/build-fix  /refactor-clean  /security-scan
/context-budget  /save-session  /resume-session
/skill-create  /mcp  /evolve
agentshield scan --path .       # audit della configurazione dell'agente

I comandi sono mantenuti per compatibilità: il progetto dice che i nuovi flussi vanno scritti come skill.

Cosa contiene

Cartella	Contenuto
agents/	71 sottoagenti specializzati
skills/	314 skill di flusso di lavoro e di conoscenza di dominio: la superficie principale
commands/	98 comandi, mantenuti per compatibilità
hooks/	automazioni a eventi
rules/	regole sempre valide, comuni e per linguaggio
scripts/	utilità Node.js multipiattaforma
mcp-configs/	14 configurazioni di server MCP
tests/	batteria di test del progetto

Agenti, per gruppo (l'elenco completo è in agents/):

Gruppo	Agenti
Flusso base	planner, architect, tdd-guide, code-reviewer, security-reviewer, spec-miner (ricava specifiche da progetti esistenti), doc-updater, refactor-cleaner, e2e-runner (Playwright), docs-lookup (documentazione via Context7)
Linguaggi e framework	revisori e, dove serve, risolutori di errori di build per C/C++, F#, Go, Kotlin, Python/Django/FastAPI, Java/Spring, Rust, PyTorch, TypeScript/JavaScript, React, Vue, Swift, Flutter/Dart, C#/.NET, PHP, HarmonyOS e database (PostgreSQL/Supabase)
Analisi della qualità	silent-failure-hunter (errori ingoiati), type-design-analyzer, pr-test-analyzer, code-explorer, code-simplifier, comment-analyzer, agent-evaluator
Prestazioni e architettura	performance-optimizer, code-architect, a11y-architect (accessibilità WCAG 2.2), harness-optimizer, loop-operator
Reti	network-architect, homelab-architect, network-config-reviewer, network-troubleshooter
ML	mle-reviewer, rag-pipeline-reviewer
Pubblicazione open source	opensource-forker, opensource-sanitizer, opensource-packager
Altri ambiti	healthcare-reviewer, chief-of-staff (smista e scrive la posta), marketing-agent, seo-specialist, bengali-reviewer, conversation-analyzer
GAN harness	gan-planner, gan-generator, gan-evaluator

L'elenco delle skill non l'ho trovato in forma ordinata: i documenti letti citano solo i linguaggi e i framework coperti (Go, Python, Perl, Swift, TypeScript, HarmonyOS/ArkTS, Django, NestJS, Spring Boot, Laravel). Non ho letto i singoli SKILL.md.

Hook installati

Secondo hooks/README.md:

Momento	Cosa fanno
Prima di uno strumento	blocca npm run dev e simili fuori da tmux; ricorda tmux per i comandi lunghi; ricorda di rivedere le modifiche prima del push; controllo prima del commit (analizza i file in stage, convalida i messaggi di commit, cerca console.log, debugger e segreti, e blocca sui problemi gravi); avvisa per file .md o .txt non standard; suggerisce /compact ogni circa 50 chiamate; valuta le regole locali di Hookify
Dopo uno strumento	registra l'URL della PR dopo gh pr create; analisi in background dopo le build; controlli rapidi di qualità; formatta i file JS/TS con Prettier; esegue tsc --noEmit dopo le modifiche a .ts/.tsx; avvisa dei console.log
Inizio sessione	carica il contesto precedente, riconosce il gestore dei pacchetti
Prima della compattazione	salva lo stato
Fine sessione	salva il riepilogo della sessione, estrae schemi per l'apprendimento continuo, registra una stima dei costi, mostra una notifica sul desktop (macOS)

Si regolano con variabili d'ambiente: ECC_HOOK_PROFILE (minimal, standard predefinito, strict), ECC_DISABLED_HOOKS (elenco di identificatori separati da virgole, per esempio pre:bash:tmux-reminder,post:edit:typecheck), ECC_HOOKS_ENABLED come interruttore generale e ECC_GATEGUARD=off per spegnere solo GateGuard.

Da sapere

• Invasivo: installa hook che girano a ogni comando e a ogni modifica, scrivono script sotto ~/.claude/ e salvano lo stato delle sessioni (riepiloghi, schemi appresi, stime dei costi). La documentazione degli hook non dice dove finiscano questi file né cosa contengano, e non descrive chiamate di rete.
• Contesto: regole e server MCP consumano la finestra di contesto. Il progetto consiglia poche regole (le regole comuni più un solo linguaggio), meno di 10 server MCP e meno di 80 strumenti attivi. Il plugin non attiva da solo i server MCP inclusi.
• Un solo metodo di installazione per strumento: sovrapporne più di uno duplica skill, comandi e hook (errori come "Duplicate hooks file"). Se usi il plugin, non copiare a mano hooks/hooks.json nelle impostazioni.
• Impostazioni consigliate dal progetto: modello Sonnet come predefinito, sforzo medio, compattazione del contesto al 50% invece che al 95%.
• Requisiti: Node.js 18 o più recente; per il plugin di Claude Code anche Git e Claude Code 2.1 o più recente nel PATH. Alcune funzioni facoltative su Windows nativo e macOS richiedono Bash, Python o WSL.
• Servizi a pagamento: il progetto si finanzia con sponsor e un livello a pagamento, ECC Pro (GitHub App ospitata con analisi dei repository privati e verifiche sulle PR). Il resto è libero.
• Sicurezza: include AgentShield (scanner delle configurazioni degli agenti, con analisi approfondita facoltativa basata su Opus), GateGuard e un controllo della catena di fornitura nella CI. Sono dichiarazioni del progetto: non le ho verificate.
• Maturità e supporto: Claude Code è il riferimento stabile; Codex e Qoder hanno plugin nativi con meno hook; Cursor e OpenCode sono adattatori in beta; GitHub Copilot ha solo istruzioni in chat e skill/agenti in beta nella CLI; Gemini, Zed, Antigravity, Qwen, Hermes, OpenClaw, Kimi, CodeBuddy e JoyCode sono sperimentali. Il progetto non dichiara parità di funzioni fuori da Claude Code.
• Memoria condivisa (Memory Vault): passaggio di consegne tra strumenti in Markdown, installato a parte da npm. La memoria richiamata va trattata come contesto non verificato, non come istruzioni.
• Fonti non lette per intero: ho letto il README quasi per intero, ma non le guide collegate (installazione dettagliata, risoluzione dei problemi, Windows) né i singoli file di skill e agenti.

Installazione

Claude Code e Codex

Claude Code, installazione guidata (consigliata dal progetto):

npx ecc-universal@2.2.3 setup

Claude Code, comandi del plugin:

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

Codex, plugin nativo:

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json

Più strumenti insieme (Claude Code, Codex, Kimi Code), con procedura guidata:

npx ecc-universal@2.2.3 install --guided

Installazione manuale o minima, da una copia del repository:

./install.sh --profile minimal --target claude
./install.sh --profile full --enable-hooks

Opzione	Significato
--profile minimal / --profile full	insieme ridotto o completo di componenti
--target claude	strumento di destinazione
--enable-hooks / --no-hooks	una delle due va indicata se l'installazione aggiungerebbe hook

Altre vie descritte dal progetto: Qoder CLI (qoder plugins install .), Cursor, OpenCode e altri tramite adattatori; non le ho provate.

Regole: i plugin di Claude Code non le distribuiscono. Copia rules/common più un solo pacchetto per il tuo linguaggio in ~/.claude/rules/ecc/, e tienile poche perché sono sempre caricate.

Dopo l'installazione riavvia la sessione. Non fare due installazioni diverse sullo stesso strumento.

Gestione: il progetto indica i comandi list-installed, doctor, repair e uninstall --dry-run per vedere, riparare o togliere un'installazione, e dice che rilanciare l'installazione guidata aggiorna ECC o ne cambia l'ambito e il profilo degli hook. La sintassi esatta non l'ho verificata. Per il plugin vale il gestore dei plugin dell'agente (/plugin in Claude Code); per un aggiornamento di versione cambia il numero nel comando npx.

npx skills add affaan-m/ecc          # solo le skill, senza agenti, hook e regole

Quest'ultimo comando è la forma standard dello strumento skills per i repository di skill, che skills.sh elenca per questo progetto: non l'ho provato e porta solo le skill, non l'insieme intero.

App desktop di Claude e ChatGPT

Queste app caricano una skill alla volta come ZIP; il plugin completo non si può installare, e perdi agenti, hook e regole, che sono la parte principale. Per provare una singola skill:

git clone --depth 1 https://github.com/affaan-m/ECC.git
cd ECC/skills && zip -r ~/<nome-skill>.zip <nome-skill>

Lo ZIP deve contenere la cartella della skill con dentro SKILL.md.

Claude (desktop o web)

1. Attiva l'esecuzione del codice in Settings → Capabilities.
2. Vai in Customize → Skills → + → Create skill → Upload a skill e scegli lo ZIP.
3. Attiva l'interruttore della skill.

ChatGPT (desktop o web)

1. Vai in Skills nella barra laterale, poi Create → Upload from your computer, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con @ nella chat.

Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.

Limite: qui non ha senso usarlo come sistema. ECC lavora con sottoagenti, hook, regole e comandi su un progetto locale, e le app di chat non li hanno. Una singola skill di conoscenza può funzionare, ma senza il resto del flusso; non ho verificato come reagiscono le app a una skill che presuppone altri componenti.

Fonti

• README di affaan-m/everything-claude-code
• AGENTS.md
• hooks/README.md
• Cartella agents/
• Release del progetto
• ecc su skills.sh
• Use skills in Claude – Claude Help Center
• Skills in ChatGPT – OpenAI Help Center