Techniques avancées Claude Code : maîtrisez les patterns de

1. Context engineering : la méta-compétence

Le contexte est primordial dans Claude Code. La qualité de vos résultats est directement proportionnelle à la qualité de votre contexte. Cette section vous apprend à maîtriser le context engineering comme un pro.

Comprendre la fenêtre de contexte

Claude Code dispose d'une fenêtre de contexte de 200K tokens. Voyez-la comme la RAM de votre assistant IA :

Qu'est-ce qui consomme du contexte ?

Toutes les actions ne se valent pas. Voici le coût réel :

Visualiseur de contexte interactif

Utilisez cet outil interactif pour visualiser comment les différentes activités consomment votre fenêtre de contexte de 200K tokens :

Symptômes d'épuisement du contexte

Apprenez à reconnaître quand le contexte s'épuise :

La commande Compact en profondeur

Quand vous lancez /compact, Claude :

1. →Résume la conversation jusqu'ici
2. →Préserve les informations essentielles (structure du projet, tâche en cours, décisions récentes)
3. →Supprime les détails verbeux (anciens diffs, sorties longues, discussions résolues)
4. →Libère typiquement 40-60 % du contexte

Une observation récurrente des ingés seniors qui livrent avec Claude Code : le context engineering n'est pas du « prompt engineering déguisé ». Les fils sur r/ClaudeAI et r/ChatGPTCoding reviennent sur le même constat — la qualité d'une session de code de plusieurs heures se joue dans les 2 000 premiers tokens. Ce que vous mettez dans le system prompt, ce qui vit dans CLAUDE.md, les fichiers que vous chargez explicitement versus ceux que le modèle découvre via Grep, et la façon dont vous délimitez la tâche : tout ça se compose. La documentation officielle d'Anthropic sur le prompt engineering l'évoque, mais les vrais playbooks émergent surtout des auteurs de repos qui livrent sous deadline.

Ce que la communauté conteste à juste titre dans le hype : aucun prompt habile ne rattrape une mauvaise stratégie de retrieval. Si le modèle ne voit pas le fichier qui contient l'invariant, il en invente un. Les praticiens sur r/LocalLLaMA et r/MachineLearning documentent ce point depuis des années — le cadrage honnête, c'est que Claude Code est un système de retrieval avec un modèle de langage attaché, pas l'inverse. Des travaux comme « Lost in the Middle » formalisent ce que tout utilisateur de long contexte sait déjà : la position compte, et une fenêtre de 200k ne signifie pas 200k tokens d'attention utile.

Règle pragmatique : traitez le contexte comme un working set, pas comme un historique. Avant chaque phase majeure — design, implémentation, revue — élaguez agressivement, rechargez seulement l'essentiel, et commit un état écrit court (un STATE.md) à partir duquel vous pouvez reconstruire la session. Ce n'est pas du théâtre ; c'est ce qui empêche les longues sessions de dériver vers l'hallucination.

2. Mémoire de session vs mémoire persistante

Claude Code dispose de deux systèmes de mémoire distincts. Comprendre la différence est crucial :

Le power pattern CLAUDE.md

CLAUDE.md est votre mémoire projet persistante. Claude le lit automatiquement à chaque lancement.

# CLAUDE.md

## Projet : Plateforme e-commerce
Stack technique : Next.js 14, TypeScript, Prisma, PostgreSQL

## Décisions prises
- Auth JWT (pas de sessions) pour le scaling horizontal
- Server Components par défaut, Client uniquement quand nécessaire
- Toutes les routes API retournent le pattern Result<T, AppError>

## Standards de code
- Pas de types `any` - utiliser `unknown` avec des type guards
- Toutes les fonctions doivent avoir des commentaires JSDoc
- Tests requis pour toute logique métier

## Focus du sprint actuel
- Système d'authentification utilisateur (70 % complété)
- Suivant : implémenter la rotation des refresh tokens

Créez votre CLAUDE.md parfait

Utilisez cet éditeur interactif pour créer un CLAUDE.md personnalisé pour votre projet. Choisissez parmi les modèles et personnalisez selon vos besoins :

Pattern de passation de session

En fin de session, créez un document de passation pour maintenir la continuité :

# Passation de session - 2025-01-15 18:00

## Accompli
- Implémenté la génération de tokens d'accès JWT
- Ajouté le endpoint /auth/login
- Créé le modèle User avec Prisma

## État actuel
- Login fonctionne pour les identifiants valides
- Refresh tokens : PAS ENCORE IMPLÉMENTÉS
- Tests : 80 % de couverture sur le module auth

## Prochaine session
1. Implémenter la génération de refresh tokens
2. Ajouter la rotation des tokens au refresh
3. Écrire les tests d'intégration pour le flux complet

## Fichiers clés
- src/auth/tokens.ts (logique principale)
- src/routes/auth.ts (endpoints)
- prisma/schema.prisma (modèle User)

3. Prompts structurés en XML

Pour les demandes complexes, les balises XML fournissent une organisation sémantique qui aide Claude à distinguer les instructions, le contexte et les contraintes.

Structure de base

<instruction>
  Votre description de tâche principale ici
</instruction>

<context>
  Informations de fond, détails du projet
</context>

<constraints>
  - Limitation 1
  - Exigence 2
</constraints>

<output>
  Format ou structure attendu
</output>

Quand utiliser les balises XML

Exemple concret

Voici un prompt de qualité production pour une revue de sécurité :

<instruction>
Examine ce middleware d'authentification pour détecter les vulnérabilités de sécurité
</instruction>

<context>
Application financière manipulant des données utilisateur sensibles.
Doit respecter OWASP Top 10 et la conformité PCI DSS.
</context>

<code>
async function authenticate(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'No token' });
  
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  req.user = decoded;
  next();
}
</code>

<constraints>
- Signaler les risques de sécurité avec des niveaux de sévérité
- Considérer les attaques temporelles et les fuites de tokens
- Suggérer des alternatives conformes PCI DSS
</constraints>

<output>
1. Problèmes de sécurité trouvés (Critique/Élevé/Moyen/Faible)
2. Corrections de code spécifiques avec exemples
3. Recommandations de renforcement supplémentaires
</output>

4. Ancres sémantiques

Les ancres sémantiques sont des termes techniques précis qui activent des patterns spécifiques dans les données d'entraînement de Claude. Des termes vagues produisent du code générique ; des ancres précises produisent des implémentations de niveau expert.

La différence de précision

Comment appliquer les ancres sémantiques

Ajoutez-les à votre CLAUDE.md :

# Principes d'architecture

Suivre ces patterns explicitement :
- **Architecture** : Architecture hexagonale (Ports & Adapters)
- **Gestion d'erreurs** : Railway Oriented Programming - retourner Result<T, E>
- **Tests** : TDD école de Londres - mocker les collaborateurs, tester les comportements
- **Documentation** : ADR (Architecture Decision Records) pour les choix

Ou utilisez-les en ligne :

Refactorise le service utilisateur en suivant le Domain-Driven Design (Evans).
Applique le pattern Repository pour la persistance et assure une 
Screaming Architecture où la structure des packages révèle l'intention.

5. Mode plan et OpusPlan

Le mode plan est le mode « regarder sans toucher » de Claude Code, essentiel pour l'exploration sûre et la réflexion stratégique.

Activer le mode plan

/plan

Ou demandez simplement à Claude :

Planifions cette fonctionnalité avant de l'implémenter

Ce que le mode plan autorise et empêche

Mode OpusPlan : le meilleur des deux mondes

OpusPlan utilise Opus pour la planification (raisonnement supérieur) et Sonnet pour l'implémentation (coût-efficace).

/model opusplan

Le workflow :

6. Monter en régime

Pour les décisions critiques, effectuez plusieurs tours de planification avant d'exécuter.

Le pattern

Workflow standard : réfléchir → planifier → exécuter

Monter en régime : réfléchir → planifier → réfléchir plus → affiner → réfléchir encore plus → finaliser → exécuter

Quand l'utiliser

• →Décisions architecturales critiques (irréversibles, fort impact)
• →Migrations complexes touchant plus de 10 fichiers
• →Domaines inconnus où les premières intuitions sont souvent fausses

Exemple en trois tours

## Tour 1 : Analyse initiale
Utilisateur : /plan
Utilisateur : Analyse le système d'auth actuel. Quels sont les composants clés,
      les dépendances et les risques de migration vers OAuth2 ?
Claude : [Analyse initiale]

## Tour 2 : Approfondissement critique
Utilisateur : Maintenant, remets en question ta propre analyse :
      - Quelles hypothèses as-tu faites ?
      - Quels modes d'échec as-tu ratés ?
      - Qu'est-ce qu'un ingénieur sécurité senior signalerait ?
Claude : [Analyse plus profonde avec auto-correction]

## Tour 3 : Plan final
Utilisateur : Sur la base des deux tours, rédige le plan de migration définitif.
      Inclus la stratégie de rollback et l'atténuation des risques.
Claude : [Plan affiné intégrant les deux tours]

## Exécution
Utilisateur : /execute
Utilisateur : Implémente le plan du tour 3.

7. Optimisation des coûts

Claude Code utilise des crédits API. Comprendre les coûts permet d'optimiser sans sacrifier la productivité.

Réalité des tarifs

Coûts typiques par session :

• →Tâche rapide (5-10 min) : 0,05-0,10 $
• →Développement de fonctionnalité (1-2 h) : 0,20-0,50 $
• →Refactoring en profondeur (demi-journée) : 1,00-2,00 $

Les opérations coûteuses

Stratégies d'optimisation des coûts

Suivez vos coûts

Vérifiez le coût de la session actuelle à tout moment :

/status

Sortie :

Statut de la session
───────────────────────────────────────────────
  Contexte :  45 % utilisé (90K / 200K tokens)
  Coût :      0,23 $ cette session
  Durée :     1h 23m
───────────────────────────────────────────────

8. Le prompt comme provocation

L'équipe Claude Code traite en interne les prompts comme des défis lancés à un pair, pas comme des instructions données à un assistant. Ce changement subtil produit des résultats de meilleure qualité.

Trois patterns de provocation

9. Pattern de contexte frais

Pour les longues exécutions autonomes, envisagez le pattern de contexte frais (aussi appelé la boucle Ralph).

Le problème : la dégradation du contexte

Les recherches montrent que les performances des LLM se dégradent avec le contexte accumulé :

• →Écart de performance de 20-30 % entre des prompts ciblés et pollués
• →La dégradation commence autour de 16K tokens
• →Les tentatives échouées et les traces d'erreur diluent l'attention

La solution

Au lieu de gérer le contexte au sein d'une session, redémarrez avec une session fraîche par tâche :

# La boucle Ralph
while :; do cat TASK.md PROGRESS.md | claude -p ; done

L'état persiste via :

• →TASK.md, Définition de la tâche actuelle
• →PROGRESS.md, Apprentissages, travail accompli, blocages
• →Commits git, Chaque itération commite de manière atomique

Quand utiliser le contexte frais

10. Résumé des workflows avancés

L'arbre de décision de l'expert

Est-ce un changement simple et réversible ?
├── OUI → Exécutez directement (pas de surcharge de planification)
└── NON → Quel est l'impact de cette décision ?
    ├── Moyen → Mode plan + Exécuter
    ├── Élevé → OpusPlan (Opus réfléchit, Sonnet implémente)
    └── Critique → Montée en régime (3 tours) + OpusPlan

Référence rapide

Et ensuite ?

Vous disposez maintenant des techniques avancées qui distinguent les utilisateurs experts des débutants. Pratiquez ces patterns et ils deviendront une seconde nature.

Continuez vers le Module 1 pour des exercices pratiques appliquant ces techniques à de vrais projets.

Cet article fait partie de la série Guide ultime Claude Code. Poursuivez votre parcours avec le Module 1 : Techniques fondamentales pour une pratique approfondie.