Votre agent IA gaspille votre argent

Les modèles d'IA modernes comme Claude Opus 4.6 et GPT 5.4 représentent un sommet de l'intelligence computationnelle. Opus 4.6 d'Anthropic, lancé en février 2026, dispose d'une fenêtre de contexte d'un million de tokens et excelle dans les tâches agentiques complexes, démontrant un raisonnement sophistiqué. Il ne s'agit pas de simples mises à niveau incrémentielles ; ce sont des systèmes robustes et très performants conçus pour la résolution de problèmes sophistiqués et le travail à long terme. Pourtant, un paradoxe déroutant afflige de nombreux utilisateurs : les modèles de pointe fournissent fréquemment des résultats frustramment médiocres, gaspillant souvent des ressources computationnelles importantes.

Le problème réside rarement dans le modèle fondamental lui-même. Comme le souligne l'expert en IA Ras Mic, les modèles actuels sont « exceptionnellement bons », capables de discerner des schémas complexes et d'exécuter des instructions complexes. Le facteur de différenciation critique devient alors le harnais et le contexte que les utilisateurs construisent autour d'eux. Cette architecture environnante dicte si le modèle produit un résultat de qualité ou de la simple « bouillie », transformant une IA puissante en un outil coûteux et sous-performant.

Cette déconnexion alimente une frustration généralisée chez les utilisateurs, entraînant un gaspillage financier considérable. Les développeurs et les utilisateurs quotidiens investissent dans une IA de pointe, pour ne rencontrer que des agents qui produisent des résultats génériques, incorrects ou terriblement inefficaces. Les coupables courants incluent des fichiers `agent.md` ou `cloud.md` verbeux, qui sont chargés dans le contexte à chaque tour, brûlant des milliers de tokens et dégradant les performances à mesure que la fenêtre de contexte se remplit. La promesse de l'automatisation intelligente cède la place à un cycle de sur-sollicitation, de coûts croissants et de rendements décroissants.

Dépasser cette inefficacité exige un changement fondamental de stratégie. Au lieu d'instructions par la force brute et de fichiers `agent.md` gonflés en tokens — que Ras Mic affirme que 95 % des utilisateurs peuvent entièrement ignorer, coûtant plus de 944 tokens par tour — l'accent doit être mis sur des flux de travail élégants et efficaces. Cela implique de comprendre les mécanismes complexes de la fenêtre de contexte et de tirer parti de techniques avancées comme les Skills personnalisées, qui coûtent environ 53 tokens par tour, pour une interaction ciblée et économe en tokens, arrêtant le cycle des tokens gaspillés et débloquant une productivité authentique.

L'efficacité d'un agent IA repose sur sa fenêtre de contexte, essentiellement la mémoire à court terme du modèle pour toute tâche donnée. Ce composant critique définit l'étendue des informations que l'IA peut accéder et traiter pour exécuter une action.

Cette fenêtre n'est pas vide ; c'est une pile dynamique d'informations. Elle comprend plusieurs éléments chargés dans la mémoire active du modèle : - L'invite système fondamentale, guidant le comportement principal de l'IA. - Les fichiers d'agent, tels que `agent.md` ou `cloud.md`, destinés à fournir des instructions spécifiques. - Les compétences personnalisées, conçues pour des flux de travail spécialisés. - Les outils intégrés et la base de code pertinente. - La conversation utilisateur en cours, incluant tous les tours précédents.

Ras Mic, expert en mécanique des agents IA, affirme que les fichiers `agent.md` s'avèrent souvent redondants pour 95 % des utilisateurs. Ces fichiers consomment un nombre significatif de tokens, se chargeant à chaque tour et dégradant les performances à mesure que la fenêtre se remplit inutilement.

Chaque information, d'un simple caractère à une base de code entière, se traduit en tokens—les unités fondamentales de données qu'une IA traite. Des modèles comme Claude Opus 4.6 et GPT 5.4 affichent des fenêtres de contexte impressionnantes, souvent autour de 250 000 tokens. Cependant, cette capacité a une limite stricte.

Une fois qu'un agent atteint sa limite de tokens, il recourt à la compaction, résumant les informations plus anciennes pour faire de la place aux nouvelles données. Ce processus entraîne inévitablement une forte baisse des performances et de la qualité de la production, semblable à un humain luttant pour se souvenir des détails d'une mémoire fortement résumée.

Maîtriser les performances des agents et optimiser la dépense de tokens exige une compréhension approfondie de l'anatomie de cette fenêtre de contexte. Gérer stratégiquement ce qui entre dans cette mémoire, notamment en tirant parti de la divulgation progressive via des compétences personnalisées (qui coûtent environ 53 tokens par tour contre 944+ pour des fichiers `agent.md` équivalents), devient primordial pour une production d'IA cohérente et de haute qualité.

La sagesse conventionnelle dicte la création de fichiers `agent.md` ou `claude.md` étendus, croyant que ces instructions détaillées sont cruciales pour la performance d'un agent. Cette pratique courante, cependant, s'avère souvent contre-productive, consommant inutilement des ressources et entravant l'efficacité. Ras Mic, un expert en optimisation d'agents IA, remet en question cette notion, affirmant que 95% des utilisateurs peuvent — et devraient — abandonner entièrement ces grands fichiers contextuels.

Les modèles de langage modernes de grande taille comme Claude Opus 4.6 et GPT 5.4 sont exceptionnellement performants ; ils infèrent le contexte directement à partir de la base de code et de la conversation en cours. Dire à un agent qu'un projet utilise React devient redondant lorsque le modèle a déjà les fichiers React dans sa fenêtre de contexte. Il possède l'intelligence inhérente pour comprendre l'environnement de développement sans instruction explicite et répétée. Cela permet une approche "super, super minimale" de la construction du contexte, simplifiant considérablement la configuration de l'agent. Pour des informations plus approfondies sur les modèles avancés d'Anthropic et leurs capacités, y compris Claude Opus, consultez leur annonce officielle : Introducing Claude 3: Opus, Sonnet, Haiku.

Le principal écueil du fichier `agent.md` surdimensionné réside dans son mécanisme de chargement. Les agents chargent ces fichiers entiers dans leur fenêtre de contexte à chaque tour, brûlant des milliers de tokens inutilement. Une compétence personnalisée, en revanche, coûte environ 53 tokens par tour, tandis qu'un fichier `agent.md` équivalent peut consommer plus de 944 tokens pour la même interaction. Cela entraîne un gaspillage significatif de tokens et une dégradation des performances à mesure que la fenêtre de contexte se remplit rapidement.

Alors, quand ces fichiers sont-ils appropriés ? Les 5% restants des cas d'utilisation impliquent des méthodologies d'entreprise hautement spécifiques et propriétaires ou des flux de travail uniques qu'un agent ne peut pas inférer du code ou de la conversation seule. Ces scénarios exigent des instructions constantes et non négociables, telles que le respect de protocoles de conformité internes complexes ou de procédures de traitement de données spécialisées. Dans ces cas, un fichier `.md` compact et précisément défini peut toujours servir un objectif vital. Autrement, faites confiance à l'intelligence du modèle et supprimez le superflu.

Abandonner ces fichiers `agent.md` volumineux révèle une alternative supérieure : les compétences (Skills). Ces ensembles d'instructions spécialisés et modulaires optimisent considérablement le fonctionnement de votre agent IA, transformant la gestion des tokens d'un inconvénient en un avantage stratégique. Les compétences représentent un changement de paradigme fondamental dans la conception des agents, s'éloignant des directives statiques et toujours actives qui étouffent la fenêtre de contexte. Elles permettent aux agents d'accéder à de vastes capacités sans la surcharge constante.

Au cœur de l'efficacité des Skills se trouve le principe de la divulgation progressive. Au lieu d'intégrer des manuels d'instructions entiers à chaque tour de conversation, seul le nom succinct d'une compétence et une brève description de haut niveau résident dans la fenêtre de contexte active de l'agent. Par exemple, une compétence pourrait être décrite comme "analyser des rapports financiers" ou "générer du contenu marketing pour les médias sociaux", offrant juste assez d'informations pour que l'agent comprenne son objectif. Cette empreinte minuscule en tokens maintient la mémoire de travail légère et ciblée.

Voici comment le flux de travail se déroule : l'agent IA, qu'il soit alimenté par Claude Opus ou GPT-5.4, scanne d'abord la liste des noms et descriptions de compétences disponibles. Il exploite ses capacités de raisonnement avancées pour déterminer si une compétence particulière est pertinente pour la tâche immédiate. Pour un agent marketing, si un utilisateur demande une publication sur les médias sociaux, la compétence "generate marketing copy" devient immédiatement pertinente. Ce n'est qu'après avoir identifié un besoin clair que l'agent charge dynamiquement les instructions complètes et détaillées pour cette compétence spécifique dans son contexte, exécutant les actions requises.

Considérez le contraste frappant en termes de consommation de tokens, un facteur critique tant pour le coût que pour la performance. Une compétence typique, bien conçue, avec son nom et sa description, n'occupe que 53 tokens dans la fenêtre de contexte à chaque tour. Cet investissement minimal permet d'avoir une vaste bibliothèque d'actions potentielles "en attente". Un fichier `agent.md` équivalent, cependant, rempli d'instructions générales, de logique conditionnelle pour plusieurs scénarios et de définitions d'outils, dévore plus de 944 tokens par tour. Cette différence stupéfiante signifie des milliers de tokens économisés au cours d'une conversation prolongée ou d'une tâche complexe en plusieurs étapes.

Cette approche économe en tokens réduit non seulement les coûts opérationnels, mais améliore également considérablement les performances et la fiabilité de l'agent. En empêchant la fenêtre de contexte de se remplir prématurément d'informations non pertinentes, les agents maintiennent un raisonnement de plus haute fidélité et réduisent la probabilité de "compaction du contexte", où des informations plus anciennes, potentiellement cruciales, sont résumées ou écartées. La divulgation progressive avec les Skills garantit que votre agent fonctionne avec une précision maximale, accédant aux connaissances spécialisées uniquement lorsque cela est vraiment nécessaire, fournissant des résultats précis sans la taxe exorbitante sur les tokens.

De nombreux utilisateurs, désireux de tirer parti des capacités avancées de l'IA, identifient instinctivement un flux de travail complexe et tentent immédiatement d'écrire un fichier de compétence complet à partir de zéro. Cette approche conventionnelle, rappelant la pré-programmation d'un script rigide, conduit souvent à une boucle d'essais-erreurs inefficace, brûlant des tokens précieux et générant des résultats incohérents, car les instructions théoriques manquent inévitablement les nuances de l'exécution réelle. Une telle rédaction initiale présume une prévoyance parfaite, un défaut qui devient rapidement évident lorsque l'agent rencontre des cas limites imprévus.

Ras Mic, un expert en IA agentique, défend une stratégie radicalement différente : la Méthode du Co-Pilote. Cette méthodologie itérative et pratique transforme le développement de compétences d'une tâche de codage solitaire en une expérience d'apprentissage collaboratif avec l'IA elle-même. Au lieu de dicter des instructions, vous guidez l'agent à travers un processus, lui permettant d'apprendre puis de documenter son propre parcours réussi.

La méthodologie de Mic fournit un plan en cinq étapes pour développer des compétences robustes et pratiques : - Premièrement, identifiez le flux de travail spécifique que l'agent doit maîtriser, qu'il s'agisse de filtrer les e-mails de sponsors ou de générer des rapports d'analyse. - Ensuite, exécutez l'intégralité du flux de travail manuellement, **étape par étape, *avec* l'agent, en le traitant comme un apprenti très capable mais non formé. - De manière cruciale, corrigez activement toute erreur, affinez les invites et guidez l'agent à travers des micro-actions réussies en temps réel. - Ce n'est qu'après avoir réalisé une exécution complète et sans faille de l'ensemble du flux de travail que l'étape finale cruciale se produit. - Ordonnez à l'agent de créer la compétence basée sur ce contexte d'interaction réussi**, documentant ainsi efficacement son propre processus éprouvé.

Considérez la formation d'un nouvel employé humain : vous ne lui donneriez pas simplement un manuel dense et théorique en vous attendant à une exécution immédiate et parfaite. Au lieu de cela, vous vous asseoiriez à ses côtés, le guidant à travers les tâches, lui offrant un feedback immédiat et le laissant apprendre par la pratique. Ce n'est qu'une fois qu'il aurait démontré sa compétence que vous documenteriez le processus affiné et éprouvé pour référence future. Cette approche centrée sur l'humain est précisément ce que la Co-Pilot Method applique aux agents IA, favorisant l'apprentissage organique avant de formaliser les connaissances.

Cette approche itérative, d'« apprentissage par la pratique », garantit que les compétences de l'agent ne sont pas des constructions abstraites et théoriques, mais plutôt des instructions robustes bâties sur une exécution éprouvée et réelle. De telles compétences sont intrinsèquement plus résilientes aux cas limites et considérablement plus efficaces en termes de jetons (tokens) car elles capturent la séquence précise des actions et des décisions réussies. En développant des compétences *avec* votre agent plutôt que *pour* lui, vous dépassez la simple instruction pour atteindre une compétence authentique et contextuellement consciente, abordant directement le gaspillage de jetons inhérent aux fichiers `agent.md` spéculatifs.

Ras Mic, une voix prépondérante dans le développement d'agents IA, a rencontré un problème familier lors de la création d'un agent pour filtrer les e-mails de sponsors. Sa première tentative, armé d'une invite vague, a abouti à un agent qui approuvait chaque sponsor entrant. Le problème principal était un manque fondamental de critères de rejet définis dans le contexte de l'agent, conduisant à une acceptation aveugle.

Sans instructions explicites sur ce qui constituait un partenaire inadapté ou sur la manière d'évaluer les conflits d'intérêts potentiels, l'agent a opté par défaut pour un biais positif. Cet écueil courant souligne à quel point même des modèles puissants comme Claude Opus 4.6 ou GPT 5.4 nécessitent des garde-fous précis et des contraintes négatives pour fonctionner efficacement et éviter un résultat « bâclé ».

Mic a ensuite appliqué la Co-Pilot Method, abandonnant l'approche traditionnelle consistant à pré-écrire un fichier de compétences complexe et statique. Au lieu de cela, il a guidé l'agent de manière interactive à travers le processus de filtrage des sponsors, étape par étape. Cette approche collaborative et itérative a permis à l'agent d'apprendre directement de son flux de travail réel, capturant les prises de décision nuancées.

Il a commencé par faire en sorte que l'agent recherche minutieusement un sponsor hypothétique, en lui demandant de récupérer des données pertinentes auprès de diverses sources externes. Ensuite, il a travaillé avec l'agent pour définir des critères granulaires pour les partenaires souhaitables et indésirables, en articulant des points de données spécifiques, des signaux d'alarme et des considérations d'alignement de marque. Enfin, ils ont établi un format de sortie clair et standardisé pour ses recommandations, garantissant la cohérence. Pour en savoir plus sur la structuration des tâches d'agent, en particulier avec des fonctionnalités avancées, reportez-vous à Tool use for Claude.

Ce processus collaboratif a abouti à une skill très fiable capable de vérifier de manière autonome les e-mails de sponsors entrants. Mic a ensuite affiné cette skill grâce à un feedback récursif, traitant chaque erreur de classification ou cas limite comme une opportunité. Il a renvoyé les échecs à l'agent, l'incitant à mettre à jour le skill file et à apprendre de ses erreurs.

Après plusieurs itérations de cette boucle d'affinage, l'agent fonctionne désormais avec une précision remarquable, gérant de manière autonome une tâche qui consommait auparavant des heures de travail manuel. La skill finale a effectivement transformé un processus manuel chronophage et sujet aux erreurs en un générateur d'insights automatisé, démontrant les gains d'efficacité profonds possibles lorsque les agents sont entraînés de manière interactive pour construire des skills robustes.

Même les skills les plus méticuleusement conçues, destinées à optimiser les performances des agents AI et l'efficacité des tokens, rencontreront inévitablement des cas limites. De nouveaux formats de données, des entrées utilisateur inattendues ou des complexités de workflow imprévues peuvent faire trébucher un agent, entraînant des erreurs ou des résultats sous-optimaux. Ce ne sont pas seulement des bugs ; elles représentent des opportunités d'apprentissage critiques et concrètes.

Voici la Recursive Refinement Loop, une méthodologie puissante qui transforme les échecs des agents en fonctionnalités robustes et auto-améliorantes. Ce processus traite chaque faux pas non pas comme un défaut à corriger en externe, mais comme un feedback inestimable que l'agent utilise pour améliorer ses propres capacités. Il instaure un cycle d'amélioration continue, modifiant fondamentalement la manière dont les systèmes AI résilients sont construits.

Cet affinage itératif suit une séquence précise en trois étapes, plaçant l'agent aux commandes de sa propre évolution : - Premièrement, identifiez l'erreur spécifique ou l'écart par rapport au résultat souhaité. Déterminez le moment exact et la raison de l'échec, en fournissant un contexte concret. - Deuxièmement, invitez l'agent à analyser son propre échec. Demandez-lui d'expliquer *pourquoi* il a échoué et, surtout, de proposer une correction logique ou une instruction supplémentaire pour éviter la récurrence de cette erreur spécifique. - Troisièmement, ordonnez à l'agent de mettre à jour son propre skill file directement avec la logique nouvellement proposée. Cette modification directe intègre la leçon apprise dans ses directives opérationnelles, rendant l'agent profondément auto-correcteur et adaptatif.

Ras Mic a démontré de manière éclatante ce principe avec son générateur de rapports d'analyse YouTube. Initialement, l'agent a eu du mal avec la variabilité inhérente des diverses entrées de données et formats de rapport, produisant fréquemment des résultats incohérents ou incomplets. Grâce à cinq itérations rigoureuses de la Recursive Refinement Loop, il a systématiquement réintroduit chaque échec unique dans le processus d'apprentissage de l'agent.

À chaque fois, l'agent a méticuleusement diagnostiqué ses lacunes, formulé des solutions précises et mis à jour ses instructions internes au sein du skill file. Cette approche disciplinée et itérative a transformé un système auparavant sujet aux échecs en un data aggregator impeccable. Désormais, l'agent exécute des rapports complexes à travers huit sources de données distinctes en environ dix minutes, fournissant constamment des insights précis et complets sans intervention humaine.

Les développeurs se précipitent souvent pour déployer des systèmes multi-agents élaborés dès le premier jour, séduits par l'attrait des architectures complexes. Cette erreur courante privilégie la sophistication perçue au détriment du résultat tangible, conduisant souvent à un gonflement des tokens et à des workflows inefficaces avant qu'une réelle valeur ne soit générée. Ras Mic, cependant, défend une approche plus pragmatique, mettant l'accent sur une stratégie fondamentale qui privilégie l'efficacité.

Au lieu d'une complexité architecturale immédiate, Ras Mic préconise de commencer par un seul agent généraliste puissant. Cet agent central gère un large éventail de tâches – du filtrage complet des e-mails à l'analyse détaillée de feuilles de calcul et à la recherche approfondie – sans la surcharge inutile de contreparties spécialisées et prématurées. L'objectif reste d'établir un noyau robuste et très performant avant d'envisager toute expansion.

Concentrez vos efforts sur la construction méticuleuse d'une bibliothèque complète de compétences robustes et fiables pour cet agent principal. Chaque compétence, affinée par des « boucles de raffinement récursif » itératives comme détaillé précédemment, devient un outil précis et efficace en termes de tokens, perfectionné à la perfection. Cette stratégie garantit que l'agent généraliste maîtrise ses flux de travail essentiels, fournissant constamment des résultats prévisibles et de haute qualité qui minimisent le gaspillage de tokens et maximisent la précision.

La mise à l'échelle n'intervient qu'après que les flux de travail fondamentaux de l'agent généraliste sont perfectionnés et que sa bibliothèque de compétences est mature. Introduisez des sous-agents spécialisés – pour des domaines distincts comme le marketing, le développement commercial ou les tâches personnelles – stratégiquement, lorsque des besoins spécifiques et complexes se présentent. Cette expansion mesurée et axée sur la productivité évite les pièges de la complexité prématurée, garantissant que chaque nouveau composant sert un objectif prouvé et efficace plutôt que de simplement contribuer à un système esthétique mais sous-performant. Privilégiez l'utilité réelle à l'éclat architectural.

L'IA agentique n'est pas une promesse lointaine ; c'est une réalité immédiate avec des modèles comme Claude Opus 4.6 et GPT-5.4. Ces systèmes avancés démontrent une autonomie et un raisonnement sans précédent, allant au-delà de la simple réponse à des invites pour orchestrer véritablement des tâches complexes. Leur puissance, cependant, reste tributaire de la qualité de leur cadre opérationnel.

Une bibliothèque de compétences méticuleusement organisée devient le fondement indispensable pour exploiter ces modèles autonomes. Au lieu de tenter d'intégrer chaque instruction potentielle dans un seul fichier de contexte monolithique, cette approche modulaire fournit aux agents une boîte à outils précise et à la demande. Elle permet à l'IA d'accéder dynamiquement à des capacités spécialisées, améliorant considérablement l'efficacité et réduisant le gaspillage de tokens associé aux fichiers `agent.md` surchargés.

Les enseignements tirés d'incidents comme le Claude Code leak soulignent davantage cette nécessité, révélant la complexité profonde et sous-jacente de l'orchestration d'agents de qualité professionnelle. Ces invites système divulguées ont démontré comment même les principaux développeurs d'IA s'appuient sur des composants hautement structurés et modulaires pour guider efficacement leurs agents. Pour une compréhension plus approfondie de ces développements, explorez Claude 3 Opus et la frontière des agents IA.

Développer une méthodologie robuste de développement de compétences, ancrée dans la divulgation progressive et le raffinement récursif, n'est donc pas un simple artifice temporaire. C'est une discipline fondamentale pour quiconque souhaite sérieusement travailler avec l'IA dans les années à venir. Maîtriser cette approche garantit que les agents peuvent évoluer pour une véritable productivité, plutôt que de s'effondrer sous le poids d'un contexte mal géré.

Le véritable potentiel de votre agent IA n'est pas libéré par des fichiers `agent.md` massifs ou des configurations multi-agents complexes dès le premier jour. Au lieu de cela, il réside dans une approche disciplinée de la gestion du contexte et du développement des compétences. Maîtriser cette méthodologie transforme l'IA d'une nouveauté gaspillant des tokens en une véritable machine à productivité.

Suivez ces étapes concrètes pour révolutionner votre flux de travail d'agent :

• 1Optimiser le contexte : Abandonnez les fichiers `agent.md` qui gonflent les tokens. Tirez parti de l'intelligence inhérente des modèles comme Claude Opus 4.6 et GPT-5.4, en leur faisant confiance pour inférer le contexte à partir de la base de code et de la conversation.
• 2Utiliser la divulgation progressive : Utilisez les Compétences comme méthode principale pour étendre les capacités de l'agent. Seuls le nom et la description de la compétence résident dans le contexte actif, chargeant les instructions complètes uniquement lorsque nécessaire, réduisant drastiquement la consommation de tokens.
• 3Construire des compétences à la manière d'un Co-Pilote : N'essayez pas d'écrire des fichiers de compétences à partir de zéro. Identifiez plutôt une tâche répétitive et exécutez-la étape par étape avec votre agent. Une fois réussie, demandez à l'agent d'encapsuler ce flux de travail dans une nouvelle compétence.
• 4Affiner de manière récursive : Traitez chaque échec d'agent comme une opportunité de fonctionnalité. Renvoyez l'erreur à l'agent, lui permettant de diagnostiquer le problème et de mettre à jour le fichier de compétence pour une résilience future. Cette boucle d'affinage récursif renforce continuellement les capacités de votre agent.
• 5Échelonner pour la productivité : Résistez à l'envie de construire immédiatement des systèmes multi-agents tentaculaires. Commencez avec un seul agent, en vous concentrant sur la création d'une bibliothèque robuste de compétences très efficaces pour ses tâches principales. N'étendez qu'après avoir atteint des performances constantes et fiables.

Cette semaine, identifiez un flux de travail répétitif dans votre vie professionnelle ou personnelle. Il peut s'agir de rédiger des e-mails de routine, de résumer des notes de réunion ou d'organiser des données. Appliquez la Méthode Co-Pilote : effectuez cette tâche avec votre agent lors d'une conversation en direct, en documentant chaque étape. Une fois terminé, demandez à l'agent de rédiger la compétence pour vous.

Cet exercice pratique ne produira pas seulement votre première compétence personnalisée, mais ancrera également les principes fondamentaux d'une IA agentique efficace. En maîtrisant cette approche légère et itérative, vous irez au-delà de la simple interaction pour débloquer les gains de productivité profonds que l'avenir agentique, alimenté par des modèles comme Claude Opus 4.6 et GPT-5.4, promet véritablement.

Quel est le principal problème dans la façon dont les gens utilisent les agents IA aujourd'hui ?

La plupart des utilisateurs surchargent la fenêtre de contexte de l'IA avec des informations inutiles, comme de longs fichiers agent.md. Cela gaspille des tokens, dégrade les performances et conduit à de mauvais résultats.

Que sont les 'compétences' d'IA et pourquoi sont-elles plus efficaces ?

Les compétences sont des instructions autonomes pour un agent. Elles utilisent la 'divulgation progressive', ce qui signifie que seuls le nom et la description sont dans la fenêtre de contexte jusqu'à ce qu'ils soient nécessaires, économisant des milliers de tokens par tour par rapport à d'autres méthodes.

Quelle est la meilleure façon de créer une nouvelle compétence IA ?

Au lieu d'écrire une compétence à partir de zéro, vous devriez d'abord parcourir la tâche étape par étape avec l'agent IA. Une fois que vous avez obtenu un résultat positif, demandez à l'agent d'écrire la compétence basée sur cette conversation éprouvée.

Ai-je besoin d'utiliser des fichiers agent.md ou claude.md ?

Selon l'expert Ras Mic, 95 % des utilisateurs n'ont pas besoin de ces fichiers. Ils ne devraient être utilisés que pour des informations propriétaires qui doivent être référencées dans chaque interaction avec l'agent.