Vibe coding : le REX d'un vieux bonhomme

Mis a jours le 20 Nov 2026 à 00:00 · 3676 mots · Lecture en 18 minutes vibe coding IA Claude Code wikipedia2book pi-appliance wikipedia wikipedia2book code-review automation ai-agents developer-tools code-quality meta-programming claude copilote subagents Made In Dauphine Eric Voltzenlogel

Vibe coding : le REX d’un vieux bonhomme

Teaser : votre vélocité lors du codage 1, 16 ou 40 ???

J’ai commencé l’informatique à une époque où le HTML n’existait que dans le laboratoire de Tim Berners-Lee, au CERN de Genève. Depuis, j’ai traversé plusieurs décennies d’évolutions technologiques, chacune accompagnée de son lot de promesses, de ruptures et parfois de prédictions alarmistes sur la disparition prochaine du métier de développeur.

J’ai connu l’arrivée des langages de programmation de plus haut niveau, qui ont progressivement éloigné les développeurs du matériel et des contraintes de bas niveau. Ce qui nécessitait autrefois une connaissance approfondie de la machine pouvait désormais être exprimé en quelques instructions. Certains y voyaient déjà une dévalorisation du métier ; c’était surtout une libération du temps consacré aux tâches les plus techniques.

J’ai également connu les L4G (langages de quatrième génération). Avec des outils comme SQL, Oracle Forms ou Informix-4GL, l’ambition était de ne plus avoir à programmer chaque instruction, mais de décrire ce que l’on voulait obtenir et de laisser l’outil se charger d’une partie de la mécanique. On passait progressivement d’une programmation impérative, où il fallait expliquer à la machine comment faire, à une approche déclarative, où l’on exprimait davantage le résultat attendu. Certains annonçaient déjà la fin du développeur traditionnel. En réalité, ces outils ont surtout déplacé son travail vers la modélisation des données, la conception fonctionnelle et la maîtrise des règles métier.

Puis sont arrivés les environnements de développement intégrés et les outils RAD (Rapid Application Development). Je pense notamment à NSDK de Nat System, qui proposait un environnement complet, un langage dédié, des composants graphiques et des mécanismes permettant de développer rapidement des applications professionnelles complexes. On ne partait plus d’une page blanche pour écrire chaque ligne de code : l’environnement fournissait une grande partie de l’architecture et des mécanismes nécessaires. C’était déjà une forme d’industrialisation du développement logiciel, avec une promesse de productivité et de standardisation.

J’ai vu ensuite l’essor des frameworks et des bibliothèques logicielles. Pourquoi réinventer ce qui existe déjà ? On disposait désormais de composants réutilisables, de structures applicatives éprouvées et d’outils toujours plus sophistiqués. Le développeur devenait davantage un assembleur de briques logicielles, mais devait aussi apprendre à maîtriser des abstractions toujours plus nombreuses.

J’ai connu la révolution du logiciel libre et de l’Open Source, qui a profondément transformé notre manière de travailler. Les communautés, les dépôts de code et les bibliothèques partagées ont fait du développeur un acteur d’un écosystème collectif, capable de s’appuyer sur le travail de milliers d’autres.

L’arrivée du Web a constitué une autre rupture majeure. L’informatique est passée d’un monde relativement fermé, composé de systèmes centralisés et d’applications réservées aux spécialistes, à un univers ouvert et interconnecté. Il a fallu apprendre à penser en pages, en liens, en navigateurs, en protocoles et bientôt en applications distribuées.

Puis le Cloud Computing a bouleversé notre rapport à l’infrastructure. Plus besoin de posséder et d’administrer physiquement ses serveurs : on pouvait provisionner des ressources à la demande, automatiser les déploiements et faire évoluer les capacités presque instantanément. Le métier s’est étendu vers le DevOps, l’architecture et l’exploitation des systèmes.

J’ai également vu se succéder les promesses du No Code et du Low Code, qui annonçaient que chacun pourrait bientôt créer ses propres applications sans savoir programmer. Là encore, le développeur n’a pas disparu. Son rôle s’est déplacé vers la conception, l’intégration, la personnalisation et la gestion de la complexité que ces outils ne savaient pas traiter.

Toutes ces évolutions ont un point commun : elles ont automatisé une partie du travail, réduit certaines barrières techniques et déplacé la valeur ajoutée du développeur. Elles ont changé les outils, les méthodes et les compétences attendues, mais elles n’ont jamais supprimé le besoin de comprendre un problème, de concevoir une solution et d’en garantir la qualité.

Le vibe coding, avec l’arrivée des modèles d’intelligence artificielle capables de produire du code à partir d’instructions en langage naturel, marque pourtant une rupture d’une autre nature. Pour la première fois, je n’ai plus simplement l’impression de disposer d’un meilleur outil ou d’un niveau d’abstraction supplémentaire. J’ai le sentiment de pouvoir démultiplier directement ma capacité à concevoir, expérimenter et réaliser.

C’est la première fois que je me sens véritablement augmenté dans ma pratique du développement.

Le vibe coding est la dernière révolution en date. Mais, contrairement aux précédentes, je ne la vis pas seulement comme une transformation de mon métier : je la vis comme une extension de mes propres capacités.

Après toutes ces années à voir évoluer les outils et les méthodes, je pensais avoir appris à relativiser les révolutions technologiques. Cette fois, je dois reconnaître que je suis sidéré.

L’année passée : tâtonnements

Pendant un an, j’ai commencé à utiliser l’IA dans mon quotidien de développeur, d’abord de manière assez ponctuelle. Je lui demandais de modifier un fichier, de créer une petite fonction, d’écrire un script, de produire du code Terraform ou encore de développer une API. Je récupérais le résultat, je l’intégrais dans mon environnement de développement, je testais, je corrigeais et je recommençais.

C’était déjà utile. Ce collègue avait un avantage considérable : il me libérait des contraintes de syntaxe. Plus besoin de garder en tête toutes les subtilités d’un langage, ses conventions, ses bibliothèques ou ses particularités. Je pouvais me concentrer davantage sur la logique, le résultat attendu et le problème à résoudre, plutôt que sur la façon exacte de traduire mon intention en instructions compréhensibles par la machine.

Je gagnais du temps sur les tâches répétitives, je pouvais explorer plus rapidement des solutions techniques et je découvrais parfois des approches auxquelles je n’aurais pas pensé spontanément. Mais l’expérience restait encore assez fragmentée. L’IA répondait à une demande, produisait un morceau de code, puis attendait la suivante. Elle ne disposait pas toujours du contexte global du projet, ne connaissait pas nécessairement les dépendances ou les conventions existantes et pouvait proposer des solutions techniquement plausibles, mais inadaptées à l’application.

Je restais donc celui qui faisait le lien entre les différentes productions, qui comprenait l’architecture, vérifiait la cohérence et assurait l’intégration. L’IA m’assistait dans l’écriture du code, mais ne prenait pas encore véritablement en charge le développement.

Avec le recul, je réalise que je l’utilisais essentiellement comme un générateur de code amélioré. Je lui demandais de produire des éléments techniques, sans encore lui confier réellement la réalisation d’un objectif. C’est précisément ce qui allait changer avec le vibe coding.

Wikipedia2Book : douze jours, 370 modifications

Le déclic est venu en novembre 2026 avec Wikipedia2Book.

Le point de départ était modeste. Wikipédia permettait autrefois de rassembler des articles dans un « livre » et de le télécharger en PDF. Cette fonction a été arrêtée en 2017. Moi, je voulais juste réunir en un seul PDF les articles que j’avais écrits sur les épaves de la rade de Saint-Pierre, en Martinique, coulées lors de l’éruption de la montagne Pelée en 1902. L’idée tenait en une ligne : une sorte de cat pdf2 >> pdf1.

Sauf qu’avec ces outils, ajouter une fonctionnalité de plus est si facile que j’en ai ajouté beaucoup : couverture, table des matières, chapitres, huit projets Wikimédia, douze langues, volumes… Oups ! C’est peut-être trop !

Les chiffres :

  • première ligne écrite le 7 novembre 2026, à partir d’une spécification d’abord rédigée avec ChatGPT ;
  • version 1.0 en ligne sur Toolforge le 12 novembre ;
  • en douze jours, plus de 370 modifications et 13 versions ;
  • environ 12 000 requêtes reçues entre le 12 et le 17 novembre.

J’ai raconté l’outil lui-même dans un billet sur Diff, le blog de la communauté Wikimédia. Ici, je veux parler de la façon de travailler.

Ce qui a changé par rapport à l’année d’avant, c’est le harnais : Claude Code n’est pas une fenêtre de discussion, c’est un environnement où l’IA lit tout le code, le modifie, lance les tests et vérifie le résultat dans un navigateur. Une fonctionnalité décrite le matin est en général écrite, testée, documentée et en ligne le soir.

Vitesse ne veut pas dire raccourcis : tout est dans un dépôt public, chaque modification est un commit lisible, une trentaine de fichiers de tests tournent avant chaque déploiement, et la spécification suit le code.

pi-appliance : deux jours

Un retour d’expérience plus expéditif cette fois : 2 jours pour concrétiser une vieille idée que je n’avais pas réussi à réaliser en 4 ans !

Le vibe coding est ici un véritable game changer !

Deux projets pour mesurer le changement

Pour mesurer concrètement ce que le vibe coding change dans ma façon de développer, je me suis appuyé sur deux projets personnels assez différents.

Le premier, Wikipedia2Book, est une application web qui permet de composer des livres au format PDF à partir d’articles Wikipédia : recherche, sélection et organisation des articles, structuration en chapitres et volumes, puis génération des livres.

Le second, pi-appliance, est d’une autre nature. Il s’agit de transformer un Raspberry Pi en une véritable appliance personnelle, capable d’héberger et de rendre accessibles depuis Internet différents services. Un projet beaucoup plus transversal, qui touche au développement logiciel, au système Linux, au réseau, à la sécurité, à l’administration et même au matériel.

Pour objectiver un peu ces réalisations, j’ai utilisé OctoCounts, qui analyse les dépôts GitHub et compte les lignes de code avec l’outil Tokei.

Au 20 novembre 2026, Wikipedia2Book représente 12 048 lignes de code, réparties dans 50 fichiers et 9 langages. pi-appliance atteint 27 343 lignes de code, réparties dans 153 fichiers et 10 langages. Au total, cela représente près de 40 000 lignes de code, dans 203 fichiers, sans compter les commentaires et les lignes blanches.

Les rapports détaillés sont accessibles ici :

Ces comptages donnent une photographie du code présent dans chaque dépôt à un instant donné. Les règles de mesure excluent notamment certains répertoires identifiés comme contenant des tests, de la documentation ou du code généré. Il ne s’agit donc pas d’une mesure directe de la productivité, mais d’un premier indicateur de la taille des réalisations.

Quelques chiffres

KPI au 20 novembre 2026Wikipedia2Bookpi-applianceEnsemble
Lignes de code (SLOC)12 04827 34339 391
Lignes de commentaires1 5873 6805 267
Lignes totales15 05933 12948 188
Fichiers analysés50153203
Langages910—
Moyenne de lignes de code par fichier241179194

La vélocité : ce que raconte l’historique Git

Pour aller au-delà du simple comptage des lignes, j’ai également analysé les historiques Git complets des deux projets. Cela permet de mesurer le rythme de développement, les périodes d’activité et la fréquence des modifications intégrées.

Wikipedia2Book a été développé entre le 7 et le 20 novembre 2026. En quatorze jours calendaires, la branche principale main a enregistré 409 commits.

Le cas de pi-appliance est particulièrement intéressant. Le projet existait depuis 2018, mais je l’avais progressivement abandonné. Je l’ai véritablement repris le 19 novembre 2026 au matin, à 7 h 49. En moins de deux jours calendaires, la branche principale master a enregistré 106 commits : 56 le 19 novembre et 50 le 20 novembre.

Il serait donc trompeur de calculer la vélocité de pi-appliance depuis 2018. Cette date correspond à la naissance du projet, pas à sa période de développement actuelle. Pour cette comparaison, je retiens uniquement la période de reprise.

KPI de développementWikipedia2Bookpi-appliance
Début de la période étudiée7 novembre 202619 novembre 2026
Dernière activité observée20 novembre 202620 novembre 2026
Durée calendaire14 jours2 jours
Commits sur la branche principale409106
Commits par jour calendaire29,253
Jours avec activité142
Lignes de code actuelles12 04827 343

Ces chiffres sont évidemment à interpréter avec prudence : un commit ne correspond pas nécessairement à une fonctionnalité, ni à une unité de travail comparable. Ils donnent néanmoins une indication intéressante du rythme auquel les deux projets ont évolué.

Ce que je veux vraiment mesurer

Le nombre de lignes de code et le nombre de commits ne suffisent pas à évaluer la vélocité. Ce qui m’intéresse davantage, c’est la capacité à transformer une idée en fonctionnalité opérationnelle, puis à la consolider pour en faire un produit utilisable.

Je retiens donc plusieurs indicateurs complémentaires pour aller plus loin :

KPICe qu’il mesurePourquoi c’est intéressant
Commits par semaine et par moisFréquence des modifications intégréesMesure le rythme d’activité
Fonctionnalités livrées par moisNombre de nouvelles fonctions identifiablesMesure le débit fonctionnel
Délai idée → fonctionnalitéTemps entre la première trace d’une idée et sa mise à dispositionMesure la rapidité de réalisation
Corrections / évolutionsRépartition entre nouvelles fonctions, corrections et refactoringMesure l’effort de consolidation
TestsEffort consacré à la validationÉvalue la qualité du résultat
DocumentationÉvolution de la documentation technique et utilisateurMesure le niveau de finition
Versions publiéesFréquence des livraisons identifiéesMesure la capacité à livrer régulièrement

Il reste à analyser plus finement les messages de commits, les changements de fichiers et les changelogs pour établir ces indicateurs. Je préfère ne pas leur attribuer de chiffres tant que cette classification n’a pas été faite.

Ce que j’en retiens

Ces deux projets sont complémentaires. Wikipedia2Book illustre la création rapide d’une application web complète. pi-appliance montre qu’il est également possible de reprendre un projet ancien, de revoir ses choix techniques et de lui donner une nouvelle dimension en un temps très court.

Ce qui m’intéresse dans ce retour d’expérience, ce n’est finalement pas le nombre de lignes écrites. C’est le chemin parcouru entre une idée et un produit fonctionnel. Ces deux projets m’ont permis d’expérimenter le développement assisté par IA à une échelle suffisamment importante pour rencontrer les vrais sujets de l’ingénierie logicielle : architecture, cohérence, sécurité, tests, documentation, ergonomie et maintenance.

Et surtout, de constater que je peux désormais mener à bien des projets que j’aurais probablement laissés de côté auparavant, faute de temps ou de disponibilité. Le changement ne se mesure pas seulement à la vitesse à laquelle on écrit du code, mais aussi à tout ce que l’on devient capable de réaliser.

Ma méthode aujourd’hui, en cinq étapes

Avec Wikipedia2Book, puis avec mon projet suivant, pi-appliance (transformer un Raspberry Pi en petit serveur personnel, pour le grand public), j’ai fini par stabiliser une manière de faire. Elle tient en cinq étapes.

1. La spécification du produit, dans un fichier Markdown

Tout commence par un fichier specification.md : à qui s’adresse le produit, ce qu’il doit faire, ce qu’il ne fait pas. Pas de code, pas de choix techniques au départ : le quoi et le pour qui. Pour pi-appliance, la première phrase qui compte est : « le public visé est le grand public ; tout se fait depuis une console web, sans ligne de commande ».

Ce fichier est la référence. Il vit dans le dépôt, à côté du code, et l’IA le lit avant chaque modification.

2. Demander à Claude de me poser des questions

C’est l’étape que je sous-estimais le plus. Plutôt que de demander « écris-moi ça », je demande : « pose-moi toutes les questions nécessaires pour préciser cette spécification ».

Et les questions tombent : quel matériel minimum ? Que se passe-t-il si l’utilisateur oublie son mot de passe ? Les mises à jour sont-elles automatiques ? Faut-il demander avant d’effacer les données d’une application désinstallée ?

Chaque réponse devient une décision, notée dans la spécification. Sur pi-appliance, cette étape a produit une trentaine de décisions avant la première ligne de code : Go pour la console, Pi 5, 4, 3 B+ et Zero 2 W, point d’accès Wi-Fi au premier démarrage, mises à jour proposées mais jamais automatiques, sauvegarde chaque nuit, etc.

L’IA est bien meilleure pour trouver les trous d’une spécification que pour deviner ce que j’ai en tête.

3. Une TODO par thèmes, dans un fichier Markdown

Une fois la spécification stable, je fais construire un TODO.md, découpé par thèmes et dans l’ordre de construction. Pour pi-appliance :

  • 0. Ménage du dépôt — le projet existait depuis 2018 sous forme de prototypes ; il fallait retirer l’ancien, changer les secrets qui traînaient dans l’historique, choisir une licence (AGPL-3.0) ;
  • 1. Décisions — toutes les réponses de l’étape 2, cochées une à une ;
  • 2. Étape 1 — Local : l’image système, la console, la marketplace d’applications (Nextcloud, site web, DokuWiki, Etherpad, WireGuard) ;
  • 3. Étape 2 — Internet : l’adresse <nom>.pi-appliance.com, l’ouverture vers internet, le relais quand la box ne coopère pas ;
  • 4. Étape 3 — Le reste : sauvegardes, mises à jour, alertes… ;
  • 5. Le site www.pi-appliance.com.

Chaque ligne a un identifiant (TODO-2.51…) et renvoie à la section de la spécification qu’elle réalise. Quand une tâche est faite, elle est cochée et la spécification passe de « cible » à « réalisé ».

4. Laisser Claude traiter tous les thèmes en sous-tâches

Là, je lâche la bride : je demande à Claude de prendre un thème entier et de le traiter en sous-tâches, chacune dans sa propre session, avec ses tests et son commit.

C’est spectaculaire. C’est aussi là que ça brûle tous mes jetons. Plusieurs agents qui lisent la spécification, le code et la TODO, qui lancent les tests, qui se relisent : la facture d’usage grimpe vite. C’est le vrai coût de la méthode, et il faut le savoir avant de se lancer.

Pour rendre ça tenable, j’ai écrit des skills partagés entre mes projets (règles de style, synchronisation de la spécification, publication d’une version) : l’IA ne réinvente pas les règles à chaque session.

5. Je teste, et j’ajoute des entrées dans la TODO

Puis je reprends la main. Je teste, pour de vrai : sur de vrais livres pour Wikipedia2Book, sur un vrai Raspberry Pi pour pi-appliance. Et chaque problème, chaque idée devient une nouvelle ligne dans la TODO. La boucle repart à l’étape 4.

C’est d’ailleurs là que j’en suis sur pi-appliance : près d’une centaine de tâches cochées, une quarantaine ouvertes, et j’ai décidé d'arrêter d’ajouter des fonctionnalités tant que tout n’a pas été éprouvé sur un vrai Pi. Le code écrit par l’IA passe les tests ; le matériel réel, lui, ne lit pas la spécification.

Ce que j’en retiens

Lors d’un échange pendant la cérémonie Made In Dauphine avec Eric Voltzenlogel, celui-ci me confiait que ses équipes de développement avaient mesuré des gains de vélocité supérieurs à un facteur 16. De mon côté, mon ressenti est encore plus spectaculaire : je situerais plutôt le gain autour d’un facteur 40 !

Avec le vibe coding, je fais finalement plus d’ingénierie logicielle que de code. Je passe moins de temps à écrire des lignes de programmation et davantage à réfléchir, concevoir, décider, vérifier et maintenir la cohérence de l’ensemble. La spécification devient presque le véritable code source : si elle est floue, l’IA produit du flou, mais elle le fait très vite ! J’ai aussi découvert que l’une des astuces les plus efficaces consiste à demander à l’IA de me poser des questions avant de commencer. Elle m’aide ainsi à préciser mon besoin, à identifier les oublis et à explorer des pistes auxquelles je n’aurais pas nécessairement pensé.

Pour un dyslexique comme moi, c’est aussi merveilleux de pouvoir simplement parler en français à son outil de développement. Pouvoir expliquer une idée avec ses propres mots, décrire un problème, formuler une intention sans se battre avec l’orthographe, la syntaxe d’un langage ou ses conventions, c’est une véritable libération. Je peux enfin me concentrer sur ce que je veux construire plutôt que sur la manière de l’écrire. Ce n’est pas un détail : c’est une nouvelle forme d’accessibilité à la création logicielle.

L’autre changement considérable, c’est que je peux enfin réaliser des choses que je ne pouvais plus faire et/ou que ne n’aurais probablement jamais pris le temps de développer auparavant. Des bancs de tests de performance, des audits et des validations de la couverture de sécurité, du SSO, des interfaces soignées, des outils d’administration, une documentation technique et utilisateur particulièrement complète… Autant d’éléments qui font la différence entre un prototype et un véritable produit abouti, mais que l’on repousse souvent faute de temps ou de moyens. Aujourd’hui, je peux les envisager et les mettre en œuvre. Je ne me contente plus de développer les fonctionnalités essentielles : je peux aussi soigner tout ce qui fait la qualité du produit.

Évidemment, tout cela a un coût. Il y a celui des jetons consommés. J’ai cramer tout les tokens du monde… Mon compte pro copilote et 2 compte pro de claude code. J’ai encore a apprendre !!! Je commence a avoir quelques pistes : éviter de faire relire systématiquement l’intégralité du projet à l’IA, ne pas mettre de documentation dans le code !, lui fournir uniquement le contexte nécessaire à la tâche, découper les demandes complexes en étapes cohérentes et conserver une documentation claire des décisions prises. Enfin, mieux vaut prendre quelques minutes pour préparer une demande précise que multiplier les échanges pour corriger une réponse mal orientée. En somme, il faut apprendre à piloter sa consommation de tokens comme on apprend à optimiser l’utilisation de ses ressources informatiques. L’IA est capable de travailler vite, mais cela ne dispense pas de travailler intelligemment.

Enfin, il ne faut pas oublier que les tests sur le terrain restent humains. L’IA peut vérifier que le code fait ce qui est écrit, mais c’est à moi de vérifier que ce qui est écrit sert réellement à quelque chose. Elle peut produire, analyser, tester et documenter ; elle ne remplace pas le jugement de celui qui connaît le besoin et les utilisateurs.

Il faut apprendre à se servir de ces nouveaux outils. Mais apprendre de nouveaux outils, c’est mon quotidien d’informaticien depuis le début. La différence, cette fois, c’est que je peux réaliser des choses que je n’aurais probablement jamais pris le temps de développer auparavant, et que je prends beaucoup de plaisir à le faire.

Et pour un dyslexique comme moi, pouvoir simplement expliquer en français à sa machine ce qu’on veut construire, c’est tout simplement formidable.

Le vieux bonhomme a encore de beaux jours devant lui.

Image de l'auteur Guillaume Moulard

L'auteur:  Guillaume Moulard

Mon premier code était sur un ZX81... Mes derniers emois sont le week-end pour mes Raspberrys PI et la semaine pour les techno du Cloud. www.moulard.org

Vous avez vu une erreur ? Quelque chose ne va pas ? Vous pouvez contribuer à cette page sur GitHub ou laisser un commentaire en dessous. Merci d'être passé par là :)