Optimisation de votre utilisation de l’IA pour optimiser l’efficacité et réduire les coûts

Découvrez comment choisir les bons modèles, structurer vos prompts et ajouter des garde-fous afin que Copilot accomplisse des tâches plus efficacement et utilise moins de AI credits.

Dans cet article

Introduction

Les stratégies décrites dans cet article vous montrent comment améliorer Copilot l’efficacité et, par conséquent, utiliser moins AI credits.

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

En sélectionnant le niveau de capacité approprié pour votre tâche, en configurant le raisonnement de manière appropriée et en tirant parti sélection automatique de modèle des modèles moins chers pour des charges de travail spécifiques, vous pouvez maintenir la qualité tout en réduisant considérablement la consommation de jetons.

Sélectionner le modèle approprié

Le choix de modèle est l’un des moyens les plus rapides d’améliorer 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 ».

Utiliser Copilot sélection automatique du modèle comme valeur par défaut

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

Un petit routeur examine votre requête et l’envoie au modèle qui peut la traiter le plus efficacement, tout en réservant les modèles de raisonnement coûteux aux problèmes complexes. Il évite également les modèles qui épuisent rapidement un budget de jetons.

Sélection automatique de modèle protège également votre cache. Il modifie uniquement les modèles aux limites du cache naturel, lorsqu’une nouvelle session démarre ou après l’exécution /compact, jamais à mi-tâche. Pour en savoir plus sur la raison de cette question, voir 4. Conservez le cache.

Sélection automatique de modèle évite également les modèles dégradés ou surchargés, ce qui vous fait rencontrer moins de limitations de débit et d’erreurs.

If you are on a paid Copilot plan, you qualify for a 10% discount on model costs while using sélection automatique de modèle in Discussion avec Copilot, Copilot pour CLI, or Agent cloud Copilot.

Pour plus d’informations sur la fonctionnalité et sa disponibilité, consultez À propos de Copilotsélection automatique de modèle.

Utiliser des modèles moins chers pour sous-agents

Exécutez sous-agents sur des modèles moins chers. Sous-agents exécutez dans leur propre session et n’héritez pas de l’historique des conversations de l’agent principal. Puisque leur contexte est circonscrit à une seule tâche précise, un modèle plus léger suffit souvent — et le fait d’en attribuer un n’affecte pas le cache de l’agent principal comme le ferait un changement de modèle en cours de session.

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 ».

4. Conserver le cache

La mise en cache permet à un modèle IA de stocker des parties du contexte d’une conversation afin qu’elles n’ont pas besoin d’être traitées à nouveau sur chaque requête. Dans le codage agentique, où le même contexte volumineux (invite système, contenu du fichier, définitions d’outils) est envoyé à plusieurs reprises à plusieurs reprises, la mise en cache a un impact : la partie mise en cache de la réponse précédente est réutilisée plutôt que retraitée, et les jetons mis en cache sont généralement facturés à 10% du prix d’entrée normal. Consultez « Modèles et tarification pour GitHub Copilot ».

Toutefois, les actions suivantes invalident le cache, ce qui entraîne le renvoi de l’intégralité du contexte et sa facturation comme de nouveaux jetons d’entrée :

  • Changement de modèles à la mi-session. Un autre modèle ne peut pas réutiliser le cache d’un autre modèle. Par conséquent, la requête suivante la régénère à partir de zéro. Choisissez un modèle (ou utilisez Copilot sélection automatique du modèle) et tenez-vous-y pendant toute la session.
  • Retour à une session précédente. Les caches expirent après une période d’inactivité (24 heures pour les modèles OpenAI et 1 heure pour la plupart des autres). Si vous avez été absent un certain temps, démarrez une nouvelle session ou exécutez /compact (en Copilot pour CLI) de sorte que ce qui est reconstruit est un bref résumé plutôt que l’historique complet.
  • Modification du raisonnement mi-session. La modification du niveau d’effort de raisonnement, de la taille du contexte ou de l’ensemble d’outils activés et de serveurs MCP pendant une session invalide le cache. Configurez ces paramètres avant de commencer et laissez-les inchangés pour la session.

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 et les informations non pertinentes s’accumulent.

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 : planifiez toujours avec un modèle de raisonnement fort, puis implémentez le travail avec un modèle moins cher.
    • 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 vous évite de conserver inutilement du contexte d’une phase à l’autre, ce qui peut augmenter la consommation de tokens 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.

6. Utiliser les apprentissages pour être plus efficaces à chaque tour

Utiliser /chronicle pour générer des insights

Dans Copilot pour CLI, /chronicle peut générer des insights utiles à partir de votre historique de session.

  • Utilisez /chronicle tips pour analyser l’historique récent de vos sessions et identifier des possibilités d’utiliser Copilot plus efficacement.
  • Permet /chronicle cost-tips de comprendre vos modèles d’utilisation des jetons et d’obtenir des insights sur la façon de réduire les coûts.

Consultez « À propos des CLI GitHub Copilot données de session ».

Ajouter des analyses à un copilot-instructions.md fichier

Un copilot-instructions.md fichier au niveau du référentiel est le moyen le plus direct d’encoder des instructions spécifiques à votre référentiel. Les instructions personnelles et au niveau de l’organisation peuvent être superposées pour une cohérence plus large.

Lorsque /chronicle fait ressortir un schéma récurrent — un outil surutilisé, un prompt qui continue à être mal interprété — consignez directement cette observation dans votre fichier copilot-instructions.md. Cela transforme un aperçu unique en conseils permanents qui s’applique à chaque session future, sans avoir à le répéter.

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

Conserver le copilot-instructions.md fichier spécifique et ancré

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. 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.

7. 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

Surveillez et gérez vos dépenses pour tirer le meilleur parti de vos AI credits: