Les LLM sont devenus presque parfaits pour générer du code, mais ce n'est pas la fin de l'histoire. Le fait que le code soit formellement correct ne signifie pas qu'il n'introduit pas d'abstractions inutiles, ne crée pas de doublons ou ne prend pas de mauvaises décisions dans l'ensemble. Ce n'est pas une observation révolutionnaire ; la plupart des personnes qui ont fait du vibe-coding sur un projet ont réalisé que chaque fonctionnalité supplémentaire peut parfois entraîner une explosion du nombre de lignes de code (LOC). Cela entraîne une perte de l'agentivité humaine, car dans les projets qui ajoutent des millions de LOC par mois, il est difficile pour les humains de suivre. Certains pourraient dire que ce n'est pas un problème du tout, car ils font confiance à leurs agents pour gérer cela. J'ai une mauvaise nouvelle pour vous : les agents ne peuvent pas vraiment gérer la négligence non plus.

Venant d'un milieu physique, j'ai toujours eu une approche expérimentale/quantitative pour résoudre les problèmes. Lorsque j'ai commencé chez Earendil, avec pour tâche de déterminer comment mesurer la négligence du code, mon instinct naturel a été de d'abord plonger dans la littérature, puis de vérifier ce que faisaient les autres entreprises. Pour être franc, à l'exception de quelques articles de recherche perspicaces, j'ai été déçu par le côté "basé sur les vibrations" de l'industrie en ce moment. Dans mes recherches et sur X, j'étais constamment bombardé de messages tels que "Agents de codage de bout en bout", "IA qui ne se contente pas de suggérer du code — elle le livre" ou "Évaluation au niveau humain sans coût au niveau humain". Qui, comme tous les bons contes, contiennent une part de vérité. Les LLM sont capables d'écrire du code presque parfaitement correct. Cela est dû à l'évolutivité et à la vérifiabilité du code. Il est assez simple de laisser les LLM générer du code, puis de laisser ce code être vérifié par des tests cachés, ce qui donne un signal de récompense clair. En contraste frappant avec cela, vérifier la « négligence » de ce code nécessite souvent une intuition et un goût humains, et est une tâche extrêmement difficile en général.

Je pense que la meilleure façon d'illustrer pourquoi il en est ainsi est de passer en revue les moyens possibles de mesurer la négligence. L'IA comme juge : c'est probablement la façon la plus courante d'évaluer la qualité du code dans l'industrie et, d'après mes observations, cela fonctionne rarement. La façon la plus naïve de le faire, à savoir demander aux modèles à quel point le code est bon sur une échelle de 1 à 10, équivaut essentiellement à un générateur de nombres aléatoires. L'approche plus sophistiquée, à savoir essayer de donner au modèle juge deux solutions A et B, puis le laisser décider laquelle il préfère, a l'inconvénient que le modèle change de préférence lorsque vous renommez les solutions. Je suis un peu facétieux ici et l'effet n'est pas aussi prononcé avec les modèles plus grands, mais le point principal reste. Demander aux LLM de juger le code qu'ils écrivent n'est pas un substitut à une évaluation appropriée. Même s'il existe des approches intéressantes avec des rubriques ou les LLM écrivant des tests, elles sont encore loin d'éliminer réellement la négligence.

Les humains jugent l'IA : si nous ignorons le fait qu'il y a une grande diversité dans la qualité des ingénieurs logiciels, ce serait la meilleure solution pour assurer que le code reste lisible par l'homme. Avec l'inconvénient que cela n'est pas évolutif pour entraîner l'IA ou avoir de grands benchmarks avec plusieurs fournisseurs de modèles et harnais. La méthode la plus simple : dans mes recherches et tests, prendre simplement le changement du nombre de LOC a été une métrique étonnamment efficace pour la négligence, avec la mise en garde ironique que si nous commencions à optimiser pour cela, cela cesserait d'être une mesure significative. Les deux mesures suivantes m'ont été présentées par l'article Slop Code Bench, et semblaient prometteuses car elles pouvaient assez bien séparer les bases de code héritées de la négligence des LLM. Verbosité : tente de mesurer la quantité de lignes dupliquées et inutilement verbeuses. Érosion : tente de mesurer combien de la masse d'une base de code est concentrée dans quelques grandes fonctions complexes.

Entités clés : Entreprises : Earendil

FAQ : Quel est le principal défi dans la mesure de la négligence du code ?

Le principal défi est que la négligence nécessite souvent...

FAQ Q : Quel est le principal défi dans la mesure de la négligence du code ?

FAQ A : Le principal défi est que la négligence nécessite souvent une intuition et un goût humains, ce qui rend difficile l'évaluation automatique. Les juges IA ne sont pas fiables, et l'évaluation humaine n'est pas évolutive.