Introduction
Lorsque les agents sont bien définis, bien instruits et opèrent dans des limites claires, l’efficacité en tokens 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.
Cet article présente cinq stratégies pour améliorer à la fois la qualité des agents et AI credits leur efficacité :
- Choisir le modèle approprié pour la tâche appropriée
- Donnez des indications claires dans vos requêtes
- Recherche, plan, puis implémentation
- Ajouter des garde-fous déterministes
- Rester concis
copilot-instructions.md
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 de la tâche à accomplir. Copilot sélection automatique du modèle peut également gérer cette opération automatiquement en fonction de l’intégrité du système en temps réel et des performances du modèle.
- 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.
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’agent 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. Recherche, plan, puis mise en œuvre
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.
- 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. Une session unique réalisée dans des limites raisonnables bénéficie de la mise en cache. Reporter le contexte des phases précédentes peut augmenter la consommation de jetons, introduire un biais et réduire la clarté pour l’agent. 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.
4. 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.
5. Maintenez un style concis copilot-instructions.md
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 de compilation, de test et de vérification du style
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 ».