Amélioration de la qualité de l’agent pour optimiser l’utilisation de l’IA

Introduction

Lorsque les assistants ont un périmètre bien défini, reçoivent des instructions claires et fonctionnent dans un cadre de garde-fous clairement établi, l’efficacité en matière de jetons s’améliore naturellement. Les agents de haute qualité effectuent des tâches en moins de tentatives, suivent des workflows plus clairs avec moins de remaniement et évitent les cycles de débogage et de correction coûteux.

Suivez les stratégies présentées dans cet article pour améliorer la qualité de l’agent et AI credits son efficacité.

1. Choisir le modèle approprié pour la tâche appropriée

Le choix de modèle est l’un des moyens les plus rapides d’améliorer la qualité de l’agent et l’efficacité des coûts, mais il est souvent négligé. Un modèle courant consiste à utiliser par défaut le modèle le plus capable pour chaque tâche, mais cela augmente souvent l’utilisation des jetons sans améliorer le résultat. Dans certains scénarios lourds d’exécution, la surutilisation des modèles de raisonnement peut réduire la qualité, car le modèle peut trop penser à la tâche ou introduire des modifications inutiles.

Choisissez le modèle en fonction du travail impliqué :

• Modèles de raisonnement : idéal pour les décisions d’architecture, le débogage complexe, la conception du système et les tâches qui nécessitent une analyse plus approfondie.
• Modèles de niveau intermédiaire : mieux quand le plan est déjà clair et que l’agent doit s’exécuter efficacement.
• Modèles plus légers : idéal pour la refactorisation, la mise en forme, les mises à jour de documentation et d’autres modifications de routine, bien délimitées.

Utilisez autant de capacités que la tâche nécessite, et aussi peu que nécessaire. La mise en correspondance de la capacité à la tâche améliore les résultats et contrôle directement les coûts à grande échelle.

Pour obtenir une répartition par modèle et type de tâche, consultez Comparaison des modèles IA à l’aide de différentes tâches.

Configurer le niveau de raisonnement du modèle

Certains modèles prennent également en charge des niveaux de raisonnement paramétrables, qui déterminent dans quelle mesure le modèle raisonne avant de répondre. Un niveau supérieur peut améliorer les réponses aux problèmes complexes, mais il consomme plus de jetons, et donc plus de crédits. Vous devez donc utiliser le niveau normal par défaut et l’augmenter uniquement pour les tâches plus difficiles. Le raisonnement configurable est disponible pour Visual Studio Code et Copilot pour CLI pour les modèles pris en charge.

Consultez « Modèles IA pris en charge dans GitHub Copilot ».

Utilisez Copilot sélection automatique du modèle.

Copilot sélection automatique du modèle choisit un modèle capable pour vous, en fonction de l’intention de votre tâche.

Consultez « À propos de Copilotsélection automatique de modèle ».

2. Donnez des instructions claires dans vos prompts

Votre prompt détermine l’orientation de tout ce que l’agent fait. Lorsqu’un prompt est vague, l’agent doit inférer l’intention, explorer davantage le contexte et exercer son jugement. Cela entraîne souvent des tentatives répétées, une dérive du périmètre et une utilisation inutile de tokens.

Les prompts bien structurés ont trois qualités :

• Définition claire de la tâche. Au lieu de « résoudre ce problème », expliquez ce qu’est le problème, où il se produit et le résultat attendu.
• Contexte pertinent fourni en amont. Si vous savez déjà quels fichiers, services, journaux, erreurs ou données d’entrée sont pertinents, incluez-les. Cela permet à l’agent d’éviter l’exploration inutile.
• Une condition d’arrêt claire. Décrivez à l’agent ce que signifie « terminé ». Sans point d’arrêt, les agents peuvent continuer au-delà de l’objectif en ajoutant des validations supplémentaires, en refactorisant du code non lié ou en développant l’étendue.

Ces indications supplémentaires n’augmentent pas sensiblement la consommation de jetons, mais elles peuvent réduire considérablement le nombre d’exécutions de l’assistant nécessaires pour parvenir au résultat souhaité.

Pour obtenir des meilleures pratiques d’ingénierie rapides, consultez Ingénierie rapide pour GitHub Copilot Chat.

3. Gardez un contexte concis

Copilot envoie le contexte auquel il a accès sous forme de jetons d’entrée, et ce contexte s’accumule : les onglets ouverts de l’éditeur, les fichiers joints et l’intégralité des allers-retours d’une longue conversation comptent tous comme contexte.

Pour garder le contexte sous contrôle, envisagez d’effectuer les opérations suivantes :

Démarrer une nouvelle conversation lorsque vous changez de problème

Un long fil transporte tout son historique à chaque nouvelle requête. Lorsque vous passez à une tâche non liée, démarrez une nouvelle conversation. Par exemple:

• Dans Copilot pour CLI, utilisez /new (ou /clear)
• Dans Discussion avec Copilot, démarrez une nouvelle session de conversation.

Réduire les longues sessions Copilot pour CLI que vous souhaitez poursuivre

Lorsque vous avez besoin que la conversation se poursuive mais qu’elle est devenue volumineuse, exécutez /compact dans Copilot pour CLI pour résumer l’historique et réduire la fenêtre de contexte, en ciblant éventuellement le résumé (par exemple, /compact focus on the auth module).

En outre, vous pouvez utiliser /context pour vérifier l’utilisation actuelle à tout moment.

Consultez « Gestion du contexte dans CLI GitHub Copilot ».

Donnez Copilot une carte de votre projet

Un fichier d’instructions personnalisées bien entretenu, tel qu’un fichier AGENTS.md ou .github/copilot-instructions.md, donne aux agents une vue d’ensemble de la structure de votre référentiel afin qu’ils n’aient pas à lire un grand nombre de fichiers simplement pour se repérer. Consultez « Prise en charge de différents types d’instructions personnalisées ».

Apportez uniquement les outils dont vous avez besoin

De vastes ensembles d’outils (par exemple, tout l’ensemble d’outils d’un serveur MCP complet) s’ajoutent au contexte à chaque requête. Là où il correspond à votre flux de travail, activez uniquement les ensembles d’outils pertinents pour la tâche.

Consultez « Configuration des ensembles d’outils pour le serveur MCP GitHub ».

Tirer parti de la mise en cache de contexte

Copilot réutilise le contexte que vous avez déjà envoyé via la mise en cache, ce qui réduit le coût des tours de suivi. Toutefois, le contexte mis en cache expire après une période d’inactivité et n’est pas réutilisé lorsque vous changez de modèle à mi-session. Dans les deux cas, le contexte est re-envoyé et facturé à nouveau en tant que jetons d’entrée frais. Pour tirer le meilleur parti de la mise en cache, conservez les tâches connexes au sein d’une même session continue et évitez de changer de modèle en cours de route.

4. Réduire les erreurs répétées avec un copilot-instructions.md fichier

Les instructions persistantes améliorent la cohérence entre les interactions de l’agent, mais leur valeur dépend entièrement de la façon dont elles sont écrites. Un copilot-instructions.md fichier au niveau du référentiel est le moyen le plus direct d’encoder ces instructions. Les instructions personnelles et au niveau de l’organisation peuvent être superposées pour une cohérence plus large.

Les meilleures instructions sont courtes, spécifiques et ancrées dans le comportement réel de l’agent observé, pas les meilleures pratiques génériques qui semblent bonnes, mais ne s’appliquent pas à votre système.

Qu’est-ce que vous devez inclure :

• Frameworks, bibliothèques ou modèles de conception requis
• Les pièges connus que l’agent a tendance à répéter
• Attentes de sortie telles que « être concis » ou « uniquement renvoyer du code »
• Conventions spécifiques à l’équipe que l’agent doit suivre
• Commandes dédiées à la compilation, aux tests et à la vérification de la syntaxe

Que faire pour éviter :

• Documentation longue et générique
• Conseils générés par l’IA qui ne reflètent pas votre système réel
• Préférences ponctuelles ou détails rarement utilisés
• Instructions surchargées qui rendent le contexte bruyant

Conservez les instructions mises à jour à mesure que votre codebase, votre architecture, vos normes et vos flux de travail évoluent. Étant donné que ces instructions sont incluses dans le contexte de l’agent à chaque exécution, même de petites améliorations peuvent réduire les erreurs répétées et diminuer l’utilisation inutile de jetons au fil du temps.

Pour plus d’informations, consultez « Ajout d’instructions personnalisées de référentiel pour GitHub Copilot ».

5. Recherche, plan, puis implémentation

L’un des changements les plus importants pour travailler efficacement avec des agents consiste à ne plus tout faire au cours d’une seule session. Lorsque la recherche, la planification et l’implémentation se produisent ensemble, le contexte augmente rapidement, les informations non pertinentes s’accumulent et la qualité de l’agent se dégrade au fil du temps.

Divisez le travail en phases claires :

• Recherche: Utilisez l’agent pour explorer le codebase, identifier les fichiers pertinents et comprendre les dépendances.
• Plan: Créez un plan détaillé, structuré ou une spécification avant d’apporter des modifications. C’est là que les modèles de raisonnement sont les plus précieux.
  • Dans Copilot pour CLI, utilisez /plan.
  • Discussion avec CopilotDans Visual Studio Code , sélectionnez « Plan » dans la liste déroulante de l’agent, ou tapez plan dans la fenêtre de contexte.
• Implémenter: Exécutez sur le plan à l’aide du contexte ciblé et d’un modèle adapté à l’exécution.

Démarrer une nouvelle session entre les phases évite de reporter un contexte superflu. Reporter le contexte des phases précédentes peut augmenter la consommation de jetons, introduire un biais et réduire la clarté pour l’assistant. Chaque phase doit fonctionner uniquement avec ce dont elle a besoin. Pour savoir comment mener efficacement des sessions de cadrage, consultez Bonnes pratiques pour l’utilisation de GitHub Copilot pour travailler sur des tâches.

6. Ajouter des garde-fous déterministes

Les agents ne sont pas déterministes et ne sont pas corrects à chaque fois, en particulier dans les flux de travail en plusieurs étapes. Sans garde-fous, de petites erreurs peuvent rapidement s’accumuler : les agents s’appuient sur des résultats erronés, s’éloignent davantage de l’objectif et rendent le débogage plus coûteux et plus long.

Les contrôles déterministes introduisent des signaux de passage/échec clairs :

• Les tests unitaires vérifient que les modifications apportées à l’agent ont produit le comportement attendu.
• Les linters imposent une structure et une cohérence, évitant les problèmes de mise en forme, les écarts de style et les tâches de nettoyage évitables.
• Les analyses de sécurité interceptent les modèles à risque tôt, avant qu’ils ne soient plus difficiles à décompresser.

Ensemble, ces contrôles créent une boucle de rétroaction étroite : l’agent apporte une modification, un test, une règle ou une analyse l’évalue, et l’agent s’ajuste avant de passer à l’avant. Cela empêche de longues chaînes de modifications incorrectes, qui sont l’un des principaux moteurs des déchets de jetons.

Les équipes qui investissent dans ces garde-fous voient moins de nouvelles tentatives, une exécution plus rapide des tâches et un comportement d’agent plus prévisible. Ils réduisent souvent la consommation totale de jetons même si les étapes individuelles utilisent légèrement plus de jetons en amont.

Étapes suivantes

En plus d’améliorer l’efficacité de l’agent, vous pouvez également surveiller et gérer vos dépenses pour tirer le meilleur parti de votre AI credits :

• Utilisez votre tableau de bord et vos contrôles budgétaires. La page « Utilisation de l’IA », sous https://github.com/settings/billing, décompose la consommation sur chaque fonctionnalité et chaque modèle. Vous pouvez donc voir où vos crédits vont réellement et s’ajuster en conséquence.
• Identifiez les modèles coûteux avant qu’ils ne s’ajoutent. Dans une session Copilot pour CLI, utilisez /usage pour voir les métriques de la session et repérer les schémas gourmands en ressources au fil de votre travail. En outre, /chronicle tips analyse l’historique récent de vos sessions et met en évidence des possibilités d’utiliser Copilot plus efficacement.
• Mise à niveau pour une allocation plus importante. Si vous approchez régulièrement de votre limite mensuelle, un plan plus élevé peut être plus économique que de payer pour une utilisation supplémentaire, car les plans plus élevés ont plus AI credit d’allocations. Consultez À propos des plans et avantages individuels GitHub Copilot et Affichage et modification de votre plan de GitHub Copilot.