Design Pattern Agentique : Prompt Chaining (Chaînage de Prompts)
Découper une grosse tâche en petites étapes, et vérifier que chaque étape est réussie avant de passer à la suivante.
Imagine une chaîne de montage automobile. À chaque poste, un ouvrier fait UNE tâche précise (souder le châssis, installer le moteur, peindre la carrosserie). Et surtout : un contrôleur vérifie le travail avant que la voiture passe au poste suivant. Si c’est raté, on corrige sur place — on n’envoie pas une voiture bancale à la peinture.
C’est exactement ça le Prompt Chaining : une chaîne de montage pour l’IA, avec des checkpoints qualité entre chaque étape. Retrouve ici tous les autres Design Patterns Agentiques.
Exemple concret
Objectif : Générer une fiche produit à partir d’une URL.
| Étape | Tâche | Output |
|---|---|---|
| 1 | Scraper la page web | JSON (titre, prix, description brute) |
| ↓ | Checkpoint : Le JSON contient bien les 3 champs ? | ✓ ou retry |
| 2 | Reformuler la description pour ton catalogue | Texte marketing |
| ↓ | Checkpoint : Le texte fait plus de 50 mots ? | ✓ ou retry |
| 3 | Générer 3 variantes de titres SEO | Liste de titres |
Si l’étape 1 échoue, on ne passe pas à l’étape 2. On corrige d’abord.
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ ÉTAPE 1 │────▶│ ÉTAPE 2 │────▶│ ÉTAPE 3 │
│ Extraction │ │ Rédaction │ │ Génération │
└──────┬──────┘ └──────┬──────┘ └─────────────┘
│ │
▼ ▼
┌───────┐ ┌───────┐
│ CHECK │ │ CHECK │
│ OK ? │ │ OK ? │
└───┬───┘ └───┬───┘
│ │
Non│ Non│
▼ ▼
┌───────┐ ┌───────┐
│ RETRY │ │ RETRY │
└───────┘ └───────┘
Quand utiliser ce pattern ?
Utilise-le si :
- Ta tâche a plusieurs étapes logiques distinctes
- Tu veux pouvoir débugger facilement (savoir OÙ ça a planté)
- La qualité de chaque étape impacte le résultat final
- Tu peux te permettre quelques secondes de latence
Évite-le si :
- Tu as besoin d’une réponse instantanée (chatbot temps réel)
- Ta tâche est simple et tient en un seul prompt
- Tu n’as pas de critères clairs pour valider chaque étape
Utilisation avec Claude Code
Pourquoi ce pattern marche bien avec Claude Code
Claude Code fonctionne déjà naturellement en mode séquentiel quand il code : il lit, analyse, planifie, implémente, teste. Le Prompt Chaining, c’est simplement rendre ce processus explicite pour le guider et éviter qu’il saute des étapes ou bâcle une phase.
Sans instruction claire, Claude Code peut :
- Foncer tête baissée dans le code sans analyser l’existant
- Générer une solution sans vérifier qu’elle compile
- Oublier de tester les edge cases
Avec le Prompt Chaining, tu le forces à valider chaque étape avant de continuer.
Les formulations qui déclenchent ce pattern
| Formulation | Effet |
|---|---|
| « Procède en X étapes » | Force le découpage explicite |
| « D’abord… ensuite… enfin » | Impose la séquence |
| « Avant de coder, analyse… » | Bloque l’impulsivité |
| « Valide que… avant de passer à… » | Active les checkpoints |
| « Ne continue que si… » | Crée une porte de validation |
| « Montre-moi le résultat de l’étape 1 avant de continuer » | Checkpoint manuel |
Exemples de prompts concrets
Exemple 1 : Refactoring de code
Refactore ce fichier utils.ts.
Procède en 3 étapes :
1. ANALYSE : Liste toutes les fonctions, leur rôle, et identifie les code smells (duplication, fonctions trop longues, nommage flou). Output : liste structurée.
2. PLAN : Propose un plan de refactoring avec les modifications prévues. Ne code rien encore.
3. IMPLÉMENTATION : Une fois le plan validé, implémente les changements.
Montre-moi le résultat de chaque étape. Je validerai avant que tu passes à la suivante.
Exemple 2 : Création d’une feature complète
Crée un système d'authentification avec Supabase.
Étapes obligatoires :
1. D'abord, liste les fichiers à créer/modifier et leur rôle.
2. Ensuite, crée le schéma de la table users si nécessaire.
3. Puis implémente les fonctions signup/login/logout.
4. Enfin, ajoute la gestion d'erreurs et les types TypeScript.
À chaque étape, vérifie que le code compile avant de passer à la suite.
Exemple 3 : Debugging
Ce composant React ne s'affiche pas correctement.
Procède méthodiquement :
1. DIAGNOSTIC : Lis le code et identifie les causes possibles du bug. Liste-les.
2. HYPOTHÈSE : Classe les causes par probabilité. Quelle est la plus probable ?
3. TEST : Propose un correctif pour la cause la plus probable.
4. VALIDATION : Vérifie que le correctif ne casse rien d'autre.
Ne saute pas à la solution. Je veux comprendre ton raisonnement.
Exemple 4 : Migration de données
Migre les données de l'ancien format JSON vers le nouveau schéma Supabase.
Chaîne de traitement :
1. EXTRACTION : Parse l'ancien fichier JSON, valide sa structure.
→ Checkpoint : le parsing est OK ? Combien d'entrées ?
2. TRANSFORMATION : Convertis chaque entrée vers le nouveau format.
→ Checkpoint : montre-moi 3 exemples avant/après.
3. CHARGEMENT : Insère dans Supabase avec gestion des erreurs.
→ Checkpoint : combien d'insertions réussies/échouées ?
Attends ma validation entre chaque étape.
Checkpoint manuel vs automatique
Checkpoint manuel (tu valides toi-même) :
Montre-moi le résultat de l'étape 1. J'approuverai avant que tu continues.
→ Utile pour les tâches critiques où tu veux garder le contrôle.
Checkpoint automatique (Claude valide lui-même) :
Après chaque étape, vérifie toi-même :
- Le code compile-t-il ?
- Les types sont-ils corrects ?
- Y a-t-il des erreurs évidentes ?
Si oui, corrige avant de passer à la suite. Si tu bloques après 2 tentatives, demande-moi.
→ Utile pour les tâches répétitives où tu veux qu’il soit autonome.
Ce qu’il faut éviter
| ❌ À éviter | ✅ Préfère |
|---|---|
| « Fais-moi une API complète » | « D’abord liste les endpoints, puis implémente-les un par un » |
| « Corrige tous les bugs » | « Identifie les bugs d’abord, puis corrige-les un par un en validant chaque fix » |
| « Refactore et ajoute des tests » | « Étape 1 : refactore. Étape 2 : une fois validé, ajoute les tests. » |
| Tout demander d’un coup | Découper et valider au fur et à mesure |
Astuce : activer le pattern par défaut
Ajoute ça dans ton fichier CLAUDE.md ou tes instructions système :
Pour toute tâche complexe (plus de 3 fichiers ou plus de 100 lignes de code),
adopte automatiquement une approche en étapes :
1. Analyse et planification (pas de code)
2. Implémentation étape par étape
3. Validation à chaque étape
Ne code jamais sans avoir d'abord montré ton plan.
Claude Code appliquera le Prompt Chaining par défaut sans que tu aies à le rappeler.
Les pièges à éviter
| Piège | Pourquoi c’est un problème | Solution |
|---|---|---|
| Context explosion | Tu passes TOUT l’historique à chaque étape → tokens explosent, hallucinations augmentent | Ne passe que l’output validé de l’étape N vers N+1 |
| Faux positif | L’étape 1 passe la validation alors qu’elle contient une erreur | Rends tes critères de validation plus stricts |
| Boucle infinie | L’étape retry en boucle sans jamais réussir | Mets une limite de 3 tentatives max |
Astuce pro : modèles hétérogènes
Tu n’es pas obligé d’utiliser le même modèle à chaque étape :
- Étape d’extraction/formatage → Modèle rapide et pas cher (GPT-3.5, Haiku)
- Étape de rédaction/raisonnement → Modèle intelligent (GPT-4, Claude Sonnet)
Tu économises des tokens sans sacrifier la qualité là où ça compte.
Intégration n8n
Dans n8n, le pattern se modélise ainsi :
- Nœud AI (Étape 1) → Output JSON
- Nœud IF (Checkpoint) → Vérifie les clés requises
- ✓ Vrai → Passe au nœud suivant
- ✗ Faux → Boucle vers l’étape 1 (avec limite de retries)
- Nœud AI (Étape 2) → Utilise
{{ $('Step1').item.json }}
En résumé
Le Prompt Chaining, c’est :
- Diviser une tâche complexe en étapes simples
- Valider chaque étape avant de continuer
- Corriger sur place plutôt que propager les erreurs
C’est plus lent qu’un prompt unique, mais beaucoup plus fiable pour les tâches complexes.
