Avec les agents de codage, le cahier des charges devient le nouveau code source

L'essor des agents de codage assistés par intelligence artificielle transforme en profondeur la manière dont les développeurs conçoivent et produisent des logiciels. Selon le témoignage du développeur Yushi, publié en mai 2026, la frontière entre le code source traditionnel et le document de spécification s'estompe : c'est désormais le cahier des charges qui devient le véritable « code source » du projet.

Une évolution progressive des outils

Yushi décrit un parcours en plusieurs étapes. Dans un premier temps, l'autocomplétion (comme Copilot) ne faisait que suggérer quelques lignes, laissant au développeur le soin d'écrire la quasi-totalité du code. Vint ensuite l'étape du chat : poser une question, copier la réponse, l'adapter et l'intégrer. L'intervention humaine restait centrale.

La rupture s'est produite avec l'apparition d'agents capables d'exécuter des tâches complètes : lire des fichiers, modifier du code, lancer des commandes et itérer sur les résultats. « Une fois que cela est devenu normal, la partie difficile s'est déplacée », explique Yushi. « Il ne s'agissait plus de 'puis-je taper le code assez vite ?' mais de 'puis-je expliquer le travail assez clairement pour que l'agent construise la bonne chose ?' »

Du code à la spécification

Lorsqu'il écrit le code à la main, le développeur se concentre sur le « comment » : quelle fonction appelle quelle fonction, où se trouve l'état, comment traiter les cas limites. Avec un agent de codage, le point de départ change. Les questions deviennent : « Que doit faire cette fonctionnalité ? Que doit voir l'utilisateur ? Que doit-il se passer dans le cas étrange ? Qu'est-ce qui est hors du périmètre ? Comment saurons-nous que c'est terminé ? »

Ce recentrage vers le « quoi » plutôt que le « comment » pousse le développeur à adopter une posture plus proche de celle d'un chef de produit. Les décisions produits, autrefois implicites, doivent être écrites noir sur blanc, faute de quoi l'agent invente une réponse. Parfois celle-ci est acceptable, parfois elle est « silencieusement erronée », ce que Yushi qualifie de « version effrayante ».

Un nouveau compilateur dans la machine

Le modèle traditionnel était : code source humain -> compilateur -> code machine -> produit. Désormais, selon Yushi, le schéma s'enrichit d'une couche supplémentaire : document de spécification -> agent de codage -> code source -> compilateur/runtime -> produit. L'agent et les couches traditionnelles coexistent, mais c'est la spécification qui devient l'entrée principale.

Cette évolution modifie la manière dont le développeur relit le code produit. Il ne l'examine plus comme s'il l'avait écrit lui-même ; il le confronte au cahier des charges. « Le comportement du produit correspondait-il à ce que nous avions dit vouloir ? L'agent a-t-il fait une hypothèse qui aurait dû être écrite ? Le code généré satisfait-il les tests pour le vrai besoin, ou seulement l'interprétation la plus facile des mots ? », s'interroge-t-il.

Le document devient la source de vérité

Une spécification vague est dangereuse, prévient Yushi, car un agent de codage ne s'arrête pas par gêne. Il fait une supposition raisonnable et continue. Utile pour avancer vite, mais cela produit un produit « presque juste à cinq endroits différents ». La solution est de traiter le document de spécification comme du code : le versionner, le réviser, le maintenir à jour, supprimer les décisions obsolètes, ajouter les cas étranges découverts, noter ce qui est hors du périmètre avant que l'agent ne le construise par défaut.

« La documentation ressemblait à quelque chose autour du travail d'ingénierie. Maintenant, elle ressemble à l'entrée du travail d'ingénierie. Mauvaise entrée, mauvaise sortie. Une très vieille leçon, un nouvel endroit où l'appliquer », résume-t-il.

Ce qui change pour les développeurs

Yushi ne croit pas que cette évolution rende la programmation moins importante. Au contraire, elle exige davantage de goût et de jugement. Le développeur doit toujours comprendre les systèmes, savoir quand l'agent a choisi la mauvaise abstraction, ce qu'un test prouve vraiment, et être capable de déboguer le désordre quand le chemin lisse se brise.

Mais le centre de gravité se déplace. Un développeur qui utilise bien les agents passe plus de temps à définir le travail, à réduire le périmètre, à vérifier le résultat et à resserrer la boucle de feedback. Le code est toujours là, mais la contribution humaine devient plus abstraite, plus orientée produit, plus proche de l'intention.

« Dans le développement assisté par IA, la spécification est en train de devenir le nouveau code source », conclut Yushi. « Non pas parce que le code source disparaît, mais parce que la chose que je dois le plus maintenir se déplace. » Le compilateur, qui commençait autrefois avec le code source, commence désormais plus tôt, avec le cahier des charges.