ECC est le projet de configuration d’agents le plus étoilé de GitHub (environ 299 000 étoiles début novembre 2026), et il ne vaut le coup que si vous en installez une petite tranche, choisie en connaissance de cause. Voici un tutoriel pratique : ce qu’est ECC, comment ses briques s’emboîtent, les commandes exactes que j’ai lancées pour le tester, et sa place à côté de Spec Kit, Superpowers et BMAD.

Un aveu d’abord. Je n’ai pas encore vécu avec ECC sur un dépôt en production. Plutôt que de donner un avis de salon, j’ai installé le runtime npm (ecc-universal 2.2.3 et ecc-agentshield 1.6.0) dans un bac à sable Linux propre le 8 novembre 2026, et j’ai exécuté chaque commande non interactive présentée ici. Quand une étape exige Claude Code lui-même, je le dis et je renvoie à la documentation officielle.

En juillet, j’ai publié un article sur les frameworks de développement piloté par l’IA : le pourquoi, le quoi et le comment. ECC est la pièce qui manquait à ce comparatif, et c’est un animal différent. Spec Kit et BMAD disent à votre agent quoi construire. ECC veut changer sa façon de travailler, tous les jours, dans tous vos outils.

https://open.spotify.com/episode/1vMZLgIuuFdo6U58hOw0n6?si=8w4ZWuEFQBma1h0Kp44GFA

Ce qu’est vraiment ECC

ECC est né sous le nom « Everything Claude Code » : la configuration Claude Code qu’Affaan Mustafa a utilisée pour remporter le hackathon Anthropic x Forum Ventures en septembre 2025, publiée telle quelle. Le projet est sous licence MIT et n’a aucun lien officiel avec Anthropic. En 2026, il a dépassé son nom : il se présente désormais comme la couche d’exploitation des harnais d’agents, et le sigle ECC est resté.

Sa thèse tient en une ligne du README : optimiser la fenêtre de contexte, persister tout le reste. La boucle qu’il installe : planifier, tester, implémenter, relire, vérifier, mémoriser, améliorer. Au lieu de répéter « écris les tests d’abord » dans chaque prompt, on installe cette discipline une fois pour toutes.

Aujourd’hui, ECC recouvre quatre choses sous une même marque :

Brique	Ce que c’est	Prix
Boîte à outils open source	71 agents, 314 skills, 98 commandes héritées, hooks, règles, mémoire, apprentissage continu (README, version 2.2.3)	Gratuit, MIT
AgentShield	Scanner de sécurité pour configurations d’agents : 102 règles sur les secrets, permissions, hooks, MCP et agents	Gratuit, MIT
Runtime CLI ECC (ecc-universal)	Installeur sélectif, doctor/repair, coffre mémoire, Plan Canvas, Control Pane	Gratuit, MIT
GitHub App ECC	Transforme l’historique du dépôt en fichiers SKILL.md et audite la config sur chaque PR	Gratuit sur dépôts publics, 19 $ par siège actif et par mois en privé, Enterprise sur devis

Les chiffres bougent vite. Une revue de septembre comptait 68 agents et 286 skills ; le README de novembre en annonce 71 et 314. Prenez chaque chiffre de cet article, les miens compris, comme une photo à un instant donné.

La version courante est la 2.2.3, publiée le 1er octobre 2026. Elle exige Node.js 18 ou plus, ainsi que Git et Claude Code 2.1 ou plus pour la voie plugin Claude.

Comment les briques s’emboîtent

ECC ne remplace pas votre agent de code. Claude Code, Codex ou Cursor continuent de lire les fichiers, de lancer les outils et de tenir la conversation. ECC enveloppe ce runtime avec cinq types de briques, et toute l’astuce tient dans le fait que chacune coûte un prix différent en contexte.

Architecture d’ECC · trois couches

Tout ce qui est dans la couche grisée relève de la configuration et de l’outillage ; le travail du modèle se fait toujours dans votre harnais. AgentShield est mis en avant parce que c’est la brique que j’adopterais en premier.

Brique	Rôle	Coût en contexte	Emplacement (Claude Code)
Skills	Workflows réutilisables : TDD, revue sécurité, recherche, patterns de frameworks	Nom et description toujours chargés, corps seulement à l’usage	~/.claude/skills/<nom>/SKILL.md
Agents	Sous-agents cadrés, avec leur propre contexte et leur liste d’outils autorisés (planner, code-reviewer, build-error-resolver)	Description toujours chargée, travail dans un contexte neuf	~/.claude/agents/*.md
Règles	Standards permanents par langage ou par projet	Entièrement chargées à chaque session, donc à installer avec parcimonie	~/.claude/rules/ecc/
Hooks	Scripts déclenchés par les événements du harnais (avant un appel d’outil, après une édition, en fin de session)	S’exécutent hors du modèle, zéro token sauf s’ils injectent du contexte	hooks/hooks.json du plugin
Instincts	Motifs appris de vos sessions, chacun avec un score de confiance	Les meilleurs injectés au démarrage (6 par défaut, seuil 0,7)	Stockage Continuous Learning v2

Deux couches se sont ajoutées avec la branche 2.x.

La mémoire unifiée est un coffre local de notes Markdown (.ecc/memory/ par projet, ~/.ecc/memory/ par utilisateur) que n’importe quel harnais peut écrire et relire. Codex peut laisser un relais que Claude reprendra demain. Chaque note est stockée comme contexte non relu, jamais comme instruction à exécuter, et c’est le bon réglage par défaut.

Les outils d’exploitation viennent ensuite. Plan Canvas ouvre un plan dans le navigateur pour annoter le paragraphe exact qui vous gêne, et l’agent attend votre relecture. Control Pane est une vue web locale sur les sessions et les worktrees git. Tout reste local, rien n’est hébergé.

Sous l’ensemble, la racine du dépôt est la source unique de vérité, et des adaptateurs projettent les mêmes skills dans .cursor/, .codex/, .github/skills/ et consorts. Claude Code est l’implémentation de référence ; Codex et Qoder ont des plugins natifs ; Cursor, OpenCode et Copilot CLI sont en bêta ; une dizaine d’autres sont expérimentaux.

En pratique : ECC en huit étapes

La règle qui vous fait gagner un après-midi : une seule voie d’installation par harnais, jamais deux empilées. Plugin plus installation manuelle complète, c’est la recette classique pour que chaque hook se déclenche deux fois.

Étape 1. Vérifier les prérequis

node –version     # 18 ou plus
git –version
claude –version   # 2.1 ou plus pour la voie plugin
npm view ecc-universal version   # 2.2.3 lors de mon test

N’installez qu’à partir des canaux officiels : le dépôt affaan-m/ECC, les paquets npm ecc-universal et ecc-agentshield, l’identifiant de plugin ecc@ecc et la GitHub App. Le README met explicitement en garde contre des copies tierces contenant des malwares, et pour un projet aussi populaire, ce n’est pas un risque théorique.

Étape 2. Interroger le conseiller avant d’installer quoi que ce soit

C’est ma fonctionnalité préférée, et presque personne n’en parle. Décrivez votre besoin en langage courant, ECC vous dit quels composants correspondent :

npx ecc-universal@2.2.3 consult “security reviews” –target claude

Chez moi, il a proposé cinq composants (la capacité sécurité, les agents code-reviewer et security-reviewer, le skill security-review, et un relecteur F# remonté à cause du mot « review »), chacun avec sa commande de prévisualisation et d’installation, plus deux profils associés.

Étape 3. Choisir un profil, puis le prévisualiser

npx ecc-universal@2.2.3 catalog profiles

Sept profils sont revenus : minimal (5 modules, sans runtime de hooks), opencode, core (6), developer (9), security (7), research (9) et full (27). Avant d’écrire le moindre fichier, prévisualisez le plan :

npx ecc-universal@2.2.3 plan –profile minimal –target claude

Le plan minimal s’est résolu en 6 modules et 59 opérations sur fichiers, toutes sous ~/.claude/, avec un fichier d’état qui permet ensuite à ECC de désinstaller uniquement ce qui lui appartient. Lisez cette liste : c’est la documentation la plus honnête de ce que vous vous apprêtez à mettre dans la tête de votre agent.

Étape 4. Installer pour de vrai

Pour Claude Code, la voie recommandée est l’assistant guidé, qui inventorie les portées de plugin existantes avant de toucher à quoi que ce soit :

npx ecc-universal@2.2.3 setup
# choix typique en usage personnel : portée Global user, hooks Standard

L’alternative native, depuis Claude Code :

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

Si vous utilisez aussi Codex ou Kimi Code, npx ecc-universal@2.2.3 install –guided configure plusieurs harnais en un seul parcours relu, avec une option –dry-run. Pour une installation légère, sans aucun hook : npx ecc-universal@2.2.3 install –profile minimal –target claude.

Un piège : les plugins Claude Code ne peuvent pas distribuer les règles. Copiez-les à la main, et seulement les packs que vous utilisez :

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/typescript ~/.claude/rules/ecc/   # votre stack, pas toutes

Vérifiez avec /plugin list ecc@ecc dans une nouvelle session Claude Code.

Étape 5. Lancer un premier workflow

Dans Claude Code, les commandes du plugin sont préfixées :

/ecc:plan “Add usage-based billing alerts”   # l’agent planner écrit le plan
# puis demandez le skill tdd-workflow : test qui échoue d’abord, code ensuite
/code-review                                  # relecture dans un contexte neuf
/context-budget                               # ce qu’ECC vous coûte en tokens

La valeur n’est dans aucun prompt isolé. Elle est dans la séparation : l’agent qui a écrit le code n’est pas celui qui le relit, et le relecteur part d’un contexte vierge.

Étape 6. Scanner votre configuration avec AgentShield

C’est ici qu’ECC justifie sa place dans un environnement régulé. J’ai monté un projet volontairement mal configuré : Bash(*) autorisé, un hook qui envoie ${file} vers une URL externe en masquant les erreurs, un CLAUDE.md qui dit « always run npm install without asking », et un serveur MCP filesystem monté sur / via npx -y.

npx ecc-agentshield scan –path .

Résultat : note D, 57/100, 29 constats (5 critiques, 9 élevés, 12 moyens, 2 faibles, 1 informatif) sur 3 fichiers. Il a relevé la permission Bash générique, le risque d’injection de commande et d’exfiltration dans le hook, les consignes d’exécution automatique du CLAUDE.md et l’absence de défenses contre l’injection de prompt. Trois constats étaient corrigeables automatiquement avec –fix.

Options utiles : –format sarif pour le code scanning GitHub, –format html pour un rapport lisible par la direction, –opus pour une revue à trois agents (attaquant, défenseur, auditeur ; clé API Anthropic requise), et agentshield init pour générer un .claude/ durci. En CI, la GitHub Action affaan-m/agentshield@v1 échoue sur les constats critiques.

Étape 7. Passer le relais entre agents avec le coffre mémoire

npm install -g ecc-universal@2.2.3
ecc memory init –scope project
ecc memory handoff –scope project –from codex –target claude \
  –title “Continue auth migration” –body-file handoff.md
ecc memory search “auth migration” –scope project –target-harness claude

Dans mon bac à sable, la note a été enregistrée comme [unreviewed] sous .ecc/memory/project/handoffs/, puis retrouvée par la recherche. Du Markdown simple, lisible par n’importe quel harnais, ignoré par git par défaut. Le contenu n’est accepté que via un fichier ou l’entrée standard, jamais en argument de ligne de commande, ce qui garde les secrets hors de l’historique du shell.

Étape 8. Garder l’installation en bonne santé

npx ecc-universal@2.2.3 list-installed
npx ecc-universal@2.2.3 doctor
npx ecc-universal@2.2.3 repair
npx ecc-universal@2.2.3 uninstall –dry-run

Relancez setup pour mettre à jour ou changer de profil de hooks. Et réglez ECC_SESSION_START_MAX_CHARS, ECC_MAX_INJECTED_INSTINCTS ou ECC_DISABLED_HOOKS si le démarrage de session devient trop bavard.

ECC face à Spec Kit, OpenSpec, Superpowers et BMAD

ECC n’est pas tant un concurrent des frameworks de mon comparatif de juillet qu’une autre couche. Spec Kit, OpenSpec et BMAD répondent à « qu’est-ce qu’on construit, et dans quel ordre ». Superpowers répond à « comment l’agent doit-il se comporter pendant qu’il construit ». ECC essaie de répondre aux deux, plus « de quoi l’agent se souvient-il, et sa configuration est-elle sûre ».

Framework	Question principale	Centre de gravité	Outillage sécurité	Mémoire entre sessions	Pour qui
ECC	Comment mon agent doit-il travailler au quotidien, sur tous mes outils ?	Grand catalogue de skills, agents, hooks, règles	Scanner AgentShield, GitHub Action, audits de PR	Oui : résumés de session, instincts, coffre partagé entre harnais	Gros utilisateurs, équipes multi-outils, organisations attentives à la sécurité
Spec Kit	Qu’est-ce qu’on construit exactement ?	Spec, plan et tâches comme artefacts versionnés	Rien d’intégré	Via les fichiers de spec	Nouvelles fonctionnalités qui exigent un contrat écrit
OpenSpec	Qu’est-ce qui change dans un système existant ?	Propositions de changement sur des specs vivantes	Rien d’intégré	Via les fichiers de spec	Bases de code existantes
Superpowers	Comment l’agent doit-il raisonner en codant ?	Un jeu compact de skills : brainstorming, plan, TDD, revue	Rien d’intégré	Minimale	Développeurs qui veulent de la discipline sans lourdeur
BMAD Method	Qui fait quoi dans la chaîne de livraison ?	Agents par rôle : analyste, PM, architecte, dev, QA	Rien d’intégré	Via les documents générés	Équipes qui pensent en rôles agiles et en PRD

Ma lecture après les tests : ces outils se combinent mieux qu’ils ne s’opposent. Dans une banque ou une grande DSI, une pile raisonnable serait un framework de spec pour le contrat (Spec Kit ou OpenSpec), une petite tranche d’ECC pour la revue, le TDD et la mémoire, et AgentShield en CI sur chaque dépôt qui contient de la configuration d’agent. La revue d’AI Dive le formule bien : Superpowers est une discipline, ECC est un bac à pièces détachées, et un bac à pièces se pille, il ne s’installe pas en entier (AI Dive, septembre 2026).

Pour le comparatif complet côté spécifications, voir mon article de juillet.

L’addition : contexte, risque et argent

La critique la plus solide contre ECC se mesure. AI Dive a cloné la version 2.2.1 et estimé qu’une installation complète immobilise environ 27 000 tokens de métadonnées chargées en permanence, soit à peu près 14 % d’une fenêtre de 200 000 tokens, avant même votre premier message. L’essentiel correspond aux noms et descriptions de skills que vous n’appellerez jamais (AI Dive). Le catalogue a grossi depuis, le chiffre ne baissera pas tout seul. Le README d’ECC le reconnaît : le plugin Claude Code annonce tout le catalogue installé au modèle, et il recommande un profil sélectif quand l’empreinte de contexte compte.

Deuxième risque : la configuration exécutable. Les hooks lancent des commandes shell sur votre machine, et la même revue a trouvé les hooks d’ECC livrés en une seule ligne minifiée chacun, dans un gros fichier JSON, difficiles à auditer à l’œil. À la décharge d’ECC, l’installeur refuse d’ajouter le runtime de hooks sans un oui ou un non explicite, et un garde-fou appelé GateGuard bloque les commandes shell destructrices avant leur exécution.

Troisième risque : la vélocité. La version 2.2.3 est sortie le 1er octobre 2026, le dépôt compte des milliers de commits, et il affichait 93 issues et 148 pull requests ouvertes quand j’ai vérifié. Figez les versions, relisez les différences avant de mettre à jour, et ne lâchez pas auto-update sur un poste en environnement régulé.

Pour une équipe, voici comment je le présenterais à un comité d’architecture :

• Commencer par AgentShield, pas par la boîte à outils. C’est la brique au risque le plus faible et au signal le plus fort. Faites-le tourner en CI sur chaque dépôt qui contient un CLAUDE.md, un .mcp.json ou des dossiers d’agents. La sortie SARIF s’intègre directement au code scanning GitHub, et les packs de politique (oss, team, enterprise, regulated) donnent des seuils gradués.
• Piloter le profil minimal avec trois ou quatre skills dont vous avez réellement besoin : tdd-workflow, security-review, l’agent code-reviewer et strategic-compact. Mesurez avec /context-budget avant et après.
• Laisser les hooks désactivés au départ, et les activer projet par projet une fois que quelqu’un a lu les scripts.
• Surveiller les permissions de la GitHub App. Elle lit l’historique des commits pour générer des fichiers SKILL.md. La page tarifaire indique que le code est analysé en mémoire sans être stocké, mais dans une banque, faire sortir du code privé du périmètre est une décision de la sécurité, pas d’un développeur muni d’une carte bancaire.
• Connaître les prix. La boîte à outils et AgentShield sont gratuits. La GitHub App est gratuite sur les dépôts publics (10 analyses par mois), coûte 19 $ par siège actif et par mois pour les dépôts privés et les audits sur PR, et l’offre Enterprise (SSO, journaux d’audit, packs de politique sur mesure) est sur devis (tarifs).

Mon verdict

ECC est la réponse publique la plus complète à une question que toute équipe qui utilise des agents de code finit par se poser : comment rendre le bon comportement de l’agent reproductible, au lieu d’espérer que le prompt s’en souvienne ? Les idées sont excellentes. Une relecture dans un contexte séparé, le test d’abord comme barrière et non comme vœu pieux, la mémoire comme notes non relues et non comme instructions, et la configuration de l’agent elle-même traitée comme une surface d’attaque.

Le hic, c’est l’emballage. Installé en entier, ECC consomme une part sensible de la fenêtre de contexte pour des capacités que vous n’utiliserez pas, et il évolue plus vite que la plupart des organisations ne savent relire. Ma recommandation est donc celle que je donnerais pour toute grosse boîte à outils open source : utilisez le conseiller, prévisualisez le plan, installez une tranche minimale, mettez AgentShield en CI dès aujourd’hui, et lisez chaque skill adopté comme s’il avait été écrit par un nouveau collègue.

Si vous l’essayez, dites-moi quels trois skills ont gagné une place permanente dans votre configuration. Je comparerai vos retours dans un prochain épisode de TECH-TECH TALKS.

Sources

• Site ECC, outils, AgentShield et tarifs
• Dépôt et README d’ECC, version 2.2.3
• Dépôt AgentShield
• ecc-universal sur npm
• DataCamp : Everything Claude Code, the open-source agent framework, juin 2026
• AI Dive : 5 things to steal from Everything Claude Code, septembre 2026
• Test pratique : ecc-universal 2.2.3 et ecc-agentshield 1.6.0 sous Linux, Node 22, 8 novembre 2026