Révision du code généré par l'IA avec Difftastic

Les outils de codage par IA regroupent fréquemment une véritable modification de logique et un reformatage complet dans un seul commit, et un git diff basé sur les lignes noie la seule ligne qui change le comportement dans un écran de rouge et de vert. Difftastic est un outil de diff structurel qui analyse le code en arbres syntaxiques et compare ces arbres plutôt que le texte brut, de sorte que le reformatage pur, le renvoi à la ligne et les modifications d’espacement n’apparaissent comme aucun changement — ne laissant apparaître que les modifications qui altèrent le comportement. Cet article présente difftastic, explique comment l’intégrer à git, et propose un workflow concret pour réviser les commits produits par un agent.

Le problème : les diffs d’IA noient la ligne qui compte

Les agents et assistants tels que Cursor, GitHub Copilot et Claude Code reformatent fréquemment une fonction entière — ou répartissent un long appel sur plusieurs lignes — dans le même commit qui modifie une seule condition. Un diff orienté lignes est incapable de faire la distinction : il marque chaque ligne touchée comme modifiée. Vous vous retrouvez face à un mur de rouge et de vert, et la seule modification qui change le comportement à l’exécution se trouve quelque part à l’intérieur. La révision du code généré par l’IA est précisément la situation où le rapport signal/bruit est le plus critique, car le reformatage est du bruit généré par la machine, tandis que la modification de comportement est ce dont vous êtes responsable lors de la fusion.

Qu’est-ce que difftastic ?

Difftastic est un diff structurel qui compare les fichiers en fonction de leur syntaxe plutôt que de leur texte. Il analyse chaque version avec tree-sitter, construit un arbre syntaxique abstrait et effectue le diff sur ces arbres. La conséquence concrète : si vous reformatez du code de façon à ce qu’il s’étende sur plusieurs lignes, difftastic n’affiche que ce qui a réellement changé, et un bloc déplacé ou renommé est signalé comme un déplacement plutôt que comme une suppression suivie d’un ajout.

Difftastic est écrit en Rust, créé par Wilfred Hughes, et publié en open source sous licence MIT. Il prend en charge plus de 30 langages de programmation via des parseurs tree-sitter — et non les « 50+ » que certaines critiques avancent. Lorsqu’un fichier possède une extension non reconnue, il bascule gracieusement vers un diff orienté lignes avec mise en évidence des mots, de sorte que rien ne se casse pour les langages qu’il ne sait pas analyser.

Installer difftastic et l’intégrer à git

Installez le binaire difft via un gestionnaire de paquets ou cargo, puis enregistrez-le comme outil de diff externe de git :

# macOS
brew install difftastic

# Chaîne d'outils Rust (nécessite Rust 1.85+ à partir de la version 0.69)
cargo install difftastic

Pour une utilisation ponctuelle, passez la configuration en ligne afin de ne rien modifier de façon permanente :

git -c diff.external=difft diff
git -c diff.external=difft show --ext-diff

Pour faire de difftastic votre outil par défaut, ajoutez ceci à ~/.gitconfig, directement depuis le manuel :

[diff]
    external = difft

Cela configure git diff pour utiliser difftastic ; les autres sous-commandes n’ont alors besoin que du flag --ext-diff, par exemple git show --ext-diff et git log -p --ext-diff. La configuration recommandée a changé dans difftastic 0.61 (octobre 2024) ; si vous copiez un extrait d’un ancien article de blog, remplacez-le par la version actuelle du manuel. Préférez l’affichage en ligne à la disposition en deux colonnes par défaut avec --display inline :

difft old.js new.js --display inline

Pourquoi difftastic s’impose pour la révision du code IA ?

Le diff structurel se concentre sur les nœuds syntaxiques modifiés et élimine le bruit des modifications non essentielles. La démonstration la plus parlante est le cas reformatage-plus-un-argument. Supposons qu’un agent prenne une signature de fonction sur une seule ligne et, parce qu’elle dépasse désormais votre limite de longueur de ligne, qu’un formateur la répartisse sur plusieurs lignes — et que l’agent ajoute un argument :

// avant
function createUser(name, email) {}

// après
function createUser(
  name,
  email,
  role,
) {}

Un diff par lignes met en évidence l’intégralité du bloc, car chaque ligne a changé textuellement. Difftastic ne met en évidence que le nouvel argument role — la seule modification qui change le comportement. C’est précisément le type d’ajout subtil qu’un agent peut faire passer inaperçu auprès d’un relecteur qui parcourt un diff bruyant. La même logique s’applique aux extractions : lorsqu’un agent déplace un bloc dans une nouvelle fonction utilitaire, difftastic signale le nouveau nom de fonction comme ajouté, plutôt que d’afficher l’enveloppe et le corps comme une suppression-ajout enchevêtrée.

Un workflow de révision de commits pour les sorties d’agent

Pour ne lire que les modifications sémantiques produites par un agent, ciblez son commit exact :

git show <agent-commit> --ext-diff
# ou réviser toute la branche
git log -p --ext-diff main..agent-branch

Recherchez trois choses : les ajouts et suppressions que difftastic signale réellement comme des changements ; les blocs signalés comme des déplacements ou des renommages plutôt que des réécritures ; et tout hunk qui revient à un diff par lignes classique — c’est le signal que difftastic a rencontré une extension non reconnue ou une erreur d’analyse. Par défaut, difftastic bascule vers un diff orienté lignes dès qu’il rencontre des erreurs d’analyse, un choix conservateur pour ne jamais affirmer que deux fichiers syntaxiquement différents sont identiques. Cela est important pour les sorties d’IA en cours de refactorisation, qui peuvent ne pas s’analyser proprement ; augmentez la tolérance avec export DFT_PARSE_ERROR_LIMIT=20 si un fichier presque valide bascule inutilement.

Pour l’automatisation, difftastic peut vérifier si deux fichiers partagent le même AST sans afficher de diff :

difft --check-only --exit-code before.js after.js

Cela fixe le code de sortie à 0 en l’absence de changements syntaxiques et à 1 en cas de changements — un filtre rapide pour un hook pré-fusion ou une étape CI qui répond à la question : « l’agent a-t-il modifié le comportement, ou s’est-il contenté de reformater ? »

Limites et association de difftastic avec delta

Soyons honnêtes sur les compromis. Difftastic passe relativement mal à l’échelle sur les fichiers comportant un grand nombre de modifications et peut consommer beaucoup de mémoire ; traitez-le donc comme un outil de révision pour des commits spécifiques, et non comme un remplacement complet de git diff. Son affichage côte à côte est généralement satisfaisant, mais peut occasionnellement prêter à confusion. C’est un outil de diff externe, et non un pager git ; il ne s’affiche pas dans l’onglet Files des PR GitHub ni dans la plupart des panneaux de diff des IDE — c’est un outil en ligne de commande local.

La solution pratique est d’utiliser les deux. Conservez un pager texte rapide pour la consultation quotidienne et basculez vers difftastic pour les diffs complexes et chargés en reformatage.

Delta et diff-so-fancy sont basés sur le texte ; aucun des deux ne fait de diff AST. Utilisez delta comme pager par défaut et recourez à difftastic lorsque le diff est noyé dans le bruit de formatage.

Un diff structurel propre est un filtre pré-fusion : il intercepte la ligne qui modifie le comportement avant que vous n’approuviez. Les modifications qui passent quand même — la subtile modification de logique cachée dans un diff d’IA bruyant — sont celles que vous finissez par reconstituer après leur mise en production. Configurez [diff] external = difft dès aujourd’hui, puis révisez votre prochain commit d’agent avec git show <commit> --ext-diff et ne lisez que ce qui a changé.

FAQ

Quelle est la différence entre difftastic et delta ?

Difftastic est un diff structurel qui analyse le code avec tree-sitter et compare des arbres syntaxiques abstraits, de sorte que le reformatage et les renvois à la ligne n'apparaissent comme aucun changement. Delta est un pager basé sur le texte avec coloration syntaxique qui effectue toujours le diff par lignes. Difftastic ne peut pas agir comme un pager git et ne fonctionne que comme un outil de diff externe, tandis que delta fonctionne comme un pager pour la consultation quotidienne. Utilisez delta par défaut et difftastic pour les diffs d'IA chargés en reformatage.

Que se passe-t-il lorsque difftastic rencontre un fichier qu'il ne peut pas analyser ?

Difftastic bascule vers un diff orienté lignes avec mise en évidence des mots dans deux cas : lorsqu'un fichier possède une extension non reconnue, et lorsqu'il rencontre des erreurs d'analyse. Le basculement en cas d'erreur d'analyse est un choix délibéré et conservateur pour que difftastic n'affirme jamais que deux fichiers syntaxiquement différents sont identiques. Cela est important pour les sorties d'IA en cours de refactorisation qui peuvent ne pas s'analyser proprement. Augmentez la tolérance avec la variable d'environnement DFT_PARSE_ERROR_LIMIT lorsqu'un fichier presque valide bascule inutilement.

Difftastic peut-il afficher des diffs dans l'onglet Files des PR GitHub ?

Non. Difftastic est un outil en ligne de commande local qui fonctionne comme outil de diff externe de git, et non comme couche de rendu dans l'onglet Files des PR GitHub ou dans la plupart des panneaux de diff des IDE. Vous l'utilisez via des commandes comme git show avec le flag --ext-diff ou git log -p --ext-diff. Des intégrations tierces existent pour certains outils comme magit, mais la prise en charge dans les onglets PR et les IDE est limitée ; difftastic est donc mieux traité comme une étape de révision en terminal.

Comment vérifier si un commit d'IA a modifié le comportement ou s'est simplement contenté de reformater le code ?

Exécutez difft avec les flags --check-only et --exit-code sur les deux versions d'un fichier. Difftastic vérifie si les fichiers partagent le même arbre syntaxique abstrait sans afficher de diff, en fixant le code de sortie à 0 en l'absence de changements syntaxiques et à 1 en cas de changements. C'est bien plus rapide qu'un diff complet et constitue un filtre efficace pour un hook pré-fusion ou une étape CI qui distingue les véritables modifications de comportement du pur reformatage.