Maîtriser Claude Code Partie 9 : Secrets de power user

Les astuces et techniques qui séparent les utilisateurs occasionnels des experts Claude Code. Certaines sont documentées, d'autres découvertes par expérimentation, et d'autres encore proviennent de la décompilation du bundle Claude Code.

Extended Thinking : la vraie histoire

On a introduit le mode réflexion étendue dans la Partie 2, mais voici l'histoire complète.

Tu as probablement entendu parler de « ultrathink » et « think harder ». Voici ce qui fonctionne vraiment selon la documentation officielle d'Anthropic.

La hiérarchie des mots-clés Think

Claude Code associe des phrases spécifiques à des budgets de réflexion. Voici les mots déclencheurs officiellement documentés :

Think (~4 000 tokens) — think

Megathink (~10 000 tokens) — think hard, think deeply, think more, megathink

Ultrathink (~32 000 tokens) — think harder, think very hard, ultrathink

Ultrathink about how to architect this authentication system

Plus le budget est élevé, plus Claude a de « piste mentale » pour considérer plusieurs approches, évaluer les compromis et repérer les cas limites.

Mises à jour de janvier 2026

Quelques changements dans Claude Code 2.1 :

• Réflexion activée par défaut pour Opus 4.5 — Plus besoin de la déclencher manuellement pour les tâches complexes
• Le raccourci est passé de Tab à Alt+T — Évite les activations accidentelles
• Affichage de la réflexion en temps réel — Appuie sur Ctrl+O pour voir le raisonnement de Claude en direct

Quand utiliser chaque niveau

ultrathink (~32K tokens) — Décisions d'architecture, revues de sécurité, debugging complexe, tout ce pour quoi tu planifierais une réunion

think hard / megathink (~10K tokens) — Refactoring multi-fichiers, conception d'API, debugging de problèmes délicats

think (~4K tokens) — Analyse rapide, revue de code, comprendre du code inconnu

Pas de mot-clé — Corrections simples, typos, tâches routinières où la réflexion étendue n'ajoute que de la latence

La règle : Adapte le budget de réflexion à la complexité du problème. Ne lance pas ultrathink pour corriger une typo, et ne saute pas la réflexion pour de l'architecture.

Reste à jour avec les informations récentes

Les données d'entraînement de Claude ont une date limite. Pour les dernières APIs de bibliothèques, les mises à jour récentes de frameworks ou les bonnes pratiques actuelles :

Utilise le serveur MCP Context7 : Récupère la documentation en temps réel, spécifique à chaque version. Voir la Partie 7 : Serveurs MCP pour la configuration.

"use context7 to look up the current API for React Query v5"

Demande à Claude de chercher en ligne : Claude peut effectuer des recherches web pour des informations récentes.

"search online for the latest Supabase auth patterns in 2026"

Ça garantit que tu travailles avec des APIs actuelles, pas des APIs dépréciées issues des données d'entraînement de Claude.

Manœuvres multi-fenêtres

N'attends pas qu'une tâche finisse. Lance plusieurs instances de Claude Code simultanément — chacune dans son propre terminal, chacune avec un contexte isolé.

Notifications sonores : sache quand Claude a fini

Quand tu jongles entre plusieurs fenêtres, tu as besoin de savoir quand Claude termine sans vérifier constamment. Active la cloche du terminal :

Claude config set --global preferredNotifChannel terminal_bell

Tu entendras un bip quand Claude termine une tâche ou a besoin d'une entrée. Plus besoin de changer de contexte pour vérifier l'avancement.

Pour des notifications plus riches, utilise un hook dans ~/.claude/settings.json :

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Ping.aiff"
          }
        ]
      }
    ]
  }
}

Ça joue un son sur macOS chaque fois que Claude a besoin d'attention. Sur Linux, utilise paplay ou aplay à la place. Sur Windows, utilise powershell.exe -c "[System.Media.SystemSounds]::Beep.Play()".

Travail cross-repo : référencer sans modifier

Tu travailles sur un frontend qui appelle une API backend ? Ne lance pas Claude dans les deux repos simultanément. Donne plutôt à Claude un accès en lecture seule au backend depuis ton projet frontend.

Dans le .claude/settings.json de ton frontend :

{
  "permissions": {
    "additionalDirectories": ["../backend-repo/"],
    "allow": [
      "Read(../backend-repo/**)",
      "Grep(../backend-repo/**)"
    ],
    "deny": [
      "Edit(../backend-repo/**)",
      "Write(../backend-repo/**)"
    ]
  }
}

Maintenant Claude peut lire les controllers et les modèles du backend pour comprendre l'API, mais ne peut pas les modifier accidentellement. Demande des choses comme :

"Check ../backend-repo/src/controllers/ for the user endpoints and wire up the frontend to match"

Claude lit le backend, comprend la forme de l'API et n'écrit que dans ton frontend.

Même projet, branches différentes : Git Worktrees

Quand tu as besoin de travailler sur plusieurs fonctionnalités dans le même repo, les git worktrees te permettent de checkout différentes branches dans des répertoires séparés :

# Crée des worktrees pour des fonctionnalités en parallèle
Git worktree add ../myproject-dashboard feature/user-dashboard
Git worktree add ../myproject-notifications feature/email-notifications

Maintenant tu as :

Myproject/                    # branche main
Myproject-dashboard/          # branche feature/user-dashboard
Myproject-notifications/      # branche feature/email-notifs

Lance Claude dans chaque répertoire — des sessions complètement isolées, pas de conflits de changement de branche.

Pourquoi ça fonctionne

• Chaque session Claude a un contexte isolé
• L'accès en lecture seule empêche les modifications accidentelles cross-repo
• Tu peux référencer du code externe sans risquer de modifications
• Le contexte d'une tâche ne pollue pas l'autre

Nettoyer les worktrees

Quand une fonctionnalité est terminée :

Cd myproject
Git merge feature/dashboard
Git worktree remove ../myproject-dashboard

Capture d'écran et images en entrée

Claude Code peut voir des images. Glisse-dépose des captures d'écran directement dans ton terminal.

Comment ça marche

1. Prends une capture d'écran (Cmd+Shift+4 sur Mac)
2. Glisse le fichier image dans ton terminal Claude Code
3. Pose ta question

Cas d'utilisation

Debugging d'interface :

[glisse une capture d'écran d'un layout cassé]
Qu'est-ce qui ne va pas avec ce layout ? Le bouton devrait être aligné à droite.

Implémentation de design :

[glisse une image de maquette]
Implémente ce design en utilisant Tailwind CSS

Captures d'écran d'erreurs :

[glisse une capture d'écran d'un dialogue d'erreur]
Que signifie cette erreur et comment la corriger ?

Génération de diagrammes Mermaid

Demande à Claude de créer des diagrammes visuels que tu peux rendre n'importe où.

Diagrammes d'architecture

Génère un diagramme mermaid montrant le flux d'authentification de cette app

Output :

Où les rendre

• mermaid.live — Éditeur en ligne avec aperçu en temps réel
• GitHub — Rend le mermaid dans les fichiers markdown et les commentaires
• VS Code — Avec l'extension de prévisualisation mermaid
• Notion — Supporte les blocs de code mermaid

Types de diagrammes

Crée un flowchart mermaid montrant les états du traitement des commandes

Génère un diagramme de classes mermaid pour les modèles de données

Fais un diagramme ER mermaid du schéma de la base de données

Le pattern Memory Bank

Persiste le contexte entre les sessions sans surcharger CLAUDE.md. Ça se marie bien avec la stratégie Document + /clear de la Partie 2.

Configuration

Crée un répertoire mémoire :

Mkdir -p .claude/memory

Fichier mémoire de session

# .claude/memory/current-session.md

## Active Focus
Implementing user dashboard feature

## Decisions Made
- Using React Query for data fetching (decided 2024-01-15)
- Chart library: Recharts (lighter than D3 for our needs)
- State: Zustand (team already familiar)

## Blocked On
- Waiting for design review on mobile layout
- Need API endpoint for activity feed

## Recent Changes
- Added DashboardLayout component
- Created useUserStats hook
- Set up Recharts for usage graphs

## Next Steps
1. Implement activity feed once API ready
2. Add export functionality
3. Mobile responsive tweaks

Utilisation des fichiers mémoire

Commence les sessions avec :

Read .claude/memory/current-session.md and continue where we left off

Mets à jour en fin de session :

Update .claude/memory/current-session.md with our progress today

Astuces d'optimisation de tokens

Économise de l'argent et améliore la qualité des réponses.

Préfère /clear à /compact

Mise à jour janvier 2026 : /compact est maintenant instantané (v2.0.64+) et l'auto-compact se déclenche à 75% de capacité. Essaie aussi /context pour vérifier l'utilisation des serveurs MCP avant de compacter.

Comme on l'a vu dans la Partie 2, /compact est tentant mais risqué. Le résumé est opaque — tu ne sais pas ce qui est conservé ou perdu.

La plupart du temps, /clear est mieux :

• 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 dois utiliser /compact, guide-le :

/compact Focus on preserving the authentication flow and database schema decisions

Référence, ne colle pas

Mauvais (gaspille des tokens) :

Voici le code :
[colle 500 lignes]

Corrige le bug dans ça

Bon (efficace) :

Corrige le bug dans src/auth/login.ts autour de la ligne 45

Claude lira le fichier lui-même, en ne chargeant que ce dont il a besoin.

Astuce pro : Copy Path dans VS Code. Clic droit sur n'importe quel fichier → Copy Relative Path (ou Cmd+Shift+Alt+C). Colle le chemin exact au lieu de le taper. Pas de typos, pas d'ambiguïté — particulièrement utile pour les fichiers profondément imbriqués ou quand plusieurs fichiers ont des noms similaires. Combine avec des numéros de lignes pour une précision chirurgicale : src/auth/login.ts:45-60

Le pattern Document & Clear

Mise à jour janvier 2026 : C'est maintenant intégré au Plan Mode. Quand tu acceptes un plan, Claude efface automatiquement le contexte et charge le plan à neuf. Désactive si tu préfères garder le contexte.

Pour le travail complexe multi-session, utilise la documentation explicite :

"Save our progress and remaining TODOs to docs/feature-plan.md"
/clear
"Read docs/feature-plan.md and continue where we left off"

Tu contrôles exactement ce qui persiste. Pas de devinette sur ce que le résumeur a gardé.

Stratégies de changement de modèle

Différents modèles pour différentes tâches.

Quand utiliser chaque modèle

Opus ($$$) — Architecture complexe, revues de sécurité, problèmes nouveaux qui nécessitent une puissance de raisonnement maximale.

Sonnet ($$) — Coding général et tâches quotidiennes. C'est le modèle par défaut qui gère la plupart du travail correctement.

Haiku ($) — Questions rapides, tâches simples, opérations à haut volume où la vitesse compte plus que la profondeur.

Utilisation stratégique des modèles

Commence les fonctionnalités complexes avec opus :

/model opus
Plan the architecture for user permissions system

Passe à sonnet pour l'implémentation :

/model sonnet
Implement the permission checking middleware we discussed

Utilise haiku pour les vérifications rapides :

/model haiku
Does this regex pattern look correct? /^[\w-]+@[\w-]+\.[\w-]+$/

Automatisation en mode headless

Scripte Claude Code pour le CI/CD et l'automatisation avec le flag -p (print).

Utilisation basique

Claude -p "analyze this PR for security issues"

Le flag -p lance Claude en mode non-interactif et quitte quand c'est terminé. Parfait pour les scripts et les pipelines.

Formats de sortie

Contrôle comment les réponses sont retournées :

# Texte brut (par défaut)
Claude -p "summarize this project"

# JSON avec métadonnées
Claude -p "list all TODO comments" --output-format json

# JSON en streaming pour le traitement en temps réel
Claude -p "analyze this code" --output-format stream-json

Auto-approbation des outils

Pré-approuve les outils pour éviter les invites de permission en CI :

# Autorise des outils spécifiques
Claude -p "run tests and fix failures" \
  --allowedTools "Bash,Read,Edit"

# Restreins à des commandes spécifiques
Claude -p "create a commit" \
  --allowedTools "Bash(git diff:*),Bash(git log:*),Bash(git commit:*)"

Exemples de pipelines

# Revue automatique de PR
Git diff HEAD~1 | claude -p "summarize these changes"

# Hook de pre-commit
Claude -p "check staged files for secrets" || exit 1

# Scan de sécurité avec sortie JSON
Claude -p "security review of this codebase" \
  --output-format json \
  --allowedTools "Read,Grep" | jq -r '.result'

Continuation de session

Continue les conversations par programmation :

# Récupère l'ID de session du premier appel
Session_id=$(claude -p "start review" --output-format json | jq -r '.session_id')

# Continue cette session
Claude -p "now check for performance issues" --resume "$session_id"

Raccourcis clavier

Maîtrise-les pour naviguer dans Claude Code plus rapidement.

Raccourcis essentiels

Escape — Interromps Claude en pleine réponse. Utile quand tu vois qu'il part dans la mauvaise direction.

Escape, Escape (double-tap) — Ouvre l'historique des commandes. Parcours tes prompts précédents et relance-les.

Ctrl+C — Annule l'opération en cours complètement.

Ctrl+L — Efface l'affichage du terminal (pas le contexte, juste le désordre visuel).

Flèche haut — Parcours tes prompts récents.

Dans l'extension VS Code

L'extension VS Code de Claude Code apporte les mêmes capacités dans ton éditeur. Ce n'est pas un produit séparé — c'est Claude Code qui tourne nativement dans VS Code, partageant la même configuration, les mêmes commandes et les mêmes serveurs MCP.

Cmd+L — Ouvre le panneau Claude. C'est là que tu passeras le plus de temps — une interface de chat persistante qui comprend ton workspace.

Cmd+Shift+L — Envoie le code sélectionné à Claude. Surligne du code, tape le raccourci, et Claude voit exactement ce que tu regardes.

Cmd+I — Mode d'édition inline. Claude édite le code en place avec une vue diff — accepte ou rejette les changements sans quitter ton fichier.

Cmd+Shift+P → « Claude » — Accède à toutes les commandes Claude depuis la palette de commandes.

L'extension partage ta configuration .claude/, donc les commandes personnalisées, les serveurs MCP et les instructions CLAUDE.md fonctionnent de manière identique. L'avantage principal par rapport au terminal Claude Code : les diffs visuels, les suggestions inline et une intégration éditeur plus serrée.

Saisie vocale : parle à Claude

Quand je suis seul dans la pièce, je passe souvent à la voix. C'est plus rapide que taper pour expliquer des problèmes complexes, et parfois parler d'un problème aide à clarifier ta réflexion avant même que Claude ne réponde.

Sur Mac, la configuration est simple : Réglages Système → Clavier → Dictée → Activer. Ensuite utilise le raccourci de dictée (double-tap Fn par défaut) n'importe où — y compris dans le panneau Claude.

La voix fonctionne particulièrement bien pour :

• Expliquer des bugs que tu fixes depuis des heures
• Décrire des changements d'interface en regardant une maquette
• Questions rapides quand tes mains sont sur le trackpad
• Verbaliser des problèmes en mode rubber duck

La combinaison de la saisie vocale avec la compréhension de Claude donne des conversations sur le code étonnamment naturelles.

Astuces de productivité cachées

Le pattern « Comme si »

Implement this as if you were a senior engineer at Stripe

Review this code as if it's going to production tomorrow

Fixe des attentes de qualité sans exigences explicites.

Le pattern de contrainte

Implement this in under 50 lines

Solve this without adding new dependencies

Les contraintes mènent souvent à de meilleures solutions.

Le pattern « Explique d'abord »

Before implementing, explain your approach in 2-3 sentences

Force Claude à réfléchir avant d'agir. Attrape les mauvaises approches tôt.

Le prompt du canard en plastique

I'm stuck on [problem]. Ask me questions to help me figure it out.

Claude comme partenaire de debugging, pas juste un générateur de code.

La suite

Tu as appris les secrets des power users — ultrathink pour le raisonnement approfondi, les worktrees pour le développement parallèle, le mode headless pour l'automatisation, et les patterns de productivité qui font la différence.

Dans la Partie 10 : Vibe Coding, on conclura avec la philosophie du travail avec l'IA — quand laisser Claude conduire, quand prendre le volant, et comment développer ton intuition pour le développement assisté par IA.