Ce que la fuite du code source de Claude révèle sur l'architecture des outils de codage d'IA

En bref

Anthropic a accidentellement expédié un fichier .map avec le package npm Claude Code, exposant ainsi le code source complet et lisible de son outil CLI. La fuite révèle des mécanismes anti-distillation avec injection d'outils factices, un moteur d'expressions régulières pour la détection de la frustration, un « mode incognito » qui masque la paternité de l'IA dans les commits open-source, et un mode d'agent autonome non encore publié appelé KAIROS. Voici ce que les développeurs d'API devraient savoir sur le fonctionnement interne des outils de codage IA.

Introduction

Le 31 mars 2026, le chercheur en sécurité Chaofan Shou a découvert qu'Anthropic avait expédié un fichier de carte source (.map) avec le package npm Claude Code. Les cartes sources sont des fichiers de débogage qui mappent le code de production minifié vers le code source lisible par l'homme. Ils sont censés être supprimés avant la publication.

Ils ne l'ont pas été. Le code source complet de Claude Code, avec les commentaires, les noms de code internes et les détails architecturaux, était lisible par quiconque téléchargeait le package.

La découverte a atteint la première place sur Hacker News (1 888 points, 926 commentaires) et s'est répandue sur Reddit, Twitter et les forums de développeurs en quelques heures. Anthropic a retiré le package, mais le code avait déjà été mis en miroir et analysé en profondeur.

Cet article analyse les principales découvertes techniques et leurs implications pour les développeurs qui s'appuient sur les outils de codage IA.

Comment le code source a fuité

La cause principale : un bug de l'outil de build Bun

Claude Code est construit sur Bun, un runtime JavaScript alternatif. Le 11 mars 2026, un bug a été signalé contre Bun (oven-sh/bun#28001) rapportant que les cartes sources sont servies en mode production malgré la documentation de Bun spécifiant qu'elles devraient être désactivées.

La chaîne de build d'Anthropic a déclenché ce bug. Lorsqu'ils ont publié le package npm Claude Code, le fichier .map a été inclus dans la distribution. Quiconque exécutait npm pack @anthropic-ai/claude-code ou inspectait le contenu du package pouvait accéder au code source complet et non minifié.

L'ironie est notable : un bug dans la propre chaîne d'outils d'Anthropic, le runtime Bun qu'ils ont choisi pour Claude Code, a fuité leur code source propriétaire via le registre npm sur lequel ils publient. Le même registre npm qui, le même jour, a distribué le package Axios compromis.

Ce qui a été exposé

La fuite comprenait :

• Le code source TypeScript complet sur tous les modules
• Des commentaires internes expliquant les décisions de conception
• Des drapeaux de fonctionnalités et des configurations expérimentales
• Des modèles de prompts système et des mécanismes de sécurité
• Des noms de code internes pour des fonctionnalités non encore publiées
• Des détails d'optimisation des performances avec des métriques spécifiques

Il ne s'agit pas d'une fuite partielle ou d'une version open-source aseptisée. C'est la base de code de production avec le contexte d'ingénierie interne intact.

Anti-distillation : protection contre le vol de modèle

Injection d'outils factices

L'une des découvertes les plus discutées est le système anti-distillation de Claude Code. Dans claude.ts (lignes 301-313), lorsque le drapeau ANTI_DISTILLATION_CC est activé, le système envoie anti_distillation: ['fake_tools'] dans les requêtes API.

Cela indique au serveur d'Anthropic d'injecter des définitions d'outils leurres dans le prompt du système. Le but : si un concurrent enregistre le trafic API pour extraire et reproduire le comportement d'utilisation d'outils de Claude, les données d'entraînement contiennent de faux outils qui n'existent pas. Un modèle entraîné sur ces données empoisonnées hallucinerait des capacités inexistantes.

Il s'agit d'une défense pratique contre une menace réelle. Les concurrents peuvent mettre en place des services proxy qui interceptent les appels API de Claude, enregistrent les prompts système et les définitions d'outils, et utilisent ces données pour affiner leurs propres modèles. Les outils factices rendent ces données capturées peu fiables.

Résumés de texte de connecteur

Un deuxième mécanisme anti-distillation dans betas.ts (lignes 279-298) adopte une approche différente. Ce système côté serveur met en mémoire tampon le texte de l'assistant entre les appels d'outils, le résume et renvoie le résumé avec une signature cryptographique.

Lors des tours de conversation suivants, le texte original peut être restauré à partir de la signature. Mais quiconque enregistre le trafic API ne capture que les résumés, pas le texte de raisonnement complet. Cela rend plus difficile la rétro-ingénierie des modèles de raisonnement de Claude à partir de conversations API interceptées.

Est-il facile de les contourner ?

L'analyse a révélé plusieurs voies de contournement :

• Un proxy man-in-the-middle pourrait supprimer le champ anti_distillation avant que les requêtes API n'atteignent les serveurs d'Anthropic
• La définition de la variable d'environnement CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS désactive l'ensemble du système anti-distillation
• Les protections ne fonctionnent que contre l'enregistrement passif du trafic, pas contre l'utilisation active de l'API

Cela ne signifie pas que les protections sont inutiles. Elles augmentent le coût et la complexité de la distillation automatisée des modèles. Mais ce sont des mesures de défense en profondeur, pas des boucliers incassables.

Mode incognito : masquer la paternité de l'IA

Ce que fait le mode incognito

Le fichier undercover.ts contient l'une des découvertes les plus controversées de la fuite. Lorsque Claude Code opère dans des dépôts non-Anthropic, il active un système de masquage de comportement qui empêche :

• Les mentions de noms de code internes comme « Capybara » ou « Tengu »
• Les références à des canaux Slack internes ou à des noms de dépôts
• L'expression « Claude Code » elle-même d'apparaître dans les sorties

Le commentaire du code source est explicite : « Il n'y a PAS de désactivation forcée. Cela protège contre les fuites de noms de code de modèle. »

Pourquoi c'est important pour l'open source

L'effet pratique : lorsque les employés d'Anthropic utilisent Claude Code pour écrire des commits, des requêtes de tirage (pull requests) ou des révisions de code dans des projets open-source, l'outil masque les preuves d'implication de l'IA. Les contributions générées par l'IA aux dépôts open-source ne divulgueraient pas la paternité de l'IA.

Cela soulève des questions sur la transparence dans le développement open-source. Plusieurs projets open-source ont adopté des politiques exigeant la divulgation du code généré par l'IA. Si un outil est conçu pour cacher son implication, ces politiques deviennent plus difficiles à appliquer.

Le contre-argument : le but déclaré du mode incognito est d'empêcher les fuites de noms de code de projets internes, et non de cacher l'utilisation de l'IA. Mais l'implémentation ne fait pas de distinction entre « ne pas révéler les noms internes » et « ne pas révéler que vous êtes un outil d'IA ». Il bloque les deux.

Détection de la frustration via les expressions régulières

Comment ça marche

Le fichier userPromptKeywords.ts implémente la détection de la frustration de l'utilisateur via la correspondance de motifs d'expressions régulières. Le système analyse les entrées de l'utilisateur pour y trouver des grossièretés et un langage chargé émotionnellement afin d'évaluer si l'utilisateur est frustré par les réponses de Claude Code.

La réaction de la communauté à cette découverte a été partagée. Certains y ont vu une recherche UX raisonnable ; comprendre quand les utilisateurs sont frustrés aide à améliorer le produit. D'autres l'ont considéré comme une surveillance des états émotionnels des utilisateurs.

L'ironie technique

Plusieurs commentateurs de HN ont souligné l'ironie : Anthropic construit les modèles linguistiques les plus avancés au monde, mais utilise des expressions régulières pour détecter les émotions des utilisateurs. Le commentaire d'ingénierie dans la source explique la raison. La détection basée sur les expressions régulières est plus rapide et moins chère que l'inférence LLM pour ce cas d'utilisation. L'exécution d'un appel LLM pour classer le sentiment sur chaque entrée utilisateur ajouterait de la latence et des coûts à chaque interaction.

C'est une décision d'ingénierie pragmatique. Des expressions régulières rapides pour la détection de sentiment dans les chemins critiques, réservant les appels LLM pour les tâches de codage principales. Que vous soyez à l'aise avec le fait que votre outil de codage IA effectue une analyse émotionnelle sur vos entrées est une décision personnelle.

Attestation du client natif

Vérification cryptographique des requêtes

Dans system.ts (lignes 59-95), les requêtes API de Claude Code incluent un placeholder cch=554eb. La pile HTTP native de Bun (écrite en Zig) écrase ce placeholder avec un hash calculé avant que la requête ne quitte le client.

Les serveurs d'Anthropic valident ce hash pour vérifier cryptographiquement que les requêtes proviennent du binaire légitime de Claude Code, et non d'un fork, d'un wrapper ou d'un proxy.

Pourquoi cela existe

Ce système d'attestation est le mécanisme d'application technique derrière les actions légales d'Anthropic contre les forks non autorisés de Claude Code. Si un fork ne peut pas produire des hashes d'attestation valides, les serveurs d'Anthropic peuvent rejeter ses requêtes.

L'implémentation a cependant des limites. Elle est soumise à des drapeaux de fonctionnalités au moment de la compilation et peut être désactivée via le paramètre CLAUDE_CODE_ATTRIBUTION_HEADER ou des interrupteurs GrowthBook. Cela suggère que l'application est graduée, Anthropic pouvant resserrer ou assouplir les restrictions selon les besoins.

Pour les développeurs d'API, cela est pertinent car cela démontre comment les outils SaaS peuvent faire respecter l'authenticité du client au niveau du protocole. Des schémas similaires existent dans le développement d'API mobiles, où l'attestation d'application empêche l'accès non autorisé à l'API. Si vous concevez des API avec vérification client, les outils de test d'Apidog peuvent vous aider à valider les flux d'attestation et le `certificate pinning` sur différentes configurations client.

KAIROS : le mode agent autonome non encore publié

Ce que le code révèle

Des références dans toute la base de code pointent vers un mode à fonctionnalités restreintes non encore publié appelé KAIROS. L'échafaudage découvert comprend :

• Une compétence /dream pour la « distillation nocturne de la mémoire »
• Une journalisation quotidienne en mode ajout seulement
• Des abonnements webhook GitHub pour la surveillance des événements de dépôt
• Des démons d'arrière-plan avec des intervalles de rafraîchissement cron de 5 minutes

Ce que cela signifie

KAIROS semble être un agent toujours actif, s'exécutant en arrière-plan, qui surveille vos dépôts et effectue des tâches autonomes sans interaction directe de l'utilisateur. Imaginez Claude Code fonctionnant en continu, observant les changements et suggérant ou effectuant de manière proactive des modifications de code.

Cela correspond à la tendance plus large de l'industrie vers les agents de codage autonomes. Le mode Agent de GitHub Copilot, le traitement en arrière-plan de Cursor et l'Agent Smith de Google pointent tous vers des outils de codage IA qui n'attendent pas que vous demandiez. Ils observent, apprennent et agissent par eux-mêmes.

Pour les équipes de développement d'API, les agents autonomes qui modifient les dépôts de code soulèvent des questions sur la stabilité des contrats d'API. Si un agent met à jour le code de votre endpoint API, met-il également à jour la spécification OpenAPI ? Les tests ? La documentation ? Ce sont les problèmes de flux de travail que les plateformes intégrées comme Apidog sont conçues pour résoudre, en gardant la conception de l'API, les tests, les mocks et la documentation synchronisés, quelle que soit la cause d'un changement de code.

Optimisations de performance exposées

Rendu terminal : techniques de moteur de jeu

Les fichiers ink/screen.ts et ink/optimizer.ts révèlent que Claude Code utilise des techniques de moteur de jeu pour le rendu du terminal :

• Des pools de caractères basés sur Int32Array pour des tampons d'écran efficaces en mémoire
• Une optimisation de patch qui réduit les calculs de largeur de caractère d'environ 50x pendant le streaming de tokens

Ceci explique pourquoi Claude Code est réactif même pendant de longs flux de sortie. La couche de rendu est optimisée à un niveau inhabituel pour les outils CLI.

L'économie du cache de prompts

promptCacheBreakDetection.ts suit 14 vecteurs de rupture de cache distincts avec des « loquets collants » qui empêchent les basculements de mode d'invalider les prompts mis en cache. Cela reflète l'importance économique du cache de prompts pour le modèle commercial de Claude Code.

Chaque rupture de cache force Anthropic à retraiter l'intégralité du prompt système et du contexte de conversation. Au prix des tokens de Claude, la prévention d'une invalidation inutile du cache permet d'économiser des coûts d'infrastructure significatifs. Le fait qu'ils suivent 14 vecteurs de rupture de cache distincts suggère que l'équipe d'ingénierie traite l'optimisation du cache de prompts comme une préoccupation de performance de premier ordre.

La cascade d'échecs d'autocompactage

Un commentaire dans autoCompact.ts (lignes 68-70) a révélé un problème de production important : « 1 279 sessions ont eu plus de 50 échecs consécutifs (jusqu'à 3 272) en une seule session, gaspillant environ 250 000 appels API par jour globalement. »

La correction en trois lignes a défini MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3. Ce bug n'apparaît qu'à grande échelle. Lorsque la gestion du contexte échoue, le système réessaie agressivement, brûlant des appels API sans progresser. Pour un outil avec des millions de sessions actives, 250 000 appels API gaspillés par jour se traduisent par un coût substantiel.

Ce contexte aide à expliquer le récent article de Hacker News sur les utilisateurs de Claude Code « atteignant les limites d'utilisation beaucoup plus rapidement que prévu » (275 points). Une partie de cette consommation de limite pourrait être attribuée à des bugs d'efficacité interne comme celui-ci.

Détails sur le durcissement de la sécurité

Sécurité Bash : 23 vérifications numérotées

bashSecurity.ts implémente 23 vérifications de sécurité numérotées pour l'exécution de commandes shell, y compris des défenses contre :

• L'exploitation des built-ins de Zsh
• L'injection d'espaces à largeur nulle Unicode dans les commandes
• L'injection de caractères nuls dans IFS (Internal Field Separator)
• Des protections supplémentaires découvertes lors de la révision de sécurité HackerOne

C'est inhabituellement approfondi pour un outil CLI. La plupart des outils de codage IA qui exécutent des commandes shell ont une assainissement basique. Les 23 vérifications de Claude Code suggèrent qu'ils ont traité (ou se sont proactivement défendus contre) des vecteurs d'attaque créatifs.

Pour les développeurs d'API qui utilisent des outils IA pour générer et exécuter des scripts de test d'API, ce niveau de sécurité shell est pertinent. Si votre outil de codage IA exécute des commandes curl, des requêtes de base de données ou des scripts d'infrastructure, la sécurité de la couche d'exécution de commandes est importante.

Ce que les développeurs d'API devraient retenir de cela

1. Comprenez ce que vos outils de codage IA font en coulisses

La fuite de Claude Code révèle des capacités dont la plupart des utilisateurs ignoraient l'existence : mesures anti-distillation, détection de la frustration, mode incognito, attestation client. D'autres outils de codage IA ont leurs propres mécanismes internes que les utilisateurs ne peuvent pas inspecter.

Demandez-vous : savez-vous quelles données votre outil de codage IA collecte ? Ce qu'il envoie à des serveurs externes ? S'il masque sa propre implication dans votre code ?

2. La chaîne d'outils de build est une surface d'attaque

La source d'Anthropic a fuité à cause d'un bug de Bun. Le même jour, Axios a été compromis par un détournement de compte npm. Vos outils de build, gestionnaires de paquets et environnements d'exécution sont tous des points de défaillance potentiels.

Pour le développement d'API, cela signifie :

• Auditez les dépendances de votre pipeline de build
• Vérifiez que votre CI/CD n'expose pas de cartes sources, de fichiers .env ou de configurations internes
• Utilisez des plateformes de développement intégrées qui minimisent les surfaces de dépendances tierces

3. Les outils de codage IA convergent vers un fonctionnement autonome

KAIROS, le mode Agent de GitHub Copilot, l'Agent Smith de Google. La direction est claire : des outils IA qui fonctionnent en continu, surveillent les dépôts et agissent de manière autonome.

Les équipes API doivent s'y préparer en s'assurant que leur cycle de vie API est géré sur une plateforme unique. Lorsqu'un agent autonome modifie l'implémentation de votre API, vos tests, mocks, documentation et spécifications doivent rester synchronisés. Des outils déconnectés créent des décalages. Les plateformes intégrées comme Apidog maintiennent l'ensemble du cycle de vie API synchronisé, que les changements proviennent de développeurs humains ou d'agents IA.

4. La transparence du code source est importante

Cette fuite s'est produite parce que le code était propriétaire et a été accidentellement exposé. Les outils IA open-source n'ont pas ce risque car leur code est déjà public.

Lorsque vous évaluez des outils de codage IA, demandez-vous si vous préférez des outils dont vous pouvez inspecter les entrailles ou des outils qui reposent sur la confiance envers le fournisseur. Les deux approches ont des compromis, mais la fuite de Claude Code démontre ce que signifie « faire confiance au fournisseur » lorsque le code du fournisseur révèle des comportements inattendus.

FAQ

Claude Code est-il sûr à utiliser après la fuite du code source ?

Oui. La fuite a exposé le code source, pas les données utilisateur. Anthropic a retiré le fichier .map et la source n'est plus distribuée avec le package npm. Les fonctionnalités révélées (anti-distillation, détection de la frustration, mode incognito) sont des décisions architecturales, et non des vulnérabilités de sécurité. Que vous soyez à l'aise avec ces décisions est une question distincte de la sécurité.

Qu'est-ce que le « mode incognito » dans Claude Code ?

Le mode incognito empêche Claude Code de révéler les noms de projets internes d'Anthropic, les noms de code et sa propre identité lorsqu'il opère dans des dépôts non-Anthropic. Il s'active automatiquement et ne peut pas être désactivé. L'effet pratique est que le code généré par l'IA dans les projets open-source ne s'identifiera pas comme étant écrit par Claude Code.

Que sont les outils factices dans Claude Code ?

Lorsque l'anti-distillation est activée, le serveur d'Anthropic injecte des définitions d'outils leurres dans le prompt système. Ces outils factices ne font rien. Ils existent pour empoisonner les données d'entraînement des concurrents qui enregistrent le trafic API pour entraîner des modèles concurrents. Si quelqu'un tente de reproduire le comportement de Claude à partir de données interceptées, son modèle hallucinerait des capacités inexistantes.

Qu'est-ce que KAIROS dans Claude Code ?

KAIROS est un mode agent autonome non encore publié, marqué par des drapeaux de fonctionnalités, découvert dans la source de Claude Code. Il comprend un échafaudage pour les démons d'arrière-plan, les abonnements webhook GitHub et une compétence /dream pour la distillation de la mémoire. Cela suggère qu'Anthropic construit un agent de codage toujours actif qui surveille les dépôts et agit de manière autonome.

Comment le code source de Claude Code a-t-il fuité ?

Un bug du runtime Bun (oven-sh/bun#28001) fait que les cartes sources sont incluses dans les builds de production même lorsqu'elles ne devraient pas l'être. Comme Claude Code utilise Bun comme outil de build, ce bug a fait que le fichier .map a été expédié avec le package npm. Quiconque inspectait le package pouvait lire le code source complet et non minifié.

Cette fuite affecte-t-elle les utilisateurs de l'API Claude ?

Non. La fuite a exposé le code source de l'outil CLI Claude Code, pas l'API Claude elle-même. Les clés API, les données utilisateur et les poids du modèle n'étaient pas impliqués. Les utilisateurs de l'API Claude peuvent continuer à utiliser l'API normalement. Les mécanismes anti-distillation révélés sont spécifiques au pipeline de requêtes de Claude Code.

Dois-je m'inquiéter de la détection de frustration dans mes outils de codage IA ?

Cela dépend de votre niveau de confort. Claude Code utilise des expressions régulières pour détecter la frustration de l'utilisateur (grossièretés, langage émotionnel) dans les prompts. C'est plus rapide et moins cher qu'une analyse de sentiment basée sur LLM. Les données semblent être utilisées pour l'amélioration du produit, et non partagées en externe. D'autres outils IA peuvent avoir des fonctionnalités similaires sans les divulguer.

Quel est le lien avec l'attaque npm d'Axios le même jour ?

Les deux événements se sont produits le 31 mars 2026, mais ils sont sans rapport. L'attaque d'Axios était un compromis délibéré de la chaîne d'approvisionnement par des hackers parrainés par l'État. La fuite de Claude Code était une erreur de configuration de build accidentelle. Ensemble, ils ont intensifié l'examen de la sécurité des packages npm et la confiance que les développeurs accordent aux outils distribués via les registres de packages.

Points clés à retenir

• La source de Claude Code a fuité via un bug de l'outil de build Bun qui a expédié des cartes sources dans le package npm
• Les mécanismes anti-distillation injectent des outils factices et résument le raisonnement pour empêcher le vol de modèle
• Le mode incognito masque l'implication de Claude Code dans les dépôts open-source non-Anthropic
• La détection de la frustration fonctionne via des expressions régulières sur les entrées utilisateur, et non via une analyse basée sur LLM
• L'échafaudage KAIROS révèle un mode d'agent autonome d'arrière-plan non encore publié
• L'attestation client vérifie cryptographiquement que les requêtes proviennent de binaires légitimes de Claude Code
• La fuite met en évidence l'importance d'outils transparents et inspectables dans les workflows de développement d'API

Comprendre le fonctionnement interne de vos outils de codage IA vous aide à prendre de meilleures décisions concernant la confiance, la confidentialité et la conception des flux de travail. Pour les équipes API, la leçon clé est que vos outils de développement font partie de votre surface de sécurité. Choisissez des outils que vous pouvez vérifier et construisez des flux de travail qui restent cohérents, que ce soit un humain ou un agent IA qui apporte le prochain changement.