TECH : IA pour développeurs en 2026 — la carte du champ de bataille

Ceux qui demandent avant d’agir

Adak avoue une préférence. Parmi toutes les extensions de complétion de code, il utilise Cline le plus souvent. La raison qu’il donne mérite qu’on s’y arrête, parce qu’elle contient toute une éthique du travail. Cline demande avant de faire quoi que ce soit de destructeur. Il ne réécrit pas les fichiers en silence. Il vérifie avec l’humain d’abord. « Pour quelqu’un qui travaille sur du code de production, ça compte énormément », écrit-il. Cette phrase, en apparence banale, est une prise de position. Dans un paysage où les outils rivalisent d’autonomie, où la mode est à l’agent qui agit seul, choisir celui qui demande la permission relève presque de la résistance. C’est refuser que la machine soit maîtresse. C’est garder la main sur la gâchette. Et pourtant, cette prudence est présentée comme une préférence personnelle, presque une excentricité, alors qu’elle devrait être la norme. On a inversé les valeurs. L’outil qui obéit est devenu l’exception ; l’outil qui décide seul, la référence.

Continue prolonge cette logique de souveraineté : un assistant modulaire à code ouvert où l’on configure ses propres points de connexion aux modèles, où l’on garde son code totalement privé. Tabby va plus loin encore — serveur local auto-hébergé, tournant sur du matériel grand public, zéro télémétrie. Aucune donnée qui fuit. Rien qui remonte vers un serveur lointain. Tabnine défend la même forteresse avec son moteur de complétion axé sur la confidentialité, son exécution sur site, son ajustement fin sur les dépôts internes des équipes. Refact, à code ouvert lui aussi, combine refactorisation locale et entraînement de modèles personnalisés sur le code d’une équipe. Un fil rouge relie ces outils : la méfiance. La conscience qu’envoyer son code source vers les serveurs d’une entreprise, c’est lui offrir la matière première de son propre remplacement. Ces développeurs-là ont compris quelque chose que les autres refusent de voir.

La vraie liberté numérique tient en un mot : refuser que tout parte ailleurs.

Claude Code, Aider, et le retour au shell

Il y a une ironie magnifique dans cette catégorie. Au moment où tout se déplace vers des interfaces graphiques lisses, vers des éditeurs qui flottent et des navigateurs automatisés, une famille d’outils fait le chemin inverse. Elle retourne au terminal. Au shell nu. À la ligne de commande sans image, sans bouton, sans fioriture. Claude Code, l’outil officiel en ligne de commande d’Anthropic, exécute des fichiers locaux, lance des tests, gère les opérations Git avec un usage avancé des outils. Aider se présente comme un programmeur en ligne de commande conscient de Git, gérant les modifications multi-fichiers et validant automatiquement les changements à l’aide de formats de comparaison personnalisés. Pas de fenêtre. Pas de menu. Juste du texte qui répond au texte, du fichier qui se transforme, du dépôt qui se met à jour. Et pourtant, ce dépouillement n’est pas un recul. C’est une reconquête. Le terminal reste l’endroit où le développeur voit exactement ce qui se passe, ligne par ligne, sans couche d’abstraction qui masque la réalité. Là où l’éditeur agentique cache la mécanique derrière une interface rassurante, l’agent de terminal l’expose. Il oblige à comprendre.

Cline propose aussi sa version en ligne de commande : un exécuteur multi-modèles qui lance des commandes shell et contrôle des navigateurs avec des limites définies par l’utilisateur. Des limites définies par l’utilisateur. Encore cette obsession du contrôle, cette insistance à garder l’humain aux commandes. RooCode fonctionne comme un assistant multi-modes opérant selon différents registres. Cette scène-là — celle des programmeurs de terminal — est peut-être la plus saine du paysage. Parce qu’elle assume la brutalité de l’outil. Elle ne prétend pas que coder est devenu magique. Elle dit : voici la machine, voici ce qu’elle fait, voici comment tu la surveilles. C’est moins séduisant qu’un éditeur qui devine tes pensées. C’est infiniment plus honnête. Et dans un métier où l’honnêteté technique devient rare, cette rugosité vaut de l’or.

Le terminal ne ment pas. C’est peut-être la dernière chose qui ne ment pas dans ce métier.

Vingt-sept applications, une seule question

Revenons à ce chiffre qui ouvre tout : 27 applications en 45 jours. Adak le présente comme une leçon. La leçon, dit-il, c’est que le paysage de l’outillage IA pour développeurs bouge à une vitesse folle et qu’il est réellement difficile de suivre. Mais il y a une autre leçon, tapie sous la première, qu’il ne formule pas et que nous devons formuler à sa place. Construire 27 applications en 45 jours, c’est en construire une tous les quarante heures. Une application tous les jours et demi. À ce rythme, que reste-t-il de l’artisanat ? Que reste-t-il de la pensée lente, de l’architecture mûrie, du choix pesé ? On produit vite. On produit beaucoup. Mais on produit quoi, exactement, et pour qui ? Et pourtant, personne ne pose la question du sens dans ces catalogues d’outils. On mesure la vitesse. On célèbre le volume. On oublie que la valeur d’un logiciel ne s’est jamais mesurée au temps qu’il a fallu pour le pondre.

Le vrai sujet de ce texte, celui qu’il n’ose pas nommer, c’est la métamorphose silencieuse du développeur en superviseur d’agents. Adak observe que des gens perdent du temps parce qu’ils ignorent qu’un outil existe : quelqu’un révise des demandes de fusion à la main pendant une semaine sans savoir que CodeRabbit existe, un autre écrit des schémas de base de données à la main quand Emergent le fait en quelques secondes, un troisième passe des jours sur une page d’accueil que v0 échafaude en une seule instruction. Ces exemples sont réels, utiles, généreux. Mais lisons-les à l’envers. Chacun décrit un savoir-faire humain rendu superflu par une machine. La révision de code, la conception de bases de données, la construction d’interfaces : trois compétences, trois métiers, trois expertises, aujourd’hui compressées en une instruction. L’outil libère du temps. La question interdite, c’est : du temps pour faire quoi, quand la machine fait déjà tout ?

On ne remplace jamais un développeur d’un coup. On le remplace une tâche à la fois, en souriant.

Ce que révèle la géographie des outils

Un détail dans le catalogue d’Adak mérite qu’on lève les yeux du code pour regarder la carte. Parmi les outils recensés figure CodeGeeX, décrit comme un outil de complétion multi-langages avec traduction automatique de code entre langages, hébergé sur un domaine chinois. Un seul nom, noyé dans une liste. Mais ce nom dit quelque chose d’immense. Les outils qui pensent le code du monde ne sont pas neutres. Ils sont ancrés quelque part, développés par quelqu’un, financés par un intérêt. Quand un développeur occidental confie sa base de code à un moteur de complétion, il faut savoir où cette base de code voyage, qui l’analyse, à quelle fin. La dépendance technologique n’est jamais qu’un enjeu de confort. C’est un enjeu de souveraineté. L’Occident a inventé la majorité de ces outils — Cursor, Windsurf, Zed, Claude Code, Copilot portent l’empreinte de la Silicon Valley et de ses satellites. Mais rien ne garantit que cette avance dure. La Chine construit ses propres agents, ses propres modèles, ses propres écosystèmes fermés.

C’est pourquoi la préférence d’Adak pour les outils à code ouvert, auto-hébergés, sans télémétrie, dépasse la simple hygiène technique. Continue, Tabby, Refact, Tabnine dans sa version sur site : ces outils incarnent une résistance. Celle de garder la maîtrise de l’infrastructure qui produit le code. Celle de ne pas offrir gratuitement, à des serveurs qu’on ne contrôle pas, la matière première de l’économie numérique. Et pourtant, la commodité pousse dans l’autre sens. Il est tellement plus simple de laisser l’outil infonuagique tout faire, d’accepter la télémétrie, de cliquer sur « autoriser ». La facilité est un anesthésiant. Elle endort la vigilance. Et pendant que les développeurs dorment sur leur confort, la carte du pouvoir technologique se redessine, ligne de code par ligne de code, dans des serveurs dont ils ignorent jusqu’à l’emplacement.

La commodité coûte toujours plus cher qu’elle ne le laisse croire. La facture arrive plus tard.

Trois cent mille jetons de contexte

Une donnée technique, dans le catalogue d’Adak, mérite d’être traduite pour qui ne code pas. Supermaven offre une fenêtre de contexte de 300 000 jetons pour une mémoire à longue portée de la base de code, avec une latence très basse. Trois cent mille jetons, cela veut dire que l’outil peut « garder en tête » l’équivalent de plusieurs livres de code simultanément. Il ne perd pas le fil. Il se souvient de ce que tu as écrit il y a mille lignes. Cette mémoire artificielle change la nature même du travail. Le développeur n’a plus besoin de tout retenir. La machine retient pour lui. GitHub Copilot propose des suggestions en ligne en temps réel à travers plusieurs onglets ouverts, en s’appuyant sur des modèles OpenAI personnalisés. Amazon Q Developer agit comme un auditeur de code conscient de l’infonuagique, gérant les mises à niveau Java et Python et le déploiement de services Amazon Web Services.

Chacun de ces outils délègue un morceau de l’esprit humain à la machine : la mémoire pour Supermaven, la vigilance pour Amazon Q, l’anticipation pour Copilot. Pris séparément, chaque délégation semble anodine, presque bénéfique. Qui refuserait une meilleure mémoire ? Qui cracherait sur un auditeur infatigable ? Et pourtant, additionnées, ces délégations dessinent un développeur amputé, qui ne retient plus, ne vérifie plus, n’anticipe plus par lui-même. Un développeur qui, privé de ses outils, se retrouverait démuni comme un pianiste à qui l’on aurait retiré les doigts. La question n’est pas de refuser ces outils — ce serait absurde et perdant. La question est de savoir lesquelles de nos facultés nous acceptons de perdre, et lesquelles nous jurons de garder vivantes, coûte que coûte, par simple discipline, par simple refus de l’atrophie.

Une mémoire qu’on n’exerce plus n’est pas augmentée. Elle est morte, simplement remplacée.

Quand la machine corrige la machine

Le catalogue d’Adak recense une catégorie particulièrement révélatrice : les outils qui réparent le code produit par d’autres outils. Sourcery agit comme un linteur de code instantané qui refactorise automatiquement selon les patrons de conception modernes. Sweep indexe le dépôt et génère des demandes de fusion complètes ciblant les rapports de bogues et les demandes de fonctionnalités. Blackbox AI propose de la génération de code en temps réel avec des citations vers les dépôts sources publics. On assiste à l’émergence d’une chaîne où une machine écrit, une deuxième vérifie, une troisième corrige, une quatrième documente. L’humain, dans cette chaîne, occupe une place de plus en plus étroite. Il devient l’arbitre final d’un processus qu’il ne conduit plus. Cette configuration a un nom qu’on évite de prononcer : l’usine. Une chaîne de production où chaque poste est tenu par un automate, et où l’ouvrier ne fait plus qu’appuyer sur le bouton de validation en bout de ligne.

Le détail des citations de Blackbox vers les dépôts sources publics soulève d’ailleurs une question que le texte effleure sans la creuser : d’où vient le code que ces machines produisent ? Il vient du code écrit par des humains, absorbé, digéré, recraché. Chaque suggestion est bâtie sur le travail antérieur de milliers de développeurs qui, eux, ne toucheront jamais un centime de la valeur produite. Et pourtant, cette question — celle de la propriété, du crédit, de la juste rétribution du travail intellectuel qui a nourri ces modèles — reste hors champ dans la quasi-totalité des catalogues d’outils. On célèbre la sortie sans jamais interroger l’entrée. On admire la magie sans demander qui a fourni le lapin et le chapeau. La transparence de Blackbox, qui cite ses sources, est louable précisément parce qu’elle est rare. Elle rappelle une vérité que l’industrie préfère taire : rien ne se crée, tout se recycle, et quelqu’un, quelque part, a écrit l’original.

La machine ne crée rien. Elle redistribue le travail des morts et des vivants sans leur demander.

L’angle mort de la fatigue humaine

Il faut saluer le geste d’Adak. Compiler ce catalogue représente un travail honnête, généreux, utile à des milliers de développeurs qui, effectivement, perdent du temps faute de connaître les bons outils. Le texte est clair, organisé, sans esbroufe. « Pas de remplissage. Juste les outils, leurs sites, et ce qu’ils font », promet-il. Il tient sa promesse. Mais un catalogue, par nature, ne peut pas dire ce qu’il ne contient pas. Et ce qui manque ici, c’est l’humain qui utilise ces outils. Sa fatigue. Son angoisse de l’obsolescence. Le sentiment croissant, chez beaucoup de développeurs, de courir derrière un train qui accélère sans eux. Le vrai coût de cette révolution ne se mesure pas en outils appris, mais en nuits blanches à les apprendre. Adak lui-même lit des readme à deux heures du matin. Cette confession, glissée en ouverture, est peut-être le passage le plus honnête du texte. Elle dit la vérité derrière la vitrine.

Car voici ce que les listes d’outils masquent : chaque nouvel outil est une nouvelle chose à apprendre, une nouvelle interface à maîtriser, une nouvelle documentation à digérer. La promesse de gagner du temps engendre paradoxalement une nouvelle forme de travail — celui, sans fin, de se tenir à jour. Et pourtant, on présente toujours l’outil comme un allègement, jamais comme une charge supplémentaire. On oublie que derrière chaque « ça vous fait gagner des heures » se cache un « à condition d’avoir passé des heures à l’apprendre ». Le développeur de 2026 n’est pas libéré. Il est enrôlé dans une course permanente où s’arrêter, ne serait-ce qu’un trimestre, signifie prendre du retard. La technologie promettait de nous rendre le temps. Elle nous a rendus esclaves de la veille technologique. Voilà le prix que les catalogues taisent.

On nous vend du temps gagné. On nous facture une vigilance qui ne dort jamais.

Deux visions, un même pari sur l’autonomie

Au cœur du catalogue, deux noms reviennent comme des totems : Cursor et Windsurf. Ils incarnent la pointe avancée de ce que le texte appelle les environnements natifs à l’IA. Cursor a fait le choix de la continuité — dériver de Visual Studio Code, l’éditeur le plus utilisé au monde, pour ne pas dépayser le développeur tout en injectant une conscience de la base de code entière et une indexation en arrière-plan. Windsurf a fait le choix de la rupture — son agent Cascade ne se contente pas de suggérer, il écrit, il teste, il répare de manière proactive. L’un rassure, l’autre bouscule. Mais tous deux parient sur la même chose : l’autonomie croissante de la machine. Adak le dit sans ambages : ces outils font tourner des agents en arrière-plan capables de modifier des fichiers pendant que le développeur réfléchit. C’est la définition même d’un métier en mutation.

Ce duel dépasse la simple rivalité commerciale. Il fixe le curseur de ce qui sera considéré comme normal demain. Si Windsurf gagne, la norme deviendra l’agent proactif, celui qui agit sans qu’on le lui demande. Si Cursor l’emporte, la norme restera l’assistance augmentée, où l’humain garde l’initiative. Et pourtant, la tendance de fond, celle qu’aucun de ces outils ne peut inverser seul, pousse vers toujours plus d’autonomie. Google Antigravity, avec son automatisation de navigateur et sa planification de tâches autonome, montre déjà la direction. Le développeur qui lit ce catalogue en 2026 ferait bien de comprendre que le choix entre Cursor et Windsurf n’est pas un choix d’outil. C’est un choix de posture face à sa propre profession. Rester le maître, ou devenir le contremaître. Le texte d’Adak, en les plaçant côte à côte, pose sans le savoir la question la plus importante de la décennie.

Choisir son éditeur, en 2026, c’est choisir combien de son métier on accepte encore de faire soi-même.

Prototyper sans jamais toucher sa machine

Une phrase d’Adak résume à elle seule une transformation profonde : Replit est probablement le meilleur endroit pour prototyper quelque chose rapidement sans toucher sa machine locale du tout. Sans toucher sa machine du tout. Autrefois, coder signifiait s’asseoir devant son ordinateur, ouvrir son environnement, compiler localement, voir la machine chauffer. Aujourd’hui, tout se passe ailleurs — dans un nuage, sur des serveurs distants, dans des espaces de travail virtuels sans serveur dédié où un agent autonome complet exécute le code. L’ordinateur physique du développeur devient une simple fenêtre vers une puissance qui réside ailleurs. Le lieu du travail s’est dématérialisé au point de disparaître. Cette délocalisation totale a des avantages évidents : puissance illimitée, collaboration instantanée, aucune configuration locale. Zed lui-même mise sur le codage multijoueur natif, cette possibilité de travailler à plusieurs mains sur le même fichier en temps réel.

Mais cette dématérialisation a un revers que le catalogue ne mentionne pas. Quand ton environnement de travail vit sur les serveurs d’une entreprise, tu ne possèdes plus ton outil de production. Tu le loues. Et ce qui se loue peut se reprendre. Un changement de tarif, une modification des conditions d’utilisation, une panne, une décision géopolitique, et le développeur se retrouve coupé de son propre travail. Et pourtant, l’attrait de la commodité balaie ces prudences. On préfère la fluidité du nuage à la souveraineté de la machine locale. C’est là que les outils auto-hébergés comme Tabby reprennent tout leur sens : ils rappellent qu’il existe une autre voie, celle de la possession réelle de son infrastructure. Entre le confort du nuage et l’indépendance du local, chaque développeur trace, souvent sans y penser, la frontière de sa propre autonomie. Le catalogue d’Adak dresse la carte. À chacun de choisir de quel côté il veut vivre.

Louer son outil de travail, c’est confier à un autre le droit de te licencier sans préavis.

Une éthique enfouie dans une préférence

Revenons, pour finir de creuser, à ce que je considère comme le passage le plus important de tout le texte d’Adak. Ce n’est pas une donnée spectaculaire. Ce n’est pas un chiffre à sept zéros. C’est une phrase modeste sur son outil préféré : « il demande avant de faire quoi que ce soit de destructeur. Il ne va pas simplement réécrire tes fichiers en silence. Il vérifie avec toi d’abord. » Dans cette phrase se cache toute une philosophie du rapport entre l’humain et la machine. Elle affirme que la meilleure intelligence artificielle n’est pas la plus autonome, mais la plus respectueuse de la décision humaine. Elle inverse la hiérarchie dominante. Là où l’industrie court vers l’agent qui agit seul, Adak préfère celui qui consulte. Là où la mode célèbre le silence efficace de la machine, il valorise le dialogue avant l’action.

Cette préférence n’est pas de la timidité. C’est de la sagesse acquise sur le terrain, dans le code de production où une erreur coûte cher, où un fichier réécrit en silence peut faire tomber un service entier. Adak a construit ses 27 applications, il a vu la machine à l’œuvre, et sa conclusion la plus profonde n’est pas « utilisez l’outil le plus puissant » mais « utilisez celui qui vous laisse maître ». Et pourtant, combien retiendront cette leçon parmi tous les développeurs qui parcourront ce catalogue en quête du dernier outil à la mode ? La tentation de la puissance brute est forte. L’agent qui fait tout, tout seul, très vite, séduit immédiatement. Il faut de l’expérience, et un peu de cicatrices, pour comprendre que la vraie force réside dans le contrôle conservé. Cette leçon-là ne se trouve dans aucune fiche technique. Elle se paie en pannes, en nuits de débogage, en confiance trahie par une machine trop zélée.

L’outil qui demande la permission n’est pas faible. Il est le seul qui respecte encore l’humain.

Ce que la vitesse ne remplacera jamais

Le catalogue d’Aniruddha Adak restera utile bien après que la moitié des outils qu’il recense auront disparu, fusionné ou changé de nom. Parce que sa vraie valeur n’est pas dans la liste. Elle est dans le geste : celui d’un développeur qui prend le temps de cartographier le chaos pour ses pairs, gratuitement, honnêtement. Ce geste-là — la transmission, le partage du savoir, l’aide au collègue qui perd son temps faute de connaître le bon outil — aucune intelligence artificielle ne le remplacera. Parce qu’il repose sur quelque chose que la machine n’a pas : le souci de l’autre. La technologie accélère. L’humanité, elle, se transmet. Voilà la ligne de partage. Les outils changeront. Cursor, Windsurf, Zed, Claude Code seront peut-être oubliés dans trois ans, remplacés par d’autres noms, d’autres promesses. Mais le développeur qui aura gardé la main sur sa décision, qui aura refusé de tout déléguer, qui aura choisi ses outils au lieu de les subir, celui-là traversera les révolutions successives sans se perdre.

Le vrai enseignement de ce texte tient en une tension jamais résolue : entre la vitesse offerte par la machine et le contrôle conservé par l’humain. Adak, à travers sa préférence pour Cline, à travers sa méfiance envers les outils qui agissent en silence, penche du côté du contrôle. C’est un choix. C’est presque un acte de foi dans la valeur irremplaçable du jugement humain. Et pourtant, la pente naturelle du secteur pousse dans l’autre sens, vers toujours plus d’autonomie, toujours plus de délégation, toujours moins d’humain dans la boucle. Alors la question qui reste ouverte, celle qu’aucun catalogue ne pourra jamais fermer, est la suivante : quand la machine saura tout faire, seule, mieux, plus vite — que restera-t-il au développeur, sinon de décider s’il accepte encore d’appuyer sur le bouton ? Ce bouton, aujourd’hui, existe encore. Demain, il faudra se battre pour le garder.

Le dernier pouvoir du développeur n’est pas d’écrire du code. C’est de dire non à la machine qui prétend le faire à sa place.

Signé Jacques PJake Provost, chroniqueur