Claude Code : skills, hooks, sous-agents et plugins

Claude Code : bien plus qu’un assistant terminal

Claude Code est l’agent en ligne de commande d’Anthropic. Il lit votre code, modifie vos fichiers, exécute des commandes, gère vos commits Git. Jusque-là, rien de très différent d’un Cursor ou d’un Copilot. Ce qui le distingue, c’est l’écosystème d’extensibilité qui s’est construit autour : skills, hooks, subagents, équipes d’agents, plugins. Claude Code n’est pas un assistant passif. C’est une plateforme sur laquelle vous construisez vos propres workflows.

Voici ce que chaque brique apporte.

Les Skills : des capacités sur mesure

Un skill est un fichier Markdown (SKILL.md) qui contient des instructions réutilisables. Quand Claude Code le charge, il sait faire quelque chose de nouveau : déployer, auditer, créer un composant selon vos conventions, lancer une suite de tests avec un protocole précis.

Les skills vivent à trois endroits :

• ~/.claude/skills/ pour vos skills personnels (disponibles dans tous vos projets)
• .claude/skills/ dans le repo pour les skills partagés avec l’équipe
• Dans les plugins (voir plus bas)

Par défaut, un skill se déclenche de deux façons : vous l’appelez par une commande slash (/deploy, /review, /scaffold-component), ou Claude le charge de lui-même quand le contexte le justifie. Le champ disable-model-invocation: true le réserve à la commande slash ; le champ user-invocable: false le réserve à Claude, pour des connaissances de fond.

Ce qui rend les skills puissants, c’est qu’ils sont dynamiques. Vous pouvez utiliser $ARGUMENTS pour injecter des paramètres, et la syntaxe !`commande` pour injecter le résultat d’une commande au moment du chargement.

Un exemple concret, un skill /deploy :

---
name: deploy
description: Run tests, build, and deploy to production
disable-model-invocation: true
---

# Deploy workflow

1. Run the full test suite: `npm test`
2. If tests pass, build the project: `npm run build`
3. Deploy to Cloudflare Pages: `npx wrangler pages deploy dist/`
4. Verify the deployment is live by checking the production URL
5. If any step fails, stop and report the error. Do NOT continue

L’avantage par rapport à un script bash : Claude Code adapte son comportement si quelque chose ne se passe pas comme prévu. Un test qui échoue ne produit pas un message d’erreur cryptique dans votre terminal, mais une explication de ce qui a cassé et une proposition de correction.

Les Hooks : automatiser les garde-fous

Les hooks sont des actions qui s’exécutent automatiquement à des moments précis du cycle de vie de Claude Code. Avant qu’il utilise un outil (PreToolUse), après (PostToolUse), quand vous soumettez un prompt (UserPromptSubmit), quand il s’arrête (Stop), ou quand il envoie une notification.

Plusieurs types de handlers existent, dont :

• command : exécute une commande shell, qui reçoit le détail de l’action en JSON sur son entrée standard
• http : envoie ce même JSON à une adresse web
• prompt : soumet la décision à Claude en un seul échange
• agent : lance un sous-agent avec accès aux outils (expérimental)

Une commande bloque l’action en sortant avec le code 2, ou en renvoyant une décision deny.

Le cas d’usage le plus immédiat : empêcher les erreurs avant qu’elles n’arrivent. Un hook PreToolUse sur l’outil Bash peut bloquer un git push --force sur main. Un hook PostToolUse sur l’outil Edit peut lancer un linter après chaque modification de fichier.

Exemple de configuration dans .claude/settings.json, où chaque script lit le JSON de l’action sur son entrée standard :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/lint.sh"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-force-push.sh"
          }
        ]
      }
    ]
  }
}

Les hooks transforment Claude Code d’un agent autonome en un agent autonome avec des rails. C’est la différence entre donner les clés de la voiture et donner les clés de la voiture avec un GPS et des limites de vitesse.

Les Subagents : déléguer intelligemment

Quand une tâche est trop grosse ou trop spécialisée, Claude Code peut lancer des sous-agents via l’outil Agent (appelé Task jusqu’à la version 2.1.63). Chaque sous-agent a sa propre conversation, son propre contexte, et peut tourner en arrière-plan pendant que l’agent principal continue.

Plusieurs types de sous-agents sont disponibles par défaut :

• Explore : lecture seule, rapide, idéal pour la recherche dans le code
• Plan : recherche du contexte pendant le mode plan, avant de présenter un plan
• General-purpose : tâches complexes en plusieurs étapes, exploration et action

Vous pouvez aussi créer des sous-agents custom dans .claude/agents/ avec un frontmatter YAML. Vous pouvez y restreindre les outils disponibles, imposer un modèle ou fixer un mode de permission.

---
name: security-reviewer
description: Reviews code changes for security issues
model: sonnet
tools:
  - Read
  - Grep
  - Glob
---

You are a security reviewer. Analyze the code changes for:
- SQL injection vulnerabilities
- XSS vectors
- Hardcoded secrets
- Insecure dependencies

Report findings with severity (critical/high/medium/low) and file locations.
Do NOT modify any files.

Une limite à connaître : par défaut, un sous-agent peut lancer ses propres sous-agents jusqu’à trois niveaux sous la conversation principale. Cette profondeur bornée évite les boucles sans fin, mais impose de bien penser la décomposition des tâches.

Les Agent Teams : orchestrer un essaim

Les Agent Teams poussent le concept un cran plus loin : plusieurs instances de Claude Code travaillent en parallèle, coordonnées par un chef d’équipe. C’est une fonctionnalité expérimentale, désactivée par défaut, qui s’active par la variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS.

Le principe : un agent leader crée une équipe, spawne des coéquipiers spécialisés, et répartit les tâches via une liste partagée. Chaque agent peut envoyer des messages aux autres, signaler un blocage, ou marquer une tâche comme terminée.

Un cas d’usage typique : vous avez une feature full-stack à implémenter. Le leader décompose le travail, assigne le frontend à un agent, le backend à un autre, et les tests à un troisième. Les trois travaillent en parallèle. Quand l’agent backend termine son endpoint, il le signale, et l’agent frontend peut commencer l’intégration.

Les outils principaux : Agent pour lancer les coéquipiers, TaskCreate et TaskUpdate pour la liste de tâches partagée, SendMessage pour la communication entre agents.

C’est puissant, mais cela demande un CLAUDE.md bien structuré pour que chaque agent ait le contexte nécessaire sans intervention manuelle.

Le contexte partagé : CLAUDE.md et mémoire

Le fichier CLAUDE.md est le cerveau de la configuration. Claude Code le lit automatiquement au démarrage et s’y réfère tout au long de la session. Il existe à plusieurs niveaux :

• Projet (.claude/CLAUDE.md ou CLAUDE.md à la racine) : conventions de code, architecture, stack technique
• Utilisateur (~/.claude/CLAUDE.md) : préférences personnelles, guidelines globales
• Local (CLAUDE.local.md à la racine du projet) : préférences personnelles pour ce projet, à exclure de Git

Le dossier .claude/rules/ permet de modulariser les instructions avec des fichiers séparés : testing.md, security.md, style.md. Chaque fichier est chargé comme une règle additionnelle.

Claude Code dispose aussi d’une mémoire automatique. Entre les sessions, il retient les patterns qu’il apprend sur votre codebase : conventions de nommage, structure de tests, préférences de formatting. Cette mémoire se cumule et rend l’agent plus efficace au fil du temps.

Conseil pratique : mettez dans le CLAUDE.md projet les conventions que tout le monde doit suivre (architecture, nommage, stack). Mettez dans votre CLAUDE.md personnel vos préférences de style (verbosité des messages, langue, comportement face à l’ambiguïté).

Et Claude Cowork

Claude Cowork applique la même logique agentique au travail de bureau, sur vos dossiers et vos outils, et il a profondément changé en 2026 : fusion avec la conversation, exécution dans le nuage, contrôles d’entreprise. Ces évolutions sont traitées dans notre guide Claude Cowork en entreprise.

Les Plugins : tout assembler

Les plugins sont le mécanisme d’empaquetage. Un plugin regroupe des skills, des hooks, des agents custom et des serveurs MCP dans un seul package installable. Chaque élément est namespacé : /marketing:brand-voice, /legal:contract-review.

Anthropic maintient des plugins officiels sur GitHub pour plusieurs domaines : legal, sales, marketing, data. La communauté en publie d’autres. Vous pouvez aussi créer les vôtres pour vos workflows internes.

L’intégration MCP (Model Context Protocol) est la couche qui connecte les plugins au monde extérieur : bases de données, API, outils SaaS. Un serveur MCP transforme n’importe quelle source de données en outil que Claude Code peut utiliser nativement.

Quand utiliser un plugin vs une configuration .claude/ standalone ? Si vos skills et hooks sont spécifiques à un projet, gardez-les dans le repo. Si vous les réutilisez sur plusieurs projets ou si vous voulez les partager avec d’autres équipes, empaquetez-les en plugin.

Notre usage chez Colombani.ai

Nous utilisons Claude Code au quotidien sur les projets clients. Nos skills custom gèrent les workflows de déploiement, la génération de documentation technique, et le scaffolding de composants selon les conventions de chaque projet. Nos hooks garantissent la qualité du code avant chaque commit. Les subagents parallélisent les revues de code et les audits de sécurité.

C’est aussi ce que nous enseignons dans nos formations. Pas la théorie de l’IA agentique, mais la mise en place concrète : comment structurer un CLAUDE.md efficace, quels hooks mettre en place dès le premier jour, comment découper un projet en tâches pour les Agent Teams.

L’écosystème Claude Code est en évolution rapide. Mais les fondamentaux sont stables : skills pour les capacités, hooks pour les garde-fous, subagents pour la parallélisation, et plugins pour le partage. Si vous travaillez avec du code au quotidien, c’est un investissement qui se rentabilise en quelques jours.

Sources

• Claude Code : documentation Anthropic
• Hooks : documentation Anthropic
• Sous-agents : documentation Anthropic

---

Formez vos équipes à Claude Code. 2 jours, setup complet inclus →

Claude Code face à Gemini CLI, Codex, Hermes et OpenClaw : notre comparatif 2026 →