
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Les assistants IA n’ont pas de « mauvaise mémoire ». Ils ont une  . mauvaise gouvernance Vous l’avez vu : 
 
 
 
 Vous avez rédigé un guide d’architecture méticuleux. Le modèle l’ignore. Vous avez dit « architecture à 4 couches ». Il en produit 3. Vous avez dit « pas de   ». Il supprime   comme s’il vous rendait service. el-input <el-input v-model="value" /> Il ne s’agit pas d’intelligence. Il s’agit d’incitations. Dans Claude Code, les  , pas une contrainte stricte. Si Claude « sent » qu’il peut répondre sans appeler une Compétence, il le fera. Et  . Compétences sont un contexte disponible le manuel de votre projet devient une décoration Dans notre équipe, en construisant une base de code RuoYi-Plus avec Claude Code, nous l’avons suivi : 
 
 Sans intervention, Claude activait proactivement les Compétences du projet seulement ~25% du temps. Donc, 3 fois sur 4, vos « règles » ne sont pas des règles. Elles sont une suggestion. Nous voulions quelque chose de plus strict : un mécanisme qui fait que Claude se comporte moins comme un stagiaire intelligent et plus comme un ingénieur expérimenté qui lit le manuel avant d’écrire du code. La solution n’était pas plus de prompts. La solution était les  . Hooks Après environ 1 mois d’itération, nous avons déployé une pile de configuration   : .claude 
 
 
 
 
  (gouvernance) 4 hooks de cycle de vie  (connaissances) 26 Compétences de domaine  (orchestration de processus) commandes slash  (spécialistes parallèles) agents Résultat : 
 
  Moins de code violant les règles, moins de cycles de « veuillez refaire », et beaucoup moins d’actions d’outils risquées. Activation des Compétences pour les tâches de développement : ~25% → 90%+ Cet article détaille l’architecture afin que vous puissiez la reproduire dans votre propre dépôt. 1) Pourquoi Claude Code « oublie » : les Compétences sont opt-in par défaut Le flux par défaut de Claude Code ressemble à ceci : Prompt utilisateur → Claude répond (peut appeler une Compétence, ou non)
 Ce « peut-être » est le problème. L’heuristique de décision interne de Claude est généralement : 
 
 
 « Puis-je répondre rapidement sans contexte supplémentaire ? » pas « Dois-je absolument respecter les règles du dépôt ? » Ainsi, le système dérive vers la commodité. Ce que vous voulez, c’est une   : un « plan de contrôle » léger qui s’exécute   que Claude ne commence à raisonner, et façonne le travail à chaque fois. friction institutionnelle avant 2) La percée : un hook d’évaluation forcée des Compétences Nous avons implémenté un hook qui se déclenche au plus tôt :  . UserPromptSubmit Il imprime un court bloc de politique que Claude voit   de faire quoi que ce soit d’autre : avant 
 
 
 
 Évaluer chaque Compétence : oui/non + raison Si « oui » : appeler la Compétence immédiatement Seulement alors : procéder à l’implémentation Le hook « évaluation forcée » (logique centrale) Nous le gardons délibérément simple et déterministe : 
 
 
 détecter les commandes slash (évasion) sinon imprimer le protocole d’évaluation // .claude/hooks/skill-forced-eval.js (idée centrale, simplifiée)
const prompt = process.env.CLAUDE_USER_PROMPT ?? "";
​
// Évasion : si l'utilisateur a invoqué une commande slash, ignorer l'évaluation forcée
const isSlash = /^\/[^\s/]+/.test(prompt.trim());
if (isSlash) process.exit(0);
​
const skills = [
  "crud-development",
  "api-development",
  "database-ops",
  "ui-pc",
  "ui-mobile",
  // ... continuer (nous en avons 26)
];
​
const instructions = [
  "## Protocole d'activation obligatoire des Compétences (DOIT ÊTRE SUIVI)",
  "",
  "### Étape 1 — Évaluation",
  "Pour CHAQUE compétence, imprimez : [compétence] — Oui/Non — Raison",
  "",
  "### Étape 2 — Activation",
  "Si UNE compétence est Oui → appelez la Compétence(<nom>) immédiatement.",
  "Si TOUTES sont Non → indiquez 'Aucune compétence requise' et continuez.",
  "",
  "### Étape 3 — Implémentation",
  "Seulement après que l'étape 2 soit terminée, commencez la solution réelle.",
  "",
  "Compétences disponibles :",
  ...skills.map(s => `- ${s}`)
].join("\n");
​
console.log(instructions);
 Ce qui change en pratique Avant (pas de hook) : 
 
 « Construisez la gestion des coupons. » Claude commence à coder… et ignore votre architecture à 4 couches ou vos composants interdits. Après (hook d’évaluation forcée) : Claude doit d’abord produire une table de décision explicite, puis activer les Compétences, puis implémenter. Le changement comportemental est spectaculaire car vous éliminez la « conformité optionnelle ». 3) Pourquoi 90% et pas 100% ? Parce que nous avons intentionnellement ajouté un  . chemin rapide Lorsque l’utilisateur sait ce qu’il veut, taper une commande comme : 
 
 
 
 /dev build coupon management /crud b_coupon /check devrait être instantané. Ainsi, le hook ignore l’évaluation des commandes slash et laisse le flux de commande prendre le relais. C’est le compromis : 
 
 
 Gouvernance pour les prompts libres Vitesse pour les commandes structurées 4) Les hooks comme plan de contrôle de cycle de vie (la pile de 4 hooks) Considérez les hooks comme un pipeline CI pour une session d’agent — sauf qu’il s’exécute en direct, dans votre terminal. Nous utilisons quatre points clés : 4.1 SessionStart : « regardez le dépôt avant de parler » Lorsqu’une session démarre, nous affichons : 
 
 
 
 
 branche git actuelle modifications non enregistrées TODOs ouverts / statut commandes courantes Exemple de sortie : 🚀 Session démarrée : RuoYi-Plus-Uniapp
Heure : 2026-02-16 21:14
Branche : master
​
⚠️ Modifications non enregistrées : 5 fichiers
📋 TODO : 3 ouverts / 12 faits
​
Raccourcis :
  /dev    construire une fonctionnalité
  /crud   générer un module
  /check  vérifier les conventions
  Claude arrête de faire comme s’il entrait dans une pièce vide. Pourquoi c’est important : 4.2 UserPromptSubmit : évaluation forcée des Compétences (discipline) C’est la porte d’entrée « il faut lire le manuel ». 4.3 PreToolUse : la couche de sécurité (gouvernance des outils) Claude Code est puissant car il peut exécuter des outils : Bash, écrire des fichiers, modifier du code. C’est aussi ainsi que les accidents arrivent. PreToolUse est votre dernière ligne de défense avant quelque chose d’irréversible. Nous bloquons une petite liste noire (et avertissons sur une liste grise plus large) : // .claude/hooks/pre-tool-use.js (conceptuel)
const cmd = process.env.CLAUDE_TOOL_INPUT ?? "";
​
const hardBlock = [
  /rm\s+(-rf|--recursive).*\s+\//i,
  /drop\s+(database|table)\b/i,
  />\s*\/dev\/sd[a-z]\b/i,
];
​
if (hardBlock.some(p => p.test(cmd))) {
  console.log(JSON.stringify({
    decision: "block",
    reason: "Modèle de commande dangereux détecté"
  }));
  process.exit(0);
}
​
// Facultatif : avertir/confirmer sur les actions sensibles (suppressions massives, chmod -R, etc.)
 Ce n’est pas de la paranoïa. Nous avons vu des modèles « nettoyer les fichiers temporaires » avec   dans le mauvais répertoire. Vous voulez un garde-fou qui ne repose pas sur la prudence du modèle. rm -rf 4.4 Stop : « fermez la boucle » avec des instructions sur la prochaine étape Lorsque Claude a terminé, nous : 
 
 
 
 résumons les modifications de fichiers (nouveaux vs modifiés) suggérons les prochaines actions (exécuter les tests, mises à jour de documentation, commit) déclencherons éventuellement des agents (revue de code) Exemple : ✅ Terminé — 8 fichiers modifiés
​
Prochaines étapes :
- @code-reviewer pour les conventions backend
- SQL modifié : synchroniser les scripts de migration
- Considérer : git commit -m "feat: module coupon"
 L’objectif : éliminer le fossé « ça a marché dans le chat ». 5) Compétences : la couche de connaissances que vous pouvez réellement appliquer Une fois que l’activation est déterministe, les Compétences deviennent ce qu’elles étaient censées être : une  . base de connaissances spécifique au domaine Nous avons créé 26 Compétences couvrant : 
 
 
 
 
 
 
 backend (CRUD, API, DB, annotations, gestion des erreurs) frontend (politique des composants PC, gestion de l’état) mobile (kits UI, contraintes de la plateforme uniapp) intégrations (paiements, WeChat, OSS) qualité (performance, sécurité, détection de bugs) gestion d’ingénierie (architecture, flux git, décisions techniques) Une structure de fichiers de Compétences qui évolue Chaque   suit le même squelette : SKILL.md # Nom de la Compétence
​
## Quand déclencher
- Mots-clés :
- Scénarios :
​
## Règles principales
### Règle 1
Explication + exemple
​
### Règle 2
Explication + exemple
​
## Interdit
- ❌ ...
​
## Code de référence
- path/to/file
​
## Liste de contrôle
- [ ] ...
 Cette cohérence est importante car le modèle apprend comment   les Compétences. consommer 6) Commandes : workflows, pas suggestions Les Compétences résolvent le « qu’est-ce qui est correct ? ». Les Commandes résolvent le « quel est le processus ? ». 6.1   : un pipeline de développement en 7 étapes /dev Nous avons conçu   comme un workflow opinionné : /dev 
 
 
 
 
 
 
 
 clarifier les exigences conception (API + modules + permissions) conception de la base de données (SQL + dictionnaires + menus) backend (sortie à 4 couches) frontend (politique des composants + routage) test/vérification documentation/mise à jour de la progression C’est essentiellement : « comment les seniors veulent que les juniors travaillent » encodé comme un script exécutable. 6.2   : générer un module complet à partir d’une table /crud Entrée : /crud b_coupon
 Sortie (ensemble d’exemples) : 
 
 
 
 
 
 Entité / BO / VO Règles DAO + Query wrapper Service + Contrôleur (pas de modèles interdits) Mapper API frontend + scaffold de page Effort manuel :     Piloté par commande :   (plus revue) 2–4 heures 5–10 minutes 6.3   : linting des conventions full-stack (lisible par l’homme) /check C’est là que nous transformons les Compétences en vérificateur : 
 
 
 
 backend : règles de superposition, héritage interdit, politique du wrapper de requête frontend : composants interdits, utilisation du wrapper mobile : kit de composants, unités, importations 7) Agents : spécialistes parallèles (ne surchargez pas le thread principal) Certaines tâches devraient être gérées par un sous-agent dédié : 
 
 
  : vérifications de conventions avec une liste de contrôle stricte @code-reviewer  : mise à jour des documents de statut, TODOs, métriques de progression @project-manager L’avantage n’est pas « plus d’intelligence ». C’est la   et la réduction de la pollution du contexte dans la session principale. séparation des préoccupations Un modèle pratique : 
 
 
 
 
 l’agent principal génère du code le hook Stop suggère une revue vous invoquez  @code-reviewer le réviseur renvoie un diff structuré + une liste de corrections 8) Le système complet : gouvernance + connaissances + processus + division du travail C’est l’architecture en une phrase : 
 
 Les Hooks appliquent le comportement, les Compétences fournissent les normes, les Commandes codent les workflows, les Agents gèrent l’expertise parallèle. Et oui — c’est ainsi que vous transformez un « assistant IA général » en un « coéquipier natif du dépôt ». 9) Configuration minimale reproductible (copier-coller amicale) Si vous voulez la version la plus petite qui fonctionne toujours, construisez ceci : .claude/
  settings.json
  hooks/
    skill-forced-eval.js
    pre-tool-use.js
  skills/
    crud-development/
      SKILL.md
 Configuration minimale   (hook UserPromptSubmit) settings.json {
  "hooks": {
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "node .claude/hooks/skill-forced-eval.js"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "node .claude/hooks/pre-tool-use.js"
          }
        ]
      }
    ]
  }
}
 Ensuite, itérez : 
 
 
 
 
 
 ajoutez SessionStart ajoutez Stop développez les Compétences seulement lorsque vous constatez un « comportement incorrect » répété encodez les workflows répétés sous forme de commandes déchargez la revue/les tâches de gestion de projet aux agents Clôture : la « capacité » n’est pas le goulot d’étranglement —   l’est l’activation Votre modèle est déjà capable. Ce qui manque, c’est un  . système qui rend le bon comportement automatique Un nouvel employé intelligent sans manuel improvisera. Un nouvel employé intelligent avec : 
 
 
 
 
 des listes de contrôle appliquées des modèles interdits clairs des workflows reproductibles des spécialistes pour les revues et la gestion de projet …deviendra rapidement cohérent. Claude est pareil.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Branch

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

Comment construire une couche de gouvernance pour le code Claude avec des hooks, des compétences et des agents

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Boostez votre productivité avec ces 18 outils de développement 🚀🔥

Le guide complet pour réussir une migration vers le cloud : stratégies et bonnes pratiques

Comment améliorer votre flux de travail par 10 : 17 applications essentielles

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Boostez votre productivité avec ces 18 outils de développement 🚀🔥

Le guide complet pour réussir une migration vers le cloud : stratégies et bonnes pratiques

Comment améliorer votre flux de travail par 10 : 17 applications essentielles

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps