Claude Code CLI : mode plan, diff et validations disciplinées

Vous savez formuler un prompt borné et votre projet a un CLAUDE.md utile. Mais il vous manque encore un rituel de contrôle : forcer un plan avant l’action, relire les diffs proposés, et lancer une validation systématique après chaque changement. C’est cette discipline qui transforme une session Claude Code correcte en session fiable.

Ce que vous allez apprendre

• Distinguer les trois modes d’exécution : default, plan, acceptEdits
• Activer et sortir du mode plan proprement
• Exiger un plan avant toute modification sur lab-claude
• Relire un diff en 30 secondes avant d’accepter
• Gérer un diff long sans se noyer
• Enchaîner ruff + pytest + git diff après chaque action
• Ajouter mypy au rituel quand le projet grossit
• Savoir ce que les hooks changeront dans l’étape suivante

Pourquoi un rituel vaut mieux qu’une vigilance ponctuelle

La vigilance s’épuise. Un rituel, non. Les défauts typiques sans rituel :

• un diff accepté sans relecture parce que “ça semble ok”
• une suite de modifications avant la première validation
• un git status découvert trop tard, avec 8 fichiers touchés au lieu de 2

Le rituel de ce guide tient en 4 gestes répétés à chaque petit changement. C’est volontairement court pour que vous l’appliquiez vraiment.

Prérequis

• lab-claude avec CLAUDE.md renseigné (voir configurer CLAUDE.md)
• uv run ruff check . et uv run pytest -q verts
• Connaissance des prompts bornés (voir prompting de base)

Les trois modes d’exécution à connaître

Claude Code propose trois modes qu’on bascule avec Shift + Tab dans la session :

Mode	Comportement	Quand l’utiliser
default	Claude demande confirmation avant chaque action sensible (écriture, suppression, commande shell)	Utilisation quotidienne, tâches normales
plan	Claude n’exécute rien, il ne propose que des plans	Début de session, tâche non cadrée, reprise après dérive
acceptEdits	Claude enchaîne les édits sans confirmation à chaque diff	Tâches répétitives et bien cadrées, en toute confiance

Glissez pour voir

Règle pratique pour débuter : restez en default ou plan. Le mode acceptEdits n’a de valeur qu’une fois le rituel solide, et seulement pour des tâches dont vous avez déjà validé la forme plusieurs fois.

Étape 1 : activer le mode plan

Le mode plan empêche Claude d’exécuter tant que vous n’avez pas validé son plan. Deux façons de l’activer :

• Raccourci clavier : Shift + Tab bascule entre les modes (default → acceptEdits → plan → default)
• Prompt explicite : ajouter Propose un plan en 3 étapes. N'exécute rien tant que je n'ai pas validé.

Préférence recommandée au début

Utilisez la formulation explicite au début. Elle force l’habitude et reste lisible dans l’historique de session. Le raccourci devient naturel ensuite.

Étape 2 : structurer le rituel en 4 gestes

Le rituel à répéter pour chaque petit changement :

1. Plan : demandez un plan court, borné aux fichiers cibles
2. Diff : relisez ce que Claude propose avant d’accepter
3. Validation technique : uv run ruff check . puis uv run pytest -q
4. Contrôle final : git diff pour vérifier le périmètre réellement touché

Schéma :

Plan -> Diff -> ruff + pytest -> git diff

Si un des 4 gestes échoue, on revient à l’étape précédente sans enchaîner.

Étape 3 : dérouler le rituel sur lab-claude

1. Ouvrez lab-claude et lancez Claude

   cd ~/Projets/lab-claude
   claude

2. Demandez un plan en mode plan

   Propose un plan en 3 étapes pour ajouter un endpoint /version
   qui renvoie la version de FastAPI.
   Limite le périmètre à app/main.py et tests/.
   N'exécute rien tant que je n'ai pas validé.

3. Validez le plan et demandez une seule étape

   Exécute uniquement l'étape 1 du plan validé.
   Affiche le diff complet avant d'appliquer.

4. Relisez le diff avant d’accepter

   Regardez : les fichiers touchés correspondent-ils au périmètre ? Y a-t-il du code non demandé (commentaires, imports, helpers) ?

5. Lancez la validation technique

   uv run ruff check .
   uv run pytest -q

6. Contrôle final avec Git

   git diff
   git status

Étape 4 : relire un diff en 30 secondes

Une relecture de diff efficace ne cherche pas à tout comprendre. Elle répond à 3 questions :

• Les fichiers touchés sont-ils dans le périmètre annoncé ?
• Y a-t-il du code non demandé (imports inutiles, commentaires génériques, refactoring spontané) ?
• La signature publique (routes, types, noms) change-t-elle de façon non prévue ?

Si vous répondez “non/non/non” en 30 secondes, acceptez. Sinon, refusez et reformulez.

Accepter, refuser, éditer : quand utiliser quoi

Claude Code propose généralement 3 actions sur un diff :

Action	Quand l’utiliser
Accepter	Diff conforme au plan et au périmètre
Refuser	Diff hors périmètre ou non conforme aux conventions
Éditer / demander modif	Proche du besoin, mais un détail à ajuster

Glissez pour voir

Ne refusez pas par réflexe. Mais ne rectifiez pas à la main ce que Claude peut refaire correctement avec une reformulation courte.

Relire un diff long sans se noyer

Un diff de 200 lignes n’est pas relisible en 30 secondes. Trois stratégies pour ne pas abandonner :

1. Fichier par fichier : relisez un fichier à la fois, pas le diff global. Validez la cohérence locale avant de passer au suivant.

2. Nouveaux symboles d’abord : concentrez-vous sur les nouvelles fonctions, classes et routes. Le reste (refactor, renommage) se relit après.

3. Demander un résumé : si le diff dépasse la limite raisonnable, demandez à Claude :

   Résume le diff en 5 points maximum :
   fichiers touchés, intention, risques, changements non demandés, suites.

Si le diff est trop gros pour la relecture, c’est souvent le signal que le plan était trop large. Revenez au plan, découpez, et rejouez.

Rituel étendu : ajouter mypy quand le projet grossit

Le duo ruff + pytest suffit pour lab-claude. Quand un projet ajoute du typing strict ou plusieurs modules, le rituel s’étend :

uv run ruff check .
uv run mypy app
uv run pytest -q

Règle d’intégration : ajoutez mypy au rituel quand il tourne en moins de 30 secondes sur le projet. Au-delà, gardez-le en pré-commit, pas dans le rituel de session.

Pensez aussi à refléter ce choix dans CLAUDE.md pour que Claude propose la bonne commande de validation sans que vous ayez à la redicter.

Exemple de permissions pour automatiser le rituel

Pour ne plus approuver chaque commande de validation, autorisez-les dans .claude/settings.json à la racine du projet :

{
  "permissions": {
    "allow": [
      "Bash(uv run ruff check:*)",
      "Bash(uv run pytest:*)",
      "Bash(uv run mypy:*)",
      "Bash(git diff:*)",
      "Bash(git status:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(git push:*)"
    ]
  }
}

Ce réglage garde l’interdiction explicite des commandes sensibles tout en fluidifiant le rituel.

Teaser : automatiser le rituel avec les hooks

La prochaine étape logique est d’automatiser ce rituel avec les hooks Claude Code. Un hook post-edit peut par exemple lancer ruff automatiquement après chaque modification, ou refuser un commit si pytest échoue.

Ce sujet dépasse la phase débutant de cette série. Retenez simplement que :

• ce que vous installez ici à la main est la base d’un hook automatisable
• plus votre rituel manuel est stable, plus l’automatisation sera simple ensuite
• sans rituel préalable, les hooks produisent du bruit plutôt que de la sécurité

Installer le rituel comme habitude

Quelques astuces pour que le rituel tienne :

• Gardez un second terminal ouvert uniquement pour ruff + pytest + git diff
• Ajoutez à CLAUDE.md une ligne : Après chaque modification, rappelle la commande de validation à lancer.
• Préférez 5 petits cycles plutôt qu’un gros changement “testé à la fin”

Erreurs fréquentes

Symptôme	Cause probable	Correction
Diff accepté puis tests rouges	Relecture trop rapide	Forcer les 3 questions à voix haute avant d’accepter
Plusieurs fichiers touchés hors scope	Plan non borné	Rejouer un prompt avec liste explicite des fichiers autorisés
Tests verts mais git diff inquiétant	Refactoring spontané accepté	Refuser et reformuler : “garde la même structure de fichiers”
Rituel sauté par manque de temps	Pas d’automatisation	Préparer les commandes dans un alias shell

Glissez pour voir

Checklist de fin de guide

• Je sais activer le mode plan en deux manières
• Je déroule les 4 gestes sans les sauter
• Je refuse un diff hors périmètre au lieu de corriger à la main
• Je lance ruff + pytest + git diff après chaque changement
• J’ai ajouté un rappel de validation dans CLAUDE.md

À retenir

• Le mode plan est la meilleure protection contre les modifications précipitées
• La relecture de diff se fait en 30 secondes sur 3 questions
• La validation technique ne remplace pas git diff : les deux sont complémentaires
• Un rituel court et répété bat une vigilance ponctuelle

Prochaines étapes

Erreurs courantes et recadrage Reprendre le contrôle quand une session dérive malgré le rituel

settings.json avancé Verrouiller permissions et attribution au niveau du projet

Configurer CLAUDE.md Revoir les règles persistantes qui alimentent le rituel

×

📖 Voir la documentation →