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

Claude Code : un agent en ligne de commande que vous pouvez étendre

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, ce sont les extensions qui se sont développées autour de lui : skills, hooks, sous-agents, équipes d’agents, plugins. Il sert de socle à vos propres workflows.

Voici ce que chaque brique apporte.

Les skills : des savoir-faire 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 se rangent à 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 lui fournir des connaissances de contexte.

Les skills ne sont pas figés : 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 laisse pas dans votre terminal un message d’erreur obscur, mais une explication de ce qui n’a pas fonctionné 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.

Il existe plusieurs types de handlers, 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.

Premier usage : prévenir les erreurs. 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"
          }
        ]
      }
    ]
  }
}

Avec les hooks, Claude Code reste autonome, mais dans un cadre qu’il ne peut pas franchir.

Les sous-agents : confier une tâche à part

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 vos propres sous-agents dans .claude/agents/, décrits par 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 : faire travailler plusieurs agents ensemble

Les Agent Teams vont 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 avec la variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS.

Le principe : un agent chef d’équipe constitue l’équipe, lance des coéquipiers spécialisés et répartit les tâches dans une liste partagée. Chaque agent peut envoyer des messages aux autres, signaler un blocage, ou marquer une tâche comme terminée.

Exemple type : vous devez développer une fonctionnalité qui touche à la fois le frontend et le backend. 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.

Le dispositif est efficace, mais il suppose un CLAUDE.md bien structuré, pour que chaque agent dispose du contexte nécessaire sans intervention manuelle.

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

Le fichier CLAUDE.md porte l’essentiel 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, consignes valables pour tous vos projets
• Local (CLAUDE.local.md à la racine du projet) : préférences personnelles pour ce projet, à exclure de Git

Le dossier .claude/rules/ permet de répartir les instructions en fichiers séparés : testing.md, security.md, style.md. Chaque fichier est chargé comme une règle supplémentaire.

Claude Code dispose aussi d’une mémoire automatique. D’une session à l’autre, il retient ce qu’il apprend de votre code : conventions de nommage, structure des tests, préférences de mise en forme. Cette mémoire s’enrichit et rend l’agent plus efficace avec le 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é).

Claude Cowork, l’équivalent pour le travail de bureau

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 cloud, contrôles d’entreprise. Ces évolutions sont traitées dans notre guide Claude Cowork en entreprise, et les équipes métier en apprennent la prise en main dans notre formation Claude Cowork.

Les plugins : tout assembler

Les plugins servent à tout empaqueter. Un plugin regroupe des skills, des hooks, des agents sur mesure et des serveurs MCP en un seul paquet à installer. Chaque élément est préfixé du nom du plugin : /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 fait de n’importe quelle source de données un outil que Claude Code utilise directement.

Faut-il préférer un plugin ou une simple configuration .claude/ dans le dépôt ? 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 propres skills gèrent les workflows de déploiement, la génération de la documentation technique et la création du squelette des 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 notre formation Claude Code. Nous n’y enseignons pas la théorie de l’IA agentique, mais sa mise en place : 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.

Claude Code change vite, mais ses principes de base, eux, restent les mêmes : skills pour les capacités, hooks pour les garde-fous, subagents pour la parallélisation, et plugins pour le partage. Si vous écrivez du code chaque jour, le temps passé à le configurer est rentabilisé en quelques jours.

Sources

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

---

Formez vos équipes à Claude Code. Deux jours, installation complète comprise →

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