Maîtriser Claude Code Partie 2 : Le Modèle Mental

Voilà une vérité qui sépare les devs qui adorent Claude Code de ceux qui le trouvent frustrant : comprendre comment il pense change tout.

La plupart des gens approchent Claude Code comme un moteur de recherche — tape une question, obtiens une réponse. Mais Claude Code n'est pas un moteur de recherche. C'est un agent autonome qui tourne en boucle, prend des décisions, utilise des outils, et s'ajuste en fonction des résultats. Une fois que tu comprends cette architecture, tu sauras exactement pourquoi certains prompts marchent brillamment alors que d'autres tombent à plat.

La Boucle Agentique : Comment Claude Code Fonctionne Vraiment

Sous le capot, Claude Code exécute un pattern d'une simplicité trompeuse :

Réfléchir → Agir → Observer → Corriger → Répéter

Voilà à quoi ça ressemble en pratique :

1. Réfléchir — Claude analyse ta demande et décide quoi faire
2. Agir — Il utilise un outil (lire un fichier, lancer une commande, éditer du code)
3. Observer — Il voit le résultat de cette action
4. Corriger — Il ajuste son approche en fonction de ce qui s'est passé
5. Répéter — La boucle continue jusqu'à ce que Claude décide que la tâche est terminée

C'est pas une conversation linéaire. C'est une boucle récursive qui continue de tourner jusqu'à ce que Claude décide explicitement qu'il a fini. Le comportement par défaut est continuer jusqu'à résolution, pas répondre une fois et s'arrêter.

Pourquoi c'est important : Quand tu demandes à Claude d'"ajouter l'authentification à cette app", il ne génère pas juste du code pour te le passer. Il lit ton code existant, comprend tes patterns, écrit l'implémentation, lance les tests pour vérifier que ça marche, corrige les problèmes qu'il trouve, et seulement après il fait son rapport. C'est la boucle en action.

La Fenêtre de Contexte : La Mémoire de Travail de Claude

Claude a une "fenêtre de contexte" — pense à ça comme la mémoire de travail. Tout ce que Claude a besoin de savoir sur ta conversation, ton codebase et la tâche en cours doit tenir dans cette fenêtre.

Contexte standard : 200 000 tokens (environ 500 pages de texte)

Contexte étendu : Claude Sonnet 4 supporte maintenant jusqu'à 1 million de tokens via l'API — assez pour des codebases entiers de plus de 75 000 lignes de code. Ça nécessite un accès API tier 4 et coûte 2x pour les tokens d'entrée au-delà de 200K.

Voilà l'insight crucial : chaque message que tu envoies inclut l'intégralité de l'historique de conversation. C'est comme ça que Claude "se souvient" de ce dont vous avez discuté avant. Mais ça veut aussi dire que les longues conversations consomment exponentiellement plus de tokens.

Ce Qui Remplit Ton Contexte

Le contexte vient de plusieurs sources, et elles s'additionnent toutes :

Tes prompts — Chaque message que tu as envoyé dans cette session

Les réponses de Claude — Tout ce que Claude a répondu

Les résultats d'outils — Le contenu des fichiers que Claude a lus, les sorties de commandes, les résultats de recherche

Le contexte système — Le contenu de CLAUDE.md, le statut git, la structure du projet

L'historique de session — L'intégralité des échanges depuis ton dernier /clear

Quand tu demandes à Claude de "lire ce fichier", le contenu entier du fichier est ajouté au contexte. Demande-lui de lire dix fichiers, et tu as potentiellement consommé des milliers de tokens avant même que Claude commence à travailler sur ta vraie demande.

Note sur les Plans d'Abonnement

À quel point tu dois te soucier du contexte dépend de ton plan :

Plans Max 5x / Max 20x — Tu as des limites de tokens confortables. La gestion du contexte reste une bonne pratique pour la qualité du output, mais tu surveilles pas chaque token.

Plan Pro / API pay-as-you-go — Chaque appel d'outil, chaque lecture de fichier, chaque réponse verbeuse te coûte. Une gestion agressive du contexte impacte directement ta facture.

Les stratégies ci-dessous comptent surtout pour les utilisateurs soucieux des coûts, mais même sur les plans illimités, un contexte plus propre produit de meilleurs outputs.

Gérer le Contexte : Les Commandes Qui Comptent

/clear — Le Choix Recommandé par Défaut

/clear

Efface tout. Nouveau départ. Zéro contexte.

Voilà un changement de perspective : /clear devrait être ton défaut, pas ton dernier recours. Les utilisateurs expérimentés de Claude Code clear de manière agressive — pas parce que quelque chose a mal tourné, mais comme pratique standard entre les tâches.

Quand l'utiliser :

• Tu commences une nouvelle feature (toujours)
• Entre des tâches sans rapport (fini l'auth, maintenant tu bosses sur l'UI)
• Quand moins de 50% de ton contexte actuel est pertinent
• Quand Claude semble confus ou tourne en boucle
• Après avoir terminé une feature
• Quand tu remarques des réponses répétitives ou hors sujet

Le pattern /clear + /catchup :

Certains devs créent une commande personnalisée /catchup qui fait lire à Claude tous les fichiers modifiés dans leur branche git. Après /clear, lance /catchup pour rétablir le contexte pertinent sans le bruit. (Voir l'implémentation complète dans la Partie 4)

/clear
/catchup
"Continue l'implémentation du flux de paiement"

Ça te donne un contexte frais avec exactement ce qui est pertinent.

/compact — À Utiliser avec Prudence

Mise à jour janvier 2026 : Depuis la v2.0.64, /compact est maintenant instantané — plus besoin d'attendre. Essaie aussi /context pour vérifier si les serveurs MCP mangent de l'espace avant de compacter.

/compact

Au lieu de tout effacer, /compact crée un résumé intelligent de ta conversation et repart avec ce résumé comme contexte.

La vérité honnête : Beaucoup d'utilisateurs expérimentés évitent /compact quand c'est possible. La résumation automatique est opaque — tu ne sais pas exactement ce qui est préservé ou perdu.

Quand /compact a du sens :

• Tu es en pleine tâche et dois préserver des décisions spécifiques
• Tu as un contexte complexe qui serait pénible à reconstruire
• Tu veux continuer mais le contexte est à 70%+

Quand préférer /clear :

• Tu commences quelque chose de nouveau
• Moins de la moitié de ton contexte est pertinent
• Tu peux facilement rétablir ce qui compte

Si tu utilises /compact, guide-le :

/compact Concentre-toi sur la préservation de notre implémentation d'authentification
et les décisions de schéma de base de données qu'on a prises

Ça dit à Claude ce qui compte le plus dans le résumé.

La Stratégie "Documenter & Clear"

Pour les tâches complexes multi-sessions, il y a un meilleur pattern que de faire confiance à la compaction :

1. Documenter : Fais écrire à Claude son plan et sa progression dans un fichier markdown
2. Clear : /clear la session complètement
3. Continuer : Repars de zéro en disant à Claude de lire le markdown et de continuer

"Sauvegarde notre progression actuelle et les TODOs restants dans docs/auth-migration-plan.md"
/clear
"Lis docs/auth-migration-plan.md et continue là où on s'est arrêtés"

Ça crée une mémoire externe durable qui survit parfaitement aux sessions — pas de résumation avec perte.

Mise à jour janvier 2026 : Ce pattern est maintenant intégré dans le Mode Plan. Quand tu acceptes un plan, Claude efface automatiquement le contexte et charge le plan dans une fenêtre fraîche. Ça améliore significativement le respect du plan. Tu peux opt out si tu préfères garder le contexte.

Auto-Compact : Le Filet de Sécurité sur Lequel Tu Ne Devrais Pas Compter

Mise à jour janvier 2026 : L'auto-compact se déclenche maintenant à 75% de capacité (pas 92-95%), laissant ~50k tokens libres pour le raisonnement. C'est une amélioration significative.

Claude Code compacte automatiquement quand ton contexte atteint la capacité. Ça empêche de manquer d'espace en pleine tâche.

Mais n'en dépends pas trop. L'auto-compaction reste un comportement d'urgence, pas une stratégie. Quand ça se déclenche, tu as peut-être déjà subi une dégradation de la qualité de l'output.

Meilleure approche : clear proactivement aux points de rupture naturels plutôt que de laisser le contexte enfler jusqu'à ce que le système intervienne.

Extended Thinking : Quand Claude a Besoin de Réfléchir Plus Fort

Claude Code supporte des déclencheurs de mode réflexion qui allouent plus de budget de raisonnement :

"think" — ~4 000 tokens de budget réflexion

"think hard" — ~10 000 tokens de budget réflexion

"ultrathink" — ~31 999 tokens de budget réflexion (maximum)

Inclus juste ces mots dans ton prompt :

"ultrathink about how to architect this payment system"
"think hard about the edge cases in this validation logic"

Quand les utiliser :

• Décisions d'architecture → ultrathink + mode plan
• Bloqué en boucle → ultrathink pour débloquer
• Debug complexe → think hard
• Tâches de routine → pas besoin de mot-clé

Note : Ces mots-clés ne fonctionnent que dans l'interface terminal de Claude Code, pas dans le chat web ou l'API. Pour un approfondissement sur tous les mots déclencheurs et les dernières mises à jour, voir la Partie 9 : Secrets de Power User.

Mode Plan : Réfléchir Avant d'Agir

C'est là que la plupart des gens se plantent : ils demandent à Claude de faire des choses sans d'abord lui demander de planifier des choses.

Le mode plan est un état lecture seule où Claude recherche, analyse et propose des approches sans toucher à aucun fichier. C'est inestimable pour les tâches complexes.

Comment Entrer en Mode Plan

Appuie sur Shift+Tab pour cycler entre les modes :

1. Premier appui : Mode auto-accept (Claude ne demande pas la permission pour chaque action)
2. Deuxième appui : Mode plan (Claude peut seulement lire, pas écrire)
3. Troisième appui : Retour au mode édition normal

Regarde le prompt en bas de ton terminal pour voir dans quel mode tu es.

Ce Que Claude Peut Faire en Mode Plan

Le mode plan restreint Claude aux outils de recherche uniquement :

• Read — Voir les fichiers et le contenu
• LS/Glob — Lister les répertoires et chercher des patterns de fichiers
• Grep — Chercher du contenu dans les fichiers
• WebSearch/WebFetch — Rechercher en ligne
• Task — Lancer des sous-agents de recherche
• TodoRead/TodoWrite — Gérer les listes de tâches

Ce qu'il ne peut pas faire : Éditer des fichiers, lancer des commandes, faire des modifications.

Quand Utiliser le Mode Plan

Explorer du code inconnu :

[Entre en mode plan avec Shift+Tab deux fois]
"Explique comment l'authentification fonctionne dans ce codebase.
Quels fichiers gèrent les sessions ? Où les tokens sont-ils validés ?"

Claude fouille dans ton code et t'explique sans risque de casser quoi que ce soit.

Planifier un refactoring :

"Je veux migrer de REST à GraphQL.
Qu'est-ce qui devrait changer ? Quel est l'ordre des opérations ?"

Claude analyse les dépendances et propose un chemin de migration.

Comprendre l'architecture :

"Comment tu aborderais l'ajout de notifications temps réel à cette app ?
Quels sont les trade-offs entre WebSockets et SSE ici ?"

Claude considère ton code existant et propose des options.

L'insight clé : planifier coûte peu, annuler coûte cher. Cinq minutes en mode plan sauvent souvent des heures à reverter de mauvaises implémentations.

L'Analogie du Dev Junior (Affinée)

Dans la Partie 1, on a présenté le modèle mental du "dev junior enthousiaste". Affinons-le maintenant que tu comprends l'architecture :

Claude Code c'est comme un dev junior très compétent qui :

A besoin d'instructions claires — Les demandes vagues produisent des résultats vagues parce que la boucle agentique n'a pas de condition d'arrêt claire

Bénéficie du contexte — Plus d'informations pertinentes signifie une meilleure sélection d'outils et moins d'itérations gaspillées

Fonctionne mieux avec des tâches spécifiques — "Ajoute la gestion d'erreurs à la fonction login" donne un état de complétion clair ; "améliore le code" non

Apprend des patterns de ton projet — Claude observe les conventions dans les fichiers qu'il lit et les applique aux fichiers qu'il écrit

Demande avant de faire de gros changements — Le système de permissions existe parce que la boucle s'exécuterait sinon indéfiniment

Peut se retrouver bloqué en boucle — Si une tâche n'est pas bien définie, Claude peut répéter des actions similaires sans progresser

Patterns de Prompting Efficaces

Maintenant que tu comprends la boucle, voilà comment écrire des prompts qui travaillent avec elle :

Sois Spécifique sur la Complétion

La boucle a besoin de savoir quand s'arrêter.

❌ "Corrige les bugs"
   (Quels bugs ? Comment Claude saura qu'il a fini ?)

✅ "Corrige l'exception null pointer dans src/auth.ts ligne 42
   où user.email est accédé avant le null check"
   (Emplacement spécifique, problème spécifique, complétion claire)

Fournis le Contexte en Amont

Chaque appel d'outil consomme des tokens et du temps. Aide Claude à trouver ce dont il a besoin plus vite.

❌ "Ajoute une page de login"
   (Claude doit explorer tout ton codebase pour comprendre les patterns)

✅ "Ajoute une page de login en utilisant le même style que src/pages/signup.tsx
   et notre service auth dans src/services/auth.ts"
   (Claude sait exactement où regarder)

Note : Sur les plans Max 5x/20x avec des limites de tokens généreuses, tu peux te permettre de laisser Claude explorer plus librement. Mais même là, les références spécifiques produisent des résultats plus rapides et plus consistants.

Découpe les Grosses Tâches

Une longue boucle est pire que plusieurs courtes boucles.

❌ "Construis un dashboard utilisateur complet avec paramètres,
    notifications et gestion de profil"
   (Scope massif, ordre flou, facile de se perdre)

✅ Étape 1 : "Crée le composant layout du dashboard"
   Étape 2 : "Ajoute le panneau de paramètres"
   Étape 3 : "Implémente les notifications"
   Étape 4 : "Construis la gestion de profil"
   (Points de complétion clairs, plus facile de corriger le cap)

Référence les Fichiers par Chemin

Ne fais pas chercher à Claude des patterns qu'il pourrait trouver directement.

❌ "Utilise le même pattern que les autres composants"
   (Claude doit lire chaque composant pour trouver le pattern)

✅ "Suis le pattern dans src/components/Button.tsx"
   (Une lecture de fichier, consommation de contexte minimale)

Quand Claude Se Bloque

Signes que la boucle agentique tourne sans progresser :

• Réponses répétitives (mêmes suggestions encore et encore)
• Logique circulaire (essayer le même fix à répétition)
• Poser des questions déjà posées
• Produire du code incorrect similaire en boucle

Solutions, par ordre :

1. /clear et repart de zéro — Le plus efficace. Un contexte propre débloque souvent immédiatement.

2. Utilise ultrathink — "ultrathink about this problem" alloue le budget de raisonnement maximum et débloue souvent là où les prompts normaux échouent.

3. Fournis plus de contexte spécifique — La boucle cherche peut-être largement parce qu'elle ne sait pas où regarder.

4. Découpe la tâche plus petit — La condition de complétion est peut-être trop vague.

5. Essaie un autre angle — "Au lieu de corriger cette fonction, réécrivons-la de zéro."

6. Passe sur Opus — Si tu es sur Sonnet (défaut du plan Pro), passer sur Opus via /model peut aider pour le raisonnement vraiment complexe. Les utilisateurs Max ont déjà Opus par défaut.

La Boucle de Feedback

L'utilisation efficace de Claude Code est itérative. N'attends pas la perfection du premier coup.

Toi : Demande initiale
Claude : Première tentative
Toi : "Bon début, mais la gestion d'erreurs ne couvre pas les défaillances réseau"
Claude : Tentative affinée
Toi : "Mieux. Tu peux aussi ajouter du logging ?"
Claude : Version finale
Toi : Accepter

C'est pas Claude qui échoue — c'est la boucle agentique qui fonctionne comme prévu. Chaque itération ajoute des informations qui guident le cycle suivant.

Calibration de Confiance dans le Temps

Ta relation avec Claude Code devrait évoluer :

Semaine 1 : Revois chaque changement attentivement. Comprends ce que Claude fait et pourquoi.

Semaine 2 : Autorise le mode auto-accept pour les opérations sûres (lecture, fichiers de test, documentation).

Mois 1 : Fais confiance pour les tâches routinières. Vérifie les refactorings complexes et tout ce qui touche aux chemins critiques.

En continu : Vérifie toujours le code critique pour la sécurité, les opérations de base de données, et tout ce qui a des effets externes.

L'objectif n'est pas la confiance aveugle — c'est la confiance éclairée. Tu entraînes ton intuition pour savoir quand Claude a besoin de supervision.

Anti-Patterns à Éviter

Coller des fichiers entiers dans ton prompt — Laisse Claude les lire lui-même. "Lis src/auth.ts et explique la gestion des sessions" c'est mieux que de coller 500 lignes.

Ignorer les questions de Claude — Quand Claude demande une clarification, c'est parce que la boucle n'a pas assez d'informations pour avancer en confiance. Réponds complètement.

Valider les permissions à la va-vite — Lis ce que tu approuves. "Toujours autoriser" c'est pratique mais ça supprime un contrôle de sécurité.

Garder un contexte périmé — /clear ne coûte rien. Un contexte périmé coûte des tokens et de la précision.

Utiliser Claude pour des tâches triviales — Parfois taper git status est plus rapide que d'expliquer ce que tu veux voir.

La Suite

Tu comprends maintenant comment Claude Code pense. Dans la Partie 3 : Configuration du Projet, on va plonger dans CLAUDE.md — le fichier qui façonne le comportement de Claude pour ton projet spécifique. Un CLAUDE.md bien conçu fait la différence entre un Claude qui comprend ton codebase et un Claude qui lutte contre tes patterns.