Maîtriser Claude Code Partie 6 : Subagents

Tu travailles sur une fonctionnalité et tu réalises que tu as besoin de trois choses : une revue de sécurité de tes changements, une analyse de couverture de tests et des mises à jour de documentation. Séquentiellement, ça fait beaucoup d'attente. Et si Claude pouvait travailler sur les trois simultanément ?

C'est ce que font les subagents. Ce sont des workers IA spécialisés avec leurs propres fenêtres de contexte qui tournent en parallèle, chacun focalisé sur une tâche spécifique, ne renvoyant que les résultats pertinents dans ta conversation principale.

Que sont les subagents ?

Les subagents sont des instances Claude isolées que le Claude principal fait apparaître pour gérer des tâches spécifiques. Le point clé : chaque subagent a sa propre fenêtre de contexte. C'est important car :

• Ta conversation principale reste propre — pas de bruit lié aux tangentes de recherche
• Les subagents peuvent travailler en parallèle sans interférer les uns avec les autres
• Seuls les résultats distillés reviennent, pas l'historique complet d'exploration
• Les tâches complexes sont découpées en morceaux gérables

Pense à ça comme déléguer à des membres de l'équipe. Tu n'as pas besoin de voir chaque recherche Google qu'ils ont faite — tu as juste besoin de leurs conclusions.

L'outil Task : comment ça marche

Sous le capot, Claude utilise l'outil Task pour créer des subagents. Quand tu demandes à Claude de faire quelque chose de complexe, il peut déléguer des parties à des workers spécialisés :

Toi : "Revois cette PR pour les problèmes de sécurité, vérifie la couverture de tests et mets à jour la doc API"

Claude en interne :
├─→ Task(Auditeur Sécurité) → Résultats de sécurité
├─→ Task(Analyseur Couverture) → Rapport de couverture
└─→ Task(Rédacteur Doc) → Documentation mise à jour

Claude : "Voici ce que j'ai trouvé dans les trois domaines..."

Claude peut faire tourner jusqu'à 7 subagents simultanément. Les résultats fusionnent dans ta conversation principale sous forme de sortie propre et résumée.

Types de subagents intégrés

Claude Code est livré avec plusieurs types d'agents intégrés que tu peux invoquer :

Explore — Exploration rapide de la codebase. À utiliser pour trouver des fichiers, chercher des patterns, comprendre l'architecture. Lecture seule, optimisé pour la vitesse.

"Utilise un agent Explore pour trouver tous les fichiers qui gèrent l'authentification utilisateur"

Plan — Mode architecte logiciel. Conçoit des stratégies d'implémentation, identifie les fichiers critiques, considère les compromis. Retourne des plans étape par étape.

"Utilise un agent Plan pour concevoir comment on devrait implémenter les notifications en temps réel"

Bash — Spécialiste de l'exécution de commandes. Lance des commandes shell, gère les opérations git, exécute des scripts.

"Utilise un agent Bash pour lancer la suite de tests et résumer les échecs"

general-purpose — Le couteau suisse. Recherche, tâches multi-étapes, tout ce qui ne rentre pas dans les types spécialisés.

"Utilise un agent general-purpose pour rechercher les meilleures pratiques de rate limiting"

Quand Claude utilise les subagents automatiquement

Claude n'annonce pas toujours quand il utilise des subagents — il le fait tout simplement quand c'est efficace. Délégations automatiques courantes :

• Exploration en mode plan — Quand tu entres en mode plan, Claude crée souvent un agent Explore pour comprendre ta codebase avant de proposer des changements
• Analyse parallèle de fichiers — Lire plusieurs fichiers non liés simultanément
• Tâches de recherche — Recherches web et consultation de documentation
• Recherche de patterns — Trouver des patterns de code dans de grandes codebases

Tu verras des indicateurs d'activité quand les subagents travaillent. Les résultats apparaissent comme si Claude avait tout fait lui-même — parce que techniquement, c'est le cas.

Créer des subagents personnalisés

Pour des tâches spécialisées et répétables, crée tes propres subagents. Ils vivent dans .claude/agents/ :

.claude/agents/
└── security-auditor/
    └── AGENT.md

Format d'AGENT.md

---
Name: security-auditor
Description: "Audit code for security vulnerabilities including OWASP Top 10, authentication issues, data exposure, and injection attacks"
Tools: Read, Grep, Glob
Model: sonnet
---

# Security Auditor

You are a security specialist focused on finding vulnerabilities in code.

## Process

1. Scan for hardcoded secrets (API keys, passwords, tokens)
2. Check input validation on all user-facing endpoints
3. Review authentication and authorization flows
4. Analyze data handling for exposure risks
5. Look for injection vulnerabilities (SQL, command, XSS)
6. Check error messages for information leakage

## Output Format

Organize findings by severity:

### Critical (Must Fix Before Merge)
- Issue description
- File and line number
- Why it's dangerous
- How to fix it

### Warning (Should Fix)
- Same format as critical

### Info (Consider Fixing)
- Same format

## Constraints

- Read-only: analyze and report, don't modify code
- Flag uncertainty: if unsure, mark for human review
- Be specific: vague warnings aren't actionable

Options du frontmatter

name (obligatoire) — Identifiant de l'agent. Minuscules, tirets autorisés.

description (obligatoire) — Quand utiliser cet agent. Claude compare tes requêtes à cette description pour décider s'il faut l'invoquer. Sois spécifique.

tools — Quels outils l'agent peut utiliser. Séparés par des virgules : Read, Grep, Glob, Bash, Write, Edit. Principe du moindre privilège — n'accorde que le nécessaire.

model — Quel modèle Claude utiliser :

• sonnet — Rapide, économique (par défaut)
• opus — Capacité maximale pour le raisonnement complexe
• haiku — Le plus rapide, pour les tâches simples
• inherit — Utiliser le même modèle que la conversation principale

color — Identifiant visuel dans l'interface (optionnel)

Invoquer des subagents personnalisés

Une fois créés, invoque les subagents naturellement :

"Utilise l'agent security-auditor pour revoir les changements de cette PR"

"Lance security-auditor sur src/auth/"

"Fais vérifier les nouveaux endpoints de paiement par l'auditeur de sécurité"

Claude reconnaît ton agent et le lance avec le contexte approprié.

Patterns d'exécution parallèle

Fan-Out : perspectives multiples

Analyse le même code sous différents angles simultanément :

"Revois cette PR avec les agents security-auditor, performance-analyzer
et test-coverage en parallèle"

┌─→ Agent Sécurité ──→ Rapport Sécurité
              │
Ton Code ─────┼─→ Agent Performance ─→ Rapport Perf
              │
              └─→ Agent Couverture ──→ Rapport Couverture

                        ↓
                Analyse Combinée

Chaque agent se concentre sur sa spécialité. Tu obtiens un retour complet plus rapidement qu'avec une revue séquentielle.

Pipeline : passage séquentiel

Chaîne des agents où chacun s'appuie sur le précédent :

Code → Agent Analyseur → Analyse
                           ↓
               Agent Refactor → Code Amélioré
                                     ↓
                           Agent Test → Tests

À utiliser quand les étapes ultérieures dépendent des résultats précédents.

Routage spécialisé

Route les tâches vers des experts du domaine :

"Implémente la fonctionnalité de tableau de bord utilisateur"

Claude route en interne :
├─→ Agent Frontend (composants React)
├─→ Agent Backend (endpoints API)
└─→ Agent Base de données (changements de schéma)

Exemple : construire une équipe de revue

Créons un système de revue de code multi-agents.

Agent 1 : Auditeur de sécurité

Mkdir -p .claude/agents/security-auditor
Cat > .claude/agents/security-auditor/AGENT.md << 'EOF'
---
Name: security-auditor
Description: "Review code for security vulnerabilities, OWASP issues, auth problems"
Tools: Read, Grep, Glob
Model: sonnet
---

# Security Auditor

Focus: Finding security vulnerabilities.

## Checklist
- [ ] Hardcoded secrets
- [ ] SQL/command injection
- [ ] XSS vulnerabilities
- [ ] Auth/authz issues
- [ ] Data exposure
- [ ] Insecure dependencies

## Output
Rate each finding: Critical / Warning / Info
Include: file, line, issue, fix
EOF

Agent 2 : Analyseur de performance

Mkdir -p .claude/agents/performance-analyzer
Cat > .claude/agents/performance-analyzer/AGENT.md << 'EOF'
---
Name: performance-analyzer
Description: "Analyze code for performance issues, N+1 queries, memory leaks, bottlenecks"
Tools: Read, Grep, Glob
Model: sonnet
---

# Performance Analyzer

Focus: Finding performance problems.

## Checklist
- [ ] N+1 database queries
- [ ] Missing indexes
- [ ] Unnecessary re-renders
- [ ] Memory leaks
- [ ] Blocking operations
- [ ] Large payload transfers

## Output
Rate each finding: Critical / Warning / Info
Include: file, line, issue, estimated impact, fix
EOF

Agent 3 : Couverture de tests

Mkdir -p .claude/agents/test-coverage
Cat > .claude/agents/test-coverage/AGENT.md << 'EOF'
---
Name: test-coverage
Description: "Analyze test coverage, identify untested code paths, suggest missing tests"
Tools: Read, Grep, Glob, Bash
Model: sonnet
---

# Test Coverage Analyzer

Focus: Identifying gaps in test coverage.

## Process
1. Run existing tests to check current coverage
2. Identify untested functions and branches
3. Flag critical paths without tests
4. Suggest specific test cases to add

## Output
- Current coverage percentage
- List of untested critical paths
- Suggested test cases with priority
EOF

Les utiliser ensemble

"Lance une revue complète du module auth avec les agents security-auditor,
performance-analyzer et test-coverage en parallèle"

Claude lance les trois, ils travaillent simultanément, et tu obtiens un rapport complet.

Bonnes pratiques

1. Responsabilité unique

Chaque agent doit faire une seule chose bien. Ne crée pas un agent « fait tout » — c'est juste Claude avec des étapes en plus.

2. Descriptions spécifiques

Le champ description détermine quand Claude invoque automatiquement ton agent. Sois spécifique :

# Mauvais - trop vague
Description: "Helps with code"

# Bon - déclencheurs spécifiques
Description: "Review code for SQL injection, XSS, CSRF, and authentication vulnerabilities using OWASP guidelines"

3. Permissions minimales

N'accorde que les outils dont l'agent a besoin :

# Agents analyseurs : lecture seule
Tools: Read, Grep, Glob

# Agents rédacteurs : peuvent modifier
Tools: Read, Write, Edit

# Agents exécuteurs : peuvent exécuter
Tools: Read, Bash

4. Format de sortie clair

Spécifie exactement comment tu veux les résultats. Les agents qui retournent des formats cohérents sont plus faciles à utiliser.

5. Section contraintes

Dis à l'agent ce qu'il ne doit PAS faire. Empêche les dépassements de périmètre et les comportements inattendus.

Collections de subagents populaires

Ne construis pas tout de zéro. Ces collections sont éprouvées :

VoltAgent/awesome-claude-code-subagents — Plus de 100 agents pour les workflows de développement généraux.

wshobson/agents — 99 agents et 15 orchestrateurs pour les workflows de production.

rshah515/claude-code-subagents — Plus de 133 agents couvrant tout le cycle de développement logiciel.

Installe en clonant dans ton répertoire .claude/agents/ :

Git clone https://github.com/VoltAgent/awesome-claude-code-subagents.git .claude/agents/voltagent

Commandes vs Skills vs Subagents

Commandes — Templates de prompts que tu invoques explicitement avec /commande. Ils partagent le contexte avec ta conversation principale et s'exécutent séquentiellement. Idéaux pour les prompts répétés où tu veux un contrôle explicite.

Skills — Modules de connaissances que Claude associe automatiquement à tes requêtes. Ils se chargent dans ton contexte principal quand ils sont pertinents. Idéaux pour les standards et patterns qui doivent s'appliquer automatiquement.

Subagents — Workers spécialisés avec des fenêtres de contexte indépendantes. Peuvent tourner en parallèle et ne renvoient que des résultats distillés. Idéaux pour les tâches parallèles complexes ou quand tu as besoin d'une exploration isolée.

Limitations

• Pas d'imbrication : les subagents ne peuvent pas créer d'autres subagents
• Coût en tokens : chaque subagent utilise son propre contexte, ce qui consomme des tokens
• Coordination : les workflows multi-agents complexes nécessitent une orchestration claire
• Conflits d'écriture : fais attention avec plusieurs agents qui écrivent dans les mêmes fichiers

La suite

Les subagents permettent à Claude de déléguer et paralléliser le travail. Mais que se passe-t-il si tu veux que Claude se connecte à des services externes — bases de données, API, ou outils personnalisés construits par ton équipe ?

C'est là qu'intervient MCP (Model Context Protocol). Dans la Partie 7 : Serveurs MCP, nous explorerons comment étendre les capacités de Claude en le connectant à des sources de données et des services externes.