# ecc (Everything Claude Code)

- **Autore:** Affaan Mustafa (affaan-m)
- **Repository:** [affaan-m/everything-claude-code](https://github.com/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](https://github.com/affaan-m/everything-claude-code), [AGENTS.md](https://github.com/affaan-m/everything-claude-code/blob/main/AGENTS.md), cartelle `agents/`, `skills/`, `hooks/`, `rules/`
- **Pagina su skills.sh:** [affaan-m/ecc](https://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](https://github.com/unju-ai/ecc) o [ysyecust/everything-claude-code](https://github.com/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](superpowers.md).

## 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:

```text
/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):

```bash
npx ecc-universal@2.2.3 setup
```

**Claude Code, comandi del plugin:**

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

**Codex, plugin nativo:**

```bash
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:

```bash
npx ecc-universal@2.2.3 install --guided
```

**Installazione manuale o minima**, da una copia del repository:

```bash
./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`.

```bash
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:

```bash
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](https://github.com/affaan-m/everything-claude-code)
- [AGENTS.md](https://github.com/affaan-m/everything-claude-code/blob/main/AGENTS.md)
- [hooks/README.md](https://github.com/affaan-m/everything-claude-code/blob/main/hooks/README.md)
- [Cartella agents/](https://github.com/affaan-m/everything-claude-code/tree/main/agents)
- [Release del progetto](https://github.com/affaan-m/everything-claude-code/releases)
- [ecc su skills.sh](https://skills.sh/affaan-m/ecc)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)