Corriger un bug, c'est faire cesser la reproduction d'un défaut reproductible, et laisser la preuve qu'il ne reviendra pas. La première moitié, c'est « modifier le code ». La seconde, c'est « le fermer correctement » — et la plupart des équipes ne font que la première, si bien que le même problème revient trois mois plus tard par une autre porte. La qualité d'une correction ne se mesure pas à l'élégance du changement. Elle se mesure à la capacité du prochain test de régression, de la prochaine personne qui reprend le code et de vous-même dans trois mois, à conclure, à partir du seul enregistrement, que le défaut a réellement disparu.
Cet article ne traite que « comment corriger, comment vérifier, comment fermer ». Quel bug corriger en premier relève du triage — voir le guide de triage des bugs. Comment écrire un rapport qui puisse être corrigé figure dans ce que doit contenir un rapport de bug.
La boucle en six étapes
Chaque étape a une exigence minimale de preuve. Si elle n'est pas remplie, revenez à l'étape précédente au lieu d'avancer — c'est la règle la plus utile de cet article.
| Étape |
Ce que vous faites |
Preuve minimale |
Si elle manque |
| 1 Lire |
Décider si le rapport est démarrable |
URL, environnement (navigateur / OS / version), attendu vs constaté |
Renvoyer plutôt que deviner |
| 2 Reproduire |
Provoquer le problème une fois soi-même |
Une reproduction confirmée, ou un « non reproductible » explicite |
Noter les essais, mettre en attente, ne jamais fermer |
| 3 Localiser |
Trouver quelle couche est en cause |
Une erreur verbatim, une requête en échec ou un résultat de bisect |
Arrêter de modifier ; ajouter de l'observabilité |
| 4 Corriger |
Supprimer la cause avec le plus petit changement |
Un changement, une cause |
Découper le commit |
| 5 Vérifier |
Prouver que c'est corrigé et que rien n'a cassé |
Même parcours + cas limites + matrice de régression |
« Ça a l'air bon » n'est pas une vérification |
| 6 Fermer |
Rendre lisible pour la personne suivante |
Une ligne de cause racine + un lien vers la preuve |
« Corrigé » seul n'est pas une fermeture |
Étape 1 : lire le rapport et décider si l'on peut démarrer
Un rapport démarrable contient trois choses : où, dans quel environnement, et en quoi le constaté diffère de l'attendu. S'il en manque une, l'action correcte est de le renvoyer, pas d'ouvrir le code pour voir.
Le coût du « voir un peu » est très sous-estimé. Une part significative des pages qu'un développeur déduit après 40 minutes d'hypothèses n'est pas celle que le rapporteur visait. Un aller-retour coûte deux minutes.
Étape 2 : reproduire, ou dire clairement que c'est impossible
La reproduction est la ligne de partage. Un défaut qui se reproduit de façon fiable n'est qu'une question de temps. Un défaut non reproductible transforme tout changement en pari.
Trois éléments doivent être figés pendant la reproduction, sinon vous ne reproduisez pas le même défaut :
État des données. Quel compte, y a-t-il du cache, reste-t-il des données anciennes dans localStorage.
Version du build. Bundle front, commit back, feature flag actif.
Chronologie des actions. Clic immédiat au chargement, après quelques secondes, après changement d'onglet, en connexion lente.
Si cela ne se reproduit vraiment pas, consignez « non reproductible » avec trois questions, au lieu de fermer :
- Sur quelle page et par quelle entrée êtes-vous arrivé ? (L'URL d'origine porte souvent des paramètres.)
- Est-ce lié à un compte, un rôle, une permission particuliers ?
- À quel moment cela s'est-il produit ? (Si cela correspond à un log ou à un déploiement, vous avez une piste.)
Étape 3 : localiser — établir la couche d'abord
Les corrections lentes sont rarement des problèmes difficiles ; ce sont des problèmes cherchés dans la mauvaise couche. Trois gestes réduisent à une seule couche :
| Geste |
Ce que vous regardez |
Ce que cela élimine |
| Console |
L'erreur verbatim et la pile |
Élimine les problèmes « purement style / purement données » |
| Panneau réseau |
Un 4xx / 5xx, et la cohérence des corps de requête et réponse |
Sépare « le front n'a jamais envoyé » de « le back a renvoyé du faux » |
| Bisect / rollback |
Quelle version ou quel commit était bon en dernier |
Élimine « c'était déjà comme ça » |
Lire les erreurs : les niveaux de log expliqués et les types d'erreurs en programmation. Ouvrir la console : ouvrir la console du navigateur. Pour les non-développeurs qui veulent un premier regard : les DevTools pour les non-développeurs.
Un ordre de décision concret : l'API répond 500 → back. L'API répond 200 mais un champ est faux → contrat. L'API n'a jamais été appelée → logique ou validation front. L'API est bonne, l'interface est fausse → rendu. Ces quatre lignes couvrent l'essentiel de ce que rencontrent les équipes web.
Étape 4 : corriger avec le plus petit changement
« Plus petit changement » n'est pas de la prudence, c'est de la vérifiabilité. Une pull request qui corrige le bug, refactorise un module et monte une dépendance en même temps vous empêche de dire laquelle des trois a causé le problème suivant — ce qui rend l'étape 5 impossible.
Deux règles :
- Un commit, une cause. Si vous découvrez un second problème en corrigeant, ouvrez un ticket séparé.
- Le refactoring a son propre temps. Le faire pendant une correction mélange risque connu et risque inconnu.
Étape 5 : vérifier — prouver que c'est corrigé, pas caché
C'est ici que cet article diffère de la plupart des textes « comment corriger un bug ». Les quatre pratiques suivantes font disparaître le défaut alors que le problème demeure :
| Pratique |
Apparence |
Réalité |
try / catch vide |
L'erreur a disparu |
La logique aval échoue en silence, les données s'écrivent de travers |
| Assouplir la validation |
Plus d'erreurs |
Des données sales entrent en base, découvertes des mois plus tard |
| Masquer le point d'entrée |
L'utilisateur ne peut plus cliquer |
Le besoin demeure, il arrive par un autre chemin, le comportement diverge |
| Un flag qu'on ne réactive jamais |
Le symptôme n'apparaît plus |
Le flag devient du code que personne n'ose supprimer |
Le seul test valable : l'utilisateur peut-il maintenant faire ce qu'il voulait faire ? Pas « l'erreur a-t-elle disparu ».
La vérification comporte trois parties :
Refaire le parcours d'origine — exactement la route décrite dans le rapport, du premier au dernier pas.
Réessayer les bords — valeurs vides, texte très long, emoji, fuseaux horaires, montants décimaux, compte sans permission. Ces six-là sont le logement des récidives.
Lancer la matrice de régression — quelle ancienne fonctionnalité ce changement a pu toucher, voir comment mener des tests de régression.
Étape 6 : fermer avec une ligne de cause racine
Fermer un défaut avec « corrigé » déplace le coût sur la personne suivante. Une note de cause racine complète comporte trois parties :
text
Cause racine : à la validation de commande, le formulaire était vidé avant
l'envoi ; une requête en échec laissait donc un formulaire
vide ; la nouvelle tentative envoyait des données vides,
recevait un 500, qu'un catch silencieux avalait.
Correction : envoyer d'abord, vider en cas de succès ; suppression du catch
silencieux au profit d'un message d'erreur.
Vérifié : Chrome 141 / macOS 14, trois tentatives réseau coupé affichent
« Échec de l'envoi, veuillez réessayer » et conservent le contenu ;
régression : tunnel de commande, codes promo, carnet d'adresses.
Ces trois parties répondent à « pourquoi c'était cassé », « qu'est-ce qui a changé » et « comment l'avez-vous prouvé ». Elles survivent au diff — six mois plus tard le diff a été réécrit, le fichier découpé, le module remplacé, et le commentaire est toujours là.
Ne laissez pas les preuves uniquement dans le chat. Captures, enregistrements et requêtes en échec doivent vivre avec l'enregistrement, sinon dans trois mois, quand la régression échouera, « à quoi cela ressemblait à l'époque » mènera à un lien mort. L'extension BugCapturer joint les erreurs console, les requêtes en échec, l'URL, le navigateur et le viewport à l'envoi et produit un lien partageable ; les rapports sont conservés à long terme sur l'offre équipe — pour une raison simple : que « le rapport d'origine s'ouvre encore » soit toujours vrai dans trois mois.
Pourquoi la reproduction échoue : trois causes réelles
« Non reproductible » est un trou noir dans un outil de suivi. C'est rarement la chance ; c'est l'une de trois différences.
1. L'environnement. Les cinq habituelles : version du build (en local, le dernier main), caches (navigateur, service worker, CDN), feature flags, rôles et permissions, fuseau horaire et langue. Le geste consiste à aligner ces cinq points un par un, pas à demander de réessayer.
2. Les données. L'enregistrement de l'utilisateur contient une note de 300 caractères, un pseudo avec emoji, un deuxième prénom null, un montant négatif. L'interface est toujours correcte sur des « données normales ». Celui qui reproduit dispose en général de l'identifiant de l'enregistrement précis.
3. La chronologie. Courses asynchrones, lazy loading, debounce, ordre des callbacks tiers. Ces problèmes n'apparaissent jamais en connexion rapide et toujours en connexion lente ; sur la machine du développeur, tout va bien. L'outil, c'est la limitation de débit et le délai artificiel, pas plus de logs.
Quand vous ne reproduisez pas, consignez en attente + la liste des conditions déjà essayées + trois questions (entrée / compte / heure). Fermer est la pire option — vous perdez l'information que cela s'est produit, et cela reviendra.
Patch, hotfix, correction régulière : trois tempos à ne pas mélanger
Le même bug prend l'une de trois routes selon l'impact et l'urgence, pas selon la difficulté :
| Correction régulière |
Patch |
Hotfix |
| Situation |
N'entrave pas le parcours principal, peut attendre |
Périmètre réduit mais à livrer vite |
Production bloquée / argent en jeu / sécurité |
| Processus |
Itération normale avec revue |
Part avec la prochaine version mineure |
Contourne le processus, revue après coup |
| Obligations |
Matrice de régression |
Matrice + note de changement |
Matrice + note de changement + post-mortem |
| Le plus souvent oublié |
Vérification des cas limites |
Prévenir les utilisateurs touchés |
Corriger le symptôme, pas la cause |
Le risque du hotfix n'est pas la vitesse, mais que personne ne revienne après. Les changements provisoires restent dans le code, la régression n'est jamais ajoutée, le post-mortem jamais écrit. Un hotfix doit laisser trois choses : une note de version, une passe de régression ciblée, et une phrase sur la façon dont c'est arrivé en production. Les notes de version vivent dans le changelog.
Cinq règles pour l'équipe
S'il ne devait en rester que cinq :
Renvoyer le rapport non démarrable ; ne pas deviner. Deux minutes de renvoi contre quarante minutes d'hypothèses.
Un commit, une cause. Un changement mixte ne se vérifie pas et ne se rollback pas.
Fermer avec une cause racine et un lien vers la preuve. La règle qui fait gagner un jour à quelqu'un, six mois plus tard.
« Non reproductible » est une raison de mettre en attente, pas de fermer.
Une correction sans mise à jour de la matrice n'est pas terminée. La ligne sautée est l'entrée du prochain incident.
La frontière entre défaut, exigence, erreur et bug est floue — voir bug vs defect vs issue vs error. S'il s'agit de « comment dire au client que c'est corrigé » : partager des rapports de bug avec des clients.
Questions fréquentes
Comment arbitrer entre corriger des bugs et livrer des fonctionnalités ?
Par impact fois fréquence, pas par volume sonore. La matrice gravité × priorité est dans le guide de triage. Un ajout utile : ne réordonnez pas la file en cours de sprint. Les équipes qui re-trient en permanence ne terminent généralement ni l'une ni l'autre des deux voies.
Peut-on corriger plusieurs bugs dans un même changement ?
Seulement avec une seule cause et un seul endroit — une cause produisant trois symptômes reste un seul bug. Des causes indépendantes dans un même commit rendent le rollback impossible : en cas d'incident en production, vous ne pouvez que tout annuler.
Faut-il un test unitaire pour chaque bug ?
Non. Trois catégories le méritent : ceux qui récidivent (avec un historique de régression), ceux dont la logique a des branches (beaucoup de cas limites), et tout ce qui calcule des données (montants, ratios, dates). L'affichage pur et les corrections de texte sont couverts par le parcours de régression.
J'ai trouvé un autre problème en corrigeant. Je le corrige aussi ?
Non. Ouvrez un ticket séparé. Le mélanger invalide l'étape 5 — vous ne pouvez plus dire quel changement a fait disparaître le problème.
Faut-il prévenir les utilisateurs après un bug en production ?
Si des données soumises, des montants ou des états de commande ont été touchés, prévenez proactivement et indiquez ce qui a été réparé. S'il s'agissait d'une indisponibilité brève et résolue, une mise à jour de statut suffit. Le consigner dans le changelog répond aussi à « existe-t-il une trace » quand un client demande.