La deuxième vague de codage de l'IA est arrivée

Demandez aux personnes qui développent l’IA générative à quoi l’IA générative sert actuellement, ce qui les passionne vraiment, et beaucoup vous répondront : le codage. 

« C'est quelque chose de très passionnant pour les développeurs », a déclaré Jared Kaplan, scientifique en chef chez Anthropic, au MIT Technology Review ce mois-ci : « Il s'agit vraiment de comprendre ce qui ne va pas dans le code, de le déboguer. »

Copilot, un outil construit sur les grands modèles de langage d'OpenAI et lancé par GitHub soutenu par Microsoft en 2022, est désormais utilisé par des millions de développeurs dans le monde. Des millions d'autres se tournent vers des chatbots à usage général comme Claude d'Anthropic, ChatGPT d'OpenAI et Gemini de Google DeepMind pour une aide quotidienne.

« Aujourd'hui, plus d'un quart de tout le nouveau code de Google est généré par l'IA, puis examiné et accepté par les ingénieurs », assure le PDG d'Alphabet, Sundar Pichai, lors d'une conférence téléphonique sur les résultats financiers en octobre : « Cela aide nos ingénieurs à faire plus et à aller plus vite. » Attendez-vous à ce que d'autres entreprises technologiques rattrapent leur retard, si ce n'est pas déjà fait.

Les outils de codage d’IA ne sont pas les seuls à être proposés par les géants du secteur. De nombreuses startups ont également fait leur entrée sur ce marché en pleine effervescence. De nouveaux venus comme Zencoder, Merly, Cosine, Tessl (évaluée à 750 millions de dollars quelques mois après sa création) et Poolside (évaluée à 3 milliards de dollars avant même la sortie du produit) se bousculent pour obtenir leur part du gâteau. « Il semblerait que les développeurs soient prêts à payer pour des copilotes », lance Nathan Benaich, analyste chez Air Street Capital, une société d’investissement. « Le code est donc l’un des moyens les plus simples de monétiser l’IA. »

Ces entreprises promettent de faire passer les assistants de codage génératifs à un niveau supérieur. Au lieu de fournir aux développeurs une sorte d’autocomplétion suralimentée, comme la plupart des outils existants, cette nouvelle génération peut prototyper, tester et déboguer du code pour vous. Le résultat est que les développeurs pourraient essentiellement se transformer en gestionnaires, qui pourraient passer plus de temps à réviser et corriger le code écrit par un modèle qu’à l’écrire eux-mêmes à partir de zéro. 

Mais ce n’est pas tout. Beaucoup de ceux qui développent des assistants de codage génératifs pensent qu’ils pourraient constituer une voie rapide vers l’intelligence artificielle générale (AGI), cette technologie surhumaine hypothétique que plusieurs grandes entreprises prétendent avoir dans leur viseur.

« La première fois que nous verrons une activité à forte valeur économique atteindre des capacités de niveau humain, ce sera dans le développement de logiciels », déclare Eiso Kant, PDG et cofondateur de Poolside. (OpenAI s'est déjà vanté que son dernier modèle o3 a battu le scientifique en chef de l'entreprise lors d'un concours de codage compétitif.)

Bienvenue dans la deuxième vague de codage de l’IA. 

Code correct 

Les ingénieurs en logiciel parlent de deux types de correction. La première est la correction de la syntaxe d'un programme (sa grammaire), c'est-à-dire que tous les mots, nombres et opérateurs mathématiques sont à la bonne place. Cela importe bien plus que la correction grammaticale en langage naturel. Une petite erreur dans des milliers de lignes de code et rien ne fonctionnera.

La première génération d'assistants de codage est désormais assez douée pour produire du code correct dans ce sens. Formés sur des milliards de morceaux de code, ils ont assimilé les structures superficielles de nombreux types de programmes.  

Mais il y a aussi le sens dans lequel le fonctionnement d'un programme est correct : bien sûr, il fonctionne, mais fait-il réellement ce que vous vouliez qu'il fasse ? C'est ce deuxième niveau de correction que vise la nouvelle vague d'assistants de codage génératif, et qui va vraiment changer la façon dont les logiciels sont créés.

« Les grands modèles de langage peuvent écrire du code qui compile, mais ils n’écrivent pas toujours le programme souhaité », explique Alistair Pullen, cofondateur de Cosine. « Pour y parvenir, il faut recréer les processus de réflexion qu’un codeur humain aurait suivis pour obtenir ce résultat final. »

Le problème est que les données sur lesquelles la plupart des assistants de codage ont été formés (les milliards de morceaux de code extraits de référentiels en ligne) ne reflètent pas ces processus de réflexion. Elles représentent un produit fini, et non ce qui a été nécessaire pour le créer. « Il existe beaucoup de code, explique Kant. Mais ces données ne représentent pas le développement de logiciels. »

Alistair Pullen, Kant et d’autres ont découvert que pour construire un modèle qui fait bien plus que de la saisie semi-automatique (un modèle qui peut générer des programmes utiles, les tester et corriger des bugs), il faut lui montrer bien plus que du code. Il faut lui montrer comment ce code a été assemblé.  

L’objectif est de créer des modèles qui ne se contentent pas d’imiter ce à quoi ressemble un bon code (qu’il fonctionne bien ou non), mais qui imitent également le processus qui produit ce code en premier lieu.

Fil d'Ariane

Pour cela, vous avez besoin d’un ensemble de données qui capture ce processus, c’est-à-dire les étapes qu’un développeur humain peut suivre lors de l’écriture de code. Considérez ces étapes comme un fil d’Ariane qu’une machine pourrait suivre pour produire elle-même un morceau de code similaire.

Vous devez d’abord déterminer les éléments à exploiter : quelles sections de la base de code existante (et d’autres sources d’information) sont nécessaires pour une tâche de programmation donnée ? « Le contexte est essentiel », explique Andrew Filev, fondateur de Zencoder. « La première génération d’outils n’était pas très efficace sur le contexte, ils se contentaient de regarder vos onglets ouverts. Mais votre référentiel [référentiel de code] pouvait contenir 5 000 fichiers et la plupart d’entre eux leur échappaient. »

Zencoder a embauché un groupe de vétérans des moteurs de recherche pour l'aider à créer un outil capable d'analyser de grandes bases de code et de déterminer ce qui est pertinent ou non. Ce contexte détaillé réduit les hallucinations et améliore la qualité du code que les grands modèles de langage peuvent produire, explique Filev : « Nous appelons cela le repo grokking. »

Cosine considère également le contexte comme un élément clé. Elle collecte toutes les informations qu’elle peut trouver et les utilise pour créer un nouveau type d’ensemble de données. L’entreprise a demandé à des dizaines de codeurs d’enregistrer ce qu’ils faisaient pendant qu’ils effectuaient des centaines de tâches de programmation différentes. « Nous leur avons demandé de tout noter », explique Pullen : « Pourquoi avez-vous ouvert ce fichier ? Pourquoi l’avez-vous parcouru à mi-chemin ? Pourquoi l’avez-vous fermé ? » Ils ont également demandé aux codeurs d’annoter des morceaux de code terminés, en marquant les sections qui auraient nécessité la connaissance d’autres morceaux de code ou une documentation spécifique pour leur rédaction.

Cosine prend ensuite toutes ces informations et génère un grand ensemble de données synthétiques qui met en correspondance les étapes typiques suivies par les codeurs et les sources d'informations sur lesquelles ils s'appuient, avec les morceaux de code finis. Ils utilisent cet ensemble de données pour entraîner un modèle afin de déterminer le chemin d'accès qu'il pourrait devoir suivre pour produire un programme particulier, puis comment le suivre.  

Poolside, basé à San Francisco, crée également un ensemble de données synthétiques qui capture le processus de codage, mais il s'appuie davantage sur une technique appelée RLCE (apprentissage par renforcement à partir de l'exécution de code). (Cosine l'utilise également, mais dans une moindre mesure.)

La méthode RLCE est analogue à la technique utilisée pour créer des chatbots comme ChatGPT, des interlocuteurs astucieux, connue sous le nom de RLHF ( renforcement learning from human feedback) . Avec RLHF, un modèle est formé pour produire du texte qui ressemble davantage au type de texte que les testeurs humains disent préférer. Avec RLCE, un modèle est formé pour produire du code qui ressemble davantage à celui qui fait ce qu'il est censé faire lorsqu'il est exécuté.  

Jouer avec le système

Cosine et Poolside affirment tous deux s’être inspirés de l’approche adoptée par DeepMind avec son modèle de jeu AlphaZero . On a donné à AlphaZero les étapes qu’il pouvait suivre (les mouvements d’un jeu) et on l’a laissé jouer contre lui-même encore et encore, en déterminant par essais et erreurs quelle séquence de mouvements était gagnante et laquelle ne l’était pas.  

« Ils lui ont permis d'explorer des mouvements à chaque tournant possible, de simuler autant de jeux que possible, ce qui l'a conduit à battre Lee Sedol », explique Pengming Wang, scientifique fondateur de Poolside, en référence au grand maître coréen du Go qu'AlphaZero a battu en 2016. Avant Poolside, Wang a travaillé chez Google DeepMind sur des applications d'AlphaZero au-delà des jeux de société, notamment FunSearch , une version entraînée à résoudre des problèmes mathématiques avancés.

Lorsque l’approche AlphaZero est appliquée au codage, les étapes nécessaires à la production d’un morceau de code deviennent les coups disponibles dans un jeu, et un programme correct devient le gagnant de cette partie. Si on le laisse jouer seul, un modèle peut s’améliorer bien plus vite qu’un humain. « Un codeur humain essaie et échoue un échec à la fois », explique Kant. « Les modèles peuvent essayer des choses 100 fois à la fois. »

Une différence clé entre Cosine et Poolside est que Cosine utilise une version personnalisée de GPT-4o fournie par OpenAI, qui permet de s'entraîner sur un ensemble de données plus grand que celui que le modèle de base peut gérer, mais Poolside construit son propre grand modèle de langage à partir de zéro.

Kant, de Poolside, pense que former un modèle sur du code dès le départ donnera de meilleurs résultats que d'adapter un modèle existant qui a absorbé non seulement des milliards de morceaux de code mais la majeure partie d'Internet. « Je n'ai aucun problème avec le fait que notre modèle oublie l'anatomie du papillon », dit-il.  

Cosine affirme que son assistant de codage génératif, appelé Genie, est en tête du classement de SWE-Bench, un ensemble standard de tests pour les modèles de codage. Poolside est encore en train de développer son modèle mais affirme que ce qu'il a jusqu'à présent correspond déjà aux performances de Copilot de GitHub.

« Personnellement, je suis convaincu que les grands modèles de langage nous permettront de devenir des développeurs de logiciels aussi compétents », déclare Kant.

Cependant, tout le monde n’est pas de cet avis.

Des LLM illogiques

Pour Justin Gottschlich, PDG et fondateur de Merly, les grands modèles de langage ne sont pas l’outil adéquat pour ce travail. Il évoque son chien : « Aucun entraînement ne lui permettra de savoir coder, cela n’arrivera jamais », dit-il. « Il peut faire plein d’autres choses, mais il est tout simplement incapable d’atteindre ce niveau de cognition profond. »  

Ayant travaillé sur la génération de code pendant plus d’une décennie, Gottschlich a un problème similaire avec les grands modèles de langage. La programmation exige la capacité de résoudre des énigmes logiques avec une précision inébranlable. Peu importe la façon dont les grands modèles de langage peuvent apprendre à imiter ce que font les programmeurs humains, ils restent essentiellement des machines à sous statistiques , dit-il : « Je ne peux pas entraîner un système illogique à devenir logique. »

Au lieu d'entraîner un grand modèle de langage à générer du code en lui fournissant de nombreux exemples, Merly ne montre pas du tout à son système le code écrit par l'homme. En effet, pour réellement construire un modèle capable de générer du code, explique Gottschlich, il faut travailler au niveau de la logique sous-jacente que le code représente, et non au niveau du code lui-même. Le système de Merly est donc entraîné sur une représentation intermédiaire, quelque chose comme la notation lisible par machine dans laquelle la plupart des langages de programmation sont traduits avant d'être exécutés.

Gottschlich ne dit pas exactement à quoi cela ressemble ni comment fonctionne le processus. Mais il propose une analogie : il existe cette idée en mathématiques selon laquelle les seuls nombres qui doivent exister sont les nombres premiers, car on peut calculer tous les autres nombres en utilisant uniquement les nombres premiers. « Prenez ce concept et appliquez-le au code », dit-il.

Non seulement cette approche permet d’accéder directement à la logique de la programmation, mais elle est également rapide, car des millions de lignes de code sont réduites à quelques milliers de lignes de langage intermédiaire avant que le système ne les analyse.

Changement des mentalités

Ce que vous pensez de ces approches rivales peut dépendre de ce que vous souhaitez que soient les assistants de codage génératif.  

En novembre, Cosine a interdit à ses ingénieurs d’utiliser des outils autres que ses propres produits. L’entreprise constate aujourd’hui l’impact de Genie sur ses propres ingénieurs, qui se retrouvent souvent à observer l’outil pendant qu’il crée du code pour eux. « Vous donnez maintenant au modèle le résultat que vous souhaitez, et il se charge de l’implémentation pour vous », explique Yang Li, un autre cofondateur de Cosine.

L’IA générative a pris le monde d’assaut en 2023. Son avenir – et le nôtre – sera façonné par ce que nous ferons ensuite.

Pullen admet que cela peut être déroutant et nécessiter un changement d’état d’esprit. « Certains ingénieurs effectuent plusieurs tâches à la fois, passant d’une fenêtre à l’autre », explique-t-il. « Pendant que Genie exécute du code dans l’une d’elles, ils peuvent lui demander d’effectuer autre chose dans une autre. »

Ces outils permettent également de prototyper plusieurs versions d'un système à la fois. Imaginons que vous développiez un logiciel qui nécessite un système de paiement intégré. Vous pouvez demander à un assistant de codage de tester simultanément plusieurs options différentes (Stripe, Mango, Checkout) au lieu de devoir les coder manuellement une par une.

Genie peut être chargé de corriger les bugs 24 heures sur 24. La plupart des équipes de développement utilisent des outils de rapport de bugs qui permettent aux utilisateurs de télécharger des descriptions des erreurs qu'ils ont rencontrées. Genie peut lire ces descriptions et proposer des correctifs. Il suffit ensuite à un humain de les examiner avant de mettre à jour la base de code.

"Aucun être humain ne peut à lui seul comprendre les milliards de lignes de code des plus grands systèmes logiciels actuels, explique Li, « et à mesure que de plus en plus de logiciels sont écrits par d’autres logiciels, la quantité de code ne fera qu’augmenter. »

Cela rendra indispensables les assistants de codage qui maintiendront ce code pour nous. « Le goulot d’étranglement sera la vitesse à laquelle les humains pourront examiner le code généré par la machine », explique Li.

Que pensent les ingénieurs de Cosine de tout cela ? Selon Pullen, tout va bien. « Si je vous donne un problème difficile, vous allez quand même réfléchir à la manière dont vous voulez décrire ce problème au modèle », dit-il. « Au lieu d’écrire le code, vous devez l’écrire en langage naturel. Mais il y a encore beaucoup de réflexion à faire, donc vous n’enlevez pas vraiment le plaisir de l’ingénierie. La démangeaison est toujours satisfaite. »

Certains s’adaptent plus vite que d’autres. Cosine aime inviter les candidats potentiels à passer quelques jours à coder avec son équipe. Il y a quelques mois, l’entreprise a demandé à l’un de ces candidats de créer un widget qui permettrait aux employés de partager sur les réseaux sociaux des éléments intéressants du logiciel sur lequel ils travaillaient. 

La tâche n'était pas simple, car elle exigeait une connaissance pratique de plusieurs sections des millions de lignes de code de Cosine. Mais le candidat a réussi à la réaliser en quelques heures. « Cette personne qui n'avait jamais vu notre base de code s'est présentée lundi et mardi après-midi, elle avait livré quelque chose », explique Li. « Nous pensions que cela lui prendrait toute la semaine. » (Ils l'ont embauché.)

Mais il y a aussi un autre aspect à prendre en compte. De nombreuses entreprises utiliseront cette technologie pour réduire le nombre de programmeurs qu’elles embauchent. Li pense que nous verrons bientôt apparaître des niveaux d’ingénieurs logiciels. À une extrémité, il y aura des développeurs d’élite avec des salaires de plusieurs millions de dollars qui pourront diagnostiquer les problèmes lorsque l’IA se dérègle. À l’autre extrémité, des équipes plus petites de 10 à 20 personnes effectueront un travail qui nécessitait autrefois des centaines de codeurs. « Ce sera comme la façon dont les distributeurs automatiques de billets ont transformé le secteur bancaire », explique Li.

« Tout ce que vous voulez faire sera déterminé par le calcul et non par le nombre d'employés », dit-il. « Je pense qu'il est généralement admis que l'ère où l'on pouvait ajouter quelques milliers d'ingénieurs supplémentaires à une organisation est révolue. »

Propulseurs à distorsion

Pour Gottschlich, il est essentiel de disposer de machines capables de coder mieux que les humains. C’est la seule façon de construire les systèmes logiciels vastes et complexes dont nous aurons besoin. Comme beaucoup dans la Silicon Valley, il anticipe un avenir où les humains se déplaceront vers d’autres planètes. Cela ne sera possible que si nous parvenons à faire en sorte que l’IA construise les logiciels nécessaires, dit-il : « Le véritable objectif de Merly est de nous emmener sur Mars. »

Gottschlich préfère parler de « programmation de machines » plutôt que d’« assistants de codage », car il estime que ce terme pose le problème de manière erronée. « Je ne pense pas que ces systèmes devraient assister les humains, mais que ce sont les humains qui devraient les assister », dit-il. « Ils peuvent évoluer à la vitesse de l’IA. Pourquoi restreindre leur potentiel ? »

Tout le monde pense savoir, mais personne n'est d'accord. Et c'est là un problème.

« Il y a un dessin animé appelé Les Pierrafeu , dans lequel on voit des voitures, mais elles ne se déplacent que lorsque les conducteurs utilisent leurs pieds », explique Gottschlich. « C'est un peu comme ça que la plupart des gens conçoivent l'IA pour les systèmes logiciels. »

« Mais ce que Merly construit, c'est essentiellement des vaisseaux spatiaux », ajoute-t-il. Il ne plaisante pas. « Et je ne pense pas que les vaisseaux spatiaux devraient être propulsés par des humains sur un vélo. Les vaisseaux spatiaux devraient être propulsés par un moteur à distorsion. »

Si cela semble fou, c'est le cas. Mais il y a une question sérieuse à se poser quant à l'objectif final que se fixent les concepteurs de cette technologie.

Gottschlich n’est pas un cas à part avec son approche futuriste. Bien qu’elles se concentrent sur des produits que les développeurs voudront utiliser aujourd’hui, la plupart de ces entreprises visent un résultat bien plus important. Visitez le site Web de Cosine et l’entreprise se présente comme un « laboratoire de raisonnement humain ». Elle considère le codage comme la première étape vers un modèle à usage plus général qui peut imiter la résolution de problèmes humains dans un certain nombre de domaines.

Poolside a des objectifs similaires : l’entreprise déclare d’emblée qu’elle développe une intelligence artificielle. « Le code est une façon de formaliser le raisonnement », explique Kant.

Wang fait appel à des agents. Imaginez un système capable de lancer son propre logiciel pour effectuer n’importe quelle tâche à la volée, explique-t-il. « Si vous parvenez à un point où votre agent peut réellement résoudre n’importe quelle tâche de calcul que vous souhaitez au moyen d’un logiciel, c’est une démonstration d’AGI, en substance. »

Sur Terre, de tels systèmes restent un rêve irréaliste. Dans le même temps, l’ingénierie logicielle évolue plus vite que ce que beaucoup de spécialistes de pointe s’attendaient. 

« Nous n’en sommes pas encore au stade où tout est fait par des machines, mais nous nous éloignons clairement du rôle habituel d’un ingénieur logiciel », déclare Pullen de Cosine. « Nous voyons les étincelles de ce nouveau flux de travail, ce que signifie être un ingénieur logiciel à l’avenir. »

https://www.technologyreview.com/2025/01/20/1110180/the-second-wave-of-ai-coding-is-here