Tutoriel GitHub Copilot : tout savoir

GitHub Copilot est un assistant au code qui est rapidement devenu un incontournable pour tous les développeurs qui veulent utiliser l'IA au quotidien. Depuis son lancement, l'outil a connu de nombreuses mises à jour en intégrant de nouvelles fonctionnalités, en proposant les derniers modèles disponibles et en créant toujours plus d'intégration dans l'éditeur de code.

Pourtant, encore aujourd'hui, de nombreux développeurs ne savent pas l'utiliser correctement. Même s'il s'agit d'un outil puissant boosté par des LLM, il convient d'utiliser les bonnes pratiques et de lui apporter les bons prompts pour tirer un maximum de cet outil.

Dans cet article, nous allons voir comment fonctionne GitHub Copilot, quelles sont ses fonctionnalités essentielles, et connaître toutes les bonnes pratiques pour utiliser cet outil comme un véritable assistant IA de code.

C'est quoi GitHub Copilot ?

Développé par GitHub en collaboration avec OpenAI, GitHub Copilot est une intelligence artificielle conçue pour aider les développeurs à coder plus vite, plus facilement et plus intelligemment. Intégré directement dans la plupart des IDE (Visual Studio Code, JetBrains, etc), cet outil agit comme un assistant virtuel qui suggère des lignes de code, des fonctions complètes, voire des algorithmes entiers, le tout avec une très faible latence.

GitHub Copilot peut intervenir sur de nombreux sujets, dont les plus fréquents sont les suivants.

Compléter automatiquement du code contextualisé et de l'ordre de la seconde.
Générer des fonctions entières à partir d’un simple commentaire ou du nom de la fonction.
Suggérer des tests unitaires en se basant sur des fonctions existantes.
Assister les développeurs au débogage, en analysant des journaux ou des captures d'écran.

Un développeur qui maîtrise l'utilisation de GitHub Copilot pourra alors se concentrer sur les tâches à forte valeur ajouté, tout en étant assisté sur des tâches répétitives mais nécessaires.

Comment installer GitHub Copilot ?

Dans cette partie, nous présenterons uniquement comment installer GitHub Copilot dans Visual Studio Code, mais son installation dans d'autre IDE est très similaire.

Pour utiliser GitHub Copilot, il est nécessaire d'avoir un compte GitHub. À l'aide du compte GitHub, il est possible d'utiliser directement Copilot (version gratuit ou payante).

Dans Visual Studio Code, cliquer sur l'icône des extensions dans le menu latéral gauche, puis rechercher GitHub Copilot dans la barre de recherche.

Cliquer sur l'extension, puis sur Installer. Une fois l'installation, l'icône GitHub Copilot devrait apparaître à droite du menu de recherche.

En cliquant dessus, Visual Studio Code devrait nous demander de nous authentifier à GitHub Copilot par l'intermédiaire du navigateur Web. En suivant les étapes, l'extension devrait être reliée au compte GitHub, et on peut démarrer sans plus attendre.

Comment utiliser GitHub Copilot ?

Pour utiliser GitHub Copilot de la manière la plus optimisée possible, il convient de suivre quelques règles pratiques et faciles à mettre en place pour gagner un maximum de temps. Pour cela, voyons les différentes fonctionnalités proposés par l'outil.

Auto-complétion

Une des premières fonctionnalités indispensables de GitHub Copilot est son auto-complétion intelligente. Contrairement aux auto-complétions classiques proposés par les éditeurs de code qui ne se basent que sur les caractères, l'auto-complétion avec GitHub Copilot comprends le contexte associé et propose un code pertinent.

Si l'on souhaite créer une fonction qui génère puisse générer un mot de passe, nous pourrions directement commencer par écrire generate_password dans l'éditeur de code. Plutôt que de demander explicitement à GitHub Copilot qu'il doit implémenter cette fonction, il peut directement comprendre qu'il doit la compléter, et propose alors une auto-complétion en conséquence.

Tout comme nous utilisons la touche tabulation (Tab) habituellement pour valider l'auto-complétion de notre éditeur, GitHub Copilot devient alors prioritaire sur cette touche, et intègre directement le code qu'il a proposé dans notre fichier.

Cette approche présente deux intérêts.

Tout d'abord, GitHub Copilot nous propose un code contextualisé à l'endroit où l'on souhaite ajouter ou modifier du code. Ainsi, il comprend parfaitement le code a proximité, ce qui nous évite de devoir formuler explicitement un prompt, et nous apporte donc un gain de temps considérable.
Également, GitHub Copilot est capable de comprendre notre manière de coder sans avoir besoin de guidage spécifique, car il va chercher à fournir le code le plus probable par rapport à notre code existant. C'est un très bon moyen de contraindre la réponse sans y passer trop de temps.

Chat dans l'éditeur

Une autre fonctionnalité particulièrement utile est que GitHub Copilot dispose d'un chat directement dans l'éditeur. Reprenons le code créé plus haut, on souhaiterait le modifier selon les deux contraintes suivantes.

Changer l'emplacement les importations afin que ceux-ci soient concentrés au début du fichier.
Rajouter du typage sur les paramètres d'entrée et de sortie.

Avec Cmd+I (macOS) ou Ctrl+I (Windows), on peut alors ouvrir le chat dans l'éditeur, et demander à notre agent de modifier le code.

En tapant la touche Entrée, GitHub Copilot réfléchit et nous propose une adaptation du code. Il ne reste plus qu'à accepter ou refuser la modification.

Fill-in-the-Middle

Enfin, il est à noter que GitHub Copilot implémente la fonctionnalité de Fill-in-the-Middle (FIM). Cette capacité, indispensable lorsque l'on doit coder, consiste à proposer du code ou du texte au milieu d'un texte déjà formé. Ainsi, comme son nom l'indique, on cherche à combler un trou (hole) où l'on s'attend à avoir du texte.

En effet, la plupart des LLM ont été entraînés pour prédire le prochain mot (ou token) à partir du mot précédent : ils sont donc particulièrement efficaces pour ce genre de tâches. En revanche, il est beaucoup moins naturel pour eux de compléter du texte contenu entre deux séquences successives.

Dans cet exemple, nous voyons que la fonction generate_password existe déjà : elle dispose déjà de sa signature, ainsi que de son corps de fonction. On aimerait pouvoir ajouter une documentation à cette fonction (via une docstring).

En positionnant le curseur juste après la définition de la signature, GitHub Copilot propose au LLM choisi (ici GPT-4.1) de compléter le texte manquant. En toute logique, le LLM estime qu'il devrait y avoir une docstring à cet endroit, et propose alors une auto-complétion qui vient documenter la fonction.

Interface de conversation

GitHub Copilot dispose également d'une interface de conversation qui permet d'engager une conversation directe avec un assistant.

Une des principales utilisations de l'interface de conversation est de pouvoir ajouter de nombreuses références dans le contexte. Ainsi, au-delà des fichiers ouverts en édition, il est possible de faire référence à tout une codebase, à des dossiers en dehors du répertoire courant, et même des images (screenshots).

En général, ce genre d'interface est plutôt utilisé pour poser des questions générales (proposer des hypothèses d'architecture, retrouver un code).

Prompter avec GitHub Copilot

Tout comme il est nécessaire d'avoir des prompts bien formulés avec les LLM, GitHub Copilot n'échappe pas à cette règle. Il est important de bien rédiger ses prompts et de faire en sorte qu'un maximum de contexte soit disponible afin que GitHub Copilot puisse proposer des réponses pertinentes et adaptées à nos besoins.

À découvrir : notre formation IA Générative

Voici quelques règles à bien avoir en tête lorsque l'on rédige des prompts pour GitHub Copilot.

Utiliser des prompts explicites, structurés et contextualisés permet de contraindre le LLM à suivre une voie particulière. Notamment, il faut être clair et concis sur ce que l'on attend : dans certains cas, un seul prompt peut ne pas suffire. On cherchera alors à engager la discussion pour arriver à nos fins.
Créer un fichier .github/copilot-instructions.md à la racine du projet permet d'ajouter des instructions globales au projet plutôt que de répéter systématiquement les prompts. Cela permet notamment d'apporter un contexte plus précis, sur des technologies particulières ou sur des pratiques personnalisées pour un projet spécifique.
Faire des références à des objets existants : le plus on laisse libre court à l'imagination de GitHub Copilot, le moins on aura un code stable et maintenable. En tant que développeur, il est nécessaie de fournir un cadre précis et rigoureux, pour évoluer avec une cohérence stable.

Toutes ces bonnes pratiques de prompting s'acquièrent avec le temps, et deviennent par la suite des réflèxes.

Avantages et inconvénients de GitHub Copilot

GitHub Copilot présente de nombreux avantages.

Un gain de temps important : GitHub Copilot propose automatiquement des lignes de code, des fonctions complètes, voire des blocs entiers adaptés au contexte. Cela réduit drastiquement le temps passé sur les tâches répétitives.
Il est à l'aise avec plusieurs langages : nous avons codé en Python, mais GitHub Copilot prend en charge une large variété de langages de programmation. Que l'on utilise Python, Java, C#, ou même Go, il s’adapte sans difficultés.
Son intégration dans la plupart des environnements de développement intégré (IDE) est fluide. Il s'intègre très bien avec les IDE modernes comme Visual Studio Code, JetBrains ou encore Eclipse.

Néanmoins, étant donné que GitHub Copilot reste alimenté par un LLM pour fournir des réponses, nous retrouvons des inconvénients déjà rencontrés auparavant.

Les propositions de code peuvent être inexactes. Il peut générer du code obsolète, inefficace ou tout simplement faux.
Le coût de la licence peut être un frein, notamment pour les structures qui emploient de nombreux développeurs. En effet, bien que GitHub Copilot dispose d'une version gratuite avec des quotas, seule la licence payante permet de tirer profit de toutes les fonctionnalités proposées.
Enfin, cela peut créer une dépendance à l'utilisation d'un assistant au code. Une dépendance trop forte empêcherai d'avoir une réflexion avancée sur d'autres projets où les assistants au code ne pourraient pas être utilisés.

Ainsi, il est toujours important de bien prendre en compte tous ces aspects avant de déployer GitHub Copilot à grande échelle. La version gratuite proposée est une première étape si l'on souhaite tester les principales fonctionnalités sans engagement important.

Blent intervient régulièrement auprès d'entreprises qui souhaitent utiliser des assistants au code comme GitHub Copilot pour former leurs équipes à utiliser efficacement ces outils. Que ce soit sur des technologies Java, Python, NodeJS, sur des besoin backend, frontend ou même pour des profils Data, Blent dispose d'une solide expérience dans l'utilisation des assistants au code pour améliorer l'efficacité opérationnelle.