Comparaison des fonctionnalités de personnalisation de l’interface CLI GitHub Copilot

Présentation

Copilot CLI est un agent IA basé sur un terminal qui peut répondre aux questions, planifier le travail et effectuer des tâches en votre nom. Il est conçu pour être hautement extensible et il existe différentes façons de personnaliser son comportement et d’étendre ses fonctionnalités.

Cet article explique la différence entre :

•         **Instructions personnalisées**
  

  Celles-ci indiquent à Copilot comment se comporter en général. Par exemple, pour vous assurer que le code Copilot écrit est conforme à vos normes de codage. En savoir plus.

•         **Compétences**
  

  Celles-ci indiquent à Copilot comment gérer un type de tâche spécifique. Par exemple, pour utiliser un outil particulier lors de l’utilisation d’un type de tâche spécifique. En savoir plus.

•         **Outils**
  
  
          **Ceux-ci fournissent des capacités**. Par exemple, pour rechercher et modifier des fichiers, ou pour interagir avec des parties de GitHub. 
          [En savoir plus](#tools).
  

•         **Serveurs MCP**
  

  Ils ajoutent des collections d’outils qui permettent à Copilot d’interagir avec les services externes. En savoir plus.

•         **Hooks**
  

  Celles-ci vous permettent d’exécuter votre propre logique à des moments de cycle de vie spécifiques. Par exemple, vous pouvez exécuter un script spécifique chaque fois qu’une session CLI démarre ou se termine. En savoir plus.

•         **Sous-agents**
  

  Il s’agit de processus d’agent délégués, liés à l’agent principal et utilisés pour effectuer des tâches spécifiques séparément du processus principal de l’agent. Ils ont leur propre fenêtre de contexte, qui peut être remplie sans affecter le contexte de l’agent principal. En savoir plus.

•         **Agents personnalisés**
  

  Il s’agit de définitions de capacités spécialisées, conçues pour effectuer des tâches spécifiques. L’agent CLI principal peut déléguer une tâche à un sous-agent, à l’aide d’un profil d’agent personnalisé, pour appliquer des connaissances spécialisées et une approche particulière à la tâche. Par exemple, un agent personnalisé peut jouer le rôle d’un réviseur React, d’un enregistreur de documents, d’un auditeur de sécurité ou d’un générateur de tests. En savoir plus.

•         **Plug-ins**
  

  Il s’agit de packages qui peuvent fournir des personnalisations préconfigurées telles que des compétences, des hooks, des agents personnalisés et des serveurs MCP. En savoir plus.

Instructions personnalisées

Qu’est-ce que les instructions personnalisées ?

          **Les instructions personnalisées** sont des instructions persistantes que le Copilot CLI charge à partir de fichiers d’instructions au début d’une session.

Copilot recherche et charge les fichiers d’instructions à partir d’un certain nombre d’emplacements par défaut dans le référentiel, tels que AGENTS.md et .github/copilot-instructions.md, ou à partir de votre répertoire de base à l’adresse $HOME/.copilot/copilot-instructions.md.

Vous pouvez utiliser l’indicateur --no-custom-instructions pour éviter de charger ces instructions.

Quel problème les instructions personnalisées résolvent-elles ?

Les instructions personnalisées vous aident à :

• Veillez à ce que Copilot soit aligné sur vos conventions et préférences de codage.
• Appliquez des normes d’équipe ou d’organisation de manière cohérente.
• Évitez d’avoir à inclure des rappels répétitifs à Copilot dans chaque invite.

Quand devez-vous utiliser des instructions personnalisées ?

Utilisez des instructions personnalisées pour :

• Règles de style et de qualité

  Exemple : « Privilégiez les petites pull requests, rédigez des tests et évitez de modifier les API publiques sans discussion. »

• Conventions de dépôt

  Exemple : « Utiliser pnpm, conserver les entrées de journal des modifications dans CHANGELOG.md, exécuter pnpm test avant la validation ».

• Préférences de communication

  Exemple : « Expliquer brièvement les compromis, puis fournir le choix recommandé ».

Quand ne devez-vous pas utiliser des instructions personnalisées ?

Évitez ou conservez-les au minimum quand :

• Vous ne souhaitez que le comportement d’un flux de travail (utilisez une compétence à la place).
• Vos instructions sont si volumineuses/spécifiques qu’elles distrairent Copilot de la tâche immédiate (préférez une compétence ou un agent personnalisé).

En savoir plus sur les instructions personnalisées

Consultez Ajout d’instructions personnalisées pour GitHub Copilot CLI.

Compétences

Qu’est-ce qu’une compétence ?

Une compétence est, au minimum, un fichier Markdown contenant des instructions que Copilot peut utiliser pour effectuer des tâches dans un contexte spécifique. Le nom et la description de la compétence permettent à Copilot de déterminer s'il doit utiliser cette compétence pour une tâche donnée. S’il décide d’utiliser la compétence, il charge les instructions et les suit pour terminer la tâche.

Les compétences peuvent éventuellement référencer d’autres fichiers, stockés dans le répertoire des compétences. Il peut s’agir de scripts qui Copilot peuvent s’exécuter lorsque la compétence est utilisée.

Quel problème une compétence résout-elle ?

Les compétences vous aident à :

• Normalisez la façon dont Copilot effectue des tâches dans un contexte spécifique (par exemple, lors de l’exécution d’une révision de code).
• Fournissez des instructions « juste-à-temps » sans modifier de façon permanente le comportement de Copilot.
• Évitez de surcharger la fenêtre de contexte de Copilot avec des instructions qui ne sont pas pertinentes pour la tâche actuelle.

Comment accéder aux compétences ?

Vous pouvez appeler manuellement une compétence à l'aide d'une commande slash. Par exemple : /Markdown-Checker check README.md. Permet /skills list de répertorier les compétences disponibles.

Copilot CLI appelle automatiquement les compétences lorsqu’elle détecte celle qui est pertinente pour la tâche actuelle.

Quand devez-vous utiliser une compétence ?

Utilisez une compétence lorsque vous souhaitez :

• Ensemble reproductible d’instructions ou de fonctionnalités à mettre à disposition pour un type de tâche.

  Exemple : compétence de documentation qui vérifie que la documentation côté utilisateur est mise à jour lorsque le code frontal est modifié.

• Format de sortie cohérent.

  Exemple : une compétence « esquisse de note de publication » qui permet de garantir que Copilot utilise un modèle pour créer une note de publication.

• Un flux de travail dont vous avez parfois besoin, mais pas toujours.

  Exemple : une compétence de « refactorisation approfondie » que vous activez uniquement pendant les migrations.

Quand ne devez-vous pas utiliser une compétence ?

Évitez d'utiliser les compétences quand :

• Les instructions doivent s’appliquer à tout ce que vous faites (utilisez plutôt des instructions personnalisées ).
• Vous avez besoin de nouvelles fonctionnalités (vous aurez peut-être besoin d’un serveur MCP pour ajouter des outils ou d’un agent personnalisé pour la spécialisation).

En savoir plus sur les compétences de l’agent

Consultez À propos des compétences de l’agent.

Tools

Qu’est-ce qu’un outil ?

Un outil est une possibilité que Copilot utilise pour obtenir quelque chose de fait, comme la recherche de fichiers, l’affichage du contenu du fichier, la modification, l’exécution d’une tâche ou l’appel d’une compétence. Certains outils sont intégrés, et d’autres peuvent être ajoutés via des serveurs MCP.

Quel problème les outils résolvent-ils ?

Les outils permettent à l'interface en ligne de commande (CLI) de :

• Collecter un contexte précis (à l’aide d’outils de lecture/recherche).
• Apportez des modifications en toute sécurité (à l’aide d’outils de modification).
• Exécutez des commandes et validez les résultats (potentiellement à l’aide de sous-éléments).

Quand devez-vous utiliser des outils ?

En règle générale, vous n’appelez pas directement des outils : Copilot décide d’utiliser les outils en fonction des besoins. Vous pouvez autoriser ou refuser l’utilisation d’outils, soit pour une tâche spécifique, pour la session active, soit pour toutes vos sessions Copilot CLI.

Vous verrez Copilot utiliser des outils lorsque vous :

• Demandez à Copilot de rechercher dans le référentiel quelque chose, de mettre à jour un fichier ou d’exécuter des tests.
• Invoquez une compétence, ce qui déclenche l’outil skill.
• Demandez à Copilot d’effectuer une tâche qui lui oblige à utiliser un outil fourni par un serveur MCP.
• Confiez à Copilot une tâche complexe et qu’il décide de déléguer à un sous-agent, ce qui déclenche l’outil task.

En savoir plus sur l’autorisation ou le refus des outils

Consultez À propos de GitHub Copilot CLI.

Serveurs MCP

Qu’est-ce qu’un serveur MCP ?

Un serveur MCP est un service qui permet aux applications IA, telles que Copilot CLI, de se connecter à des sources et outils de données externes.

L’ajout d’un serveur MCP à Copilot CLI fournit des fonctionnalités supplémentaires, en vous permettant d’utiliser les outils fournis par ce serveur MCP. Par exemple, vous pouvez ajouter un serveur MCP qui fournit des outils pour interagir avec une application de calendrier en ligne ou un système de ticket de support.

Quel problème les serveurs MCP résolvent-ils ?

Les serveurs MCP aident quand les outils intégrés ne sont pas suffisants. Ils peuvent effectuer les tâches suivantes :

• Connectez Copilot CLI à des systèmes externes.
• Ajoutez des outils conçus à des fins (par exemple, pour utiliser des API, des bases de données ou une génération d’images).
• Normaliser les modèles d’accès sécurisé pour les ressources non référentiels.

Quand devez-vous utiliser un serveur MCP ?

Utilisez un serveur MCP lorsque vous avez besoin des éléments suivants :

• Intégration avec des données ou des systèmes externes.

  Exemple : How many support tickets have been opened this month for Product X?

• Actions spécifiques au domaine que vous souhaitez que l’interface CLI effectue en votre nom.

  Exemple : Message the bug-watch channel: Only 2 support tickets raised this month for Product X.

Quand ne devez-vous pas utiliser un serveur MCP ?

Évitez d’ajouter des serveurs MCP quand :

• Les outils intégrés couvrent déjà vos besoins.

En savoir plus sur les serveurs MCP

Consultez À propos du Model Context Protocol (MCP).

Hooks

Qu’est-ce qu’un crochet ?

          **Les hooks** vous permettent de spécifier qu’à un moment donné dans un cycle de vie de session, Copilot CLI exécute une commande shell que vous avez définie.

Hook	Quand il s’exécute
preToolUse / postToolUse	Avant/après l’exécution d’un outil.
userPromptSubmitted	Lorsqu’un utilisateur envoie une invite.
sessionStart / sessionEnd	Au début/à la fin d’une session.
errorOccurred	Lorsqu’une erreur se produit.
agentStop	Quand l’agent principal s’arrête sans qu'il y ait d'erreur.
subagentStop	Lorsqu'un sous-agent a terminé sa tâche.

Quel problème les crochets résolvent-ils ?

Les hooks sont utiles lorsque vous souhaitez un contrôle programmable ou une observabilité autour du comportement de Copilot CLI, par exemple :

•         **Application de garde-fous** : bloquer ou avertir avant l’exécution de certains outils.
  

•         **Ajout de la journalisation/télémétrie**
  

•         **Personnalisation du comportement de nouvelle tentative/abandon sur les erreurs récupérables**
  

•         **Ajout de vérifications de « stratégie »,** par exemple pour empêcher les modifications des chemins protégés.
  

•           **Intercepter le moment où un sous-agent se termine** : avant que les résultats ne soient renvoyés à l’agent parent.
  

Les hooks sont utiles lorsque vous avez besoin d’un contrôle plus important que les compétences ou les instructions personnalisées peuvent fournir. Alors que les compétences et les instructions guident le comportement de Copilot par le biais des invites, les hooks garantissent que les opérations que vous avez définies seront effectuées à des moments précis. Par exemple, pour empêcher l’exécution d’un outil ou pour consigner l’activité lorsqu’une session se termine.

Quand devez-vous utiliser les hooks ?

Utilisez des hooks lorsque vous le souhaitez :

•         **Garde-fous de l’outil**
  

  • Exemple : avant la réalisation de bash, exigez que la commande spécifique corresponde à une liste d'autorisation.
  • Exemple : avant l'exécution de edit, bloquez les modifications dans le cadre de infra/, sauf si un identifiant de ticket est présent.

•         **Automatisation du cycle de vie des sessions**
  

  • Exemple : lorsque l’agent s’arrête, archivez la transcription de la session dans un emplacement de stockage.

•         **Stratégie de gestion des erreurs**
  

  • Exemple : sur les erreurs de limite de débit, choisissez automatiquement « réessayer » avec un nombre limité de nouvelles tentatives.

•         **Contrôle de flux de travail subagent**
  

  • Exemple : lorsqu’un sous-agent se termine, validez sa sortie avant de renvoyer les résultats à l’agent principal.

Quand ne devrais-tu pas utiliser des crochets ?

Évitez les crochets quand :

• Vous avez simplement besoin d’instructions de sollicitation ou de workflow cohérentes (utilisez compétences).
• Vous souhaitez des préférences et des normes persistantes (utilisez des instructions personnalisées).
• Vous avez besoin de nouvelles fonctionnalités externes (utilisez des serveurs et des outils MCP).
• La gestion de la configuration qui peut affecter chaque session peut être problématique pour vous.

En savoir plus sur les hooks

Consultez Utilisation des hooks avec GitHub Copilot CLI.

Sous-agents

Qu’est-ce qu’un sous-agent ?

Un sous-agent correspond à l’exécution d’un agent d’IA distinct que l’agent principal d’une session Copilot CLI lance pour effectuer une tâche spécifique.

Copilot CLI utilise un sous-agent lorsque l’agent principal décide que la délégation d’un bloc de travail à un agent distinct est le meilleur moyen d’effectuer la demande de l’utilisateur.

Quel problème les sous-éléments résolvent-ils ?

Les sous-agents aident Copilot :

• Conservez la fenêtre de contexte de l’agent principal dans une session CLI axée, en déchargeant un bloc de travail vers un agent distinct.
• Parallélisez le travail, le cas échéant, en exécutant certaines tâches en arrière-plan.
• Exécutez un agent personnalisé séparément de l’agent principal, effectuant un travail spécialisé avec une approche différente du travail effectué par l’agent principal.

Quand les sous-agents sont-ils utilisés ?

Copilot est susceptible d’utiliser un sous-agent pour :

• Exploration de la base de code

  Par exemple, répertorier tous les points de terminaison d’une API.

• Exécution de commandes pour les tâches complexes

  Par exemple, l’exécution d’une suite de tests ou la création d’un projet volumineux et l’analyse des résultats.

• Examen des modifications

  Par exemple, examiner les modifications intermédiaires et identifier les problèmes de sécurité potentiels.

• Travail en plusieurs étapes complexes

  Par exemple, l’implémentation d’une fonctionnalité avec plusieurs modifications.

• Pour utiliser des agents personnalisés

  Si vous avez défini un agent personnalisé et qu’il est éligible à l’inférence (infer n’est pas défini sur false), Copilot peut choisir de déléguer le travail à cet agent personnalisé en créant un sous-agent avec la configuration de l’agent personnalisé.

Agents personnalisés

Qu’est-ce qu’un agent personnalisé ?

          **Les agents personnalisés** sont un moyen de fournir Copilot avec des connaissances spécialisées sur un sujet particulier et de définir une approche particulière que vous souhaitez Copilot à utiliser lors de l’utilisation dans ce domaine. Vous pouvez considérer un agent personnalisé comme une « personnalité » que Copilot peut adopter lors de la réalisation de certaines tâches.

Vous définissez un agent personnalisé dans un fichier Markdown avec un frontmatter YAML. Le fichier contient :

• Description du rôle et de l’expertise de l’agent
• Liste des outils autorisés (ou tous les outils)
• Connexions de serveur MCP facultatives
• Lorsque le paramètre facultatif infer est activé, Copilot délègue automatiquement à cet agent lorsqu'il détecte une tâche qui correspond à la spécialité de l'agent.

Quel problème les agents personnalisés résolvent-ils ?

Les agents personnalisés vous aident quand vous avez besoin des éléments suivants :

• Connaissances spécialisées à appliquer de manière cohérente dans un contexte particulier.
• Différentes autorisations d’outil pour différents travaux, telles que définies dans la configuration de l’agent personnalisé.
• Pour que la fenêtre de contexte de l’agent principal reste centrée sur la tâche principale, on utilise celle de l’agent personnalisé pour les travaux spécialisés qu’il effectue.

Quand devez-vous utiliser un agent personnalisé ?

Utilisez un agent personnalisé lorsque vous souhaitez :

• Réviseur ou assistance spécialisé

  Exemple : Créez un agent personnalisé « react-reviewer » qui se concentre sur le travail impliquant des modèles React.

• Autorisations plus sûres

  Exemple : agent personnalisé qui peut uniquement view/grep/glob (en lecture seule) pour réaliser des audits.

• Délégation facultative automatique

  Exemple : Définissez infer: true dans la configuration de l’agent personnalisé afin que Copilot puisse utiliser automatiquement cet agent personnalisé le cas échéant.

Quand ne devez-vous pas utiliser un agent personnalisé ?

Évitez les agents personnalisés quand :

• Vous n’avez besoin que d’un texte d'orientation (une compétence peut être une solution plus légère).
• Vous n’avez pas besoin de spécialisation et l’agent par défaut effectue bien des tâches.

En savoir plus sur les agents personnalisés

Consultez Configuration des agents personnalisés.

Plug-ins

Qu’est-ce qu’un plug-in ?

Un plug-in est un package installable qui peut fournir un ensemble de fonctionnalités à Copilot. Un plug-in peut inclure n’importe quelle combinaison des autres fonctionnalités de personnalisation. Par exemple, les compétences, les agents personnalisés, les hooks et les configurations de serveur MCP.

Copilot inclut des commandes de gestion des plug-ins (installer, mettre à jour, lister, désinstaller) et prend en charge l’installation à partir d’une Place de marché ou directement à partir d’un référentiel GitHub.

Quel problème les plug-ins résolvent-ils ?

Les plug-ins vous aident à :

• Ajoutez facilement un ensemble de fonctionnalités à Copilot sans avoir à configurer manuellement chaque élément.
• Empaqueter et distribuer une configuration personnalisée ( potentiellement une combinaison de compétences, d’agents personnalisés, de hooks et de serveurs MCP) à votre équipe ou au public.
• Modifiez les fonctionnalités disponibles sans avoir à copier manuellement des fichiers dans des répertoires.

Quand devez-vous utiliser un plug-in ?

Utilisez un plug-in quand :

• Vous souhaitez un bundle à l’échelle de l’équipe

  Exemple : plug-in d’ingénierie à l’échelle de l’entreprise qui inclut :

  • Compétences en matière de réponse aux incidents.
  • Agent personnalisé pour la révision du code.
  • Un serveur MCP pour les services internes.

• Vous souhaitez installer et mettre à jour facilement

  Exemple : Installez initialement un plug-in, puis mettez-le à jour régulièrement à l’aide /plugin update PLUGIN-NAMEde .

Quand ne devez-vous pas utiliser un plug-in ?

Évitez les plug-ins quand :

• Vous expérimentez localement et n’avez pas besoin de distribution (utilisez des compétences locales, des instructions personnalisées ou des agents personnalisés).
• Vous n’avez besoin que d’un petit flux de travail unique. Un fichier de compétence unique peut être plus simple.

Mise en place : choix de l’option appropriée

Requirement	Meilleure option
Je souhaite que Copilot suive toujours nos conventions de dépôt.

          **Instructions personnalisées** |

| Je veux un flux de travail reproductible que je peux appeler à la demande. | Compétences | | Je veux que Copilot réponde aux questions et effectue du travail dans mon référentiel. | Copilot demande l’autorisation d’utiliser les outils appropriés | | Je veux des garde-fous, une stratégie ou une automatisation autour de l’utilisation des outils et des événements de session. | Hooks | | J’ai besoin de Copilot pour pouvoir utiliser des outils fournis par un service externe. | Serveurs MCP | | Lorsque vous travaillez sur des tâches particulières, je souhaite que Copilot fonctionne en spécialiste avec un ensemble d’outils restreint. | Agent personnalisé | | Je souhaite que Copilot effectue une tâche complexe en mon nom. | Copilot utilise automatiquement sous-agents le cas échéant. | | Je souhaite ajouter un package de fonctionnalités à Copilot CLI sans le configurer manuellement. | Plug-in |