IAMaîtriser l'IA générative Plan du corpus
Accueil/Applications au developpement/Debug et analyse d erreur

04 - Debug et analyse d erreur

Le meilleur gain de temps au quotidien : un template de debug en quatre blocs que tu remplis en 90 secondes au lieu de raconter ton probleme pendant dix minutes.

Temps de lecture : 13 min | Niveau : Debutant a Intermediaire

Ce que tu sauras faire apres

  • Remplir un template de debug complet sans avoir a chercher tes mots.
  • Lire une stack trace et poser la bonne question dessus.
  • Traiter 200 000 lignes de logs sans saturer le contexte du modele.
  • Attaquer un bug intermittent avec une methode plutot qu au hasard.
  • Exiger la cause racine au lieu d un pansement.

Le template de debug en quatre blocs

C est le seul template du corpus a apprendre par coeur. Quatre blocs, toujours les memes, toujours dans cet ordre.

CONTEXTE
- Projet : [NOM_ET_ROLE_DU_PROJET_EN_UNE_PHRASE]
- Fichier concerne : @[CHEMIN/DU/FICHIER]
- Commande qui declenche le probleme : [COMMANDE_EXACTE]
- Environnement : [LOCAL / CI / PROD], [OS], [VERSION_LANGAGE], [VERSIONS_LIBS_CLES]
- Frequence : [SYSTEMATIQUE / INTERMITTENT / DEPUIS_TEL_CHANGEMENT]

CE QUE J ATTENDS
[DECRIS_LE_RESULTAT_ATTENDU_AVEC_UNE_VALEUR_CONCRETE]

CE QUE J OBTIENS
[COLLE_LA_SORTIE_OU_LA_STACK_TRACE_COMPLETE]

CE QUE J AI DEJA ESSAYE
1. [ESSAI_1] -> [RESULTAT]
2. [ESSAI_2] -> [RESULTAT]

CE QUE JE VEUX DE TOI
1. Les 3 causes les plus probables, classees par probabilite
2. Pour chacune : comment la confirmer ou l ecarter en une commande
3. Seulement apres, le correctif de la cause retenue
4. Attaque la cause racine, ne masque pas l erreur

Ne devine pas le contenu des fichiers : ouvre-les avant de repondre.

Pourquoi ces quatre blocs

Chaque bloc correspond a un conseil documente.

BlocCe que dit la doc officielle
Contexte"Tell Claude the command to reproduce the issue and get a stack trace" (Common workflows)
Frequence"Let Claude know if the error is intermittent or consistent" (meme page)
Ce que j attends / ce que j obtiensGitHub : "instead of asking 'What's wrong with this function?' try 'Why is this function returning undefined when the input is valid?'" (How to debug code with GitHub Copilot)
Ce que j ai deja essayeEvite qu on te repropose ce qui a deja echoue
Cause racine"fix it and verify the build succeeds. address the root cause, don't suppress the error" (Best practices)

AVANT / APRES

Cas reel : un DAG Airflow qui echoue une fois sur cinq

Mauvais prompt :

mon dag airflow plante, tu peux regarder ?

Resultat : on te pose cinq questions, ou pire, on te donne une reponse generique sur les retries.

Prompt ameliore :

CONTEXTE
- Projet : pipeline d ingestion des commandes, Airflow 2.9, Python 3.11
- Fichier : @dags/ingest_orders.py
- Commande : airflow dags test ingest_orders 2026-09-20
- Environnement : prod, executor Celery, 4 workers
- Frequence : environ 1 run sur 5, toujours sur la tache load_to_postgres

CE QUE J ATTENDS
La tache load_to_postgres ecrit environ 120 000 lignes dans staging.orders
et se termine en success.

CE QUE J OBTIENS
[stack trace complete collee ici]
psycopg2.errors.UniqueViolation: duplicate key value violates unique
constraint "orders_pkey"
DETAIL:  Key (order_id)=(A-99182) already exists.

CE QUE J AI DEJA ESSAYE
1. Augmente le timeout de la tache -> aucun effet
2. Relance manuelle du meme run -> passe une fois sur deux
3. Verifie que l API source ne renvoie pas de doublons -> elle n en renvoie pas

CE QUE JE VEUX DE TOI
1. Les 3 causes les plus probables, classees par probabilite
2. Pour chacune, la requete SQL ou la commande qui permet de trancher
3. Seulement apres, le correctif de la cause retenue
4. Attaque la cause racine ; ne me propose pas un ON CONFLICT DO NOTHING
   comme solution definitive sans m expliquer ce qu on masque

Pourquoi c est mieux : la frequence "1 sur 5 sur la meme tache" plus le message UniqueViolation orientent immediatement vers un rejeu partiel (retry qui reinsere des lignes deja ecrites) plutot que vers un probleme de donnees source. Le bloc "deja essaye" ecarte d emblee deux fausses pistes. Et la derniere ligne empeche le pansement.


Lire une stack trace

Une stack trace se lit du bas vers le haut : la derniere ligne est l erreur, les lignes au-dessus sont le chemin qui y mene. Ce qui t interesse, ce sont les lignes de ton code, pas celles des librairies.

Template - Analyse de stack trace

Voici une stack trace. Analyse-la en 5 points :

1. La ligne EXACTE de MON code qui declenche l erreur (ignore les frames
   des librairies, sauf si le bug vient d un mauvais usage de l API)
2. Ce que signifie ce type d exception, en une phrase simple
3. Les valeurs qui devaient etre presentes a ce moment-la et qui ne l etaient
   probablement pas
4. Les 3 causes possibles, classees par probabilite
5. Pour chaque cause : la ligne de log ou l assertion a ajouter pour trancher

Ne propose pas encore de correctif.

STACK TRACE :
[COLLE_LA_STACK_TRACE_COMPLETE_SANS_LA_TRONQUER]

FICHIER CONCERNE : @[CHEMIN/DU/FICHIER]

Deux erreurs frequentes a eviter :

  • tronquer la trace : la premiere ligne "Traceback (most recent call last)" et la derniere ligne comptent autant ;
  • coller uniquement le message sans le chemin des appels : tu perds l information la plus utile.

Logs volumineux : ne colle jamais tout

200 000 lignes de logs saturent le contexte et noient le signal. Trois techniques, de la plus simple a la plus efficace.

Technique 1 - Filtrer avant de coller

# Garder seulement les erreurs et 5 lignes de contexte autour
grep -n -A 5 -B 5 -i "error\|exception\|traceback" app.log > extrait.log

# Compter les types d erreurs pour voir laquelle domine
grep -o "[A-Za-z]*Error" app.log | sort | uniq -c | sort -rn | head -20

# Isoler une fenetre de temps
sed -n '/2026-09-20 14:3/,/2026-09-20 14:4/p' app.log > fenetre.log

Technique 2 - Piper directement le fichier

La doc Claude Code donne la syntaxe :

cat error.log | claude

et, pour un traitement en une passe :

claude -p "Analyze this log file" --output-format stream-json --verbose

Technique 3 - Deleguer a un sous-agent

Un sous-agent lit dans sa propre fenetre de contexte et ne te renvoie que la synthese. La doc le resume : "The subagent reads files in its own context window and reports a summary."

Utilise un sous-agent pour analyser @[CHEMIN/DU/LOG]. Il doit me renvoyer
uniquement :
- le nombre d occurrences de chaque type d erreur
- la premiere et la derniere occurrence de l erreur [NOM_DE_L_ERREUR]
- les 10 lignes qui precedent la premiere occurrence
- une hypothese sur l evenement declencheur
Pas de log brut dans la reponse.

Template - Analyse de logs

Log : @[CHEMIN/DU/LOG] (environ [NOMBRE] lignes)
Incident : [CE_QUI_S_EST_PASSE] le [DATE] vers [HEURE]

Analyse-le et renvoie UNIQUEMENT :
1. Une chronologie de l incident, heure par heure, en 10 lignes maximum
2. Le premier evenement anormal, avec son horodatage exact
3. Les erreurs en cascade qui en decoulent (distingue cause et consequence)
4. Ce qui se passait juste AVANT le premier evenement anormal
5. Les 3 hypotheses de cause racine, classees

Ne recopie pas de longs extraits de log : cite l horodatage et 1 ligne.

Un detail de mise en page change le resultat : place le gros document avant ta question, jamais apres. La doc Anthropic, section "Long context prompting", est explicite : "Put longform data at the top: Place your long documents and inputs near the top of your prompt, above your query, instructions, and examples. This improves performance across all models."

Donc dans le template ci-dessus, si tu colles un extrait de log plutot que de passer un chemin de fichier, colle-le en haut et mets tes consignes en dessous.


Le bug intermittent

Un bug qui se produit "parfois" a presque toujours une cause dans cette liste courte. Fais-la parcourir systematiquement.

Template - Bug intermittent

Bug intermittent : [DECRIS_LE_SYMPTOME]
Frequence observee : [X] fois sur [Y] executions
Ce qui est identique a chaque execution : [CODE / DONNEES / COMMANDE]
Ce qui varie : [HEURE / VOLUME / WORKER / ORDRE DES DONNEES / RIEN_DE_CONNU]
Fichier : @[CHEMIN]

Passe en revue, une par une, ces familles de causes, et dis pour chacune si
elle est plausible ici et comment la tester :

1. CONCURRENCE : deux processus qui ecrivent au meme endroit, verrou manquant
2. ORDRE NON DETERMINISTE : dictionnaire, set, resultat SQL sans ORDER BY,
   parallelisme
3. TEMPS : fuseau horaire, changement d heure, minuit, fin de mois, timeout
4. ETAT RESIDUEL : cache, fichier temporaire, connexion reutilisee, variable
   globale
5. REJEU PARTIEL : retry qui reprend une operation deja a moitie faite
6. DONNEES : une valeur rare dans le jeu de donnees (NULL, accent, valeur
   negative, chaine vide, doublon)
7. RESSOURCES : memoire, descripteurs de fichiers, pool de connexions sature

Termine par : le test ou le log a ajouter pour capturer l information
manquante au prochain incident.

Le dernier point est souvent la vraie reponse. Quand on ne peut pas reproduire, on instrumente d abord et on corrige ensuite.


La demarche : comprendre d abord, corriger ensuite

La doc Claude Code decrit un enchainement en trois messages :

  1. I'm seeing an error when I run npm test
  2. suggest a few ways to fix the @ts-ignore in user.ts
  3. update user.ts to add the null check you suggested

GitHub decrit le meme decoupage avec les commandes de Copilot Chat : /explain pour comprendre, /startDebugging pour mettre en place le debogage, puis /fix pour corriger. L article cite aussi ce reflexe utile : "I find it useful to ask GitHub Copilot for three or four different options on how to fix a problem or to analyze for performance."

La lecon commune : comprendre d abord, corriger ensuite, en deux messages separes. Si tu demandes le correctif dans le premier message, tu obtiens un correctif sur la premiere hypothese venue.

Template - Demander plusieurs options

Ne corrige rien encore. Propose-moi 3 facons differentes de regler
[LE_PROBLEME], avec pour chacune :
- en quoi elle consiste, en 2 lignes
- ce qu elle coute (complexite, performance, risque de regression)
- dans quel cas elle est le bon choix
Puis recommande-en une et explique pourquoi.

Et pour finir : boucler la verification

Applique l option [NUMERO]. Puis lance [COMMANDE_DE_TEST] et corrige jusqu a
ce que ca passe. Montre-moi la sortie de la commande, pas un resume.

Cette derniere phrase applique la regle centrale de la section : "Have Claude show evidence rather than asserting success."


Trois pieges de debug avec l IA

  1. Le pansement. Le modele attrape l exception et la masque. Parade : ajouter systematiquement "address the root cause, don't suppress the error" dans le prompt.
  2. La correction sans reproduction. Si personne n a reproduit le bug, le correctif est une hypothese. Parade : exiger l etape "comment confirmer ou ecarter cette cause".
  3. La session polluee. Apres deux corrections ratees, ton contexte est plein de pistes mortes. Parade documentee : "After two failed corrections, /clear and write a better initial prompt incorporating what you learned."

A retenir

  • Quatre blocs, toujours : contexte, ce que j attends, ce que j obtiens, ce que j ai deja essaye.
  • Dis toujours si le bug est systematique ou intermittent : ca change toute l analyse.
  • Colle la stack trace ENTIERE, jamais le seul message d erreur.
  • Sur des logs volumineux : filtre avec grep, ou delegue a un sous-agent, ne colle pas tout.
  • Deux messages separes : comprendre d abord, corriger ensuite.
  • Exige la cause racine et la preuve par la commande, pas l affirmation "c est corrige".

Sources

Corpus personnel de formation · genere le 26/09/2026 · source : 04-debug-et-analyse-derreur.md