Sommaire
Encore un journal sur l'IA, mais pour tenter d'avancer sur le sempiternel débat sur le vibe-coding. Enfin, que dis-je, ce débat est pratiquement plié sur LinuxFR, la très grande majorité le déteste… Personnellement, je suis plutôt à le défendre et à considéré qu'un projet open-source vibe codé est valable. Mais pourtant, force est de constater, qu'évidemment, l'IA produisant tellement de code, qu'humainement, on ne peut pas tout relire, et cela va inévitablement s'empirer. Alors je tente de lancer une idée bien prétentieuse pour tenter de réconcilier une partie des libriste.
Le problème
Le problème, n'est plus tant la qualité du code. Clairement, l'IA se remarque d'ailleurs au fait qu'elle produit du code trop parfait, trop bien commenté et documenté, quand un humain laisse de côté certains aspect par manque de temps (et parfois de compétences).
Le problème de fond est plutôt à chercher du côté de la relecture. Et cela tient tout particulièrement au fait, que même en ayant le prompt initial on n'a aucune garantit de retomber sur le même logiciel avec un autre agent IA. Il n'y a pas de déterminisme. Alors c'est vrai que j'aime dire que dans les autres logiciels il n'y a pas non plus de déterminisme, du moins pas au sens strict (cf le paragraphe du dessous pour les détails) mais il faut reconnaître, que l'on a rarement un bug qui ne soit pas dû au code source (cela peut arriver, surtout en JS et parfois en manipulation binaire). Avec l'IA, donner le prompt, ne suffit pas car il y a généralement des retouches avec d'autres prompts qui dépendent du résultat du prompt précédent, ce qui est par essence non prévisible.
Le déterminisme des compilateurs
Le code assembleur produit par un code source donné dépends du compilateur mais aussi parfois de choix plus ou moins random du compilateur (Va-t-il garder la fonction indépendante ou la mettre en "inline" par exp mais aussi dans l'utilisation des registre entre autre.).
Mais c'est encore plus vrai dans les langages avec ramasse miettes ou l'on ne maîtrise plus le moment de son passage ni ce qu'il va supprimer.
Et c'est encore plus vrai avec les langages interprétés ou carrément on ne sait pas s'il va optimiser en compilant en ASM ou s'il va l'interpréter à la volée.
Et pour finir, avec HTML, le comportement est rarement parfaitement défini avec le CSS. Le comportement dépends entièrement du client (soft et hard) et même de la configuration de celui-ci pour l'auto-complétion par exemple. D'ailleurs dans les spécifications du logiciel, on a toujours la cible (Firefox, Safari, Edge en tel version) un peu comme si en IA on avait, pour "Claude Sonnet 5.2".
L'idée
On le voit, avec un compilateur, plus le langage est de haut niveau, plus on perd le contrôle du résultat, et pourtant, moins cela a peu d'importance. On peut toujours avec un langage de haut niveau repréciser au besoin les détails mais c'est souvent laissé de côté.
Sur ce même, principe, on peut comprendre que la précision, est encore plus rarement importante avec une IA. Et il y a des cas, ou un prompt assez détaillé suffit largement a donner un résultat suffisant, si le logiciel est assez simple (pour des démos par exemple).
Mais dès que l'on veut aller plus loin, on touche vite les limites.
Je me suis alors dit que l'on pourrait utiliser l'IA pour lire le code et nous donner un prompt complet détaillant les spécifications. C'est bien mais c'est difficile de savoir quel est la pertinence du résultat, et c'est vain d'espérer aussi un résultat complet et facile à lire. C'est anti-nomique soit le prompt est complet et long à lire soit il est court et imprécis. On peut tout de même interroger l'IA pour comprendre un code. Elle sait très bien le faire, elle peut même décompiler un logiciel d'ailleurs. On il faudra toujours le readme pour comprendre le sens du code.
J'ai aussi pensé qu'il faudrait les spécifications dans le dépôt Git, cela se fait parfois. Cela ne résout pas vraiment le problème puisque les spécifications sont souvent plus abscons que le code et que les spécifications ne précisent jamais tout quand elles sont à jour. Mais cela peut aider à valider le logiciel ou à analyser des problèmes.
Je propose un peu plus: de stocker dans le répertoire, 4 niveaux de spécifications en plus du code, chacun dans un répertoire différent. L'idée est que l'on peut se contenter de lire le niveau 1 pour avoir rapidement l'idée général du code, un peu au delà du readme. Puis suivant ce qui nous intéresse, on peut aller dans les niveaux du dessous. Le gros point fort serait de pouvoir, à partir d'un niveau, de générer le niveau du dessous tout en modifiant les partis que l'on veut préciser. Même pour l'IA, cela l'aiderait à structurer sa pensé et à poser les bonnes question dès le début. Et on peut ensuite imaginer un EDI, capable de régénérer les niveaux du dessous affectées à chaque modifications.
L'existant
A ma connaissance, la seule chose qui existe que j'ai trouvé, vraiment adapté à l'IA (au delà de quelques PDF à chercher sur le partage réseau) c'est OpenSpecs. OpenSpecs est un projet bien plus abouti mais a priori aux ambitions bien plus restreint. Il ne présente pas le projet de manière hiérarchique ni de manière complète.
La mise en place
Pour concrétiser l'idée, j'ai créé des spécifications encore très embryonnaires OpenSoftwareDefinitionFramework. J'avoue, j'ai utilisé l'IA pour, vous avez le droit de me taper dessus.
La pratique
En théorie du moins, le test ultime, est de donner à l'IA les spécifications d'OpenSoftwareDefinitionFramework et qu'elle puisse les générer pour un logiciel dont on connaît le code, et ensuite pouvoir régénérer le code avec. Le code régénéré n'est pas censé être identique au départ mais avoir un fonctionnement identique. Je l'ai testé un peu avec succès sur des projets simple.
1. Pour les humains
Grâce à ces définitions logicielles hiérarchisées, je penses qu'un humain pourrait naviguer dans le logiciel depuis une vue d'ensemble jusqu'aux détails qui l'intéressent.
Il peut commencer par consulter le premier niveau pour comprendre les objectifs généraux et les fonctionnalités du logiciel. Il peut ensuite explorer progressivement les niveaux inférieurs afin de comprendre les composants spécifiques ou les parties qu'il souhaite analyser.
De plus, un humain peut modifier un composant à n'importe quel niveau. Avec l'aide d'un agent, que je met en place, les sous-niveaux correspondants seront automatiquement mis à jour ou supprimés afin de maintenir la cohérence de l'ensemble de la hiérarchie. Si nécessaire, l'agent IA peut solliciter l'humain pour lui demander de prendre certaines décisions ou de clarifier des points particuliers. Si c'est un niveau du dessous qui est modifié en contrariant des contraintes supérieur, un message d'erreur est laissé et signalé à l'utilisateur.
Ainsi, plutôt que de devoir examiner l'ensemble du code source de bas niveau, un humain pourrait principalement se concentrer sur la vérification des spécifications intermédiaires affectées par les modifications.
2. Pour l'intelligence artificielle
Ce framework aide l'IA à structurer son processus de développement logiciel. Il l'encourage à raisonner progressivement, en partant d'une vision globale pour descendre jusqu'aux plus petits détails de l'implémentation.
Il définit également explicitement les périmètres et les limites des modifications, ce qui permet de réduire les risques de changements involontaires sur des parties non concernées du logiciel.
Par ailleurs, cette approche hiérarchique pourrait réduire la consommation de tokens et les besoins en mémoire. Lors du démarrage d'un nouveau projet ou de la modification d'un projet existant, un agent IA pourrait initialement charger uniquement les spécifications de haut niveau, puis consulter progressivement les niveaux inférieurs lorsque cela devient nécessaire. Cela lui permettrait de conserver les concepts essentiels sans avoir à analyser l'intégralité du code source à chaque intervention.
Paradoxalement, cela risque d'empêcher l'IA d'optimiser de trop le logiciel en évitant des raccourcis. En effet, plus l'IA progresse plus elle arrive a créer sa propre architecture un peu brouillons mais très efficace, comme le fait la nature. Prenons un exemple : Linux. D'un point de vue optimisation, le noyau monolithique est mieux car chaque process a directement accès au noyau mais d'un point de vue sécurité et surtout complexité, c'est une horreur. Un bug peu venir de n'importe quel module et cela demande à chaque module de tout comprendre. Le principe d'avoir une interface simplifie beaucoup la gestion. Mais on pourrait aller beaucoup plus loin et imaginer l'absence de driver. Un peu comme le système nerveux humain ou chaque neurone envoi un peu ce qu'il veut au cerveau. C'est plus efficace et null doute, qu'avec la perte de contrôle humaine qui arrive, on y viendra.
3. Pour la sécurité et la pérennité
Ce framework pourrait également être considéré comme un mécanisme de sécurité et de résilience face à la perte de données.
Par exemple, si le code source (L6) venait à être perdu, il serait potentiellement possible de le régénérer à partir des spécifications de niveaux supérieurs (L1 à L5). Inversement, si les spécifications étaient perdues mais que le code source était toujours disponible, elles pourraient être partiellement ou totalement reconstituées par rétro-ingénierie.
Les différents niveaux constituent ainsi plusieurs représentations complémentaires d'un même logiciel. Cela réduit la dépendance à une représentation unique et améliore la capacité de récupération et de maintenance à long terme du projet.
Au-delà de cet aspect, les spécifications pourraient devenir une véritable forme de préservation du patrimoine logiciel.
Habituellement, le code source est considéré comme l'actif principal d'un projet logiciel. Cette approche propose une vision différente : les spécifications, et particulièrement celles de haut niveau, pourraient devenir le patrimoine le plus précieux du projet.
Le projet pourrait ainsi survivre à la disparition de son implémentation initiale, être réécrit dans un autre langage de programmation ou être adapté à de nouvelles technologies, sans perdre les connaissances et les intentions qui ont présidées à sa conception. C'est vrai que l'IA est capable de le faire seule, mais sans aucune garanti, alors que là elle aurait un cadre bien défini.
On ne va pas se mentir, il existe des specs des logiciels mais en PDF, jamais mises à jour et souvent perdues.
Conclusion
Donnez moi des retours et avis. Quels contrôle avez vous sur vos process IA? Ce que je ne veux pas entendre c'est le « Tout est relu par un humain » qui est devenue un réflexe de conformité et de réassurance très proche du célèbre « J'ai lu et j'accepte les conditions générales d'utilisation ». C'est mensonger et cela sert juste au manager à s'affranchir de toute responsabilité.
# Retour de la bouillie sur le "déterminisme des compilateurs" (qui mélange compilateurs, navigateurs, interpréteurs, etc.)
Posté par Benoit Sibaud (site web personnel) . Évalué à 4 (+1/-0).
Cf https://linuxfr.org/users/samuel/journaux/par-la-loi-du-bobsleigh-de-lemmer-webber-le-code-genere-par-llm-n-est-a-terme-pas-libre#comment-2039542
Envoyer un commentaire
Suivre le flux des commentaires
Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.