Comment annuler les modifications d’un agent de code IA

Pour annuler les modifications d’un agent de code IA, regarde ce qui a changé, puis utilise la commande Git adaptée : git restore pour les fichiers modifiés, git clean pour les nouveaux fichiers et git revert pour un commit. Fais d’abord une copie de sécurité avec git stash. La commande /rewind de Claude Code peut aussi restaurer le code, mais elle ne suit pas toutes les modifications.

Ce guide commence une fois que tu as décidé d’abandonner le travail ; le guide pour vérifier les modifications de code de l’IA t’aide à trancher. Mono montre ce qui a changé mais ne l’annule pas : les commandes sont donc les mêmes avec Mono.

1. Arrête l’agent et regarde ce qui a changé

Commence par arrêter l’agent. Dans Mono, le bouton d’envoi devient un bouton d’annulation pendant que l’agent travaille. Dans un terminal ouvert dans le dossier du projet, lance :

git status
git log --oneline -5

La première commande liste les fichiers modifiés, supprimés, indexés et nouveaux. La seconde montre les commits récents, y compris ceux de l’agent. Repère les modifications qui viennent de toi : les commandes d’annulation ne savent pas qui a écrit une ligne.

Dans Mono, « Afficher les modifications » liste les fichiers modifiés et nouveaux depuis le dernier commit : un commit fait par l’agent n’y apparaît donc pas.

2. Fais d’abord une copie de sécurité

Les commandes restore et clean effacent définitivement le travail qui n’est pas dans un commit, alors sauvegarde tout avant :

git stash push --include-untracked -m "before undo"
git stash apply --index

La première enregistre tes fichiers modifiés et nouveaux, puis nettoie l’arbre de travail ; la seconde les remet en place en conservant ce qui était indexé. Rien ne semble avoir changé, mais git stash list contient désormais une copie nommée « before undo ».

Si tu annules trop de choses, git restore --source "stash@{0}" <path> récupère un fichier modifié depuis le stash le plus récent.

3. Annule un fichier ou une partie d’un fichier

Choisis la commande la plus ciblée :

• git restore <path> abandonne les modifications non indexées de ce fichier.
• git restore --staged <path> retire une modification de l’index, mais la garde dans le fichier.
• git restore -p <path> te demande quoi faire pour chaque partie modifiée (hunk), ce qui aide quand l’agent et toi avez modifié le même fichier.
• git clean -n <path> liste les fichiers non suivis que git clean -f <path> supprimerait. Indique toujours un chemin.

La documentation de git restore explique chaque option.

4. Annule tout ce que l’agent a laissé sans commit

Si aucune des modifications ne vient de toi, abandonne-les toutes depuis la racine du projet avec git restore --staged --worktree ., puis git clean -n . et git clean -f . pour les nouveaux fichiers. Sinon, procède chemin par chemin.

Voici un exemple fictif : tu as demandé à un agent de renommer la classe CSS .btn-primary en .button-main dans un projet « tidy-recipes ». Plus tôt, il a créé un commit de mise à jour du lockfile que personne n’avait demandé. Cette fois, il a changé la classe dans 3 fichiers, reformaté 12 fichiers sans rapport et créé styles/tokens.css. Pendant ce temps, tu as modifié README.md à la main, et tu veux garder cette modification.

Après la copie de sécurité, restaure les fichiers de l’agent (ici, src/ et styles/main.css) et supprime son nouveau fichier :

git restore src/ styles/main.css
git clean -n styles/tokens.css
git clean -f styles/tokens.css

N’utilise pas git restore . ici : la commande supprimerait aussi ta modification du README. Si tu avais des modifications dans src/, nomme les fichiers de l’agent un par un.

Maintenant, git status ne liste plus que README.md, et git diff ne montre que tes lignes. Le commit du lockfile est toujours là.

5. Annule un commit que l’agent a déjà fait

git revert enregistre un nouveau commit qui inverse un commit précédent. La documentation de git revert indique qu’il faut un arbre de travail propre. Mets donc d’abord de côté ta modification du README :

git stash push -m "readme" README.md
git revert <lockfile commit>
git stash pop

Utilise le hash donné par git log, et ajoute --no-edit pour ne pas passer par l’éditeur de message. git stash pop récupère « readme » et laisse « before undo » dans la liste. Maintenant, git status ne liste plus que README.md, et git log --oneline affiche Revert "Update lockfile" tout en haut.

Pour un commit déjà poussé, préfère revert à git reset, qui réécrit un historique que d’autres ont peut-être déjà récupéré. Si un commit semble perdu après un reset ou un rebase, git reflog liste les commits sur lesquels tu t’es trouvé récemment, avec leurs hashs.

6. Utilise les points de contrôle de l’agent, avec Git en secours

Claude Code enregistre un point de contrôle avant chaque prompt : lance /rewind, ou appuie deux fois sur Échap avec un prompt vide, pour restaurer le code, la conversation ou les deux. Sa documentation sur les points de contrôle en donne les limites : les modifications faites par des commandes shell ne sont pas suivies, les modifications extérieures ne sont généralement pas capturées, et les points de contrôle ne remplacent pas la gestion de versions. Leur disponibilité dépend aussi de l’application dans laquelle tu fais tourner l’agent.

Fais donc de Git ton filet de sécurité :

• Fais un commit ou crée une branche avant chaque tâche, pour que « le dernier commit » veuille dire « avant l’agent ».
• Demande à l’agent de ne pas faire de commit sans te demander, par exemple dans ton fichier AGENTS.md.
• Laisse les demandes d’autorisation activées. Le Mode YOLO de Mono, qui accepte toutes les demandes de l’agent, est désactivé par défaut. Consulte ce qu’il faut vérifier avant d’autoriser.

Dans Mono, la carte d’un projet ouvre un terminal dans le dossier du projet sur ton ordinateur, depuis ton téléphone aussi (voir le guide pour coder à distance). Mono n’est pas encore disponible, mais tu peux rejoindre la liste d’attente.