Patterns avancés Claude Code : Trinity, téléportation de session et contexte frais (2026)

Table des matières

1. →Au-delà de l'usage basique
2. →Le Trinity Pattern
3. →Téléportation de session
4. →Stratégie de contexte frais
5. →Maîtrise de CLAUDE.md
6. →Workflows multi-sessions
7. →Études de cas concrètes
8. →Anti-patterns à éviter
9. →FAQ

Au-delà de l'usage basique

La plupart des développeurs utilisent Claude Code pour des tâches simples : « corrige ce bug », « ajoute cette fonctionnalité », « écris des tests pour cette fonction ». Mais les capacités agentiques de Claude Code permettent des workflows bien plus sophistiqués.

Ce guide couvre les patterns avancés qui distinguent les utilisateurs experts des utilisateurs occasionnels :

Niveaux de maîtrise de Claude Code

Le Trinity Pattern

Le Trinity Pattern est une approche en trois phases pour aborder les fonctionnalités complexes ou les bases de code inconnues. Il empêche l'erreur courante de se lancer dans les modifications de code avant de comprendre le terrain.

Le problème qu'il résout

Mode d'échec courant :

• →Développeur : « Ajoute l'authentification à cette app »
• →Claude : commence immédiatement à écrire du code d'auth
• →Résultat : le code ne correspond pas aux patterns existants, casse les fonctionnalités existantes, utilise les mauvaises bibliothèques, rate des cas limites importants

Pourquoi cela arrive :

• →Claude fait des suppositions sur la base de code
• →Aucune exploration des patterns existants
• →Aucune compréhension des contraintes
• →Exécution prématurée

Les trois phases

PHASE 1 : EXPLORER

Prompt : « Explore la base de code pour comprendre comment [X] fonctionne actuellement. Ne fais aucun changement pour l'instant. »

Claude va :

• →Lire les fichiers pertinents
• →Identifier les patterns et conventions
• →Cartographier les dépendances
• →Rendre compte de ses découvertes

PHASE 2 : PLANIFIER

Prompt : « Sur la base de ton exploration, crée un plan détaillé pour implémenter [Y]. Ne commence pas à coder. »

Claude va :

• →Proposer une architecture
• →Lister les fichiers à modifier/créer
• →Identifier les problèmes potentiels
• →Suggérer un ordre d'implémentation

PHASE 3 : EXÉCUTER

Prompt : « Implémente le plan. Commence par [première étape]. »

Claude va :

• →Suivre le plan établi
• →Respecter les patterns existants
• →Respecter les contraintes découvertes
• →Implémenter de façon systématique

Exemples du Trinity Pattern

Exemple 1 : Ajouter une nouvelle fonctionnalité

PROMPT PHASE 1 :
"Je veux ajouter des notifications utilisateur à cette app. Avant 
de faire des changements, explore la base de code pour comprendre :
- Comment fonctionne le système utilisateur actuel
- Quels patterns de notification existent (le cas échéant)
- Comment des fonctionnalités similaires (comme l'email) sont implémentées
- Quel schéma de base de données est utilisé pour les utilisateurs

Rapporte tes découvertes mais ne fais aucun changement."

PROMPT PHASE 2 :
"Sur la base de ton exploration, crée un plan d'implémentation 
détaillé pour un système de notifications qui :
- Supporte les notifications par email et in-app
- Permet les préférences utilisateur
- S'intègre au modèle utilisateur existant

Inclus :
- Les fichiers à créer/modifier
- Les migrations de base de données nécessaires
- Les endpoints API à ajouter
- Les défis potentiels

Ne commence pas à coder."

PROMPT PHASE 3 :
"Implémente le système de notifications en suivant ton plan. 
Commence par la migration de base de données, puis le modèle, puis l'API."

Exemple 2 : Refactoriser du code legacy

PROMPT PHASE 1 :
"Ce module est devenu difficile à maintenir. Explore :
- La structure actuelle et les dépendances
- Comment il est utilisé par d'autres parties de l'app
- Quelle semble être l'intention de conception originale
- Où la complexité s'est accumulée

Pas de changements pour l'instant."

PROMPT PHASE 2 :
"Sur la base de ton analyse, propose un plan de refactoring qui :
- Maintient la compatibilité ascendante
- Améliore la testabilité
- Réduit la complexité

Découpe-le en petites étapes sûres."

PROMPT PHASE 3 :
"Exécute l'étape 1 du plan de refactoring. 
Crée d'abord les tests, puis fais les changements."

Pourquoi le Trinity fonctionne

Avantages du Trinity Pattern :

1. Implémentation ancrée

• →Claude comprend les patterns existants avant d'écrire du nouveau code
• →Le nouveau code correspond aux conventions du projet
• →Pas de code « étranger » qui ne s'intègre pas

2. Raisonnement visible

• →Vous pouvez relire le plan avant l'exécution
• →Détectez les incompréhensions tôt
• →Ajustez l'approche avant des changements coûteux

3. Exécution systématique

• →Les fonctionnalités complexes sont découpées en étapes
• →Chaque étape s'appuie sur la précédente
• →Plus facile à déboguer en cas de problème

4. Transfert de connaissances

• →L'exploration de Claude vous apprend des choses sur la base de code
• →La documentation du plan capture les décisions
• →Les futures sessions peuvent référencer le plan

Téléportation de session

La téléportation de session est une technique pour transférer le contexte entre les sessions Claude Code. Chaque session démarre avec une page blanche, mais la téléportation permet de préserver le contexte important.

Le problème

Le problème de la frontière de session :

Session 1 (2 heures de travail) :

• →✅ Exploration des patterns d'authentification
• →✅ Découverte des particularités du modèle utilisateur
• →✅ 5 tentatives échouées avant de trouver la solution
• →✅ Implémentation fonctionnelle de l'auth
• →⚠️ Fin de session (ou crash)

Session 2 (nouveau départ) :

• →❌ Aucune mémoire de l'exploration
• →❌ Aucune connaissance des tentatives échouées
• →❌ Risque de répéter les mêmes erreurs
• →❓ « On en était où déjà ? »

Connaissances perdues : Pourquoi certaines approches n'ont pas fonctionné, contraintes et patterns découverts, état du travail partiellement terminé, raisonnement des décisions.

Technique de téléportation

TÉLÉPORTATION DE SESSION :

ÉTAPE 1 : EXTRAIRE LE CONTEXTE (fin de la Session 1)

Prompt : "Crée un résumé de notre session de travail que je peux utiliser pour continuer dans une nouvelle session. Inclus :

1. →Ce qu'on essayait d'accomplir
2. →Ce qu'on a exploré et appris
3. →Les décisions clés prises et pourquoi
4. →L'état actuel du travail
5. →Ce qu'il reste à faire
6. →Les pièges ou avertissements pour le travail futur

Formate cela comme un document de contexte que je peux coller dans une nouvelle session."

ÉTAPE 2 : SAUVEGARDER L'ARTÉFACT

• →Sauvegarder dans un fichier (SESSION_CONTEXT.md)
• →Ou copier dans le presse-papiers
• →Ou ajouter au CLAUDE.md

ÉTAPE 3 : INJECTER DANS LA NOUVELLE SESSION (début de la Session 2)

Prompt : "Je continue le travail d'une session précédente. Voici le contexte :

[COLLER LE CONTEXTE DE SESSION]

Examine ce contexte et confirme que tu comprends l'état actuel avant qu'on continue."

Modèle de téléportation

# Contexte de session : [Nom de la fonctionnalité/tâche]
Date : [Date de la session originale]

## Objectif
[Ce qu'on essaie d'accomplir]

## Résumé de la progression
- [x] Terminé : [liste des éléments terminés]
- [ ] En cours : [élément actuel]
- [ ] Restant : [liste des éléments restants]

## Découvertes clés
1. [Découverte importante sur la base de code/contraintes]
2. [Autre découverte]

## Décisions prises
1. **[Décision]** : [Justification]
2. **[Décision]** : [Justification]

## Approches échouées (ne pas répéter)
1. [Approche] : [Pourquoi ça n'a pas marché]
2. [Approche] : [Pourquoi ça n'a pas marché]

## État actuel
- Fichiers modifiés : [liste]
- Statut des tests : [passent/échouent/à créer]
- Problèmes bloquants : [le cas échéant]

## Prochaines étapes
1. [Action immédiate suivante]
2. [Action suivante]

## Avertissements
- [Pièges ou points de vigilance]

Téléportation automatisée

Pour les utilisateurs avancés, automatisez le processus :

# Alias .bashrc ou .zshrc
alias claude-save='claude "Crée un résumé de contexte de session 
en suivant notre modèle standard. Sauvegarde dans SESSION_CONTEXT.md"'

alias claude-resume='claude "Lis SESSION_CONTEXT.md et 
confirme que tu comprends l état actuel avant qu on continue"'

Stratégie de contexte frais

La stratégie de contexte frais est le pendant de la téléportation — savoir quand repartir de zéro plutôt que de continuer avec un contexte pollué.

Quand utiliser un contexte frais

DÉCLENCHEURS DE CONTEXTE FRAIS :

1. POLLUTION DU CONTEXTE
   - Trop de tentatives échouées dans l'historique
   - Claude répète sans cesse les mêmes erreurs
   - Confusion sur l'état actuel

2. CHANGEMENT DE CAP MAJEUR
   - Changement significatif d'approche
   - Une nouvelle compréhension invalide l'ancien contexte
   - Début d'un aspect différent du même projet

3. PROBLÈMES DE LONGUEUR DE CONTEXTE
   - /compact n'aide plus
   - Réponses lentes
   - Avertissements de troncature

4. RÉINITIALISER LES HYPOTHÈSES
   - Claude a un mauvais modèle mental
   - Impossible de « désapprendre » une hypothèse incorrecte
   - Plus facile de repartir de zéro que de corriger

Modèle de prompt pour contexte frais

PROMPT CONTEXTE FRAIS :

"Je repars de zéro sur une tâche. Voici le contexte essentiel :

PROJET : [Brève description du projet]
OBJECTIF : [Objectif spécifique de cette session]
CONTRAINTES : 
- [Contrainte 1]
- [Contrainte 2]

FICHIERS PERTINENTS :
- [fichier1.ts] : [brève description]
- [fichier2.ts] : [brève description]

CONTEXTE IMPORTANT :
[Toute découverte ou décision des sessions précédentes encore 
pertinente, débarrassée des tentatives échouées et du bruit]

DEMANDE SPÉCIFIQUE :
[Exactement ce que vous voulez faire dans cette session]"

Matrice de décision : frais vs continuer

Symptômes de pollution du contexte

Signes d'un contexte pollué :

1. Répétition

• →« Comme je l'ai mentionné plus tôt... » « Comme nous en avons discuté... » (alors que ce n'est pas le cas)

2. Confusion

• →Claude mélange différentes approches
• →Référence des fichiers qui n'existent pas
• →Oublie les changements récents

3. Résistance

• →Continue de suggérer la même approche qui a échoué
• →N'« entend » pas vos corrections
• →Conversations circulaires

4. Dégradation

• →Les réponses deviennent plus lentes
• →Plus d'erreurs dans le code
• →Explications moins cohérentes

Solution : Créer un contexte frais avec une téléportation propre

Maîtrise de CLAUDE.md

Le fichier CLAUDE.md est la mémoire persistante de Claude Code. Maîtrisez son utilisation pour une efficacité maximale.

Structure de CLAUDE.md

# CLAUDE.md

## Vue d'ensemble du projet
[Brève description du projet, son but et son architecture]

## Stack technique
- Frontend : [framework, version]
- Backend : [framework, version]
- Base de données : [type, ORM]
- Bibliothèques clés : [lister les importantes]

## Conventions de code
- [Convention 1 : ex. « Utiliser le mode strict TypeScript »]
- [Convention 2 : ex. « Composants en PascalCase »]
- [Convention 3 : ex. « Tests co-localisés avec le source »]

## Structure du projet

**Organisation des dossiers :**
- **src/components/** - Composants React
- **src/hooks/** - Hooks personnalisés
- **src/services/** - Clients API
- **src/utils/** - Fonctions utilitaires
- **src/types/** - Types TypeScript

## Commandes courantes
- `npm run dev` : Démarrer le serveur de développement
- `npm run test` : Lancer les tests
- `npm run build` : Build de production

## Patterns importants
### [Nom du pattern]
[Description de l'utilisation de ce pattern dans le projet]

### [Autre pattern]
[Description]

## Pièges et avertissements
- ⚠️ [Problème connu ou particularité à connaître]
- ⚠️ [Autre avertissement]

## Travail en cours
### [Nom de la fonctionnalité/tâche]
Statut : [En cours / Bloqué / Terminé]
Contexte : [Brève description]
Prochaines étapes : [Ce qu'il faut faire]

Mises à jour dynamiques de CLAUDE.md

Gardez CLAUDE.md à jour pendant le développement :

PROMPTS DE MISE À JOUR DYNAMIQUE :

Après une découverte majeure :
"Ajoute ce qui suit au CLAUDE.md dans 'Pièges' : 
[particularité découverte]"

Après avoir établi un pattern :
"Mets à jour CLAUDE.md pour documenter notre nouveau pattern [X] 
dans 'Patterns importants'"

Après avoir terminé une fonctionnalité :
"Mets à jour la section 'Travail en cours' de CLAUDE.md pour 
marquer [fonctionnalité] comme terminé et ajouter [prochaine fonctionnalité]"

Instructions spécifiques au projet

# CLAUDE.md - Sections supplémentaires

## Instructions pour l'IA
Quand tu travailles sur ce projet :
1. Lance toujours les tests après avoir fait des changements
2. Utilise les fonctions utilitaires existantes de src/utils avant d'en créer de nouvelles
3. Suis le pattern de gestion d'erreurs de src/services/api.ts
4. Vérifie les erreurs TypeScript avant de considérer une tâche comme terminée

## À ne pas faire
- Ne modifie pas les fichiers dans /legacy (code obsolète, risque de casse)
- N'ajoute pas de nouvelles dépendances sans demander
- Ne change pas le schéma de base de données sans migration
- N'utilise pas le type `any` en TypeScript

## En cas de blocage
1. Consulte le README.md pour les problèmes de configuration
2. Regarde /docs pour les décisions d'architecture
3. Cherche des implémentations similaires existantes
4. Demande des clarifications plutôt que de deviner

Workflows multi-sessions

Pour les grandes fonctionnalités ou projets, orchestrez plusieurs sessions ciblées.

Planification des sessions

WORKFLOW MULTI-SESSIONS :

**Fonctionnalité : Système d'authentification utilisateur**

| Session | Focus | Tâches |
|---------|-------|--------|
| **Session 1 : Exploration** (30 min) | Découverte | Trinity Phase 1 : Explorer les patterns d'auth actuels, Identifier tous les points de contact, Documenter les découvertes dans CLAUDE.md, Créer le plan d'implémentation |
| **Session 2 : Couche données** (45 min) | Base de données | Modifications du schéma de BDD, Mises à jour du modèle utilisateur, Scripts de migration, Téléporter le contexte pour la session suivante |
| **Session 3 : Couche API** (45 min) | Backend | Endpoints d'auth, Middleware, Gestion des tokens, Téléporter le contexte |
| **Session 4 : Frontend** (60 min) | Interface | Formulaires login/inscription, Routes protégées, Gestion de session, Téléporter le contexte |
| **Session 5 : Tests et finition** (45 min) | Qualité | Tests d'intégration, Cas limites, Gestion d'erreurs, Revue finale |

Passations entre sessions

Protocole de passation de session :

Fin de la Session N :

1. →S'assurer que tous les changements sont sauvegardés/committés
2. →Lancer les tests pour vérifier l'état
3. →Créer le contexte de téléportation
4. →Noter les problèmes bloquants éventuels

Début de la Session N+1 :

1. →Revue rapide du git diff
2. →Injecter le contexte de téléportation
3. →Vérifier que Claude comprend l'état
4. →Continuer depuis la prochaine étape documentée

Stratégie de sessions parallèles

Pour des flux de travail indépendants :

Approche sessions parallèles :

Coordination :

• →Chaque session a sa propre section dans CLAUDE.md
• →Les points de fusion sont documentés
• →Les dépendances sont suivies

Études de cas concrètes

Étude de cas 1 : Migration TypeScript de Boris Cherny

D'après le Guide ultime Claude Code, Boris Cherny (auteur de « Programming TypeScript ») a utilisé Claude Code pour migrer une grande base de code :

DÉFI : 
Migrer une base de code JavaScript legacy vers TypeScript

APPROCHE :
1. SESSION D'EXPLORATION
   - Cartographié tous les fichiers JavaScript
   - Identifié les dépendances
   - Trouvé les patterns communs

2. SESSION DE PLANIFICATION
   - Créé l'ordre de migration (feuilles en premier)
   - Identifié les scénarios de typage complexes
   - Configuré TypeScript progressivement

3. SESSIONS D'EXÉCUTION (par lots)
   - 10-20 fichiers par session
   - Chaque session : migrer, tester, vérifier
   - Téléporter le contexte entre les lots

4. SESSION DE RENFORCEMENT
   - Activer le mode strict progressivement
   - Corriger les types any restants
   - Ajouter les définitions de type manquantes

Résultats : Des semaines de travail compressées en quelques jours, des patterns de typage cohérents dans tout le code, documentation générée en parallèle.

Étude de cas 2 : Refonte d'API

Défi : Refondre une API REST tout en maintenant la compatibilité ascendante

Déroulement des sessions :

Résultats : Migration sans interruption de service, documentation complète, SDK client prêt, couverture de tests exhaustive.

Anti-patterns à éviter

Anti-pattern 1 : le mégaprompt

❌ MAUVAIS : LE MÉGAPROMPT
"Ajoute l'authentification à l'app avec des tokens JWT et des 
refresh tokens avec stockage sécurisé par cookies, ajoute aussi 
la limitation de débit et la protection anti-bruteforce, crée 
des pages de login et d'inscription avec vérification email et 
réinitialisation de mot de passe, ajoute le support OAuth pour 
Google et GitHub, implémente la fonctionnalité 'se souvenir de moi', 
ajoute le support 2FA avec TOTP, crée la gestion admin..."

PROBLÈMES :
- Trop de préoccupations en même temps
- Claude va rater des détails
- Difficile à déboguer en cas de problème
- Pas de points de contrôle pour vérifier la progression

✅ BON : TRINITY + INCRÉMENTAL
"Ajoutons l'authentification. D'abord, explore le système 
utilisateur actuel et fais-moi un rapport..."
[Puis procéder phase par phase, fonctionnalité par fonctionnalité]

Anti-pattern 2 : l'accumulation de contexte

❌ MAUVAIS : NE JAMAIS REPARTIR DE ZÉRO
"On travaille depuis 4 heures sur plein de sujets, je vais 
continuer et ajouter cette fonctionnalité sans rapport..."

PROBLÈMES :
- Le contexte pollué affecte la qualité
- Risque accru d'hallucination
- Réponses plus lentes
- Confusion entre les sujets

✅ BON : REDÉMARRAGES STRATÉGIQUES
Lors d'un changement de sujet majeur ou après des sessions prolongées,
repartir de zéro avec uniquement le contexte essentiel téléporté.

Anti-pattern 3 : pas de vérification

❌ MAUVAIS : CONFIANCE AVEUGLE
"Super, la fonctionnalité est finie !"
[Sans tester, sans relire, sans exécuter]

PROBLÈMES :
- Bugs subtils dans le code généré
- Implémentations incomplètes
- Logique qui semble correcte mais ne l'est pas

✅ BON : VÉRIFIER CHAQUE ÉTAPE
- Lancer les tests après les changements
- Relire les diffs avant de committer
- Tester manuellement les chemins critiques
- Demander à Claude de vérifier son propre travail

Anti-pattern 4 : ignorer CLAUDE.md

❌ MAUVAIS : RÉPÉTER LE CONTEXTE À CHAQUE SESSION
"N'oublie pas, on utilise TypeScript en mode strict, nos 
composants vont dans src/components, on utilise React Query 
pour le data fetching, et..."

PROBLÈMES :
- Gaspillage de tokens
- Facile d'oublier quelque chose
- Incohérent entre les sessions

✅ BON : MAINTENIR CLAUDE.md
Documenter le contexte du projet une fois, mettre à jour au besoin.
Claude le lit automatiquement à chaque session.

FAQ

Q : Quelle devrait être la durée d'une session Claude Code ? R : Les sessions optimales durent 30 à 60 minutes, focalisées sur un objectif spécifique. Les sessions plus longues accumulent du contexte qui peut polluer les réponses. Utilisez la téléportation pour les travaux de plusieurs heures.

Q : Dois-je toujours utiliser le Trinity Pattern ? R : Utilisez-le pour les travaux complexes ou sur des bases de code inconnues. Pour les changements simples et bien compris dans des projets familiers, vous pouvez passer directement à l'exécution. Votre jugement s'améliore avec l'expérience.

Q : Comment savoir si le contexte est pollué ? R : Les signes incluent : suggestions répétées d'approches déjà échouées, confusion sur l'état des fichiers, mélange de différentes fonctionnalités, réponses plus lentes et baisse de la qualité du code.

Q : Puis-je utiliser ces patterns avec d'autres outils de code IA ? R : Oui ! Trinity, téléportation et contexte frais sont des patterns généraux. L'implémentation spécifique peut varier (fichiers mémoire différents, commandes différentes), mais les concepts s'appliquent largement.

Q : Quel niveau de détail pour le contexte de téléportation ? R : Incluez suffisamment pour reconstruire la compréhension, mais pas chaque détail. Concentrez-vous sur : l'état actuel, les décisions clés, les approches échouées et les prochaines étapes. Visez typiquement 200-500 mots.

Q : Faut-il committer CLAUDE.md dans git ? R : Oui, c'est une documentation précieuse. Certaines équipes excluent la section « Travail en cours » (utilisez .gitignore pour un CLAUDE_WORK.md séparé si besoin).

Conclusion

L'utilisation avancée de Claude Code ne repose pas sur des commandes secrètes — c'est une question de gestion stratégique du contexte. Les patterns de ce guide vous aident à :

1. →Trinity Pattern : Explorer avant d'implémenter pour éviter les erreurs coûteuses
2. →Téléportation de session : Maintenir la continuité entre les sessions
3. →Stratégie de contexte frais : Savoir quand repartir de zéro
4. →Maîtrise de CLAUDE.md : Construire une mémoire projet persistante
5. →Workflows multi-sessions : Orchestrer efficacement les travaux complexes

Maîtrisez ces patterns et vous tirerez bien plus de valeur de Claude Code.

Prêt à maîtriser le développement assisté par IA ?

Nos modules de formation couvrent les workflows de code IA pratiques avec des exercices concrets.

📚 Découvrir nos modules de formation | Commencer le Module 0

Articles connexes :

• →Bien démarrer avec Claude Code
• →Prompt engineering pour développeurs
• →Bonnes pratiques du pair programming IA

Dernière mise à jour : 29 janvier 2026