Agents IA de code
Entropie du code : des contrôles CI pour que l’IA n’empile pas du legacy
La complexité du code croît d’elle-même, et l’IA a simplement accéléré cette vieille loi. Voici sept niveaux de contrôles CI qui empêchent le legacy de s’accumuler, dans l’ordre où je les mets en place.
L’entropie croît d’elle-même. En physique, c’est le deuxième principe de la thermodynamique. Le développement logiciel s’en rapproche : le désordre s’accumule facilement, et l’ordre demande des efforts.
Il en a toujours été ainsi. À mesure qu’un projet grandit, sa complexité grandit aussi : le legacy s’accumule, le projet devient plus difficile à maintenir, chaque modification pèse plus lourd, et le risque de casser quelque chose ne cesse d’augmenter. En 1974, Manny Lehman l’a formulé comme une loi de l’évolution du logiciel : la complexité d’un système augmente, à moins qu’on ne travaille à la réduire. L’IA n’a rien changé à cela. Elle a seulement accéléré l’accumulation du legacy.
L’objectif est de garder le code aussi simple que possible, et c’est là que les contrôles CI vous aident.
- 1Code mortfait échouer le build
- 2Linters et formateursfait échouer le build
- 3Analyse statiquefait échouer le build
- 4Tests unitaires et couverturefait échouer le build
- 5Complexité et duplicationfait échouer le build
- 6Architecture et couplagefait échouer le build
- 7Règles écrites (AGENTS.md)non imposé par la CI
1. Code mort
L’étape la plus simple consiste à supprimer ce qui ne sert plus. Elle s’automatise aussi : placez un détecteur de code mort dans la CI (vulture pour Python, knip pour JS/TS), et le code inutilisé fait tout simplement échouer le build.
2. Linters et formateurs
Vient ensuite le linter : phpcs pour PHP, ruff pour Python, ESLint et Prettier pour JS/TS, et ainsi de suite. Chaque langage a son propre style de code, et le choix du style importe peu. L’essentiel est de ne pas dépenser de temps ni d’argent à lire du code et à écrire en revue des commentaires du genre « remplace les guillemets doubles par des simples ». Mettez-vous d’accord une fois sur le style, et la CI le vérifie ensuite automatiquement.
3. Analyse statique
Le niveau suivant, ce sont les analyseurs statiques : PHPStan pour PHP, mypy pour Python, tsc pour JS/TS. Un contrôle de types statique et strict attrape les erreurs simples : une chaîne passée là où un nombre était attendu, ou l’oubli qu’une valeur peut être vide. Votre logique reste à votre charge, mais toute une classe d’erreurs disparaît. Les valeurs vides sont le cas d’école : Tony Hoare, l’inventeur de la référence nulle, l’a appelée son « erreur à un milliard de dollars », et selon les données 2020 de Harness, NullPointerException figurait encore dans le top 10 des exceptions dans 70 % des environnements Java de production qu’ils avaient étudiés.
4. Tests unitaires et 80 % de couverture
Pourquoi ? Parce que du mauvais code est très difficile à tester unitairement. Pour rendre du code couvrable par des tests unitaires, il faut le découper en classes et en fonctions distinctes, réfléchir au couplage et aux interfaces, décider de ce qui reste public et de ce qui reste privé, utiliser l’injection de dépendances et éviter l’état global. Bien sûr, ce n’est pas une garantie à 100 %, d’autant que l’IA gonfle facilement la couverture avec des tests qui ne vérifient presque rien. Mais d’une manière ou d’une autre, le seuil impose des contraintes à la conception et augmente les chances d’obtenir du bon code.
5. Complexité et duplication
La mémoire de travail humaine ne retient que quelques éléments indépendants à la fois : George Miller en comptait 7 ± 2 en 1956, et Nelson Cowan a affiné ce chiffre à environ quatre en 2001. Au-delà, cela devient difficile et part dans le swap. Je n’ai pas vu de recherche sur ce point pour l’IA, mais si le code est compréhensible pour un humain, les chances augmentent que l’IA n’hallucine pas. Et si le code est si emmêlé qu’un humain ne peut pas le suivre, l’IA y empilera très probablement de nouvelles couches de legacy.
Je fixe donc des limites strictes sur les métriques de duplication et de complexité. Limite dépassée → la CI échoue → il faut refactorer et extraire du code dans des méthodes et des classes séparées. Pour Python, complexipy en est un exemple.
Voici ce que cela donne sur un vrai projet. Sur une plateforme où j’ai travaillé, des agents IA écrivaient l’essentiel du backend. Au bout de six semaines, avant que ces contrôles n’existent, la première mesure a trouvé 143 fonctions d’une complexité supérieure à 10 et 202 fragments copiés-collés, soit environ 5 % du code. Plus tard, quand un plafond strict a été introduit, la pire fonction traitait des reçus, donc de l’argent : 490 lignes pour une complexité de 73. Dès que ce plafond a commencé à faire échouer le build, elle est passée de 73 à 30 en quatre jours de refactoring, une fonction par commit. Dans les deux mois qui ont suivi la première mesure, la duplication est tombée à environ 3 %.
Si le legacy s’est déjà accumulé, vous pouvez partir de là où vous en êtes : fixez la limite au niveau de votre fonction la plus complexe, et au moins rien ne se dégradera. La dette, elle, reste là. Vous la remboursez à part : réservez du temps pour le refactoring et abaissez la limite après chaque étape pour verrouiller le résultat. Les contrôles empêchent le désordre de grandir ; le ménage, c’est à vous de le faire.
6. Architecture et couplage
Des frontières strictes réduisent aussi la complexité, un niveau plus haut. C’est comme l’encapsulation en POO : le système est construit à partir de gros blocs dont vous n’avez pas besoin de garder le fonctionnement interne en tête ; connaître leur contrat suffit. Et l’implémentation d’un bloc peut être remplacée au besoin, sans réécrire le reste du système. Au lieu de dizaines de classes et de liens, vous raisonnez sur quelques gros blocs. Une fois encore, vous réduisez le nombre de choses à garder en tête en même temps, cette fois à chaque niveau de l’architecture.
En pratique, cela veut dire Clean Architecture et architecture hexagonale : le code est découpé en couches, et les dépendances entre elles sont strictement limitées. Le domaine ne sait rien de la base de données, de HTTP ni des API externes, et le code extérieur y accède par des interfaces définies à l’avance. Cela aussi se vérifie automatiquement (avec import-linter pour Python, par exemple) : un import interdit apparaît, la CI échoue.
7. Règles écrites
Le dernier niveau, ce sont les règles écrites. Autrefois, c’étaient des guides et de la documentation pour les développeurs ; aujourd’hui, c’est un fichier AGENTS.md et de la documentation pour l’IA. Contrairement aux contrôles ci-dessus, le résultat n’est pas déterministe : l’IA peut lire une règle et l’enfreindre quand même. Les règles écrites sont donc le dernier kilomètre. Elles ne portent que ce qui n’a pas pu être couvert par des contrôles. À choix égal, laissez tomber la prose et écrivez un contrôle strict dans le code.
L’IA essaie sans cesse de désactiver le contrôle au lieu de corriger le code : relever la limite, ajouter une exception, faire taire la règle avec un commentaire. Mon fichier de règles le dit donc sur une ligne à part : affaiblir un contrôle pour qu’il passe, c’est contourner le problème, et le problème reste entier.
Les outils, par langage
| Niveau | Python | PHP | JS/TS |
|---|---|---|---|
| Code mort | vulture | shipmonk/dead-code-detector (PHPStan) | knip |
| Linters et formateurs | ruff | PHP_CodeSniffer (phpcs) | ESLint + Prettier |
| Analyse statique | mypy (strict) | PHPStan | tsc (strict) |
| Tests unitaires et couverture | pytest + coverage | PHPUnit | Jest / Vitest |
| Complexité | complexipy | PHPMD, cognitive-complexity (PHPStan) | ESLint complexity |
| Duplication | pylint duplicate-code | jscpd | jscpd |
| Architecture et couplage | import-linter | Deptrac | dependency-cruiser |
Il existe aussi une version pas à pas de cet article, écrite pour les agents de code : le playbook des garde-fous CI (en anglais). Pour l’appliquer à un dépôt, dites à votre agent : Applique https://sg4.tech/blog/code-entropy-ci-checks-ai-legacy/playbook.md à ce dépôt.
En résumé
L’entropie grandira quoi qu’il arrive ; la seule question est de savoir qui la contient. Plus les règles passent des guides écrits aux contrôles CI automatiques, moins elles dépendent de l’attention d’un humain en revue. L’IA lance elle-même les contrôles, voit ce qui a échoué et le corrige : elle peut sauter une ligne d’AGENTS.md, mais elle ne peut pas ignorer un build CI en échec. Et plus vous avez de contrôles, plus vous pouvez lui confier du code sereinement.
Si vous êtes fondateur et que vous ne lisez pas de code, cette liste vous sert quand même de questionnaire pour votre équipe : lesquels de ces niveaux font réellement échouer le build ? Chaque réponse du type « on le repère en revue » est une règle qui dépend de l’attention de quelqu’un un jour donné. Pourquoi le code écrit par des agents a besoin de ces garde-fous, c’est une autre histoire : gérer l’IA comme un junior.
Un modèle de projet pour Python
L’approche ne dépend pas du langage. Pour Python, j’ai tout rassemblé dans un modèle de projet prêt à l’emploi ; servez-vous-en librement : python-guardrails-template.
Au programme :
- tous les contrôles de cet article derrière une seule commande
make verifydans Docker, et la même commande dans GitHub Actions ; - des couches d’architecture avec contrôle des imports ;
- un détecteur de secrets au moment du commit ;
- un AGENTS.md où presque chaque règle renvoie au contrôle qui la fait respecter ;
- un petit exemple, pour que les contrôles passent dès la création du projet.
Un nouveau projet se crée en une commande :
copier copy gh:sg4tech/python-guardrails-template my-projectEt quand le modèle est mis à jour, copier update apporte les nouveaux contrôles aux projets existants en conservant vos modifications. Fini de tout reconfigurer de zéro à chaque nouveau projet.
Questions fréquentes
Des contrôles CI stricts ne vont-ils pas ralentir l’équipe ?
Les contrôles déplacent le coût de la revue et de la production vers un build qui échoue, là où il est le plus faible. Sur un code legacy, vous partez du niveau actuel, donc rien ne bloque dès le premier jour.
Puis-je ajouter ces contrôles à un projet legacy existant ?
Oui : figez le niveau actuel comme limite pour que rien ne se dégrade, puis abaissez-la pas à pas au fil du refactoring.
La revue de code ne suffit-elle pas à repérer tout cela ?
La revue dépend de l’attention et ne suit pas le rythme auquel les agents écrivent du code. Un contrôle s’exécute à chaque modification et échoue de la même façon à chaque fois.
Faut-il mettre en place les sept niveaux d’un coup ?
Non. Ajoutez-les dans l’ordre : code mort, formatage et types d’abord, parce qu’ils coûtent peu. Les limites de complexité et d’architecture deviennent rentables quand le code grossit.