Au-delà de la génération de code par IA : Les coûts cachés du développement assisté par agents

Les gains de productivité avec l'IA en codage sont évidents. Les devs déploient plus vite que jamais. Mais la vitesse ne rime pas toujours avec qualité. La vague des agents IA révèle un vrai souci : on a résolu le mauvais problème.

Les chiffres masquent la réalité

Récemment, des stats impressionnantes ont fait le buzz. Certains devs disent que 100 % de leur code récent vient d'agents IA, avec peu d'intervention humaine. Près de 70 % écrivent moins de la moitié manuellement. On est passés de "l'IA aide sur les 20 % finaux" à "les humains corrigent les 20 % derniers".

À première vue, c'est génial. Les métriques explosent. Les déploiements s'accélèrent. Les side projects bouclent en jours au lieu de semaines.

Mais les titres passent à côté d'un shift majeur : la nature des bugs a radicalement changé.

Une nouvelle génération d'erreurs

Au début, les assistants IA rataient la syntaxe. Points-virgules oubliés. Signatures de méthodes foireuses. Erreurs d'index dans les boucles. Facile à spotter avec un linter.

Aujourd'hui, c'est plus vicieux et discret.

Propagation d'hypothèses : L'agent interprète mal une spec floue et bâtit une feature entière dessus. Trois PR plus tard, l'architecture repose sur du vent. L'IA a fait une supposition logique, l'a appliquée sans se remettre en question. Quand tu t'en rends compte, les patterns sont gravés dans tout le code.

Complexité superflue : Laisse l'agent libre, il vise l'exhaustivité au lieu de la simplicité. Tu obtiens 1000 lignes sophistiquées pour 100 qui suffiraient. Classes abstraites inutiles. Scaffolding en trop. L'IA n'est pas paresseuse, elle est zélée. Trop zélée.

Dégradation silencieuse : Les agents ne rangent pas toujours derrière eux. Ils touchent du code adjacent sans le maîtriser. Suppriment des commentaires par effet collatéral. Laissent des implémentations mortes. Ça paraît isolé en PR, mais six mois après, tu debug un truc pété par un refactor bien intentionné.

Obéissance aveugle : Le pire ? Les agents ne contestent jamais. Pas de questions pour clarifier. Pas d'alerte sur les incohérences. Pas de "t'es sûr de cette approche ?". Ils exécutent, point. Optimisés pour obéir, pas pour penser critique.

Ce ne sont pas des cas isolés. Ce sont des patterns récurrents, malgré les prompts système, les README détaillés ou les plans discutés avant.

La crise de la vérification

Ça empire. Une enquête récente montre que seuls 48 % des devs review systématiquement le code IA avant commit. Et 38 % de ceux qui le font disent que ça demande plus d'effort que pour du code humain.

On génère du code propre plus vite, mais on ne le valide pas bien. Le goulot d'étranglement passe de la création à la vérification. Et on perd la bataille.

La dette de compréhension : un passif invisible

Écrire du code et le lire, ce n'est pas pareil. Tu peux piger une implé sans la recoder de zéro. Mais il y a un seuil où la compréhension vire au tamponnage automatique.

Quand l'agent pond du code qui marche (ou semble marcher), la pression pour avancer est folle. Deadline qui approche. Tests OK. Code plausible. L'agent file au suivant. Pourquoi passer 30 minutes à décortiquer ?

C'est la dette de compréhension. Pas trackée sur aucun dashboard.

Au fil des mois, tu empiles des couches de code vaguement comprises. Le système tourne, plus ou moins. Mais tu perds la vue d'ensemble. Un bug ? C'est une enquête, pas un diagnostic rapide. Un changement de spec ? Refactor risqué, car tu ignores les dépendances.

Le problème du timing

Cette dette s'accumule en différé. Pas visible en sprint. Elle surgit lors d'une modif : le système est plus fragile que prévu. Ou une perf qui dégringole sans raison. Ou une feature simple qui vire à la réarch en deux semaines.

En équipe, c'est pire. Agent A génère, B modifie, C étend. Les hypothèses s'empilent comme un téléphone arabe entre machines sans questions.

Vers une meilleure approche

Ça ne veut pas dire que les agents IA sont nuls. Les gains sont réels, top pour les projets neufs ou tâches cadrées. Mais l'état d'esprit compte.

Traite le code IA comme un brouillon. Scrute-le comme celui d'un junior. Pose des questions. Justifie la complexité. Conteste les bases.

Investis dans la compréhension. Décrypte les choix d'archi, pas juste la syntaxe. Si tu ne sais pas expliquer la structure, tu creuses la dette.

Intègre la vérification. Vise plus que 48 %. Review obligatoire, surtout pour l'IA. "Ça marche" ≠ "C'est solide".

Utilise les agents tactiquement. Ils brillent sur des tâches précises. Garde les humains pour l'archi, les patterns et les impacts multi-systèmes.

Le vrai défi, ce n'est pas les 80/20. C'est un process où les humains restent vigilants pour choper les fails que les métriques loupent. La vitesse ne vaut que si elle assure la solidité.