Claude brûle silencieusement votre argent

Les utilisateurs de Claude Code ont soudainement constaté une diminution rapide de leurs limites d'utilisation, souvent sans modifier leurs habitudes de codage ou la complexité de leurs prompts. Beaucoup signalent atteindre leurs plafonds d'abonnement 40 % plus vite qu'il y a quelques semaines seulement, suscitant une frustration généralisée. Cette augmentation inattendue et significative de la consommation a rapidement alerté les communautés de développeurs, entraînant des appels à la transparence de la part d'Anthropic.

Bien qu'Anthropic ait reconnu que les utilisateurs atteignaient les limites plus rapidement que prévu, la communauté a lancé sa propre enquête approfondie. Les développeurs ont méticuleusement capturé les requêtes API brutes à l'aide d'un proxy HTTP, révélant une divergence frappante et quantifiable. L'enquête a mis en évidence un saut direct de 40 % des jetons par requête lors de la comparaison des versions 2.1.98 et 2.1.100 de Claude Code. Il ne s'agissait pas d'une fluctuation mineure, mais d'une augmentation spectaculaire et mesurable impactant chaque interaction.

Sur la version 2.1.98, une requête de base typique consommait environ 50 000 jetons. Cependant, suite à la mise à niveau vers la version 2.1.100, le serveur a commencé à facturer 20 000 jetons supplémentaires pour la *même opération côté client*. Cela s'est produit bien que le client ait envoyé moins d'octets, ce qui indique sans équivoque une modification côté serveur. Surtout, ces jetons ajoutés sont entièrement invisibles dans la vue `/context` de la CLI, les rendant intraçables et inexplicables pour l'utilisateur.

Ce surcoût caché se traduit directement par des utilisateurs payant substantiellement plus cher pour un résultat identique, transformant souvent une requête de 10 cents en une facturation de 2 $ instantanément. Le problème n'est pas que le code utilisateur devienne plus « gourmand en jetons » ; au lieu de cela, l'infrastructure d'Anthropic facture silencieusement des jetons qui n'ont jamais été générés par l'entrée explicite du client. Cela soulève une question critique : d'où viennent ces jetons mystères, et pourquoi sont-ils ajoutés à la facture de chaque utilisateur sans divulgation ni contrôle ?

Une partie significative de la récente augmentation des jetons de Claude Code provient de ce que la communauté appelle une taxe invisible sur les jetons. Cette charge cachée découle des « jetons d'entrée de création de cache », une catégorie de facturation qui reste complètement opaque pour les utilisateurs. Bien qu'Anthropic facture ces jetons, ils sont manifestement absents de la vue `/context` de la CLI, donnant aux utilisateurs une impression dangereusement fausse de leur consommation réelle.

Les développeurs ont capturé des requêtes API brutes, révélant un contraste frappant entre les versions de Claude. Sur la version 2.1.98, une requête de base coûtait environ 50 000 jetons. Mais la version 2.1.100 a vu ce chiffre augmenter de 20 000 jetons – une augmentation de 40 % par requête – même lorsque les clients envoyaient moins d'octets. Cette augmentation substantielle n'apparaît tout simplement pas dans l'audit `/context`, rendant impossible pour les utilisateurs de suivre efficacement leurs dépenses.

Puisqu'Anthropic n'a pas publié de post-mortem technique, les développeurs ont rétro-ingénierie la CLI pour découvrir la cause profonde. Une théorie principale pointe vers une expansion massive du registre d'outils système de Claude. Pour que Claude soit plus performant dans l'utilisation des outils MCP et la gestion d'essaims complexes, Anthropic a probablement intégré une lourde couche d'instructions et de schémas. Ce manuel d'instructions étendu et caché accompagne désormais chaque requête.

Imaginez payer pour le poids entier d'un livre de cuisine complexe chaque fois que vous achetez un seul ingrédient au magasin. C'est précisément ce qui se passe avec ces jetons invisibles. Même si les utilisateurs n'exploitent pas activement ces nouvelles fonctionnalités ou outils complexes, ils supportent néanmoins le fardeau des jetons pour l'infrastructure étendue nécessaire pour les prendre en charge, brûlant silencieusement votre argent à chaque interaction.

Claude Code a conçu son mécanisme de mise en cache pour être une pierre angulaire de l'efficacité des coûts. Les utilisateurs s'attendaient à ce que le système stocke intelligemment la majeure partie du contexte de leur projet, souvent jusqu'à 90 % de la base de code, en particulier le contenu de `Claude.md` et d'autres fichiers stables. Cette stratégie visait à facturer uniquement le code nouvellement introduit ou les modifications spécifiques, rendant le développement itératif avec Claude économiquement viable. La promesse était claire : payez pour le delta, pas pour l'ensemble.

Cependant, un défaut critique est apparu dans certaines versions du binaire autonome Claude, sapant fondamentalement cette fonctionnalité d'économie de coûts. Ce bug fait que le binaire corrompt l'empreinte de cache, un identifiant unique destiné à confirmer l'intégrité et l'identité des données de projet mises en cache. Au lieu de reconnaître le contexte de projet existant, l'API interprète chaque interaction ultérieure comme une soumission de projet entièrement nouvelle, forçant un retraitement complet.

Les répercussions financières de ce seul bug sont stupéfiantes. Une requête de routine, peut-être une petite interrogation sur une base de code établie qui devrait coûter quelques centimes—environ 10 cents—escalade instantanément. La ré-ingestion forcée par l'API de l'intégralité du contexte du projet peut transformer cette opération nominale de 10 cents en une requête de 2 $, représentant une augmentation de prix de 20x. Cette surfacturation invisible contribue directement à ce que les utilisateurs atteignent leurs limites d'utilisation beaucoup plus rapidement que prévu.

En approfondissant le problème, les développeurs de la communauté ont identifié une défaillance de cache particulière liée à un problème au sein d'un fork personnalisé du Bun runtime utilisé par le binaire autonome Claude Code. Ce runtime spécialisé, sous certaines conditions, effectue une substitution de chaîne erronée. Plus précisément, si l'historique de chat contient du contenu lié à la facturation, cette substitution peut corrompre le préfixe du cache, rendant le système incapable d'identifier les informations précédemment traitées. Cela force la réévaluation de l'ensemble du projet à partir de zéro à chaque interaction. Pour des discussions techniques supplémentaires et des rapports d'utilisateurs, consultez le dialogue en cours : CC v2.1.100+ inflates cache_creation by ~20K tokens vs v2.1.98 — same payload, server-side · Issue #46917 · anthropics/claude-code - GitHub.

Un autre défaut significatif lié au cache aggrave encore le problème. L'activation de la commande `--resume` ou `--continue`, destinée à reprendre les conversations précédentes de manière transparente, rompt par inadvertance le cache pour l'intégralité de l'historique de conversation. Cela se produit dès la première requête reprise, déclenchant un coût de jeton substantiel et unique alors que Claude ré-ingère tout le contexte antérieur. De tels frais cachés contredisent l'attente d'une interaction continue et efficace.

Le bug précédent, qui corrompait les empreintes de cache, n'est pas le seul coupable du comportement gourmand en jetons de Claude. Un second défaut, tout aussi insidieux, cible spécifiquement les utilisateurs qui tentent de reprendre là où ils s'étaient arrêtés. Ce problème distinct tourne autour de la commande `--resume` ou `--continue`, une fonctionnalité apparemment anodine conçue pour une continuation de flux de travail et une préservation du contexte sans heurts.

L'utilisation de `--resume` déclenche une pénalité significative et immédiate. Dès la toute première requête après la reprise d'une conversation, Claude Code brise inexplicablement le cache de *tout* l'historique de conversation précédent. Au lieu d'exploiter intelligemment le cache de projet à 90%, qui devrait stocker votre contenu `Claude.md` et les tours précédents, le système retraite chaque interaction à partir de zéro.

Cet échec à utiliser le mécanisme de mise en cache prévu se traduit directement par un coût de jetons massif et unique. Les développeurs, s'attendant à ne payer que pour leur nouvelle entrée, sont au lieu de cela facturés pour le contexte complet et accumulé de toute leur session. Cette dépense inattendue peut rapidement consommer une part substantielle du quota mensuel d'un utilisateur, le laissant perplexe face à la hausse soudaine de l'utilisation et à l'épuisement rapide de son allocation.

Imaginez une longue session de codage, mise en pause puis reprise. La commande `--resume`, destinée à économiser du temps et des jetons, initie au lieu de cela un retraitement complet de tout ce qui a précédé. Ce coût unique peut être disproportionnellement élevé, transformant une simple requête de suivi en une opération coûteuse. C'est une surprise onéreuse qui impacte directement la valeur perçue des fonctionnalités de développement continu de Claude Code.

Combinés au problème d'empreinte de cache corrompue et à la taxe de jetons invisible due au registre d'outils système étendu, ces bugs créent une tempête parfaite. Chaque défaut gonfle indépendamment la consommation de jetons, mais leur effet cumulatif transforme les sessions de codage de routine en une rapide ponction des ressources. Claude Code brûle silencieusement votre argent, faisant du développement continu une proposition de plus en plus coûteuse, et laissant les utilisateurs frustrés par une facturation imprévisible.

Un événement pivot le 31 mars 2026 a fourni un aperçu critique de la consommation croissante de jetons de Claude. Une inclusion accidentelle dans un package npm a exposé une source map JavaScript de 59,8 Mo, révélant un nombre stupéfiant de 500 000 lignes du fonctionnement interne de Claude Code. Cette divulgation involontaire est devenue une confession accidentelle, mettant à nu l'architecture sous-jacente contribuant aux factures gonflées des utilisateurs.

Les développeurs ont découvert le fichier massif dans la version 2.1 du binaire de Claude Code. Cette publication involontaire, et non un piratage ciblé, a offert un aperçu sans précédent des coulisses d'Anthropic. Le volume impressionnant de code exposé a immédiatement suscité l'intérêt de la communauté, déclenchant un examen intense.

Anthropic a rapidement reconnu l'incident, publiant une déclaration officielle le classant comme « erreur humaine, pas une faille de sécurité ». Bien qu'Anthropic ait minimisé la gravité du point de vue de la sécurité, la communauté a compris ses profondes implications pour la transparence et les pratiques de facturation. Cette fuite accidentelle a offert des preuves cruciales, et non des données utilisateur.

La communauté des développeurs n'a pas perdu de temps, se plongeant immédiatement dans la base de code exposée. Leur analyse rapide a confirmé des suspicions de longue date concernant la complexité croissante du backend de Claude Code. Cette exploration approfondie a fourni des preuves concrètes de la théorie du feature creep, que beaucoup avaient spéculé être à l'origine des récentes augmentations de jetons.

L'analyse du code a révélé des drapeaux de fonctionnalités internes pour des fonctionnalités à venir comme Terminal Pets, Proactive Mode et la consolidation de la mémoire en arrière-plan. Ces découvertes suggéraient qu'Anthropic superposait silencieusement une nouvelle infrastructure complexe à chaque requête, même pour les utilisateurs n'employant pas activement ces fonctionnalités. Par conséquent, les utilisateurs qui brûlaient silencieusement leur argent payaient une taxe de jetons invisible pour des capacités futures, et non pour leur utilisation actuelle.

La fuite accidentelle du code source le 31 mars 2026 a offert un aperçu saisissant de la feuille de route ambitieuse d'Anthropic, révélant par inadvertance la source d'une grande partie de la consommation cachée de tokens de Claude. Un fichier de carte source JavaScript de 59,8 Mo, brièvement exposé, contenait des indicateurs de fonctionnalités internes pour des capacités non encore publiées, confirmant les soupçons de la communauté concernant le feature creep. Cette fuite s'est produite à peu près au même moment où Anthropic a reconnu que les utilisateurs atteignaient les limites d'utilisation plus rapidement que prévu, comme rapporté par Anthropic admits Claude Code quotas running out too fast - The Register.

Parmi les révélations les plus intrigantes figuraient : - Terminal Pets : Un assistant de type Tamagotchi conçu pour vivre au sein de l'environnement de développement, offrant une compagnie persistante et interactive. - Proactive Mode (Kairos) : Un agent toujours actif destiné à anticiper les besoins des développeurs, surveillant activement le code et suggérant des améliorations sans sollicitation explicite. - Background memory consolidation (Auto Dream) : Un système d'apprentissage persistant et de rétention de contexte, permettant à Claude de développer une compréhension plus profonde et à long terme d'un projet.

Ces fonctionnalités complexes et non encore publiées exigent une infrastructure sous-jacente sophistiquée. Les développeurs spéculent qu'Anthropic a massivement étendu le registre d'outils système de Claude pour prendre en charge ces futures capacités, même si elles ne sont pas encore actives pour les utilisateurs. Cette expansion implique l'ajout d'une lourde couche d'instructions, de schémas et de logique interne, désormais intégrée et envoyée avec chaque requête adressée à Claude Code.

Ce vaste « manuel d'instructions » pour les futures fonctionnalités, crucial pour le déploiement éventuel de fonctionnalités comme Kairos et Auto Dream, contribue directement à la taxe invisible sur les tokens. Ces schémas complets sont facturés comme des « cache creation input tokens », ce qui signifie qu'ils s'accumulent silencieusement sur votre facture mais restent complètement cachés de la vue `/context` de la CLI, les rendant intraçables par les outils d'audit.

Les utilisateurs paient donc, de fait, une taxe d'infrastructure pour le développement futur des produits d'Anthropic, même si leurs propres projets sont confrontés à des augmentations de coûts soudaines et inexpliquées. Cette facturation prématurée de fonctionnalités non publiées, qui brûle silencieusement votre argent, transforme le codage quotidien en une ponction financière inattendue. Le système consomme des tokens précieux pour préparer des fonctionnalités qui restent inaccessibles, impactant les coûts opérationnels actuels sans apporter de valeur immédiate.

Bienvenue dans l'ère troublante de la shrinkflation de l'IA, où les clients paient le même prix pour un modèle d'intelligence artificielle qui offre des capacités manifestement moindres ou impose des restrictions plus importantes. Cet analogue numérique de la shrinkflation traditionnelle des consommateurs, où la taille ou la qualité des produits diminue discrètement tandis que les prix restent stables, afflige désormais la pointe de l'IA générative. Les utilisateurs ont soudainement vu leurs budgets de calcul s'évaporer, non pas en raison d'une augmentation de leur utilisation personnelle, mais parce que les modèles sous-jacents exigent discrètement plus de ressources pour le même résultat, souvent sans notification explicite.

Le comportement insidieux et gourmand en tokens de Claude Code, brûlant silencieusement votre argent via des « cache creation input tokens » invisibles et des empreintes de cache corrompues, illustre parfaitement cette tendance alarmante. Ce problème, où une requête de 10 cents peut instantanément devenir une charge de 2 $, reflète une insatisfaction plus large. Les utilisateurs avancés de l'écosystème de l'IA signalent des expériences similaires, en particulier avec des modèles phares comme Claude Opus 4.6, citant une baisse notable de la qualité des résultats, de la capacité de raisonnement et de la fiabilité globale. Ces plaintes détaillent fréquemment des modèles devenant plus verbeux, moins précis, ou échouant simplement à accomplir des tâches qu'ils géraient auparavant avec facilité et efficacité.

Anthropic, comme d'autres grands développeurs d'IA, nie officiellement toute dégradation intentionnelle de ses modèles. Au lieu de cela, bien qu'Anthropic ait reconnu que les utilisateurs atteignaient les limites d'utilisation plus rapidement que prévu, ils présentent souvent ces changements comme des optimisations nécessaires, des améliorations d'efficacité ou des ajustements des « niveaux d'effort » internes plutôt que des dégradations explicites. Ce langage nuancé, souvent vague, alimente la suspicion des utilisateurs, transformant les baisses de performance perçues en un important déficit de confiance entre les fournisseurs et leurs clients les plus investis. Le manque de post-mortem techniques détaillés ne fait qu'exacerber cette frustration.

Cette stratégie de communication opaque, associée aux mécanismes de facturation cachés révélés par la fuite du code source du 31 mars 2026, érode gravement la confiance vitale entre les entreprises d'IA et leurs utilisateurs les plus dévoués. Les développeurs, qui comptent sur des performances prévisibles et une facturation transparente pour leurs projets professionnels et leurs applications innovantes, se retrouvent à naviguer dans un paysage de plus en plus imprévisible et coûteux. La promesse implicite d'amélioration continue, pierre angulaire du progrès technologique rapide, se heurte de plein fouet à la réalité frustrante des hausses de coûts inattendues et des régressions de capacités perçues, laissant les utilisateurs avancés se sentir exploités et ignorés dans un marché en évolution rapide.

Face au tollé général de la communauté et aux rapports détaillés des utilisateurs concernant leur abonnement Claude Code qui épuisait silencieusement les limites d'utilisation 40 % plus rapidement, Anthropic a initié une réponse publique. La frustration croissante, alimentée par des enquêtes indépendantes et la fuite révélatrice du code source du 31 mars 2026, a mis en lumière des divergences de facturation critiques et des inefficacités du backend.

Lydia Hallie, responsable produit pour Claude Code, a publiquement reconnu le problème croissant, confirmant que l'entreprise « enquête activement » sur l'épuisement plus rapide que prévu des quotas. Cet aveu est survenu après que de nombreux utilisateurs ont signalé avoir soudainement atteint leurs plafonds d'utilisation beaucoup plus rapidement, malgré le maintien d'habitudes de codage et de tailles de projets cohérentes, déclenchant un débat généralisé sur les coûts cachés des jetons.

Pour répondre aux préoccupations immédiates, Anthropic a mis en œuvre plusieurs ajustements de backend ayant un impact sur la consommation de jetons. Ils ont drastiquement réduit le Time To Live (TTL) du cache de prompt d'une heure à seulement cinq minutes, empêchant l'API de référencer des données mises en cache obsolètes ou non pertinentes qui contribuaient auparavant à un retraitement inutile. Anthropic a également abaissé le niveau d'« effort » par défaut pour certaines opérations internes, une mesure conçue pour réduire la surcharge computationnelle en arrière-plan et l'utilisation des jetons.

Anthropic a en outre justifié la restriction des frameworks d'agents tiers en citant une « contrainte excessive sur nos systèmes ». Cette décision, bien que présentée comme nécessaire à la stabilité du système, éloigne également les développeurs des intégrations externes et potentiellement vers les outils propriétaires d'Anthropic. Elle représente un changement subtil mais significatif dans le contrôle de la manière dont les utilisateurs interagissent avec les capacités de Claude et les étendent.

Ces actions représentent la tentative d'Anthropic de contrôler les dégâts face aux accusations croissantes d'« AI Shrinkflation » — le phénomène de payer le même prix pour un modèle d'IA moins performant ou plus restrictif. Bien que ces mesures offrent un soulagement immédiat, les problèmes fondamentaux, y compris le bug de l'empreinte de cache corrompue et le registre d'outils système étendu, attendent toujours un post-mortem technique complet et une résolution définitive de la part d'Anthropic.

Les utilisateurs souffrant de la taxe invisible sur les tokens d'Anthropic et des bugs de cache persistants peuvent mettre en œuvre des contre-mesures immédiates, bien que temporaires. La communauté des développeurs, grâce à une analyse rigoureuse des proxys HTTP, a identifié une solution de contournement critique : l'usurpation de l'en-tête User-Agent. En configurant manuellement les requêtes pour s'identifier comme `claude-cli/2.1.98`, au lieu des versions problématiques `claude-cli/2.1.100` ou ultérieures, les développeurs peuvent réduire considérablement les « tokens d'entrée de création de cache » secrètement ajoutés à chaque appel d'API. Ce simple changement semble contourner une partie substantielle du surcoût du registre d'outils système étendu, qui autrement augmente les coûts jusqu'à 40 % par requête.

Faites preuve d'une extrême prudence lors de l'utilisation des commandes `--resume` ou `--continue` dans Claude Code. Des enquêtes indépendantes ont confirmé que cette fonctionnalité déclenche souvent un bug spécifique, cassant le cache pour l'historique d'une conversation entière lors de sa première requête reprise. Cela peut entraîner un pic de tokens substantiel et unique, transformant instantanément une requête de 10 cents en une charge de 2 $ car l'intégralité de la base de code est retraitée. Surveillez toujours méticuleusement vos tableaux de bord de facturation ; la vue `/context` de la CLI ne tient pas compte de ces tokens invisibles, rendant le suivi granulaire des coûts absolument essentiel pour prévenir les frais inattendus.

La rétrogradation de votre version de Claude Code CLI directement à `2.1.98` présente une option plus complète, mais potentiellement moins stable. Bien que ce retour en arrière atténue efficacement la consommation accrue de tokens observée dans les versions plus récentes, cela signifie également renoncer à toute correction de bugs légitime, amélioration des performances ou nouvelles fonctionnalités introduites dans les versions ultérieures. Les utilisateurs doivent peser les économies immédiates par rapport au risque de rencontrer des problèmes plus anciens et connus ou des défis de compatibilité. Pour une analyse plus détaillée du pic de tokens spécifique entre les versions, consultez Claude Code Silently Burns 40% More Tokens Since v2.1.100 | Awesome Agents.

Ces mesures servent de palliatif, pas de solution permanente. Anthropic a la responsabilité de résoudre ces problèmes fondamentaux de facturation et de mise en cache directement et de manière transparente. Jusqu'à ce qu'une solution complète arrive, la vigilance proactive des utilisateurs et les solutions de contournement partagées par la communauté restent la principale défense contre la consommation silencieuse de votre argent en tokens invisibles et mécanismes de cache défectueux.

L'identité de marque d'Anthropic, méticuleusement cultivée autour de la sécurité et de la confiance en l'IA, fait maintenant face à un défi important. La révélation que Claude Code brûle silencieusement l'argent des utilisateurs via des tokens invisibles et des bugs de cache persistants contredit directement leur promesse fondamentale d'une IA éthique. Cette érosion de la confiance des utilisateurs est particulièrement dommageable pour un outil de développement où des coûts prévisibles et des performances fiables sont des attentes non négociables. L'incident jette une longue ombre sur leur engagement envers la transparence et la conception centrée sur l'utilisateur.

La « Shrinkflation de l'IA » vécue par les utilisateurs de Claude Code offre une ouverture concurrentielle flagrante pour les rivaux. Pendant qu'Anthropic est aux prises avec son déficit de confiance, des acteurs établis comme GitHub Copilot et Cursor continuent d'affiner leur expérience développeur. Cet incident donne aux développeurs une puissante incitation à réévaluer leurs choix d'assistants de codage IA, pouvant entraîner une migration significative de Claude Code vers des alternatives offrant une tarification plus stable et des opérations transparentes. Le marché des outils de développement IA est impitoyable ; des faux pas comme celui-ci entraînent de lourdes conséquences.

Les problèmes de facturation de Claude Code mettent en lumière un problème systémique dans l'ensemble de l'industrie de l'IA : un profond manque de transparence de la facturation. De nombreux fournisseurs d'IA masquent le coût réel des opérations, enfouissant les invites système, le traitement en arrière-plan et la gestion du cache dans des décomptes de tokens opaques. Cet incident sert de signal d'alarme crucial, pouvant forcer les entreprises à adopter des pratiques de facturation plus claires et auditables, offrant aux utilisateurs des informations granulaires sur la manière exacte dont leurs tokens sont consommés. L'attente de ventilations de coûts explicites ne fera que croître.

Rétablir la confiance des utilisateurs exige des actions décisives de la part d'Anthropic. Un postmortem technique approfondi est primordial, détaillant ouvertement les bugs spécifiques – de l'empreinte de cache corrompue aux coûts cachés de la commande `--resume` – et l'expansion systémique du registre d'outils causant l'augmentation de 40% de la consommation de tokens. Au-delà de la transparence technique, Anthropic doit offrir des solutions tangibles : des remboursements proactifs pour les utilisateurs surfacturés, un tableau de bord d'utilisation repensé fournissant des ventilations de tokens granulaires en temps réel, et un engagement envers des audits indépendants. Ce n'est que par de telles mesures complètes qu'ils peuvent espérer restaurer leur crédibilité et démontrer un véritable engagement envers leurs utilisateurs.

Qu'est-ce qui fait que Claude Code utilise autant de tokens ?

Une combinaison de facteurs, incluant une expansion massive du registre d'outils système facturée de manière invisible, un bug de cache qui retraite l'intégralité de votre base de code à chaque tour, et des modifications des paramètres par défaut du cache.

Anthropic a-t-il intentionnellement augmenté les coûts pour les utilisateurs de Claude Code ?

Bien qu'Anthropic ait nié dégrader intentionnellement les modèles, les enquêtes ont révélé des changements tels qu'une TTL de cache réduite et de nouvelles instructions en arrière-plan gourmandes en tokens pour des fonctionnalités non publiées, menant à des accusations de 'AI shrinkflation'.

Qu'est-ce qui a été révélé dans la fuite du code source de Claude Code ?

Une fuite en mars 2026 a exposé des indicateurs de fonctionnalités internes pour des outils non publiés comme 'Terminal Pets' et 'Proactive Mode', renforçant la théorie selon laquelle les utilisateurs paient pour une infrastructure de fonctionnalités en arrière-plan qu'ils ne peuvent pas encore utiliser.

Comment puis-je réduire mon utilisation de tokens Claude Code dès maintenant ?

Les membres de la communauté ont trouvé une solution temporaire en falsifiant leur User-Agent vers une version plus ancienne (claude-cli/2.1.98), ce qui peut réduire l'injection invisible de tokens. Soyez également prudent avec la commande '--resume'.