🤖 ChatGPT, dis-moi comment utiliser Copilot?

La semaine passée, je me suis dit qu’il fallait absolument que je passe du temps à apprendre à mieux utiliser les outils d’intelligence artificielle que j’ai à ma disposition. Les articles du style de celui de Matt Shumer “Something Big Is Happening” traduisent bien mon impression actuelle: les outils d’IA deviennent monstrueusement puissants et nous allons subir un changement complet dans notre manière de travailler qu’on le veuille ou non. C’est vrai partout, et en particulier à l’université. Il semble donc indispensable de s’y préparer.

Je me rends compte que, progressivement, toutes mes tâches quotidiennes sont pour la plupart faisables par une IA. Et quand elles ne le sont pas, c’est surtout parce que je n’arrive juste pas à piloter correctement l’IA pour obtenir ce que je veux. Dans ce contexte, je dois absolument apprendre à utiliser mieux l’IA. J’utilise très souvent ChatGPT et je commence à bien me débrouiller (du moins, beaucoup mieux qu’avant). Je connais différentes astuces pour obtenir de meilleures réponses. J’ai créé des GPTs pour effectuer différentes tâches répétitives (améliorer un texte, corriger un rapport, reviewer un travail, résumer un article, etc). J’utilise les “projets” pour travailler sur des tâches qui possèdent des sous-tâches. J’ai configuré finement le ton et le contenu des réponses que je souhaite obtenir, …

A côté de ChatGPT, j’utilise également Copilot dans le VSCode pour générer du code sous mon curseur. Copilot me suggère des choses et je les accepte ou je les refuse. C’est très impressionnant parce que depuis quelques temps, il s’amuse même à aller un peu au delà de mon curseur, anticipant mon prochain mouvement de souris. Déjà via cette interaction basique avec Copilot, c’est extrêmement troublant comme il arrive à comprendre ce qui se passe dans ma tête, et tout ça automatiquement… Suis-je si prévisible que ça?

Mais Copilot est bien plus qu’un simple outil de suggestion de code: il y a également le “Chat” qui permet de discuter sur les fichiers ouverts et obtenir des suggestions de modifications. Depuis peu, ce chat s’est amélioré et est devenu “agentique” (je traduis librement ici le terme agentic AI). Qu’est ce que ça change? Et bien cela veut dire que Copilot peut parcourir tout le projet ouvert et surtout modifier le code lui-même pour proposer des modifications. Mieux: il peut lancer des commandes dans le terminal (powershell sous windows, bash sous linux) et, compiler le projet tout seul pour tester le résultat obtenu! C’est assez incroyable.

J’ai donc décidé de faire un petit test sur un petit code que je maîtrise. Il s’agit d’un tout vieux projet de mon cours de “Dynamique des Constructions Mécanique” en “1ère tech” de mes études d’ingénieur.

Le projet en question

C’est un des premiers projets que j’ai eu pendant mes études. Il s’agissait de simuler un mécanisme “3 barres” et l’optimiser par la suite. Pour la partie “optimisation”, j’avais délégué à l’époque le codage de la matrice des dérivées à ma co-équipière de l’époque et elle n’avait pas réussi à avoir quelque chose qui fonctionne. Donc difficile de coder un algo d’optimisation avec un bug… Ca ne marchait juste pas du tout. Pour me sortir de là sans trouver le bug des dérivées, je me suis amusé à coder un affichage graphique sur mon PC de l’époque (mon premier PC, tournant sous DOS et équipé du Borland C++!). L’idée était donc d’avoir une interface graphique, faire “tourner” le mécanisme à l’écran et faire varier les paramètres manuellement pour avoir une meilleure trajectoire. Sans surprise, cette démarche un peu trop expérimentale n’a séduit le correcteur et on a obtenu un 14/20…

Extrait du rapport en question (on est en 1994!)

Mais bon, revenons à ce petit programme écrit en Borland C++ qui affiche un mécanisme tournant. Quand j’ai appris à utiliser git, j’ai mis tous les programmes dans un bon gros repository (j’ai appris que ça s’appelait un “monorepo”) pour les avoir sous la main et pouvoir m’en inspirer quand je code un nouveau projet. Ca m’a permis également d’améliorer certains programmes, vérifier qu’ils compilent et marchent toujours au cours du temps. Dans le cas de ce petit projet, je l’ai pris pour base de mon apprentissage de la bibliothèque Qt. Il y a 8 ans, j’ai donc remplacé manuellement (sans IA) l’utilisation des routines graphiques du Borland C++ (BGI) par Qt.

Ca a donné ceci:

C’est à dire un programme “interactif” dans un widget Qt où le mécanisme est en mouvement continu et les paramètres du mécanisme sont modifiables à la souris via des sliders Qt. L’affichage s’adapte en temps réel.

Amélioration avec Copilot

L’idée de mon travail de la semaine passée était de fournir ce code à Copilot et de lui demander différentes modifications, sans toucher au code moi même. Je ne ferais que regarder ce que Copilot fait et accepter des modifications.

Le résultat “m’a troué l… heu… m’a étonné” comme aurait dit ma belle-soeur 😁.

Ne sachant pas trop comment parler à Copilot de manière efficace, j’ai demandé à ChatGPT de le faire à ma place. Les difficultés que je voyais étaient:

• Le projet est perdu dans un gros “monorepo” parmi du code qui n’a rien à voir. Comment faire pour que Copilot ne se perde pas dans l’arborescence de fichiers?
• Le projet contient la vielle version Borland que j’ai gardée dans l’espoir de la recompiler un jour dans un émulateur. Il y a également des scripts Matlab utiles au travail de l’époque qui traînent parmi les sources. Comment restreindre Copilot dans son envie de tout lire? (sachant que l’utilisation de Copilot n’est pas illimitée, chaque demande “complexe” demande plus ou moins de Premium Requests qui se traduisent en Crédits débités d’un compte de 300/mois)
• Comment éviter qu’il propose tout et n’importe quoi?
• Comment travailler en pratique? Une seule conversation pour toutes les modifs ou plusieurs conversations (1 par tâche)? Mais alors dans ce second cas, comment conserver la mémoire qu’à Copilot sur le code et éviter qu’il re-scanne toutes les sources au prix de nombreuses Premium Requests inutiles?
• …

ChatGPT a répondu à toutes ces questions. Le principe est d’ouvrir uniquement le sous-dossier qui contient les sources dans Visual Studio Code et de travailler avec un ou plusieurs fichiers du type AI_CONTEXT.md qui résument l’état des sources et les connaissances qu’acquiert Copilot pendant son travail. Il faut donc créer ce fichier et le modifier constamment pour qu’il reflète au mieux l’état du repository et l’historique des modifs. Quand on démarre une tâche, on lui demande de lire ce fichier pour le mettre dans le bain… A la fin, on lui demande de le mettre à jour pour son futur-lui dans une autre conversation. C’est simple, mais il fallait y penser.

J’ai donc demandé à ChatGPT de me donner une série d’améliorations possible du code. Il m’a fourni une liste impressionnante de tâches qui pourraient être réalisées. J’ai donc commencé à superviser un dialogue entre ChatGPT et Copilot pour:

• transformer l’application en “vraie” application Qt (une QApplication au lieu d’un simple widget),
• ajouter un menu et une barre de statut,
• ajouter un chargement/sauvegarde des paramètres au format JSON,
• ajouter la possibilité de drag&drop un fichier de paramètres JSON dans la fenêtre pour le charger,
• optimiser le code (ne recalculer la trajectoire que lorsque c’est nécessaire et pas à toutes les frames),
• extraire tous les nombres magiques liés aux paramètres graphiques dans une structure et en faire des vrais paramètres (couleurs, épaisseur de trait, traille de police),
• ajouter une fenêtre de configuration de ces paramètres,
• améliorer les “sliders” pour régler les paramètres du mécanisme dans l’interface graphique,
• rendre la fenêtre redimensionnable,
• ajouter une grille de visualisation,
• ajouter un zoom/pan à la souris,
• ajouter un start/stop et la possibilité de faire du “frame par frame” avec les flèches du clavier,
• faire un réglage de la vitesse du mécanisme,
• ajouter une traduction de l’interface et un choix de langue anglais/français,
• améliorer le système de build,
• ajouter des tests et une exécution de ceux-ci par CTest.

Tout ça en quelques heures! Ca m’a vraiment bluffé.

Une des étapes les plus impressionnantes selon moi est l’extraction des nombres magiques. Elle nécessite de comprendre à quoi correspondent chaque constante pour d’une part la réutiliser au bon endroit si nécessaire et d’autre part nommer correctement la nouvelle variable. Pour ça, il faut vraiment comprendre le code et ce qu’il fait.

J’ai aussi été impressionné par la partie “tests”. Copilot a d’abord compris les équations du mécanisme et les as reproduites dans un script powershell. Il a ensuite évalué la configuration du mécanisme dans différentes configurations et a sauvé les positions des charnières dans un fichier CSV qui est relu par le programme de test. On comprends vite que Copilot a une vision très claire de ce que fait le code.

Un autre test: le code PiC de mon cours

Comme je l’ai écrit dans ce billet “PiC les débuts” et ce billet “emscripten”, je suis en train de coder un petit simulateur “Particle in Cell” parallèlement à mes étudiants. Le but premier était de me familiariser avec la méthode numérique pour les aider. J’ai également utilisé cette occasion pour jouer avec PixelGameEngine, Dear ImGui et Emscripten.

Il était temps de voir à quel point Copilot peut réaliser mon travail et me faire avancer dans ce projet. J’ai donc fait la même chose qu’avec le code précédent: ChatGPT allait m’aider à piloter Copilot en mode “agent”. Ce code est un peu plus gros, plus complexe et il est divisé en plusieurs bibliothèques dont deux ne sont que des copies des fichiers sources de PixelGameEngine et ImGui.

J’ai tout d’abord essayé de générer un fichier AI_CONTEXT.md mais ChatGPT m’a finalement suggéré de scinder ce fichier en plusieurs parties. En faisant des recherches dans l’aide de Copilot, j’ai vu qu’il était possible configurer Copilot au travers de fichiers du style copilot-instructions.md dans un répertoire .github/ dans les sources (même si celui-ci est finalement hébergé par GitLab). J’ai donc créé une série de fichiers contenant différentes instructions et décrivant l’architecture du code. Le but premier est de ne pas se répéter, mais aussi que Copilot ne relise pas trop souvent la totalité des fichiers pour comprendre le contexte ou ce qui se serait passé dans une autre conversation avec l’agent.

Et voici donc mes commits, ou plutôt ceux de Copilot:

A la fin, c’est même lui qui écrit le message et se charge de faire le git push!

Mon idée était de voir si Copilot était capable d’ajouter une résolution par gradient conjugué pour le solveur de Poisson. Je savais que cette méthode était plus performante que celles que j’avais implémentées (Jacobi et Red-Black / Gauss-Seidel).

Il m’a en fait tout d’abord corrigé 2 bugs. Le premier était un simple memory leak pas très important en fin de programme et le second était un vrai bug dans le calcul de mon gradient de pression. Les index étaient mal choisis et mon gradient mal calculé. Au départ, je n’y ai pas cru, mais il avait raison. C’est fou!

J’ai fait faire quelques opérations de refactoring avant de demander l’implémentation du gradient conjugué. C’est finalement le déplacement d’une fonction du fichier d’entête vers le fichier .cpp qui a été la tâche la plus laborieuse pour lui, alors qu’elle aurait pu être faire facilement à la main. Copilot a eu beaucoup de mal à juste copier/coller un (gros) bloc de code d’un fichier à l’autre et d’adapter l’indentation. En fait, il ne s’en sortait pas et il lui manquait des accolades. Après quelques tentatives de recompilation et d’analyse d’erreurs, il y est tout de même arrivé tout seul mais ça m’a un peu étonné, vu ses performances pour faire d’autres tâches que je trouve beaucoup plus subtiles.

C’était d’ailleurs le cas pour l’ajout du nouveau solveur linéaire: il a extrait l’opérateur linéaire de la méthode dans une fonction dédiée avec un premier prompt ; il a ensuite implémenté le solveur correctement du premier coup! Pour le vérifier, il a ajouté le calcul du résidu. Enfin, il a ajouté un préconditionneur diagonal et il a interfacé le nouveau solveur dans l’interface graphique ImGUI.

Copilot en train d’exécuter des tâches de sa liste “Todo” créée par lui-même pour arriver à son but.

J’ai arrêté là pour pouvoir “digérer” un peu ce que je venais de vivre et prendre le temps d’écrire ce billet. Cette expérience est vraiment incroyable, même si j’ai cru comprendre que Copilot n’est pas l’agent le plus puissant à l’heure actuelle. Certains de mes contacts ne jurent que par Claude Code. D’autres utilisent Codex, dont j’ai une licence pro via mon abonnement ChatGPT… Il y a vraiment trop de choses à tester!

Pour le code PiC, j’aimerais faire une passe de nettoyage manuel avant de continuer, ne serait-ce que pour assimiler le nouveau code qui a été généré.

La suite au prochain numéro!