GitHub Copilot : l'IA entre dans l'éditeur de code

Le 29 juin 2021, GitHub a présenté un outil dont le nom disait déjà l'ambition : Copilot. Un copilote, donc, installé à l'intérieur même de l'éditeur de code, capable de proposer non plus un mot ou deux, mais des lignes entières et parfois des fonctions complètes, à partir d'un simple commentaire ou du contexte du fichier ouvert. Derrière ce compagnon se cachait un modèle inédit, OpenAI Codex, taillé pour comprendre et produire du code. L'annonce, faite en accès restreint sous forme de préversion technique, avait quelque chose d'un basculement discret : pour la première fois, l'intelligence artificielle générative s'invitait dans le geste le plus quotidien du développement logiciel, celui d'écrire du code, ligne après ligne. Cet article raconte ce moment, ce qui l'a rendu possible, ce qu'il a transformé dans la pratique des développeurs, et la trajectoire que Copilot a dessinée jusqu'à aujourd'hui.

Cinq ans plus tard, en 2026, la suggestion de code par IA fait partie du décor. Un développeur ouvre son éditeur, commence à taper une fonction, et voit apparaître en gris pâle une proposition qu'il valide d'une touche de tabulation. Un autre décrit en langage naturel ce qu'il veut obtenir et laisse l'assistant esquisser une première version qu'il corrigera. Ce réflexe, aujourd'hui banal, Copilot l'a très largement contribué à installer. Comprendre comment un assistant de programmation a fait entrer l'IA générative dans le poste de travail du développeur éclaire un mouvement plus vaste : celui d'une technologie de recherche devenue un outil du quotidien, au point de redéfinir ce que signifie « écrire du code ».

Un mot de méthode avant d'entrer dans le sujet. Autour de Copilot, comme autour de toute cette période de l'IA appliquée au code, circulent des récits parfois approximatifs. Les dates, versions, chiffres et citations réunis ici proviennent des annonces officielles de GitHub et d'OpenAI, de l'article de recherche présentant Codex, de la presse technologique spécialisée et des pièces publiques de la procédure judiciaire qui a suivi. Lorsqu'une donnée n'est pas confirmée par une source solide, elle est présentée avec la prudence qui convient. C'est la règle de ce média : on privilégie ce qui se vérifie.

Ce que c'était : un binôme de programmation propulsé par l'IA

Le 29 juin 2021, GitHub, la plateforme d'hébergement de code détenue par Microsoft, dévoile Copilot et ouvre une préversion technique à un cercle restreint de développeurs invités. Le pitch tient en une formule que l'entreprise place au cœur de sa communication : « votre binôme de programmation par IA ». La référence est directe à une pratique bien connue des équipes de développement, le pair programming, où deux personnes travaillent ensemble sur un même clavier, l'une écrivant, l'autre relisant et suggérant. Copilot se propose de tenir ce second rôle, mais depuis la machine.

GitHub Copilot est un nouveau binôme de programmation par IA qui vous aide à écrire du meilleur code. Copilot tire son contexte du code sur lequel vous travaillez, en suggérant des lignes entières ou des fonctions complètes.
— Nat Friedman, alors PDG de GitHub, annonce du 29 juin 2021

Concrètement, l'assistant s'installe sous la forme d'une extension pour l'éditeur Visual Studio Code, l'environnement de développement le plus répandu à l'époque. Une fois activé, il observe en permanence ce que le développeur est en train d'écrire : le nom d'une fonction, un commentaire décrivant l'intention, les lignes déjà présentes dans le fichier. À partir de ce contexte, il propose une suite, affichée en grisé, que l'utilisateur accepte, ignore ou fait défiler parmi plusieurs variantes. Le geste d'acceptation, d'une touche, se fond dans le flux de frappe sans imposer de rupture.

Un spectre de langages, quelques terrains de prédilection

GitHub précise d'emblée que Copilot fonctionne avec un large éventail de langages et de cadres de développement, mais que la préversion se montre particulièrement à l'aise dans cinq d'entre eux : Python, JavaScript, TypeScript, Ruby et Go. Ce choix n'a rien d'anodin. Il correspond aux langages massivement présents dans le code public dont le modèle sous-jacent s'est nourri. Là où l'assistant dispose de beaucoup d'exemples, ses suggestions gagnent en pertinence ; là où le corpus se raréfie, elles deviennent plus hésitantes. Cette asymétrie, honnêtement reconnue par GitHub, dessine la carte des forces et des limites de l'outil à ses débuts.

La nature des suggestions varie elle aussi. Copilot peut compléter la ligne en cours, proposer le corps entier d'une fonction à partir de sa signature et de son commentaire, générer un cas de test, ou traduire une intention formulée en langage naturel en un bloc de code. Cette palette distingue nettement l'outil des assistants antérieurs, qui se limitaient le plus souvent à suggérer le nom d'une méthode ou d'une variable. Copilot, lui, raisonne à l'échelle du bloc, parfois de la fonction, ce qui change la nature même de l'aide apportée.

Le moteur : OpenAI Codex

Cœur du dispositif, le modèle qui alimente Copilot s'appelle OpenAI Codex. GitHub le présente comme « un nouveau système d'IA créé par OpenAI », et souligne un point technique décisif : Codex possède une connaissance étendue de la manière dont les développeurs se servent du code, et se révèle « nettement plus capable que GPT-3 en génération de code, en partie parce qu'il a été entraîné sur un jeu de données comportant une concentration bien plus forte de code source public ». Autrement dit, Codex n'est pas un modèle de langue générique auquel on aurait demandé, par hasard, d'écrire du code. C'est un modèle spécialisé, façonné pour cette tâche.

Ce fondement explique la qualité perçue des suggestions. En apprenant sur d'immenses volumes de code réel, Codex a intériorisé non seulement la syntaxe des langages, mais aussi des tournures idiomatiques, des schémas de conception récurrents, des façons habituelles de résoudre tel ou tel problème. Quand un développeur écrit un commentaire du type « trier une liste de dates par ordre chronologique », le modèle reconnaît une intention qu'il a rencontrée sous mille formes, et propose une implémentation plausible. Ce n'est pas de la compréhension au sens humain, mais une restitution statistique très fine des régularités du code existant.

Comment un tel modèle apprend

Le principe d'entraînement de Codex mérite d'être précisé, car il éclaire à la fois ses forces et ses limites. Le modèle appartient à la famille des transformeurs, l'architecture de réseau de neurones qui domine le traitement du langage depuis 2017. Sa tâche d'apprentissage est en apparence simple : à partir d'une portion de code, prédire ce qui vient ensuite. Répétée des milliards de fois sur un corpus considérable de code source public, cette prédiction du prochain fragment conduit le modèle à emmagasiner une représentation dense des motifs récurrents du code. Rien de magique dans ce mécanisme : c'est l'échelle des données et la taille du modèle qui font émerger une compétence utile.

L'article de recherche présentant Codex détaille cette dimension. Le corpus d'entraînement rassemble une masse de code Python collecté sur des dépôts publics, filtrée pour écarter les fichiers volumineux, générés automatiquement ou peu représentatifs. Cette curation compte autant que le volume : un modèle nourri de code de piètre qualité produirait des suggestions médiocres. OpenAI décrit également une variante affinée sur des exemples de problèmes correctement résolus, afin d'aligner davantage les productions du modèle sur ce que l'on attend d'un programme fonctionnel. Cette étape supplémentaire améliore sensiblement les résultats mesurés.

Une conséquence importante découle de cette approche. Le modèle ne « connaît » pas la bonne réponse ; il produit la continuation la plus probable au vu de ce qu'il a appris. Cela explique pourquoi ses propositions brillent sur les tâches fréquentes, largement documentées dans le corpus, et faiblissent sur les cas rares, spécifiques ou récents. Cela explique aussi une caractéristique bien connue des grands modèles : la capacité à produire un code d'apparence convaincante mais parfois inexact, qu'une relecture attentive doit rattraper. La force et la limite procèdent du même ressort statistique.

Le contexte : de l'autocomplétion classique à l'IA générative

Copilot n'est pas né dans le vide. Pour mesurer ce qu'il apporte, il faut restituer l'état de l'aide à l'écriture de code juste avant lui, puis la lignée technique dont Codex est l'héritier direct.

Ce que faisait l'assistance au code avant Copilot

Depuis longtemps, les éditeurs de code proposent une forme d'assistance. La plus répandue, connue sous le nom générique d'autocomplétion, suggère le nom d'une fonction, d'une variable ou d'un membre disponible à mesure que l'on tape. Chez Microsoft, cette fonctionnalité porte le nom d'IntelliSense et structure depuis des années le confort de frappe dans Visual Studio et Visual Studio Code. Son principe reste toutefois local et déterministe : elle propose ce qui existe déjà dans le projet ou la bibliothèque, sans rien inventer.

Une première couche d'intelligence statistique s'ajoute à partir de 2018 avec IntelliCode, qui classe les suggestions par ordre de probabilité, en s'appuyant d'abord sur des modèles simples puis, autour de 2020, sur des approches d'apprentissage profond. Dans le même mouvement, de jeunes acteurs explorent la piste des grands modèles de langue appliqués au code. Tabnine, apparu en 2019, s'appuie sur l'architecture qui allait devenir dominante, celle des transformeurs, pour proposer des complétions apprises sur du code public. Kite, de son côté, se concentre sur l'assistance au développement en Python. Ces outils préparent le terrain : ils habituent les développeurs à l'idée qu'une machine peut suggérer du code, et non plus seulement le compléter.

La différence de degré finit par produire une différence de nature. Les assistants antérieurs restaient cantonnés à des suggestions courtes et prévisibles. Copilot, adossé à un modèle bien plus vaste et spécialisé, franchit un seuil : il propose des blocs entiers, contextualisés, souvent corrects du premier coup dans les cas simples. C'est ce saut qualitatif qui a frappé les premiers utilisateurs et qui explique l'écho considérable de l'annonce.

Codex, descendant de GPT-3

Pour comprendre Codex, il faut remonter à GPT-3, le grand modèle de langue dévoilé par OpenAI en 2020. GPT-3 avait démontré qu'un modèle suffisamment vaste, entraîné sur de larges corpus de texte, pouvait accomplir des tâches très diverses sans apprentissage spécifique. Parmi ses aptitudes émergentes figurait une capacité, encore rudimentaire, à produire du code. OpenAI a fait le pari de spécialiser cette compétence en affinant un modèle de la même famille sur d'immenses volumes de code source public. Le résultat porte le nom de Codex.

En août 2021, quelques semaines après l'annonce de Copilot, OpenAI ouvre l'accès à Codex via une interface de programmation en beta privée, et publie un article de recherche détaillant ses performances. Ce document introduit un instrument de mesure appelé à devenir une référence du domaine : HumanEval, un jeu de 164 problèmes de programmation en Python, chacun accompagné d'une signature de fonction, d'une description de l'objectif et de cas de test permettant de vérifier objectivement si le code produit fonctionne. La méthode a le mérite de trancher : ou bien le programme passe les tests, ou bien il échoue.

Les chiffres publiés éclairent le saut accompli. Sur ce jeu d'épreuves, une version de Codex dotée d'environ douze milliards de paramètres résout 28,8 % des problèmes à la première tentative, quand un modèle GPT-3 de taille comparable en résout 0 %. L'écart est éloquent : la spécialisation sur le code fait passer le modèle d'une incapacité quasi totale à une réussite significative sur des problèmes non triviaux. OpenAI montre en outre qu'en autorisant plusieurs tentatives et en sélectionnant la meilleure, la proportion de problèmes résolus grimpe nettement, ce qui laisse entrevoir le potentiel d'un usage interactif, où le développeur trie parmi plusieurs propositions.

Repère	Date	Fait vérifié
GPT-3	2020	Grand modèle de langue d'OpenAI, socle dont Codex est affiné
Copilot — préversion technique	29 juin 2021	Annonce par GitHub, accès sur invitation, extension VS Code
Codex — article + API	août 2021	Beta privée ; HumanEval : 28,8 % à la 1re tentative pour Codex-12B, 0 % pour GPT-3 comparable
Copilot — disponibilité générale	21 juin 2022	Sortie de préversion ; 10 $/mois ou 100 $/an ; libre pour étudiants et mainteneurs open source

Pourquoi ce moment précis

La convergence de plusieurs facteurs explique que Copilot arrive à l'été 2021 et pas avant. D'abord la maturité des grands modèles de langue, dont GPT-3 avait montré la puissance un an plus tôt. Ensuite la disponibilité d'un corpus de code public gigantesque, hébergé notamment sur GitHub, qui offrait la matière première nécessaire à l'entraînement. Enfin l'alliance entre deux acteurs complémentaires : OpenAI, qui apportait le modèle, et GitHub, filiale de Microsoft, qui apportait la plateforme, la relation directe avec des millions de développeurs et l'intégration dans l'éditeur. Cette conjonction rare a permis de porter une avancée de laboratoire jusque dans l'outil de travail, en quelques mois.

Ce que ça a changé : l'IA générative dans le geste quotidien du code

L'apport de Copilot ne se mesure pas seulement à la prouesse technique. Il tient surtout à un déplacement d'usage : l'IA générative, jusque-là confinée à des démonstrations spectaculaires, devient un compagnon de travail sollicité des dizaines de fois par heure.

Un an de préversion, puis la disponibilité générale

Après un an d'expérimentation à grande échelle, GitHub franchit une étape décisive. Le 21 juin 2022, l'entreprise annonce que Copilot sort de préversion et devient accessible à tous les développeurs. L'offre s'établit à 10 dollars par mois ou 100 dollars par an pour un usage individuel, avec un accès libre pour les étudiants vérifiés et les mainteneurs de projets open source populaires. Ce passage à une mise à disposition ouverte marque le moment où l'outil quitte le cercle des invités pour entrer dans la pratique courante.

À cette occasion, GitHub livre un chiffre qui frappe les esprits. Dans les fichiers où l'assistant est activé, près de 40 % du code écrit dans les langages les plus répandus, comme Python, proviennent de Copilot. La donnée, à manier avec discernement puisqu'elle concerne les fichiers où l'outil est effectivement utilisé, dit néanmoins l'ampleur de l'adoption. GitHub précise que la préversion aura duré douze mois et rassemblé plus de 1,2 million de développeurs, un ordre de grandeur qui témoigne de l'engouement.

Le codage assisté par l'IA va transformer en profondeur la nature du développement logiciel, en donnant aux développeurs un nouvel outil pour écrire du code plus facilement et plus vite, afin qu'ils soient plus épanouis dans leur vie.
— Thomas Dohmke, PDG de GitHub, annonce de disponibilité générale, 21 juin 2022

La productivité et la manière de travailler

Sur le terrain, les praticiens décrivent plusieurs effets concrets, que l'on peut résumer ainsi :

• La corvée allégée. Copilot excelle sur le code répétitif et standardisé : mise en place d'une structure de données, écriture d'un cas de test simple, formatage, appel d'interface bien documentée. Ces tâches, chronophages sans être stimulantes, se trouvent accélérées.
• La friction réduite. Face à une bibliothèque peu familière, le développeur obtient une première esquisse d'usage sans quitter son éditeur pour consulter la documentation. Le maintien de l'attention sur la tâche s'en trouve favorisé.
• Le brouillon assumé. Beaucoup adoptent une posture d'esquisse : laisser l'assistant produire une première version, la juger, la retravailler. Le code proposé devient un point de départ à relire, non une réponse à accepter les yeux fermés.
• La vigilance maintenue. Les suggestions peuvent comporter des approximations, des inexactitudes ou des choix discutables. La relecture humaine reste indispensable, ce que GitHub n'a cessé de rappeler.

Ce dernier point mérite d'être souligné. Copilot ne se substitue pas au jugement du développeur ; il lui propose des pistes qu'il revient à ce dernier d'évaluer. Un modèle statistique produit du code plausible, ce qui n'est pas synonyme de code correct, sûr ou adapté au contexte précis du projet. L'outil déplace donc l'effort : moins de frappe mécanique, davantage de lecture critique. Cette redistribution des tâches est peut-être son effet le plus durable sur le métier.

Ce que disent les études de productivité

Au-delà des témoignages, plusieurs travaux ont cherché à quantifier l'effet de Copilot. Le plus cité est une expérience contrôlée dont les résultats ont été publiés dans un article de recherche en 2023. Le protocole était rigoureux : des développeurs recrutés devaient implémenter un serveur HTTP en JavaScript le plus vite possible, un groupe disposant de Copilot, l'autre non. Les personnes équipées de l'assistant ont accompli la tâche en une heure et onze minutes en moyenne, contre deux heures et quarante et une minutes pour celles qui en étaient dépourvues, soit un gain de temps d'environ 55,8 %. L'intervalle de confiance, large, appelle à la prudence, et la tâche retenue restait circonscrite ; mais l'ordre de grandeur a marqué les esprits.

Un résultat plus fin ressort de ces travaux : les gains ne se répartissent pas uniformément. Les développeurs les moins expérimentés, ceux qui programment de longues heures, et parfois les plus âgés, semblent tirer le meilleur parti de l'assistant. Ce constat a une portée pratique. Il suggère que Copilot agit d'abord comme un accélérateur sur les tâches balisées et un soutien pour ceux qui construisent encore leur maîtrise, plutôt que comme un multiplicateur uniforme. Comme toujours avec ce genre de mesure, la lecture honnête consiste à retenir la tendance, non le chiffre isolé : d'autres études, menées dans des contextes différents, aboutissent à des gains plus modestes, ce qui rappelle que l'effet dépend fortement de la nature du travail.

Nous constatons que les développeurs disposant de l'accès à GitHub Copilot accomplissent la tâche 55,8 % plus vite que le groupe témoin.
— Peng, Kalliamvakou, Cihon, Demirer, expérience contrôlée sur Copilot, article de recherche 2023

GitHub a par ailleurs mis en avant un autre versant, plus qualitatif : la satisfaction. Dans des enquêtes menées auprès de ses utilisateurs, l'entreprise rapporte qu'une majorité de développeurs déclarent se sentir plus concentrés, moins fatigués par les tâches ingrates et plus à l'aise pour rester dans le fil de leur travail. Ces déclarations, subjectives par nature, complètent utilement les mesures de temps : la valeur d'un assistant ne se réduit pas à la vitesse, elle tient aussi à la charge mentale qu'il allège.

La question des licences et du droit d'auteur

L'arrivée de Copilot a soulevé une interrogation sérieuse, qu'il serait malhonnête de passer sous silence. Le modèle Codex a été entraîné sur d'immenses volumes de code public, dont une large part est soumise à des licences open source assorties de conditions, par exemple l'obligation de citer l'auteur ou de conserver la mention de licence. Une partie de la communauté a posé une question de fond : lorsque l'assistant restitue des fragments proches de code existant, sans en indiquer l'origine ni la licence, respecte-t-il les droits des auteurs de ce code d'entraînement ?

Cette interrogation s'est traduite sur le terrain judiciaire. En novembre 2022, une action collective est engagée aux États-Unis contre GitHub, Microsoft et OpenAI, à l'initiative du programmeur et juriste Matthew Butterick, avec le cabinet Joseph Saveri. Les plaignants reprochaient à Copilot d'avoir reproduit du code protégé sans attribution ni respect des licences. La procédure a connu un parcours contrasté : au fil des décisions, le juge fédéral Jon Tigar a écarté la plupart des demandes, jugeant notamment que les extraits produits par Copilot n'étaient pas suffisamment semblables aux codes des plaignants pour fonder une réclamation au titre de la loi sur le droit d'auteur numérique. Quelques griefs, portant sur des questions de contrat et de respect des licences, ont un temps subsisté avant que le contentieux ne se réduise encore.

Au-delà de l'issue juridique, ce débat a eu un mérite : il a obligé l'ensemble du secteur à clarifier ses pratiques. GitHub a introduit un mécanisme de filtrage, activable par l'utilisateur, destiné à détecter les suggestions qui reproduisent des fragments de code public identifiables et à les bloquer, ou du moins à en signaler l'origine. Ce filtre de détection des correspondances s'appuie sur une comparaison entre la proposition générée et un index de code public, afin d'éviter qu'un extrait recopié presque à l'identique ne soit livré sans mention. Parallèlement, GitHub a ouvert aux organisations des réglages leur permettant de mieux encadrer le comportement de l'assistant au sein de leurs équipes.

Un autre volet de la réponse a touché aux données elles-mêmes. Les développeurs ont demandé, et progressivement obtenu, davantage de contrôle sur l'utilisation de leur code : possibilité de refuser que les extraits saisis dans l'éditeur servent à améliorer le modèle, engagements plus explicites sur la conservation des données, séparation entre l'usage individuel et l'usage en entreprise. Cette logique de retrait à la demande, où chacun peut soustraire sa contribution à certains traitements, s'est imposée comme une bonne pratique du secteur. Elle répond à une exigence légitime : celle de savoir ce que devient le code que l'on écrit, et de pouvoir en disposer.

La discussion sur la provenance des données d'entraînement, ouverte en grande partie par Copilot, irrigue depuis toute la réflexion sur l'IA générative, bien au-delà du seul code. Les questions posées à propos du logiciel — consentement des auteurs, attribution, respect des licences — se retrouvent, presque terme à terme, dans les débats sur le texte, l'image et le son. On peut y voir un effet secondaire fécond : une avancée technique a forcé une maturation collective sur la propriété intellectuelle à l'ère des grands modèles, et le terrain du code, précis et documenté, aura servi de laboratoire à cette réflexion plus large.

L'héritage : de l'autocomplétion aux copilotes et aux agents

Avec le recul de 2026, la préversion de juin 2021 apparaît comme le point de départ d'une lignée d'outils qui n'a cessé de s'enrichir. Copilot a moins été un aboutissement qu'une matrice, dont sont sortis des usages successifs de plus en plus ambitieux.

Du complètement à la conversation

La première extension majeure fut la conversation. En 2023, GitHub ajoute Copilot Chat, une interface de dialogue intégrée à l'éditeur, permettant de poser des questions sur le code, de demander une explication, de solliciter une correction ou une réécriture, sans quitter son environnement de travail. Cette capacité s'appuie sur des modèles plus récents et plus puissants que le Codex des débuts, à mesure que la génération d'assistants conversationnels prend son essor. On passe alors d'un assistant qui complète à un assistant avec lequel on échange.

Cette bascule est loin d'être anecdotique. La complétion en ligne restait un dialogue muet : le développeur écrivait, l'outil suggérait. Avec la conversation, l'interaction devient explicite. Le développeur peut demander « pourquoi cette fonction échoue-t-elle sur les entrées vides ? » ou « réécris ce bloc de façon plus lisible », et obtenir une réponse argumentée. L'assistant se rapproche alors d'un interlocuteur technique disponible en permanence, capable de raisonner sur le code existant.

Vers des espaces de travail et des agents

L'étape suivante a consisté à élargir le champ d'action, de la ligne de code au projet entier. En avril 2024, GitHub présente en préversion technique Copilot Workspace, un environnement conçu autour de l'IA où l'on part d'une demande formulée en langage naturel, par exemple une tâche à accomplir, pour que l'assistant propose un plan, esquisse les modifications à travers plusieurs fichiers, puis aide à les tester. Cette préversion a été arrêtée en mai 2025, mais son architecture, sa logique de passage d'une demande à une proposition de modification, et son découpage en sous-tâches ont été repris et refondus dans les briques ultérieures. Rien ne se perd : une expérimentation nourrit la suivante.

C'est ainsi qu'émerge la notion d'agent. Là où l'assistant classique répond à une sollicitation ponctuelle, un agent se voit confier un objectif et enchaîne de lui-même une série d'actions pour l'atteindre : explorer le dépôt, lire les fichiers liés, tracer les dépendances entre eux, proposer des modifications cohérentes sur plusieurs fichiers. En 2025, un mode agent apparaît, permettant une édition autonome à travers un projet. Cette autonomie encadrée déplace encore le curseur : le développeur passe de l'écriture ligne à ligne à la supervision d'un collaborateur logiciel auquel il délègue des tâches délimitées, tout en gardant la main sur la validation finale.

Un écosystème devenu pluriel

La dernière évolution notable tient à l'ouverture. Aux origines, Copilot reposait sur un unique modèle, le Codex d'OpenAI. Avec le temps, l'outil s'est ouvert à plusieurs familles de modèles, provenant de différents concepteurs, avec la possibilité de choisir celui qui convient le mieux à une tâche donnée, voire une sélection automatique. Cette pluralité reflète la maturation du domaine : le copilote n'est plus adossé à un moteur unique, mais devient un cadre capable d'orchestrer des modèles variés selon le besoin. Elle témoigne aussi d'un marché de l'assistance au code devenu foisonnant, où de nombreux acteurs proposent leurs propres approches.

Un marché devenu concurrentiel

Le succès de Copilot n'est pas resté sans réponse. Il a ouvert un marché entier, sur lequel se sont positionnés des acteurs aux stratégies distinctes. Plusieurs ont choisi de proposer, non plus une extension greffée sur un éditeur existant, mais un éditeur repensé autour de l'IA. Cursor, développé par la société Anysphere et lancé en 2023, illustre cette approche : il s'agit d'une variante de Visual Studio Code entièrement conçue pour placer l'assistance par IA au centre de l'expérience. Codeium, apparu dès 2022 comme complément d'autocomplétion gratuit pour de nombreux environnements, a pour sa part présenté fin 2024 son propre éditeur, Windsurf. Ces initiatives, citées ici à titre de repères factuels, montrent la vitalité d'un secteur né dans le sillage de Copilot.

Cette effervescence a un effet vertueux pour les développeurs : elle stimule l'innovation et élargit l'éventail des outils disponibles. Chaque acteur explore des choix différents — intégration plus ou moins profonde, modèles retenus, ergonomie de la conversation, degré d'autonomie des agents — et l'ensemble du domaine progresse par cette émulation. Copilot, en démontrant l'appétit du marché, a joué le rôle de catalyseur : il a rendu crédible une catégorie de produits qui, avant lui, relevait de l'expérimentation confidentielle.

Cette trajectoire, de la complétion en ligne de 2021 à l'écosystème de copilotes et d'agents de 2026, mérite qu'on la lise sans emphase excessive. Copilot n'a pas remplacé le développeur, et rien n'indique qu'il en prenne le chemin. Il a changé la texture du travail : moins de frappe répétitive, plus de conception et de relecture, une part croissante d'orchestration. Le métier se déplace vers l'énoncé clair du besoin, l'évaluation critique des propositions et l'assemblage réfléchi. En cela, l'esprit du binôme de programmation, revendiqué dès le premier jour, s'est révélé juste : Copilot occupe la place du second, celui qui suggère et relit, tandis que le développeur reste aux commandes.

Ce qu'on en retient, cinq ans après

Dans l'esprit de cette chronique, essayons un bilan pragmatique. Qu'est-ce que Copilot a réellement apporté, une fois retombée l'écume des annonces ?

D'abord, une popularisation. Avant lui, l'idée d'une IA écrivant du code appartenait à quelques laboratoires et à de rares outils confidentiels. Après lui, elle est devenue une attente ordinaire, au point que la plupart des éditeurs et des plateformes proposent désormais leur propre assistant. Copilot a joué le rôle de démonstrateur à grande échelle : il a prouvé qu'un modèle spécialisé, bien intégré, apportait une valeur d'usage réelle et immédiate.

Ensuite, une clarification. Le débat sur les licences et la provenance des données d'entraînement, qu'il a cristallisé, a fait progresser toute la réflexion sur l'IA générative. Les questions posées à propos du code valent aussi pour le texte, l'image ou le son. En affrontant ces questions tôt, sur un terrain circonscrit et technique, le domaine du développement a servi de laboratoire à des problématiques désormais générales.

Enfin, un déplacement du métier. Le développeur de 2026 n'écrit pas moins de logiciels qu'en 2021, mais il les écrit autrement. Il formule des intentions, arbitre entre des propositions, supervise des agents, relit avec exigence. La compétence centrale se recompose autour du jugement plutôt que de la seule maîtrise syntaxique. Copilot, en installant ce nouveau geste, a moins mécanisé le code qu'il n'a haussé le regard porté sur lui. Pour un outil présenté un jour d'été 2021 comme un simple compagnon de frappe, la portée aura été considérable.

Sources

• GitHub Blog — Introducing GitHub Copilot: your AI pair programmer (Nat Friedman, 29 juin 2021)
• GitHub Blog — GitHub Copilot is generally available to all developers (Thomas Dohmke, 21 juin 2022)
• GitHub Changelog — GitHub Copilot is now available to individual developers (21 juin 2022)
• OpenAI — Evaluating Large Language Models Trained on Code (article de recherche présentant Codex et HumanEval, arXiv)
• Peng, Kalliamvakou, Cihon, Demirer — The Impact of AI on Developer Productivity: Evidence from GitHub Copilot (arXiv, 2023)
• Wikipedia (EN) — GitHub Copilot (chronologie et faits recoupés)
• GitHub Copilot litigation — Joseph Saveri Law Firm & Matthew Butterick (dossier de l'action collective, nov. 2022)
• GitHub Blog — GitHub Copilot Workspace (préversion, avril 2024)