J'ai lu le code source de Claude Code pour que vous n'ayez pas à le faire

La plupart des gens ouvrent Claude Code, tapent une requête, attendent la réponse, tapent une autre requête.

C'est comme acheter une Ferrari et ne rouler qu'en première vitesse.

Je voulais comprendre pourquoi certaines personnes semblent tirer 10x plus de Claude Code que d'autres. Alors j'ai fait ce que toute personne raisonnable ferait : j'ai lu tout le code source (quand je dis "j'ai", je veux dire Claude Code bien sûr).

11 couches d'architecture. Des milliers de lignes. Une plateforme d'orchestration d'agents déguisée en chat terminal.

Voici ce que le code source révèle sur la façon d'utiliser réellement ce truc.

1. CLAUDE.md est chargé à chaque tour. Chaque. Tour.

C'est la chose à plus fort levier que tu puisses faire, et presque personne ne le fait correctement.

La plupart des gens soit n'ont rien dans leur fichier CLAUDE.md, soit y ont écrit la bible.

Le code source montre que Claude Code lit tes fichiers CLAUDE.md à chaque itération de requête. Pas au lancement de la session. À chaque tour. Ce qui signifie que chaque fois que tu envoies un message, il relit tes instructions.

Il y a toute une hiérarchie :

• ~/.claude/CLAUDE.md — global (ton style de code, tes préférences)

• ./CLAUDE.md — niveau projet (décisions d'architecture, conventions)

• .claude/rules/*.md — règles modulaires

• CLAUDE.local.md — notes privées (gitignoré)

Tu as 40 000 caractères. C'est ÉNORME. La plupart des gens en utilisent peut-être 200.

Mets-y tes décisions d'architecture. Tes conventions de fichiers. Tes habitudes de test. Tes règles "ne jamais faire ça". Le modèle les lit à chaque tour. C'est la différence entre Claude Code en tant qu'assistant générique et Claude Code en tant que TON assistant qui connaît TA base de code.

Si tu ne fais qu'une chose après avoir lu ceci, c'est celle-ci.

2. Les sous-agents partagent le cache d'instructions (le parallélisme est quasiment gratuit)

C'est ce qui m'a époustouflé.

Quand Claude Code fork un sous-agent, il crée une copie identique octet par octet du contexte parent. L'API met ceci en cache. Donc lancer 5 agents pour travailler sur différentes parties de ta base de code coûte à peine plus qu'un seul agent qui fait la même chose séquentiellement.

Relis ça.

5 agents. Même coût qu'un seul. Parce qu'ils utilisent tous le cache d'instructions.

La plupart des gens utilisent Claude Code comme un travailleur isolé. Une tâche à la fois. Attendre qu'elle finisse. Donner la suivante.

Le code source contient littéralement trois modèles d'exécution pour les sous-agents :

• fork — hérite du contexte parent, optimisé pour le cache

• teammate — panneau séparé dans tmux ou iTerm, communique via une boîte aux lettres basée sur des fichiers

• worktree — obtient son propre git worktree, branche isolée par agent

Tu peux demander à Claude Code de lancer 5 agents : un qui fait un audit de sécurité, un qui refactorise le module d'authentification, un qui écrit des tests, un qui met à jour la documentation, un qui corrige des bugs. Tous en même temps. Tous partageant le cache.

L'architecture est CONÇUE pour ça. L'utiliser en mono-thread est criminel.

3. Le système d'autorisations est conçu pour être configuré, pas cliqué

Chaque fois que Claude Code demande "Autoriser cette action ?" et que tu cliques sur oui, c'est un échec de la configuration, pas une fonctionnalité.

Le code source révèle une cascade de paramètres à 5 niveaux :

1politique > indicateur > local > projet > utilisateur

Dans ~/.claude/settings.json, tu peux définir des motifs glob pour ce qui est toujours autorisé :

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm *)",
5      "Bash(git *)",
6      "Edit(src/**)",
7      "Write(src/**)"
8    ]
9  }
10}

Il existe trois modes d'autorisation :

• bypass — aucune vérification d'autorisation (dangereux mais rapide)

• allowEdits — autorise automatiquement les modifications de fichiers dans ton répertoire de travail

• auto (c'est nouveau) — exécute un classifieur LLM sur chaque action. C'est le sweet spot.

Le mode auto a ses propres listes d'autorisation/refus que tu peux configurer. Le code source montre qu'il fait concourir plusieurs résolveurs en parallèle : clic utilisateur, classifieur de hook, pont, et le premier à répondre gagne.

Chaque fois que tu t'arrêtes pour cliquer sur "Autoriser", c'est du temps perdu. Configure-le une fois. Ne clique plus jamais.

4. Il y a 5 stratégies de compaction. La pression du contexte est un vrai problème

Le code source propose CINQ façons différentes de compresser ta conversation quand elle devient trop longue :

1. microcompact — effacement temporel des vieux résultats d'outils

1. context collapse — résume des segments de conversation

1. session memory — extrait le contexte clé dans un fichier

1. full compact — résume tout l'historique

1. PTL truncation — supprime les groupes de messages les plus anciens

Cela te dit quelque chose d'important : le débordement de contexte est un problème central sur lequel les ingénieurs ont passé BEAUCOUP de temps.

Ce que cela signifie pour toi :

• Utilise /compact de manière proactive. N'attends pas que le système se compacte automatiquement et perde le contexte qui t'importe.

• La fenêtre par défaut est de 200 000 tokens. Mais tu peux opter pour 1 million de tokens en utilisant le suffixe de modèle [1m]. Pour les gros refactorings sur de nombreux fichiers, cela compte.

• Les sessions longues accumulent une "mémoire de session" — des résumés structurés des spécifications de tâche, des listes de fichiers, de l'état du flux de travail, des erreurs et des apprentissages. C'est pourquoi reprendre une session est mieux que d'en commencer une nouvelle.

• Les grands résultats d'outils sont stockés sur disque avec seulement un aperçu de 8 Ko envoyé au modèle. Si tu colles un fichier énorme, le modèle n'en verra peut-être qu'une fraction. Garde les entrées ciblées.

Les personnes qui tirent le meilleur parti de Claude Code utilisent /compact comme un point de sauvegarde manuel dans un jeu vidéo. Préserve ce qui compte, efface ce qui ne compte pas, continue d'avancer.

5. Le système de hooks est la vraie API d'extension (plus de 25 événements de cycle de vie)

C'est la fonctionnalité de power-user que presque personne ne connaît.

Le code source révèle plus de 25 événements du cycle de vie auxquels tu peux te brancher :

• PreToolUse — s'exécute avant que tout outil ne s'exécute

• PostToolUse — s'exécute après que tout outil s'est exécuté

• UserPromptSubmit — s'exécute quand tu envoies un message

• SessionStart / SessionEnd — cycle de vie de la session

• et plus de 20 autres

Avec 5 types de hooks :

• command — exécute une commande shell

• prompt — injecte du contexte via LLM

• agent — exécute une boucle de vérification d'agent complète

• HTTP — appelle un webhook

• function — exécute du JS

Exemples concrets de ce que tu peux faire :

• Lancer automatiquement un linting avant chaque écriture de fichier

• Exécuter des tests après chaque modification

• Injecter automatiquement la documentation pertinente dans chaque requête

• Envoyer une notification Slack quand une tâche se termine

• Valider que les motifs de sécurité sont respectés avant que le code soit livré

Le hook UserPromptSubmit est particulièrement dingue. Tu peux injecter additionalContext dans chaque message que tu envoies. Imagine attacher automatiquement les résultats de tests, les diffs git récents ou l'état du projet à chaque requête sans avoir à taper quoi que ce soit.

C'est ainsi que tu construis un environnement de développement personnalisé sur Claude Code. Pas en améliorant tes prompts. En te branchant sur le système lui-même.

6. Les sessions sont persistantes et récupérables (arrête de repartir de zéro)

Chaque conversation est sauvegardée en JSONL dans

1~/.claude/projects/{hash}/{sessionId}.jsonl

Le code source prend en charge :

• --continue — reprendre ta dernière session

• --resume — choisir une session passée spécifique

• --fork-session — bifurquer à partir d'une conversation passée (j'adore personnellement celle-ci)

L'extraction de mémoire de session préserve le contexte clé à travers les compactions : spécifications de tâche, listes de fichiers, état du flux de travail, erreurs et apprentissages.

La plupart des gens commencent une nouvelle session à chaque fois qu'ils ouvrent Claude Code. C'est comme fermer ton IDE et le rouvrir à zéro toutes les heures. Tout le contexte sur ce que tu faisais, ce qui a échoué, ce que tu as appris — perdu.

Utilise --continue. Toujours. Laisse le contexte s'accumuler. Laisse la mémoire de session construire des apprentissages au fil du temps. Le code source contient littéralement une infrastructure pour cela. Utilise-la.

7. Le système d'outils exécute plus de 60 outils avec un traitement par lots intelligent

Claude Code dispose de plus de 60 outils intégrés. Mais la partie intéressante est COMMENT il les exécute.

Le code source partitionne les appels d'outils en deux catégories :

• concurrent — les opérations en lecture seule (lecture de fichiers, recherche, globbing) s'exécutent en parallèle

• séquentiel — les opérations de mutation (éditions, écritures, commandes bash) s'exécutent une par une

Cela signifie que lorsque Claude Code a besoin de lire 10 fichiers pour comprendre ta base de code, il lit les 10 simultanément. Mais quand il doit modifier 3 fichiers, il le fait un par un pour éviter les conflits.

En plus des outils intégrés, tu peux connecter des serveurs MCP qui ajoutent plus d'outils. Le code source utilise le chargement différé. Les outils MCP ne se chargent que lorsque nécessaire, donc connecter 5 serveurs MCP ne ralentit pas chaque requête.

Et il y a ToolSearch pour la découverte différée d'outils que l'agent ne connaît pas encore.

Le point pratique : si ton flux de travail implique des systèmes externes (bases de données, fournisseurs cloud, CI/CD), connecte-leur des serveurs MCP. L'architecture gère la complexité. Tu obtiens juste plus de capacités.

8. L'architecture de streaming rend l'interruption peu coûteuse

Tout le pipeline utilise des générateurs asynchrones qui produisent des événements individuels. Appuyer sur Échap annule proprement le flux actuel sans perdre le contexte précédent.

Cela semble anodin mais ça change la façon dont tu devrais utiliser Claude Code.

N'attends pas une réponse dont tu sais qu'elle va dans la mauvaise direction. Interromps immédiatement et redirige. Le code source est conçu pour ça. Ton contexte précédent est préservé. La réponse interrompue est jetée proprement. Zéro pénalité.

Pense-y comme à du programmation en binôme. Si ton binôme commence à partir dans la mauvaise direction, tu n'attends pas qu'il finisse. Tu dis "en fait, va par là plutôt." Même énergie.

9. Le système de réessai est plus sophistiqué que tu ne le penses

Le code source révèle :

• 10 tentatives avec backoff exponentiel et gigue (500 ms de base)

• Rafraîchissement automatique du jeton OAuth en cas de 401/403

• Repli de modèle : si Opus échoue 3 fois avec des erreurs 529, il bascule automatiquement vers Sonnet

• Chien de garde d'inactivité de 90 secondes sur les flux — si le streaming se bloque, il bascule vers le non-streaming

• Le mode persistant a un nombre infini de tentatives avec un backoff maximal de 5 minutes

Cela signifie que Claude Code est conçu pour rester en fonctionnement. Il gère les aléas de l'API, les limites de débit et les pannes avec élégance. Tu n'as pas besoin de le surveiller. Laisse-le tourner en arrière-plan et reviens aux résultats.

Le résumé : les actions au plus fort levier selon le code source

• Écris un vrai CLAUDE.md → chargé à chaque tour. 40 000 caractères. Configuration au plus fort levier.
• Parallélise avec des sous-agents → le modèle fork partage le cache d'instructions. 5 agents ≈ coût de 1.
• Configure les autorisations dans settings.json → élimine la fatigue des clics pour toujours.
• Utilise /compact de manière proactive → 5 stratégies de compaction existent parce que la pression du contexte est réelle.
• Mets en place des hooks → plus de 25 événements, 5 types. C'est la vraie API d'extension.
• Toujours --continue les sessions → persistance JSONL + mémoire de session = contexte accumulé.
• Connecte des serveurs MCP → chargement différé signifie zéro coût jusqu'à utilisation.
• Interromps librement → les générateurs asynchrones signifient zéro pénalité pour rediriger.

Le fond de l'affaire : Claude Code est une plateforme d'orchestration d'agents déguisée en interface utilisateur de terminal.

Les personnes qui obtiennent un rendement 10x ne sont pas de meilleurs rédacteurs de prompts. Ils l'ont configuré. Ils l'ont parallélisé. Ils s'y sont branchés. Ils ont laissé le contexte s'accumuler entre les sessions.

Le code source rend cela évident. Maintenant tu sais ce qu'il fait réellement sous le capot.

RT si tu as trouvé ça utile 🫶