Cursor, Windsurf et l'essor des éditeurs de code pilotés par l'IA

En mars 2023, quatre anciens étudiants du MIT mettent en ligne un éditeur de code d'un genre nouveau. Baptisé Cursor et bâti par la jeune société Anysphere, il ressemble à s'y méprendre à l'outil que des millions de développeurs utilisent déjà — Visual Studio Code — mais avec un modèle de langage cousu au cœur de l'expérience. La même semaine, presque au même moment, OpenAI présente GPT-4 et Anthropic ouvre l'accès à Claude. Ce n'est pas un hasard de calendrier : une génération de modèles bien plus capables venait de rendre praticable une idée qui trottait depuis des années dans la tête des ingénieurs. Faire de l'IA non plus un correcteur discret en marge du code, mais un partenaire d'écriture installé au centre de l'atelier. Vingt mois plus tard, fin 2024, un second acteur, Windsurf (né chez Codeium), pousse la logique un cran plus loin avec un agent nommé Cascade. Ensemble, ces deux outils incarnent un basculement discret mais profond : le passage de la complétion de code à l'édition assistée par des agents.

Cet article retrace cette histoire de fond. D'où venaient ces éditeurs, sur quelles briques ils se sont appuyés, ce qu'ils ont concrètement changé dans le geste de programmer, et comment on relit leur trajectoire avec le recul de mi-2026 — croissance fulgurante de l'un, saga de rachat spectaculaire pour l'autre. Le but n'est pas de célébrer un champion, mais de comprendre un déplacement de fond qui touche le métier de développeur, et d'en tirer les enseignements utiles pour qui met ces outils en production.

Ce que c'était : un éditeur où l'IA prend le volant

Pour saisir la rupture, il faut partir de l'objet lui-même. Un éditeur de code, c'est le logiciel dans lequel un développeur passe ses journées : il y écrit, y lit, y navigue, y corrige. Depuis les années 2000, cette catégorie était dominée par des outils matures — Visual Studio, IntelliJ, puis Visual Studio Code, publié par Microsoft en 2015 et devenu en quelques années l'éditeur le plus répandu au monde selon les enquêtes annuelles Stack Overflow Developer Survey. L'assistance intelligente y existait déjà, sous forme de complétion : à mesure qu'on tapait, l'outil suggérait la suite d'un nom de variable ou d'une fonction, à partir d'une analyse syntaxique du projet.

Cursor et Windsurf changent la nature de cette assistance. Tous deux sont des forks de VS Code — c'est-à-dire des copies du code source de l'éditeur, modifiées et republiées sous une nouvelle identité. Ce choix technique n'est pas anodin : il offre d'emblée une interface familière, tout l'écosystème d'extensions de VS Code, et la liberté d'intégrer l'IA bien plus profondément qu'une simple extension ne le permettrait. Là où un greffon reste cantonné aux points d'entrée que l'éditeur veut bien lui exposer, un fork peut reprogrammer le cœur de l'expérience.

Trois gestes nouveaux

Concrètement, qu'est-ce que ces éditeurs savent faire que les précédents ne faisaient pas ? On peut résumer la nouveauté à trois gestes.

• Éditer en langage naturel. On sélectionne un bloc de code, on décrit en français ou en anglais la transformation souhaitée — « rends cette fonction asynchrone », « ajoute la gestion des erreurs » — et l'éditeur réécrit le code sur place, en montrant les modifications à valider.
• Travailler sur plusieurs fichiers à la fois. Une demande comme « renomme ce concept partout dans le projet » ou « ajoute cette colonne du formulaire à la base et à l'API » suppose de toucher à plusieurs fichiers cohérents entre eux. Ces éditeurs lisent le contexte du dépôt entier et proposent un ensemble de changements coordonnés.
• Déléguer à un agent. Au-delà de l'édition ponctuelle, on peut confier une tâche à un agent qui décompose le travail, lit les fichiers pertinents, exécute des commandes, observe le résultat et itère — en gardant le développeur dans la boucle de validation.

Ce troisième geste est le plus structurant. Il marque le passage d'un outil qui suggère à un outil qui agit, sous supervision. C'est précisément le sens du mot « agentique » qui revient sans cesse dans le vocabulaire de cette période : un système qui ne se contente pas de répondre, mais qui enchaîne des actions pour atteindre un objectif.

Le contexte : Copilot avait ouvert la voie, les modèles ont suivi

Cursor et Windsurf n'ont pas surgi d'un vide. Ils sont l'aboutissement d'une lignée d'outils et d'une maturation des modèles qui, ensemble, ont rendu leur promesse crédible. Deux jalons méritent qu'on s'y attarde.

2021 : GitHub Copilot défriche le terrain

Le premier déclencheur remonte à l'été 2021. Le 29 juin 2021, GitHub présente Copilot en préversion technique, un « programmeur en binôme » propulsé par OpenAI Codex — une version spécialisée du modèle GPT-3, entraînée sur d'immenses volumes de code public. Copilot s'installe comme extension de VS Code et suggère, à la volée, des lignes ou des fonctions entières à partir du contexte. La disponibilité générale suit le 21 juin 2022. Pour la première fois à cette échelle, un modèle de langage aidait des millions de développeurs à écrire du code, et non plus seulement du texte.

Copilot a prouvé deux choses. D'une part, que la complétion pilotée par un grand modèle apportait un gain de productivité tangible et adopté massivement. D'autre part — et c'est ce qui a ouvert un espace à Cursor et Windsurf — qu'une extension restait bridée : elle vivait dans les marges de l'éditeur, sans pouvoir réorganiser l'expérience autour de l'IA. L'étape suivante logique était de repenser l'éditeur lui-même.

Mars 2023 : une génération de modèles change la donne

Le second déclencheur est l'arrivée, en mars 2023, de modèles nettement plus capables. Le 14 mars 2023, OpenAI publie GPT-4, présenté comme un saut de fiabilité et de finesse par rapport à GPT-3.5, capable de suivre des instructions bien plus nuancées. Le même jour, Anthropic ouvre l'accès à Claude via son API, un assistant conçu pour être fiable et prévisible, à l'aise notamment sur les tâches de code. Cette coïncidence de dates n'est pas qu'anecdotique : elle signale qu'une frontière de capacité venait d'être franchie, simultanément, par plusieurs laboratoires.

La complétion pilotée par un grand modèle avait prouvé sa valeur ; il manquait des modèles capables de raisonner sur du code multi-fichiers pour passer de la suggestion à l'action. Mars 2023 a fourni cette pièce manquante.

C'est dans cette fenêtre précise que Cursor est lancé, en mars 2023 également. Le timing raconte tout : sans des modèles capables de comprendre un dépôt de code dans son ensemble et d'y proposer des modifications cohérentes, l'idée d'un éditeur « agentique » serait restée un prototype de laboratoire. Les modèles de mars 2023, puis leurs successeurs des mois suivants, ont transformé cette idée en produit utilisable au quotidien.

Cursor : la complétion réinventée, puis l'agent

Anysphere, la société derrière Cursor, est fondée début 2022 par quatre camarades du MIT — Michael Truell, Sualeh Asif, Arvid Lunnemark et Aman Sanger — au parcours marqué par les olympiades de mathématiques et d'informatique, et des passages chez Google, Stripe ou Jane Street. Leur pari : ne pas ajouter de l'IA à un éditeur existant, mais forker VS Code pour construire un éditeur où l'IA est le principe organisateur.

Une adoption qui s'emballe

Le produit trouve son public avec une rapidité peu commune. Après un premier tour d'amorçage de 8 millions de dollars mené par l'OpenAI Startup Fund en octobre 2023, Cursor enchaîne les levées et, surtout, les paliers de revenu. Les chiffres publiés donnent le vertige : environ 100 millions de dollars de revenu annualisé en janvier 2025, 500 millions en juin 2025, un milliard en novembre 2025. Cette trajectoire fait de Cursor l'une des ascensions commerciales les plus rapides jamais observées dans le logiciel d'entreprise.

Les valorisations suivent le même rythme : une série C de 900 millions de dollars menée par Thrive Capital en juin 2025 valorise l'entreprise autour de 9,9 milliards, une série D de 2,3 milliards en novembre 2025 la porte à quelque 29,3 milliards. Ces montants sont spectaculaires, mais l'important pour notre propos est ce qu'ils traduisent : une demande de fond pour ce type d'outil, et pas seulement un engouement passager.

De l'assistant à l'agent parallèle

Sur le plan des fonctionnalités, Cursor a d'abord brillé par une complétion contextuelle particulièrement fluide et une édition en langage naturel bien intégrée. Puis l'outil a suivi le mouvement général vers l'agentique. En octobre 2025, la version Cursor 2.0 introduit la possibilité de faire travailler plusieurs agents en parallèle, chacun isolé dans sa propre copie du dépôt — une manière de confier simultanément plusieurs pistes à l'IA sans qu'elles se marchent dessus. La même période voit apparaître Composer, un modèle maison orienté codage agentique. Le message est clair : l'édition ligne à ligne n'est plus qu'une porte d'entrée ; le cœur de la valeur se déplace vers la délégation de tâches structurées.

Windsurf : l'agent Cascade au centre de l'éditeur

Le second protagoniste vient d'une trajectoire différente. Codeium, société fondée en 2021, s'était d'abord fait connaître par une extension de complétion de code disponible sur de nombreux éditeurs. Le 13 novembre 2024, elle franchit le pas et publie son propre éditeur, Windsurf — lui aussi un fork de VS Code — présenté comme un environnement de développement « agentique ». En avril 2025, l'entreprise adopte définitivement le nom de sa vedette et devient Windsurf.

Cascade, ou l'agent conscient du dépôt

La pièce maîtresse de Windsurf, c'est Cascade, un agent installé au cœur de l'éditeur. Sa particularité tient à sa conscience du dépôt entier : Cascade ne raisonne pas seulement sur le fichier ouvert, mais sur l'ensemble du projet. On peut lui demander d'ajouter une fonctionnalité, de corriger une anomalie répartie sur plusieurs fichiers, de restructurer un module ou d'écrire des tests ; il lit les fichiers concernés, applique les modifications et explique ce qu'il a fait. Windsurf a résumé cette ambition par une formule imagée : créer un « flow », une continuité fluide entre le développeur et l'IA, où l'agent agit sur le code au lieu de se contenter de le suggérer.

Windsurf s'est présenté comme « le premier IDE agentique » — une revendication marketing, mais qui capte bien le glissement de l'époque : d'un assistant qui répond à un agent qui exécute, sous la supervision du développeur.

Techniquement, Windsurf et Cursor partagent donc beaucoup : même socle VS Code, même conscience du dépôt, même bascule vers l'agentique. Leurs différences relèvent surtout de l'ergonomie et du dosage entre assistance et autonomie. L'essentiel est ailleurs : deux équipes, parties de points distincts, ont convergé vers la même vision de l'éditeur. C'est le signe d'une tendance de fond, pas d'une trouvaille isolée.

Comment ça marche, sous le capot

Une question revient chez les praticiens : par quel mécanisme un éditeur parvient-il à raisonner sur un projet entier, alors qu'un grand modèle ne peut ingérer qu'une quantité limitée de texte à la fois ? La réponse tient en trois idées simples, qu'il est utile de distinguer pour comprendre les forces et les limites de ces outils.

Trois niveaux d'assistance

Il faut d'abord séparer trois régimes de fonctionnement, souvent confondus sous le mot « IA ».

• La complétion en ligne. Un modèle prédit la suite du code à mesure qu'on tape, à partir du fichier courant et de quelques fichiers voisins. C'est le régime hérité de Copilot : rapide, discret, sans dialogue. Il excelle sur les tâches courtes et répétitives.
• Le chat contextuel. On dialogue avec le modèle dans un panneau latéral, en lui donnant accès à des fichiers ou à une sélection. Il explique, propose, réécrit un extrait. Le développeur reste maître du copier-coller et de l'application des changements.
• L'agent. On confie un objectif ; le système planifie, lit des fichiers, applique des modifications, lance parfois des commandes, observe et recommence. C'est le régime le plus autonome — et celui qui demande le plus de supervision.

Cursor et Windsurf offrent les trois, et c'est leur combinaison qui fait l'expérience. Un développeur bascule naturellement de l'un à l'autre selon la tâche : complétion pour dérouler un algorithme connu, chat pour comprendre un bout de code hérité, agent pour une modification transverse. Comprendre ces trois niveaux, c'est éviter deux écueils symétriques : sous-utiliser l'outil en restant à la complétion, ou lui déléguer aveuglément des tâches qui exigeraient un cadrage humain plus serré.

Le nerf de la guerre : le contexte

Le second mécanisme clé est la gestion du contexte. Un grand modèle raisonne dans une fenêtre limitée — un certain nombre de mots qu'il peut « voir » d'un coup. Or un projet réel compte souvent des centaines de milliers, voire des millions de lignes. Impossible de tout lui montrer. Ces éditeurs résolvent le problème par une forme d'indexation : ils analysent le dépôt en amont, en découpent le code en fragments, et retrouvent à la volée les portions pertinentes pour la demande en cours, qu'ils glissent dans la fenêtre du modèle. C'est ce mécanisme de récupération sélective qui donne l'illusion — utile — que l'agent « connaît » tout le projet.

La qualité d'un éditeur agentique se joue moins dans le modèle brut que dans sa capacité à sélectionner, au bon moment, les quelques fragments de code réellement utiles à la tâche. C'est un art de la pertinence autant qu'un art du modèle.

Cette architecture explique une bonne partie des réussites et des ratés observés en pratique. Quand le mécanisme de récupération pointe sur les bons fichiers, le résultat impressionne ; quand il rate le contexte pertinent, l'agent produit un code cohérent en apparence mais inadapté au reste du projet. C'est aussi pourquoi ces outils sont sensibles à l'organisation du code : un dépôt bien structuré, aux noms explicites, se prête mieux à cette récupération qu'un code opaque. L'IA amplifie les qualités d'une base de code — et en révèle les faiblesses.

Le rôle des modèles sous-jacents

Dernier point, souvent mal compris : ces éditeurs ne fabriquent pas nécessairement leurs propres modèles. Longtemps, ils se sont appuyés sur les modèles de tiers — ceux d'OpenAI, d'Anthropic et d'autres — accessibles par interface de programmation. Cette dépendance a une conséquence stratégique majeure, que la saga Windsurf illustrera : la relation entre un éditeur et les fournisseurs de modèles est à la fois vitale et fragile. Un éditeur dépend de la qualité, de la disponibilité et du coût des modèles qu'il intègre ; réciproquement, les fournisseurs de modèles voient dans ces éditeurs un canal de distribution précieux. De cette interdépendance naît une bonne part des tensions qui ont agité le secteur en 2025. Depuis, les principaux éditeurs ont commencé à développer leurs propres modèles orientés code — le Composer de Cursor en est un exemple — pour réduire cette dépendance et mieux maîtriser le compromis coût-qualité.

Ce que ça a changé : un nouveau geste de programmation

Au-delà des produits, qu'est-ce qui a réellement bougé dans la pratique ? Trois déplacements se dégagent, chacun mesurable dans le quotidien d'une équipe.

Du fichier au projet

Le premier changement est l'unité de travail. La complétion classique opérait à l'échelle de la ligne ou du fichier ouvert. L'édition assistée par agent opère à l'échelle du projet : elle lit le contexte de plusieurs fichiers, comprend leurs relations et propose des modifications coordonnées. Pour un développeur, cela déplace l'effort. Décrire précisément une intention et relire un ensemble de changements devient une part croissante du travail, au détriment de la frappe caractère par caractère.

De la syntaxe à l'intention

Le deuxième changement touche au langage de commande. Longtemps, dire à un ordinateur ce qu'il devait faire supposait une syntaxe précise. L'édition en langage naturel introduit une couche d'intention : on formule un objectif, l'outil propose une réalisation. Cela ne dispense pas de connaître la programmation — au contraire, il faut savoir lire et juger le code produit — mais cela abaisse le coût des tâches répétitives ou mécaniques, et libère de l'attention pour la conception.

De l'exécution à la supervision

Le troisième changement, le plus profond, concerne le rôle du développeur face à un agent. Quand une IA enchaîne des actions — lire, écrire, exécuter, corriger — le développeur devient en partie un superviseur : il cadre la tâche, relit les décisions, valide ou rejette. Cette posture rappelle celle d'un responsable technique qui délègue à un binôme junior compétent mais faillible. Elle appelle des réflexes nouveaux : décrire clairement une tâche, relire attentivement, tester systématiquement. Loin de disparaître, le jugement humain se déplace vers l'amont (la formulation) et l'aval (la vérification).

Il faut ici rester honnête sur les limites. Ces outils produisent parfois du code plausible mais incorrect ; ils peuvent introduire des anomalies subtiles, mal interpréter une intention, ou proposer une solution qui compile sans répondre au besoin réel. La supervision n'est pas une formalité : c'est le prix à payer pour bénéficier de la vitesse. Les équipes qui en tirent le meilleur parti sont celles qui ont adapté leurs pratiques de relecture et de test, plutôt que celles qui ont fait une confiance aveugle à la machine.

Une chronologie pour situer les jalons

Pour fixer les idées, le tableau ci-dessous récapitule les étapes vérifiées de cette histoire, de la préversion de Copilot aux mouvements de 2026.

Date	Événement
29 juin 2021	GitHub Copilot en préversion technique (propulsé par OpenAI Codex)
21 juin 2022	Copilot passe en disponibilité générale
Début 2022	Fondation d'Anysphere par quatre étudiants du MIT
14 mars 2023	GPT-4 (OpenAI) et Claude (Anthropic) ouverts le même jour
Mars 2023	Lancement de Cursor, fork de VS Code
13 nov. 2024	Codeium publie l'éditeur Windsurf et son agent Cascade
Janv. 2025	Cursor atteint ~100 M$ de revenu annualisé
Avril 2025	Codeium se rebaptise Windsurf
Mai 2025	OpenAI conclut un accord (~3 Md$) pour racheter Windsurf — non finalisé
11 juil. 2025	Google licencie la techno de Windsurf et recrute ses dirigeants (2,4 Md$)
14 juil. 2025	Cognition (Devin) rachète le reste de Windsurf
Oct. 2025	Cursor 2.0 (agents parallèles) et modèle Composer
Nov. 2025	Cursor franchit 1 Md$ de revenu annualisé ; valorisation ~29,3 Md$
16 juin 2026	SpaceX annonce le rachat d'Anysphere (~60 Md$, clôture prévue T3 2026)

L'héritage : croissance record et saga de rachat

Avec le recul de mi-2026, deux récits distincts se dessinent — l'un pour chaque protagoniste. Ils éclairent, chacun à sa manière, la valeur qu'a prise cette catégorie d'outils.

Cursor : une trajectoire commerciale hors norme

Du côté de Cursor, l'histoire est celle d'une adoption et de valorisations qui ont battu des records. Après le milliard de revenu annualisé atteint fin 2025 et une valorisation d'environ 29,3 milliards de dollars, un rebondissement majeur survient au printemps 2026. Le 16 juin 2026, SpaceX annonce le rachat d'Anysphere pour environ 60 milliards de dollars en actions, une opération décrite par la presse comme l'une des plus importantes jamais réalisées sur une entreprise financée par capital-risque. La clôture est attendue au troisième trimestre 2026, sous réserve des approbations réglementaires. Ce montant doit se lire avec la prudence d'usage — une annonce n'est pas une transaction finalisée — mais il donne la mesure de l'intérêt stratégique que suscite désormais l'outillage des développeurs.

Windsurf : une saga de rachat révélatrice

Le parcours de Windsurf, lui, est plus mouvementé, et sans doute plus riche d'enseignements sur l'écosystème. En mai 2025, la presse rapporte qu'OpenAI a conclu un accord d'environ 3 milliards de dollars pour acquérir Windsurf. Cet accord n'est jamais finalisé. À la mi-juillet 2025, il se défait, sur fond de tensions entre acteurs du secteur — la relation d'OpenAI avec Microsoft, qui aurait eu accès à la propriété intellectuelle de Windsurf, ayant notamment pesé selon les comptes rendus de presse.

La suite se joue en quelques jours. Le 11 juillet 2025, Google annonce recruter le cofondateur et dirigeant de Windsurf, Varun Mohan, ainsi que plusieurs responsables clés, et licencier une partie de la technologie, pour un total d'environ 2,4 milliards de dollars. Trois jours plus tard, le 14 juillet 2025, la société Cognition — créatrice de l'agent de développement Devin — annonce racheter le reste de Windsurf : produit, marque, propriété intellectuelle et équipes restantes, avec Jeff Wang comme dirigeant par intérim. En moins d'une semaine, une seule entreprise s'est ainsi retrouvée découpée entre trois acteurs.

La saga Windsurf montre à quel point l'outillage des développeurs est devenu un terrain stratégique : en 2025, un éditeur de code pouvait susciter l'intérêt simultané d'OpenAI, Google, Anthropic, Microsoft et Cognition.

Il faut souligner que ces épisodes de rachat, par leur rapidité et leur complexité, ont été relatés par la presse à partir de sources parfois anonymes. Les grandes lignes — accord OpenAI non finalisé, opération Google, reprise par Cognition — sont solidement corroborées par plusieurs médias de référence ; certains montants précis, en revanche, méritent d'être lus comme des ordres de grandeur rapportés plutôt que comme des chiffres officiels et définitifs.

Un mot nouveau pour un usage nouveau

Signe que le geste s'est ancré dans la culture des développeurs : un vocabulaire est né pour le nommer. En février 2025, le chercheur Andrej Karpathy popularise sur les réseaux l'expression « vibe coding » pour décrire une manière de programmer où l'on formule ses intentions en langage naturel et où l'on laisse le modèle produire le code, en le guidant par le dialogue plutôt qu'en l'écrivant soi-même. Le terme connaît une diffusion fulgurante : le dictionnaire Merriam-Webster le référence dès mars 2025 comme expression tendance, et le Collins English Dictionary en fait son mot de l'année 2025.

Ce succès lexical mérite une lecture nuancée. Il traduit une réalité — l'édition en langage naturel est devenue assez fiable pour qu'un usage décomplexé s'installe — sans dispenser de prudence. Karpathy lui-même décrivait un mode où « l'on oublie que le code existe » : formule séduisante pour du prototypage rapide, mais qui ne saurait tenir lieu de méthode pour du logiciel destiné à la production. Le « vibe coding » brille sur les maquettes et les scripts jetables ; sur un système critique, la relecture et les tests restent la règle. Le mot capte bien l'esprit d'une époque, à condition de ne pas confondre l'aisance du geste avec la garantie du résultat.

Une catégorie qui s'installe

Par-delà les péripéties financières, l'héritage le plus durable est ailleurs. Cursor et Windsurf ont établi une catégorie : l'éditeur de code où l'IA agentique est le principe central, et non un ajout. Les acteurs historiques ont suivi. GitHub Copilot, initialement cantonné à la complétion, a intégré la conversation puis des capacités d'agent, et permet désormais de choisir parmi plusieurs modèles, dont Claude. Cette diffusion large est le vrai signe qu'une idée s'est imposée : quand les pionniers et les mastodontes convergent vers le même modèle d'usage.

À cette même période, une autre approche a gagné du terrain : celle des agents de développement pilotés depuis un terminal ou en autonomie, comme l'agent de codage d'Anthropic — un sujet que ce média traite dans un article dédié, et que l'on cite ici seulement pour situer le paysage. Éditeurs augmentés d'un côté, agents autonomes de l'autre : deux familles complémentaires, nées de la même maturation des modèles, qui redéfinissent ensemble l'atelier du développeur.

En production : ce que ces outils demandent aux équipes

Puisque cette chronique s'intéresse à ce qui se passe une fois le prototype dépassé, terminons par le terrain. Adopter un éditeur piloté par l'IA n'est pas un geste anodin pour une équipe : cela réorganise des pratiques établies. Quelques repères se dégagent de cette première vague d'adoption.

• La relecture devient centrale. Plus l'IA produit de code vite, plus la relecture humaine est le goulet — et le garde-fou. Les équipes qui réussissent renforcent leurs processus de revue plutôt que de les alléger.
• Les tests automatisés prennent de la valeur. Un agent qui modifie plusieurs fichiers a besoin d'un filet de sécurité. Une bonne couverture de tests transforme la vitesse de l'IA en gain net, sans laisser passer de régressions.
• La formulation devient une compétence. Décrire clairement une tâche, borner son périmètre, préciser les contraintes : ce savoir-faire conditionne directement la qualité du résultat.
• La confidentialité se pense en amont. Ces outils envoient du contexte de code à des modèles distants. Les organisations sensibles doivent examiner les options de déploiement, les politiques de traitement des données et les configurations qui limitent ce qui est transmis.

Rien de tout cela n'est propre à Cursor ou à Windsurf : ce sont les exigences génériques d'un flux de travail où une IA agentique intervient sur le code. Les nommer, c'est reconnaître que l'outil ne remplace pas la discipline d'ingénierie — il la déplace et, bien employé, la valorise.

La question du coût, vue du côté de l'exploitation

Un aspect passe souvent au second plan dans l'enthousiasme : ces outils ont un coût d'exploitation. Chaque suggestion, chaque tour d'agent, sollicite un modèle, et cette sollicitation se paie — en abonnement pour l'utilisateur, en dépenses d'inférence pour l'éditeur. Un agent qui itère sur une tâche complexe peut consommer beaucoup de ressources de calcul, car il enchaîne les allers-retours avec le modèle. Pour une organisation qui déploie ces outils à l'échelle de dizaines ou de centaines de développeurs, la maîtrise de cette dépense devient un sujet de gestion à part entière : arbitrer entre modèles plus rapides et modèles plus fins selon les tâches, plafonner certains usages, mesurer le retour réel sur les temps de développement.

Cette économie de l'inférence éclaire d'ailleurs la course aux modèles maison évoquée plus haut. En développant leurs propres modèles orientés code, les éditeurs cherchent à faire baisser leur coût marginal par requête, à réduire leur dépendance à des fournisseurs tiers et à ajuster finement le compromis entre vitesse, qualité et dépense. Pour un responsable d'infrastructure, c'est un signal utile : la valeur de ces outils ne se mesure pas seulement à leur confort d'usage, mais à leur efficacité par unité de calcul consommée — un critère promis à gagner en importance à mesure que l'adoption se généralise.

Mesurer plutôt que croire

Enfin, la posture qui distingue les équipes matures est la mesure. L'intuition d'un gain de productivité ne suffit pas à piloter une adoption. Suivre des indicateurs concrets — temps de cycle d'une tâche, taux de code généré effectivement conservé après relecture, fréquence des anomalies introduites, satisfaction des développeurs — permet de calibrer l'usage et d'éviter deux excès : le rejet de principe et l'adoption sans discernement. Ces outils rendent des services réels et documentés ; les objectiver, c'est se donner les moyens d'en tirer un bénéfice durable plutôt qu'un effet de mode.

Ce qu'il faut retenir

L'histoire de Cursor et de Windsurf tient en une phrase : entre 2023 et 2025, l'éditeur de code est passé d'un outil qui suggère à un atelier où des agents agissent sous supervision. Ce basculement n'a pas été décrété ; il a été rendu possible par la conjonction d'un précurseur qui avait défriché le terrain — GitHub Copilot, dès 2021 — et d'une génération de modèles, arrivée en mars 2023, capable de raisonner sur des projets entiers.

Ce qui frappe, avec le recul, ce n'est pas tant la performance d'un produit particulier que la convergence de plusieurs équipes vers la même vision, et l'ampleur de l'intérêt qu'elle a suscité — au point de nourrir des rachats parmi les plus commentés de la période. Pour un développeur ou un responsable technique, l'enseignement est pragmatique : ces outils accélèrent réellement le travail, à condition d'adapter en conséquence les pratiques de relecture, de test et de formulation. La bonne question n'est pas de savoir quel éditeur l'emportera, mais comment intégrer sereinement l'édition agentique dans un flux de production fiable. C'est là, au fond, que se joue la valeur — non dans la promesse, mais dans la mise en œuvre.

Sources

Cet article s'appuie sur des sources publiques vérifiées. Les faits et dates ont été recoupés ; les montants de rachat 2025-2026, rapportés par la presse, sont donnés comme ordres de grandeur.

• GitHub Blog, « Introducing GitHub Copilot: your AI pair programmer » (29 juin 2021) — github.blog.
• Wikipedia, « GitHub Copilot » (préversion, Codex, disponibilité générale, modèles) — en.wikipedia.org.
• TechCrunch, « OpenAI releases GPT-4 » (14 mars 2023) — techcrunch.com.
• Anthropic, « Introducing Claude » (14 mars 2023) — anthropic.com.
• Wikipedia, « Cursor (code editor) » (fondation Anysphere, lancement, levées, valorisations, revenus) — en.wikipedia.org.
• Contrary Research, « Cursor Business Breakdown & Founding Story » (fondateurs, mars 2023, fork VS Code) — research.contrary.com.
• Maginative, « Codeium launches Windsurf Editor, an Agentic IDE » (13 nov. 2024, Cascade) — maginative.com.
• DeepLearning.AI, The Batch, « Google, Cognition Carve Up Windsurf After OpenAI's Failed $3B Acquisition Bid » — deeplearning.ai.
• Fortune, « OpenAI's $3 billion deal with AI coding startup Windsurf collapses » (11 juil. 2025) — fortune.com.
• TechCrunch, « Cognition, maker of the AI coding agent Devin, acquires Windsurf » (14 juil. 2025) — techcrunch.com.
• TechCrunch, « SpaceX to acquire Cursor for $60B in stock » (16 juin 2026) — techcrunch.com.
• CNBC, « SpaceX to acquire the AI coding startup Cursor for $60 billion » (16 juin 2026) — cnbc.com.
• Wikipedia, « Vibe coding » (terme d'Andrej Karpathy, février 2025 ; reprises Merriam-Webster et Collins) — en.wikipedia.org.