---
title: Les fonctionnalités de Claude Code : l'arbre complet
source: https://synapx.fr/blog/claude-code-fonctionnalites/
date: 2026-06-26
category: Claude Code
site: SynapxLab
---

# Les fonctionnalités de Claude Code : panorama complet

Claude Code ne se limite pas à un agent capable de modifier du code. Il s'agit d'un **écosystème** de mécanismes complémentaires : compétences, déclencheurs, outils externes, sous-agents, orchestration… Voici une vue d'ensemble de ses fonctionnalités, branche par branche.

```
Claude Code
├── 🛠️  Outils de base
│   ├── Lecture / écriture / édition de fichiers
│   ├── Recherche (glob, grep) et navigation
│   ├── Exécution shell (avant-plan & arrière-plan)
│   └── Web (recherche & récupération de pages)
│
├── 🎯  Skills (compétences)
│   ├── Intégrés  : /code-review, /security-review, /loop, /schedule…
│   ├── Projet    : .claude/skills/
│   ├── Utilisateur : ~/.claude/skills/
│   └── Plugins   : marketplace
│
├── 🪝  Hooks (déclencheurs d'événements)
│   ├── PreToolUse / PostToolUse   (avant / après un outil)
│   ├── UserPromptSubmit, Stop
│   ├── SessionStart, PreCompact, PostCompact…
│   └── Types : command · prompt · agent · http · mcp_tool
│
├── 🔌  MCP (Model Context Protocol)
│   └── Connecte des outils externes (Gmail, Drive, bases, navigateurs…)
│
├── 🤖  Sous-agents
│   ├── Explore (recherche), Plan (architecture)
│   ├── general-purpose, fork (hérite du contexte)
│   └── Agents personnalisés (.claude/agents/)
│
├── 🔭  Workflows (orchestration multi-agents)
│   └── Scripts déterministes : fan-out, pipeline, vérification…
│
├── 🧠  Mémoire persistante
│   └── Faits retenus par projet, d'une session à l'autre
│
├── ⚙️  Modes & permissions
│   ├── default · plan · acceptEdits · auto · bypassPermissions
│   └── Règles allow / deny / ask (settings.json)
│
└── 💬  Commandes slash
    └── /help · /clear · /config · /agents · /workflows · /hooks …
```

Revenons sur les branches qui font réellement la différence.

## 🪝 Les Hooks — automatiser avec précision

Un **hook** exécute une commande à un moment précis du cycle de vie. C'est le mécanisme de référence pour mettre en place des automatismes du type « à chaque fois que… » :

- *« Après chaque écriture de fichier, lance Prettier »* → hook `PostToolUse` sur `Write|Edit`.
- *« Avant de compacter, demande-moi quoi garder »* → hook `PreCompact`.
- *« Journalise toutes les commandes bash »* → hook `PreToolUse` sur `Bash`.

Point important : **c'est le harnais qui exécute le hook, pas l'agent**. Le comportement reste donc fiable et déterministe, ce qui en fait un levier adapté pour formater, tester, journaliser ou bloquer une action.

## 🔌 MCP — connecter le monde extérieur

Le **Model Context Protocol** permet de connecter des serveurs d'outils : messagerie, agenda, stockage cloud, bases de données, navigateurs headless… L'agent étend ainsi ses capacités au-delà de votre machine, tout en restant sous votre contrôle, puisque chaque serveur doit être explicitement autorisé.

## 🤖 Les sous-agents — déléguer sans perdre le fil

Au lieu de tout traiter dans un seul fil, Claude Code peut **déléguer** certaines tâches à des sous-agents spécialisés :

- **Explore** — balaye de nombreux fichiers et ne renvoie que la conclusion (sans polluer le contexte principal).
- **Plan** — conçoit une stratégie d'implémentation.
- **fork** — repart avec **tout votre contexte** pour une tâche en parallèle.
- **Agents personnalisés** — vos propres profils dans `.claude/agents/`.

L'intérêt est double : lancer plusieurs agents **en parallèle** sur des tâches indépendantes, tout en préservant un fil principal plus lisible.

## 🔭 Les Workflows — orchestrer à grande échelle

Lorsqu'une tâche mobilise des dizaines d'agents coordonnés (audit complet, migration massive, recherche exhaustive), les **workflows** prennent le relais : des scripts déterministes qui décrivent le *fan-out* (paralléliser), le *pipeline* (enchaîner) et la *vérification adversariale* (faire contrôler chaque résultat par d'autres agents).

> Exemple concret : une recherche web déclinée en 6 angles, qui récupère 30 sources, extrait 113 affirmations, puis les fait vérifier par vote par 3 agents avant synthèse. C'est un workflow.

## 🧠 La mémoire — conserver le contexte

Claude Code dispose d'une **mémoire fichier persistante** : préférences, décisions de projet, pièges connus… Au démarrage d'une session, l'index de mémoire est rechargé et l'agent reprend là où vous en étiez, sans qu'il soit nécessaire de tout réexpliquer.

## ⚙️ Modes & permissions — ajuster le niveau de confiance

- **default** — demande avant les actions sensibles.
- **plan** — réfléchit et propose un plan, sans rien modifier.
- **acceptEdits** — applique les éditions sans confirmer.
- **auto** — autonomie encadrée par un classifieur de sécurité.
- **bypassPermissions** — plus aucune barrière (à réserver aux environnements jetables).

L'ensemble peut être affiné avec des règles `allow` / `deny` / `ask` dans `settings.json`.

## 💬 Les commandes slash courantes

| Commande | Rôle |
|---|---|
| `/help` | Aide |
| `/config` | Réglages (modèle, thème, mode…) |
| `/clear` | Réinitialise la conversation |
| `/agents` | Gère les sous-agents |
| `/workflows` | Suit les workflows en cours |
| `/hooks` | Configure les hooks |
| `/code-review` | Relit le diff courant |
| `/security-review` | Revue sécurité |
| `/loop` | Tâche récurrente |
| `/schedule` | Agents planifiés (cron) |

---

> La force de Claude Code ne réside pas dans chacune de ces fonctionnalités prise isolément, mais dans leur **composition**. Un skill peut déclencher un workflow, lancer des sous-agents, être encadré par des hooks, s'appuyer sur des serveurs MCP, le tout avec une mémoire conservée d'une session à l'autre. C'est cet assemblage qui transforme un assistant en véritable **collègue de développement**.