Pendant longtemps, l’extensibilité des logiciels concernait surtout les utilisateurs avancés.
La plupart des gens utilisaient les logiciels tels qu’ils étaient livrés. Certains les personnalisaient à l’aide de réglages, de scripts, d’extensions, de thèmes ou de macros. D’autres, moins nombreux, les considéraient comme une plateforme à explorer et à adapter à leur manière de travailler.
Cette dernière approche restait limitée par le coût de la programmation. Même avec un bon système d’extensions, il fallait du temps, des compétences, de la documentation et la volonté d’entretenir le résultat. Afficher une information de type supplémentaire dans son éditeur, ajouter un bouton dans son navigateur ou créer un widget de bureau supposait d’écrire soi-même le code. Pour beaucoup, l’effort était trop important : l’idée restait sans suite.
Les agents de programmation changent la donne.
Cela ne signifie pas que tout le monde devient développeur professionnel. En revanche, beaucoup plus de personnes peuvent décrire l’outil dont elles ont besoin et demander à un agent d’en réaliser une première version. C’est particulièrement utile lorsque le logiciel est déjà conçu pour accueillir des extensions.
Une extension de navigateur qui résume les commentaires d’une publication Reddit ? Un widget GNOME qui affiche des conjugaisons françaises pendant vos révisions ? Une commande d’éditeur qui rassemble l’état d’un projet, ouvre le bon répertoire de travail Git et lance un agent avec des consignes structurées ? Ces projets personnels sont désormais à portée de main.
Ce ne sont ni des idées de start-up ni des produits destinés à être commercialisés. Ce sont de petits outils personnels, adaptés à un usage précis, que l’on renonçait souvent à développer parce que le bénéfice ne justifiait pas l’effort. Les agents de programmation réduisent fortement cet effort.

Les logiciels extensibles y gagnent en intérêt.
Face à un logiciel fermé, l’agent doit contourner les obstacles : automatiser l’interface, générer des fichiers à l’extérieur ou ajouter du code pour relier les outils. Cela suffit parfois, mais reste fragile. Les résultats sont meilleurs lorsque le logiciel offre de vrais points d’extension : interfaces de programmation documentées, points d’accroche stables, commandes automatisables, état consultable, événements et conventions claires.

Plus un logiciel permet d’explorer son fonctionnement, plus un agent peut y être utile.
C'est pour cela qu'Emacs me semble à nouveau moderne.
Emacs est assez ancien pour passer, selon les modes du développement logiciel, pour une pièce de musée. Pourtant, son principe fondateur me semble de plus en plus pertinent. Sa célèbre description le présente comme un éditeur « extensible, customizable, self-documenting » : extensible, personnalisable et doté d’une documentation accessible depuis l’outil lui-même.
Cette phrase est presque une spécification du type de logiciel qui fonctionne bien avec les agents de code.
Extensible : le logiciel est conçu pour être modifié. Personnalisable : chacun peut adapter ces modifications à ses besoins, sans attendre qu’une équipe produit en développe une version générale. Autodocumenté : le système donne suffisamment d’informations sur son propre fonctionnement pour qu’un utilisateur, et désormais un agent, sache comment intervenir.
Ce dernier point est souvent sous-estimé. La documentation ne sert pas seulement aux personnes qui lisent un manuel : les outils peuvent aussi l’exploiter. Si les commandes, variables, fonctions, raccourcis, modes et points d’accroche sont consultables, l’agent dispose de repères concrets. Il peut explorer ce qui existe, respecter les conventions locales et ajouter un comportement de la manière prévue par le logiciel.
J’ai moi-même constaté cette différence.
Il y a quelques années, lorsque le vérificateur de types Flow de Facebook était encore courant dans les projets JavaScript, je voulais afficher ses informations de type dans Emacs, via eldoc. L’idée était simple : voir le type à proximité du code. La réalisation l’était moins. Il fallait comprendre l’intégration à l’éditeur, l’interface en ligne de commande de Flow, le format des réponses, les délais d’exécution, l’affichage et le code Emacs Lisp permettant de relier l’ensemble. J’y ai consacré bien plus de temps que prévu.
Récemment, un autre besoin est apparu. Avec les agents de programmation, les worktrees Git, qui permettent de travailler sur plusieurs branches dans des répertoires distincts, étaient entrés dans mon quotidien. Je voulais les gérer depuis Emacs : voir les branches ouvertes, les agents en cours d’exécution et les tâches à relire, sans devoir changer d’application.
J'ai donc construit ceci :
Je n’étais pas soudain devenu un expert d’Emacs Lisp. J’avais simplement un agent pour m’aider à concevoir et développer l’outil, dans un environnement déjà prévu pour être étendu. En une journée, j’avais une version suffisamment utile pour l’adopter au quotidien.
C'est ce futur qui m'intéresse : pas seulement des applications générées par IA, mais l'adaptation assistée par IA des applications que nous utilisons déjà.
Cela invite à revoir nos critères de conception. Pour durer, un logiciel ne devrait pas seulement répondre à la question « Quelles fonctionnalités faut-il développer ? », mais aussi à celle-ci : « Que pourront y créer les utilisateurs et leurs agents, en toute sécurité et sans nous solliciter ? »
Les points d’extension méritent donc autant d’attention que les autres fonctionnalités. Les interfaces de programmation doivent être stables et documentées, la configuration consultable, les concepts internes clairement nommés et les commandes combinables. L’état du logiciel doit être accessible sous une forme structurée. Créer, tester et partager une extension doit rester simple, tout comme effectuer une petite modification locale.
Il ne s’agit pas de transformer toutes les applications en Emacs. Beaucoup d’utilisateurs veulent un logiciel prêt à l’emploi, sans avoir à se soucier de ses possibilités d’extension. C’est bien ce qu’il faut leur offrir. Mais les agents de programmation rendent viables de nombreux usages personnels très spécifiques. À condition que le logiciel le permette, les utilisateurs peuvent désormais développer les fonctionnalités trop particulières pour figurer dans sa version standard.
À mon sens, les logiciels les mieux placés seront ceux qui donnent aux agents assez de repères pour intervenir, sans imposer aux utilisateurs de comprendre toute leur base de code.
Avant les agents, l’extensibilité profitait surtout aux rares utilisateurs qui avaient à la fois l’envie et les compétences pour programmer leurs outils. Demain, beaucoup plus de personnes pourront se dire « J’aimerais que ce logiciel fonctionne un peu autrement » et concrétiser cette idée.
L’extensibilité devient ainsi moins un luxe réservé aux utilisateurs avancés qu’une qualité essentielle des logiciels conçus pour durer.
L’introduction en Bourse d’Anthropic pose une question : que devient la promesse d’une IA responsable quand elle rencontre la course à la domination du logiciel ?
Une étude de cas sur la revue de code à l’heure des agents de développement, à partir des données de l’espace de travail Pyratz Labs du 13 août au 5 novembre 2026.
Pourquoi nous avons créé des salons chiffrés autour des sessions d’agents existantes, et comment le démon de Paseo, les questions structurées et le partage d’images rendent cette collaboration possible.