Accéder au contenu principal

Un auto-entrepreneur passionné à votre service,

Pour votre projet de site internet et vos dépannages informatiques

Claude Code : 6 conseils tirés du leak pour booster votre productivité

Publié le 9 Août 2026, dernière mise à jour le 8 Août 2026

Le 31 mars 2026, la veille du 1er avril, Anthropic a publié sur npm une version de Claude Code contenant un fichier qui n'aurait jamais dû s'y trouver. Un source map de 59,8 Mo, oublié dans le paquet @anthropic-ai/claude-code en version 2.1.88. Chaofan Shou, chercheur en sécurité, l'a repéré par hasard et l'a décodé : 1 884 fichiers TypeScript, plus de 512 000 lignes, soit la quasi-totalité du code de l'agent de développement le plus utilisé du marché. En moins de deux heures, les miroirs GitHub explosaient les compteurs d'étoiles.

J'utilise Claude Code tous les jours, et cette fuite m'intéressait moins pour son côté spectaculaire que pour ce qu'elle disait des rouages internes de l'outil. J'ai passé les semaines suivantes à tester les enseignements que la communauté en tirait. Certains se sont révélés extrêmement rentables. D'autres ont vieilli très vite : ULTRAPLAN, la fonctionnalité cachée la plus commentée du leak, est sortie en avril, puis Anthropic l'a purement et simplement retirée. Elle n'existe plus. C'est le genre de retournement qui rend les articles écrits dans la foulée du leak trompeurs aujourd'hui.

Voici donc six pratiques que j'applique concrètement, chacune revérifiée contre la documentation officielle, et un point de situation honnête sur les fonctionnalités fantômes.

Ce qui a fuité, et ce qui n'a pas fuité

La cause est banale : le bundler de Bun génère des source maps par défaut, et le fichier cli.js.map n'a pas été exclu via .npmignore. Une ligne manquante dans un fichier de configuration.

Anthropic a retiré le paquet du registre npm dans la foulée et confirmé qu'aucune donnée client, aucune clé API et aucun poids de modèle n'avaient été exposés. La distinction compte : ce n'est pas le modèle qui a fuité, c'est le harnais autour. Les prompts système, la logique d'orchestration des outils, la gestion du contexte, les drapeaux de fonctionnalités en cours de développement.

Pour les utilisateurs, le dégât était nul. Pour Anthropic, il était stratégique : une trentaine de drapeaux de fonctionnalités non annoncées se sont retrouvés en clair, révélant la feuille de route produit à la concurrence. Comme le notait un commentateur sur Hacker News, les noms des drapeaux étaient plus parlants que le code lui-même.

1. Soigner son fichier CLAUDE.md

C'est le levier numéro un, et de très loin. Si vous ne devez retenir qu'une chose de cet article, prenez celle-là.

Le fichier CLAUDE.md contient les instructions permanentes que Claude lit au démarrage de chaque session. Une précision qui a son importance, et que beaucoup d'articles ont écorchée : ce contenu n'est pas injecté dans le prompt système. La documentation d'Anthropic est explicite là-dessus, il est délivré comme un message utilisateur placé après le prompt système, et il n'y a aucune garantie de conformité stricte. Claude le lit et essaie de le suivre. Il n'est pas contraint de le faire. Pour bloquer une action de façon déterministe, il faut passer par un hook PreToolUse, pas par une phrase dans un fichier markdown.

Cette nuance change la façon d'écrire le fichier. Une instruction vague dans un CLAUDE.md sera suivie une fois sur trois. Une instruction précise et vérifiable sera suivie presque systématiquement.

Les emplacements possibles

La hiérarchie s'est étoffée depuis les premiers jours de l'outil. Les fichiers se cumulent au lieu de s'écraser, du plus général au plus spécifique.

Emplacements des fichiers CLAUDE.md, par ordre de chargement
PortéeCheminÀ quoi ça sert
Politique d'entreprise /etc/claude-code/CLAUDE.md (Linux et WSL), /Library/Application Support/ClaudeCode/CLAUDE.md (macOS), C:\Program Files\ClaudeCode\CLAUDE.md (Windows) Règles imposées par la DSI, non désactivables par l'utilisateur
Utilisateur ~/.claude/CLAUDE.md Vos préférences personnelles, valables sur tous vos projets
Projet ./CLAUDE.md ou ./.claude/CLAUDE.md Conventions partagées avec l'équipe via le dépôt Git
Local ./CLAUDE.local.md Vos préférences sur ce projet uniquement, à mettre dans le .gitignore

Les fichiers situés dans des sous-répertoires ne sont pas chargés au lancement : ils entrent en contexte quand Claude lit un fichier de ce dossier. Pratique pour des conventions propres à un module, moins fiable qu'on ne le croit après un compactage, j'y reviens plus bas.

Ce que j'y mets

Voici la trame que j'utilise sur mes projets web. Elle tient en une trentaine de lignes, et c'est volontaire.

# Conventions du projet MonApp

## Stack technique
- Frontend : React 18 + TypeScript strict
- Backend : Node.js 20, Express, PostgreSQL
- Tests : Vitest pour les unitaires, Playwright pour les E2E

## Règles de code
- Toujours typer explicitement les retours de fonction
- Pas de `any` sauf commentaire justificatif
- Les composants React doivent rester sous 150 lignes
- Indentation : 2 espaces

## Ce qu'il faut éviter
- Ne jamais modifier `schema.sql` sans migration associée
- Pas de `console.log` en production, utiliser le logger interne

## Discipline de réponse
- Maximum 30 mots entre deux appels d'outils
- Maximum 100 mots pour les réponses finales

Trois commandes rendent le fichier beaucoup plus facile à maintenir. /init génère un premier jet en analysant votre dépôt. /memory ouvre la liste des fichiers d'instructions et permet de les éditer. /context montre lesquels ont réellement été chargés dans la session en cours, avec leur coût en tokens. Quand Claude ignore une règle, c'est souvent que le fichier n'a jamais été chargé, et /context le dit en deux secondes.

Visez moins de 200 lignes par fichier. Anthropic le recommande explicitement : au-delà, le fichier mange du contexte à chaque session et l'adhérence aux règles baisse. Un CLAUDE.md de 400 lignes est contre-productif, il coûte cher et il est moins suivi qu'un fichier de 60 lignes bien ciblé.

Le répertoire .claude/rules/

Pour les gros projets, il existe mieux qu'un CLAUDE.md obèse : le dossier .claude/rules/. Chaque fichier markdown y couvre un sujet, et surtout, une règle peut être limitée à certains chemins grâce à un en-tête YAML.

---
paths:
  - "src/api/**/*.ts"
---

# Règles de développement API

- Tous les endpoints valident leurs entrées
- Utiliser le format d'erreur standard du projet
- Documenter avec des commentaires OpenAPI

La règle ne se charge que lorsque Claude touche un fichier correspondant. Sur un monorepo, c'est la différence entre 8 000 tokens de règles chargées en permanence et 300 tokens chargés au bon moment.

2. Laisser Claude tenir sa propre mémoire

Le leak avait révélé un module de consolidation mémoire baptisé autoDream. Une partie de cette idée est aujourd'hui dans l'outil, sous le nom de mémoire automatique, et c'est probablement le changement le plus sous-estimé de l'année.

Le principe : Claude écrit lui-même des notes entre les sessions. Commandes de build découvertes, pièges de débogage, préférences que vous avez corrigées deux fois. Chaque projet dispose de son répertoire dans ~/.claude/projects/<projet>/memory/, avec un fichier MEMORY.md qui sert d'index, plus des fichiers thématiques.

Seules les 200 premières lignes de l'index, ou les 25 premiers kilo-octets, sont chargées au début de chaque conversation. Les fichiers thématiques restent sur le disque et ne sont lus qu'à la demande. C'est une architecture d'index léger, et elle explique pourquoi la mémoire automatique coûte beaucoup moins cher en contexte qu'un CLAUDE.md qui aurait gonflé.

CLAUDE.md
C'est vous qui l'écrivez. Il contient des instructions et des règles. Vous le partagez avec votre équipe via Git.
Mémoire automatique
C'est Claude qui l'écrit. Elle contient des apprentissages et des constats. Elle reste locale à votre machine et n'est jamais partagée.

La mémoire automatique est active par défaut. On la coupe depuis /memory, ou avec autoMemoryEnabled: false dans les réglages du projet, ou encore avec la variable d'environnement CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Je la laisse allumée, mais je relis son contenu une fois par semaine : ce sont de simples fichiers markdown, éditables et supprimables. Il m'est arrivé d'y trouver une note obsolète qui envoyait Claude dans le mur à chaque session.

Quand vous dites à Claude « retiens que les tests API demandent une instance Redis locale », c'est là que ça atterrit. Si vous voulez que l'information aille dans le CLAUDE.md à la place, demandez-le explicitement : « ajoute ça au CLAUDE.md ».

3. Compacter le contexte avant de heurter le mur

La compaction est le mécanisme par lequel Claude Code résume la conversation pour continuer à travailler quand la fenêtre de contexte se remplit. Beaucoup d'articles issus du leak citent un seuil de déclenchement compris entre 75 et 98 % de la fenêtre. Ce chiffre ne correspond à rien dans la documentation actuelle.

Le comportement réel est plus simple et plus configurable. Sans réglage, Claude Code compacte quand la conversation atteint la limite de contexte du modèle. Les sessions cloud compactent un peu plus tôt. Et surtout, vous pouvez décider vous-même du seuil.

# Régler la fenêtre pour cette session et les suivantes
/autocompact 500k

# Revenir au réglage automatique du modèle
/autocompact auto

# Pour un seul lancement
claude --autocompact 200k

Les valeurs acceptées vont de 100 000 à 1 000 000 de tokens. En scripts et environnements cloud, la variable CLAUDE_CODE_AUTO_COMPACT_WINDOW prend le dessus sur tout le reste.

Diriger le résumé plutôt que le subir

Le vrai geste utile, c'est de compacter volontairement à un moment propre, avant de démarrer une nouvelle grosse tâche, et de dire ce qu'il faut garder.

/compact concentre-toi sur l'architecture des composants et les décisions
d'API prises jusqu'ici, ignore les échanges de débogage résolus

La version permanente de cette instruction s'écrit dans le CLAUDE.md, sous une section intitulée Compact Instructions. Elle s'applique alors à tous les compactages, y compris ceux que vous n'avez pas déclenchés.

Ce qui survit vraiment

C'est le tableau que j'aurais aimé avoir dès le début. Il évite énormément de mauvaises surprises.

Sort des différents mécanismes d'instruction après un compactage
MécanismeAprès compaction
Prompt système et style de sortie Intacts, ils ne font pas partie de l'historique des messages
CLAUDE.md à la racine et règles sans portée Relus depuis le disque et réinjectés
Mémoire automatique Relue depuis le disque et réinjectée
Règles avec en-tête paths: Perdues jusqu'à la prochaine lecture d'un fichier correspondant
CLAUDE.md des sous-répertoires Perdus jusqu'à la prochaine lecture d'un fichier du dossier
Corps des compétences invoquées Réinjectés, plafonnés à 5 000 tokens par compétence et 25 000 au total
Instructions données uniquement dans la conversation Résumées, donc souvent perdues dans le détail

Autrement dit : si une règle doit absolument survivre, elle n'a rien à faire dans un sous-répertoire ni dans une règle à portée de chemin. Elle va à la racine.

Une vulnérabilité mise en évidence par le leak reste d'actualité : des instructions malveillantes glissées dans un fichier que Claude lit (un README, une configuration tierce, un CLAUDE.md dans un dépôt cloné) peuvent survivre au résumé et se retrouver dans le contexte compacté. Sur un projet avec des dépendances externes que vous ne contrôlez pas, gardez un œil sur ce que Claude ouvre.

Dernier point, et il change la donne sur les longues sessions : Claude Fable 5, Sonnet 5, Sonnet 4.6 et les modèles Opus à partir de la 4.6 acceptent une fenêtre d'un million de tokens. Sonnet 5 tourne à 1 M par défaut. Le problème du contexte saturé ne disparaît pas, mais il se pose beaucoup plus tard.

4. Déléguer aux sous-agents sans hésiter

Un sous-agent dispose de sa propre fenêtre de contexte, distincte de la session principale. Il lit ses fichiers dans son coin et ne renvoie qu'un résumé. C'est la mécanique la plus rentable de tout l'outil, et le leak confirmait que la parallélisation était une directive de conception, pas un comportement émergent.

Un exemple chiffré tiré de la documentation d'Anthropic : un sous-agent de recherche lit 6 100 tokens de fichiers et renvoie un résultat de 420 tokens. Votre fenêtre principale encaisse 420 tokens au lieu de 6 100.

Une nuance, parce que je l'ai lue partout sous une forme trop optimiste. On dit souvent que lancer cinq sous-agents ne coûte guère plus qu'un seul, grâce au cache clé-valeur. C'est vrai pour la partie de contexte déjà traitée, mais chaque sous-agent recharge son propre exemplaire du CLAUDE.md, ses définitions d'outils MCP et son prompt système. Les agents Explore et Plan intégrés sautent le CLAUDE.md pour rester légers, pas les autres. La parallélisation reste très rentable, elle n'est pas gratuite.

Les cas où j'y gagne systématiquement :

  • Revue de code multifichiers, avec un sous-agent par module
  • Tests unitaires lancés pendant qu'un autre agent prépare les tests d'intégration
  • Refactoring segmenté sur des zones qui ne se chevauchent pas, typiquement frontend et backend d'une même fonctionnalité
  • Migration de base de données : un agent écrit les migrations, un autre met à jour les modèles, un troisième adapte les tests
  • Exploration d'un dépôt inconnu, où les lectures de fichiers restent hors de ma fenêtre

Un sous-agent peut désormais entretenir sa propre mémoire persistante, via le champ memory de sa configuration. Un agent de revue de code accumule alors, session après session, la connaissance de vos défauts récurrents. Attention toutefois : chaque sous-agent a son répertoire mémoire, cloisonné des autres.

La parallélisation ne marche que si les modifications ne peuvent pas entrer en conflit. Deux agents qui écrivent dans le même fichier produisent des résultats imprévisibles. Dans ce cas, séquencez.

5. Imposer des réponses courtes et chiffrées

C'est l'enseignement le plus directement actionnable du leak, et le seul qui n'ait pas bougé d'un pouce depuis mars.

Le prompt système de Claude Code n'est pas un bloc figé : il est assemblé à partir de plus d'une centaine de composants conditionnels, activés selon le profil de l'utilisateur, le mode d'exécution et la configuration du projet. Certaines variantes internes contenaient des contraintes chiffrées strictes, quand les versions grand public se contentaient d'une formulation qualitative du type « va droit au but ». Un commentaire dans le code notait un gain mesurable de tokens de sortie grâce aux contraintes chiffrées.

La conclusion est facile à tester chez soi, et je l'ai fait : les nombres marchent, les adjectifs non.

Reformuler une consigne vague en consigne chiffrée
Instruction vagueInstruction chiffrée
Sois concis Maximum 30 mots entre deux appels d'outils
Ne t'épanche pas Réponses finales : 100 mots maximum
Va droit au but Pas de phrase d'introduction avant une réponse courte
Évite les redondances Ne résume pas ce que tu viens de faire, sauf demande explicite
Reste bien organisé Maximum 5 puces par liste, une ligne par puce
Formate le code proprement Indentation 2 espaces, guillemets simples

Sur une session longue, la différence se voit sur la facture comme sur la fenêtre de contexte. Chaque commentaire superflu entre deux actions grignote de la place qui manquera plus tard.

6. Ancrer les longues sessions avec les tâches

Le prompt système contenait une instruction en majuscules demandant à l'agent d'utiliser très fréquemment ses outils de liste de tâches. La raison est mécanique : cette liste vit en dehors du flux de messages, donc elle survit au compactage. Quand la conversation est résumée, les messages disparaissent, la liste reste.

Le conseil tient toujours. Les outils, eux, ont changé de nom, et c'est un piège pour quiconque recopie un prompt trouvé dans un article d'avril. Depuis la version 2.1.142 de Claude Code, TodoWrite et TodoRead sont désactivés par défaut. Ils ont été remplacés par quatre outils structurés : TaskCreate, TaskUpdate, TaskGet et TaskList. Un prompt qui mentionne encore TodoWrite renverra une erreur d'outil indisponible.

Le changement va au-delà du renommage. Les tâches sont stockées sur le disque, dans ~/.claude/tasks/, en dehors du projet. Elles acceptent des dépendances, une tâche pouvant en bloquer une autre. Elles peuvent être revendiquées par une session ou un agent précis, et les mises à jour se diffusent à toutes les sessions qui suivent la même liste. La commande /todos reste disponible comme alias.

Voici le prompt de démarrage que je réutilise pour les tâches lourdes :

Avant de commencer, crée une liste de tâches détaillée avec TaskCreate en
décomposant le travail en étapes atomiques. Marque chaque dépendance avec
addBlockedBy. Passe chaque tâche en in_progress puis completed au fur et à
mesure. Si le contexte est compacté, relis la liste avec TaskList avant
toute action.

Quand je réclame une liste de tâches : dès que plus de trois ou quatre fichiers sont concernés, pour toute session susceptible de déclencher un compactage, sur les migrations à étapes séquentielles, et systématiquement quand je sais que je vais interrompre le travail pour le reprendre le lendemain depuis un autre terminal.

La séparation reste la même qu'au premier jour : la liste de tâches est faite pour le travail en cours, le CLAUDE.md pour ce qui doit servir aux sessions futures. Ne rangez pas de l'éphémère dans le second, et n'attendez pas du premier qu'il remplace votre documentation.

Buddy, Coordinator, Undercover : le reste du butin

Tout ce qui dormait derrière les drapeaux de fonctionnalités n'était pas sérieux, et c'est une partie du charme de cette fuite.

Buddy est un animal de compagnie façon Tamagotchi qui vit dans le terminal. Dix-huit espèces recensées dans le code, du canard au capybara en passant par l'axolotl, le champignon et le fantôme, avec six niveaux de rareté allant du commun, à 60 % de chances, au brillant à 1 %. Statistiques individuelles, objets cosmétiques, le dispositif complet. Une fonctionnalité de gamification pure, qui n'a jamais été activée publiquement.

Coordinator Mode orchestre plusieurs agents en parallèle sur une même tâche. C'est le drapeau qui, à mon avis, avait le plus de valeur commerciale directe, et une partie de cette logique se retrouve aujourd'hui dans les mécanismes de délégation multi-agents.

Undercover Mode est le plus gênant du lot : il efface discrètement les marqueurs d'attribution à l'IA dans les contributions open source. Autrement dit, il permet de masquer qu'un commit a été écrit par un agent. Le sujet a fait grincer beaucoup de mainteneurs de projets libres, à juste titre.

ANTI_DISTILLATION_CC, enfin, injecte de fausses définitions d'outils dans les requêtes API pour polluer les données d'entraînement d'un concurrent qui enregistrerait le trafic. Un second mécanisme résume les raisonnements entre les appels d'outils avec des signatures cryptographiques. Défensif, et révélateur de ce qu'Anthropic craint réellement.

S'y ajoutaient une interface vocale, un mode passerelle pour piloter une session depuis un navigateur ou un mobile, et les noms de code de modèles non annoncés : Capybara, Fennec, Numbat.

Où en sont KAIROS, autoDream et ULTRAPLAN

C'est la partie de l'histoire que les articles de printemps ne pouvaient pas raconter.

Statut des trois fonctionnalités phares révélées par la fuite
FonctionnalitéCe que le code annonçaitOù ça en est
ULTRAPLAN Planification déléguée à une session cloud, jusqu'à 30 minutes de réflexion, validation dans le navigateur Sortie en avril en recherche préliminaire, puis retirée par Anthropic. La commande /ultraplan, le mot-clé déclencheur et l'option de bascule dans la boîte d'approbation ont tous disparu.
autoDream Consolidation nocturne de la mémoire en quatre phases, fusion des observations, suppression des contradictions Sorti autrement : Anthropic a lancé « Dreaming » en mai, en recherche préliminaire sur l'API Managed Agents, et Claude Code embarque désormais sa mémoire automatique.
KAIROS Démon autonome permanent, prompts périodiques, abonnement aux webhooks GitHub, notifications push Toujours pas disponible publiquement. C'est la promesse la plus radicale du leak, et la seule qui n'ait rien donné à ce jour.

Le cas d'ULTRAPLAN mérite un mot. La fonctionnalité déportait la phase de planification vers un conteneur cloud, on relisait le plan dans le navigateur avec des commentaires en ligne, puis on choisissait d'exécuter dans le cloud ou de rapatrier le plan dans son terminal. Sur le papier, c'était élégant. En pratique, elle exigeait un dépôt hébergé sur GitHub, un compte Claude Code on the web, et elle ne fonctionnait ni sur Amazon Bedrock, ni sur Google Cloud Vertex AI, ni sur Microsoft Foundry. Anthropic renvoie aujourd'hui vers deux alternatives : le mode plan local, et Claude Code on the web pour les sessions cloud.

Pour les besoins de planification lourde, je fais désormais tourner Opus 5, sorti le 24 juillet, directement en mode plan local. Le modèle est disponible sur l'abonnement Pro, et le gain de qualité sur les plans complexes rend la boucle cloud beaucoup moins nécessaire qu'en avril.

Mémo : commandes, chemins et variables

Le récapitulatif que je garde ouvert dans un onglet.

Références utiles pour configurer Claude Code
ÉlémentRôle
/init Génère un premier CLAUDE.md à partir de l'analyse du dépôt
/memory Liste et ouvre les fichiers d'instructions et de mémoire
/context Détaille l'occupation réelle de la fenêtre, par catégorie
/compact Résume la conversation, accepte une consigne de focus
/autocompact Règle le seuil de déclenchement automatique, de 100k à 1M
/clear Repart d'une fenêtre vide, sans résumé lossy
~/.claude/tasks/ Stockage disque des tâches, hors du projet
~/.claude/projects/<projet>/memory/ Mémoire automatique, avec MEMORY.md en index
CLAUDE_CODE_AUTO_COMPACT_WINDOW Fixe la fenêtre de compactage, prioritaire sur tout le reste
CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 Coupe la mémoire automatique
CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1 Charge aussi les CLAUDE.md des dossiers ajoutés par --add-dir
claudeMdExcludes Réglage qui ignore certains CLAUDE.md, utile en monorepo
autoMemoryDirectory Déplace le répertoire de mémoire automatique

La documentation officielle fait référence sur tous ces points : la page sur la mémoire et celle sur la fenêtre de contexte valent le détour, cette dernière proposant une simulation interactive plutôt bien faite d'une session complète.

Questions fréquentes

Le code source fuité est-il encore accessible quelque part ?

Anthropic a retiré le paquet npm et fait supprimer les dépôts miroirs principaux. Des copies circulent encore, mais je ne les conseille pas : il s'agit de code propriétaire, et les informations qu'on en tire vieillissent très vite, comme le montre le sort d'ULTRAPLAN. La documentation officielle est plus fiable et, sur la plupart des sujets, plus complète.

Mes données ont-elles été exposées par cette fuite ?

Non. Anthropic a confirmé qu'aucune donnée client, aucune clé API et aucun poids de modèle ne figuraient dans le fichier. Ce qui a fuité, c'est la logique applicative de l'outil en ligne de commande, pas les données qui y transitent.

Faut-il un CLAUDE.md par sous-répertoire ?

Seulement si les conventions diffèrent vraiment d'un module à l'autre, et en gardant en tête que ces fichiers ne survivent pas au compactage tant qu'aucun fichier du dossier n'est relu. Pour un projet de taille moyenne, un fichier à la racine sous les 200 lignes couvre l'essentiel. Au-delà, le dossier .claude/rules/ avec des règles à portée de chemin est une meilleure réponse.

Pourquoi mon prompt avec TodoWrite ne fonctionne plus ?

Parce que l'outil est désactivé par défaut depuis la version 2.1.142. Remplacez les références par TaskCreate, TaskUpdate, TaskGet et TaskList. Si vous devez temporairement revenir à l'ancien comportement, la variable CLAUDE_CODE_ENABLE_TASKS=0 réactive TodoWrite, mais c'est une rustine, pas une solution durable.

KAIROS va-t-il finir par sortir ?

Impossible à dire. Le code existait, testé, derrière un drapeau désactivé. Une partie de ses briques a été livrée séparément, la mémoire automatique côté Claude Code et Dreaming côté API. Le démon permanent, lui, n'a pas refait surface. Un drapeau de fonctionnalité dans une base de code n'est jamais une promesse de sortie, et le retrait d'ULTRAPLAN après quelques semaines le rappelle assez bien.

Ces conseils valent-ils pour d'autres agents que Claude Code ?

Les principes se transposent, oui : instructions persistantes sur disque, contraintes chiffrées plutôt que qualitatives, délégation à des contextes isolés, ancrage par liste de tâches. Les noms de fichiers, commandes et variables cités ici sont en revanche spécifiques à Claude Code.

Ce que je retiens

Cette fuite aura été un cadeau involontaire pour les utilisateurs. Elle a confirmé que l'outil est nettement plus sophistiqué qu'il n'y paraît en surface, et elle a rendu publiques des mécaniques qu'on devinait sans pouvoir les vérifier.

Les six leviers tiennent : un CLAUDE.md court et précis, une mémoire automatique surveillée, un compactage dirigé plutôt que subi, une délégation systématique aux sous-agents, des consignes chiffrées à la place des adjectifs, et une liste de tâches sur disque pour les sessions longues. Aucun ne demande d'abonnement particulier ni de configuration exotique. Tous s'appliquent dès la prochaine session.

La leçon secondaire est peut-être la plus utile sur la durée. Un drapeau de fonctionnalité n'engage personne, et une info tirée d'un leak a une durée de vie de quelques semaines. ULTRAPLAN est né, a vécu et a disparu en deux mois. La documentation officielle, elle, est mise à jour en continu, et c'est toujours là qu'il faut retourner vérifier.