Des articles approfondis sur les technologies qui façonnent l'avenir.

Assistants de code IA : 5 mythes, testés

Les assistants de code IA accélèrent la saisie, pas la qualité logicielle. Cinq mythes passés au crible : conception, vérification, complexité.

Un bras robotisé inonde un atelier de briques lumineuses qui s'entassent devant une unique porte d'inspection étroite.
La génération est devenue rapide. L'inspection, non — et le débit est fixé par l'étape la plus lente.

Jonathan Blow — le concepteur de Braid et The Witness, et un homme assez obstiné pour passer une décennie à construire son propre langage de programmation — a récemment posé une question qui devrait piquer tous les éditeurs qui vendent des assistants de code IA : si l'IA a résolu le codage, pourquoi mes logiciels sont-ils toujours les mêmes ? Mêmes plantages. Mêmes mises à jour alourdies. Les mêmes plaintes, depuis dix ans, sur des applis qui bouffent la RAM tout en faisant moins que les outils qu'elles ont remplacés. La réplique habituelle — attendez six mois — ne suffit pas vraiment, et je ne pense pas que Blow ait tort d'appuyer là où ça fait mal.

Voici ma position, après des années à construire des systèmes de ML puis à voir ces outils arriver dans de vraies équipes : les assistants de code IA sont réellement bons aujourd'hui, et ils n'ont réellement pas changé la donne pour les logiciels que vous et moi utilisons chaque jour. Les deux sont vrais en même temps, et ils le sont parce que ces outils n'ont jamais visé la vraie contrainte. Le moyen le plus clair de le voir est de prendre les cinq croyances que j'entends le plus souvent et de les tester une à une.

Mythe 1 : la saisie est le goulot d'étranglement du développement logiciel

Le discours est tout trouvé : coder, c'est produire du code, donc une machine qui en produit dix fois plus vite rend les logiciels dix fois plus rapides. C'est un syllogisme bien ficelé avec un seul défaut — personne ne travaille vraiment comme ça. Il existe une vieille règle empirique, popularisée par Clean Code, selon laquelle les développeurs passent bien plus de dix fois plus de temps à lire du code qu'à en écrire. Ce ratio est antérieur aux LLM de quinze ans, mais toute analyse sérieuse de la façon dont les heures d'ingénierie sont dépensées aboutit au même constat : comprendre le système existant, se coordonner avec d'autres humains, attendre des décisions. Les frappes au clavier ? Une erreur d'arrondi.

Vous le sentez dans votre propre semaine. L'autocomplétion fait gagner de vraies minutes — je ne m'en passerais pour rien au monde — mais mes journées difficiles n'ont jamais été difficiles parce que je ne tapais pas assez vite. Elles l'étaient parce que le service de paiement avait un invariant que personne n'avait écrit, ou parce que trois équipes n'étaient pas d'accord sur ce que l'API devait garantir. Accélérer l'unique étape qui n'était pas lente ne change presque rien au débit global. Une usine qui estampe des pièces plus vite que sa ligne d'inspection ne peut en valider ne livre pas plus de produits. Elle produit simplement un plus gros tas de pièces.

Il existe un seul endroit où la frappe est vraiment le goulot : le travail en terrain vierge, sans système existant à respecter. Le boilerplate, les prototypes, les scripts jetables, la première version de n'importe quoi. C'est justement pour ça que les démos paraissent magiques — les démos sont toujours en terrain vierge. L'ingénierie en production, elle, se fait presque entièrement en terrain déjà occupé, et ce travail-là consiste à lire.

Mythe 2 : le code généré par l'IA arrive déjà vérifié

La version optimiste du workflow se déroule ainsi : décrire la tâche, le modèle écrit le code, les tests passent, on merge. Le défaut se cache dans l'étape du milieu. Les tests passent indique seulement que les tests que vous avez pensé à écrire sont d'accord avec le code que le modèle a pensé à écrire. Les deux peuvent se tromper dans le même sens, et avec les sorties des LLM c'est souvent le cas — le modèle produit un code fluide, idiomatique, sûr de lui, et c'est précisément cette fluidité qui désarme la relecture.

Voici un petit exemple que j'ai vu en pratique, dans l'esprit sinon à la lettre. Demandez un planificateur de tâches mensuelles et vous obtiendrez quelque chose comme ceci :

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Lisez-le comme vous liriez la pull request d'un collègue. Il est idiomatique. Il gère le passage d'année. La docstring est même exacte. Exécutez-le maintenant le 15 avril avec day=31 : now.replace(day=31) lève une ValueError, car avril n'a pas de 31. La fonction plante précisément pour la demande de planification la plus courante — la fin du mois — et seulement pendant les mois courts, si bien qu'elle peut tourner en production sans broncher pendant des semaines avant que quelqu'un ne remarque. Un test qui parcourt une année entière de valeurs de now le détecte en quelques secondes. Un relecteur humain attentif le repère peut-être une fois sur deux. Cet écart, c'est le problème de la vérification en miniature.

C'est pourquoi je ne cesse de dire que, dans un workflow très instrumenté par l'IA, le choix entre les contrôles de compréhension et les tests n'a rien d'académique — c'est tout l'enjeu. Lire du code qu'on n'a pas écrit est déjà plus difficile que de l'écrire. Lire du code qu'aucun humain n'a écrit, au volume que ces outils produisent, inverse entièrement l'économie de la relecture. Les équipes que je côtoie ne manquent plus de code. Elles manquent de gens qui comprennent ce que fait ce code et qui acceptent de signer en dessous.

Une loupe révèle une fissure capillaire traversant une dalle de marbre poli.
Un code plausible casse comme le marbre : le long d'une fissure que l'on ne voit que si l'on regarde de près.

Mythe 3 : un code bon marché rend la conception logicielle bon marché

Une croyance plus subtile : si le code ne coûte presque rien, l'architecture compte moins, puisqu'on peut toujours réécrire. Mauvaise abstraction ? On la régénère. Mauvais modèle de données ? On régénère aussi. J'ai entendu des ingénieurs seniors le dire le plus sérieusement du monde, et cela confond le coût de modifier du texte avec le coût de modifier des décisions.

La partie difficile du logiciel n'a jamais été le code. Elle consiste à décider ce qui mérite d'être construit, à modéliser un domaine humain confus pour le rendre exécutable par une machine, et à faire des paris architecturaux qui ne s'effondreront pas quand les besoins changeront — et ils changent toujours. Ce sont des problèmes d'intention et de valeurs, pas de complétion de motifs. Un modèle entraîné sur le corpus des logiciels existants peut vous dire à quoi ressemblent généralement les systèmes comme le vôtre. Il ne peut pas vous dire à quoi le vôtre devrait ressembler, car cette réponse se trouve dans vos utilisateurs, vos contraintes et l'appétit de risque de votre organisation. Sur ce terrain, nous n'avons quasiment pas progressé, et je soutiens que ce n'est pas un écart de capacité qu'on peut combler par l'échelle. C'est une erreur de catégorie.

Les réécritures ne sont pas gratuites non plus. La plupart de l'argent investi en ingénierie sert à modifier des systèmes qui existent déjà, et modifier un système implique d'abord de rétro-ingénierer l'intention qui y est gravée — les invariants que personne n'a documentés, le cas limite qui s'avère porteur pour un client important. Le modèle ne connaît pas cette intention. L'équipe, souvent, non plus. C'est le fossé entre spécification et implémentation, là où vivent réellement les bugs, et en générer davantage l'élargit, à moins que quelqu'un ne tienne fermement la spécification.

Fred Brooks avait un terme pour désigner ce qui rend un logiciel cohérent : l'intégrité conceptuelle — le sentiment qu'un seul esprit, ou quelques esprits alignés, a pris les décisions. La génération fluide de code ne nous en rapproche pas. Au contraire, elle rend bon marché mille micro-décisions non alignées, et c'est ainsi qu'on obtient des systèmes qui ont l'air conçus et qui donnent l'impression d'avoir été assemblés.

Mythe 4 : un logiciel inchangé prouve que le codage par IA a échoué

Voici maintenant le contrepoint, car le cadrage de Blow n'est pas non plus imparable. Au-delà des logiciels commerciaux grand public, les choses bougent. La scène indépendante a produit des jeux de stratégie dotés de moteurs maison — réalisés par de toutes petites équipes — qui auraient exigé les effectifs de Blizzard il y a dix ans. Ce qui me frappe davantage, c'est la montée discrète des logiciels personnels : des gens qui construisent leurs propres clients mail, applis de calendrier, outils de suivi financier et interfaces git, taillés exactement selon leur façon de penser. Ces outils sont rustiques et ne survivraient jamais à une diffusion auprès de dix mille inconnus. Mais ils existent, on s'en sert tous les jours, et ils n'étaient simplement pas rentables à construire auparavant.

Même les institutions évoluent d'une manière que la métrique phare ne voit pas. Je connais des organisations dont le plan de modernisation consiste, en substance, à exposer le système legacy via des API correctes et à laisser le personnel construire lui-même ses propres endpoints et interfaces par-dessus, avec un outil de codage agentique. Ce n'est pas « mon logiciel a toujours la même tête ». C'est un logiciel qui se dissout dans quelque chose de plus personnel — invisible si l'on ne regarde que le classement des stores.

La raison plus profonde pour laquelle l'observation de Blow semble juste est pourtant organisationnelle plutôt que technique. Les logiciels commerciaux sont façonnés par ce que les entreprises optimisent — l'engagement, l'enfermement client, la cadence des versions, le coût du support — et l'IA vous en donne davantage, plus vite. Elle ne change pas ce que vous voulez. Une entreprise qui livrait des logiciels alourdis parce que le poids n'apparaissait pas dans son budget continuera à livrer des logiciels alourdis, sur un cycle de développement plus court. Le niveau d'exigence des logiciels destinés à des milliers d'utilisateurs est fixé par les incitations, la discipline de test et le goût — rien de tout cela n'est une sortie de modèle.

Il y a aussi un simple argument de décalage. Un codage IA réellement fiable n'a peut-être qu'un an ; la période précédente était instable, et avant cela c'était un jouet. Les produits prennent des années à concevoir, construire et livrer. Juger aujourd'hui l'effet de ces outils sur les logiciels livrés, c'est juger une nouvelle charrue d'après la récolte qui suit son invention d'un mois.

Mythe 5 : le prochain modèle comblera l'écart

La version la plus forte de l'argument de l'optimiste : chaque objection ci-dessus décrit les modèles actuels, et les modèles actuels sont les pires que nous utiliserons jamais. C'est en partie vrai. Les fenêtres de contexte vont s'agrandir, les API hallucinées vont diminuer, les agents deviendront meilleurs pour exécuter leurs propres tests. Je m'attends à de vrais gains, surtout sur les tâches bien spécifiées.

Mais remarquez quels goulots relèvent de la capacité et lesquels n'en relèvent pas. La vérification devient plus facile à mesure que les modèles gagnent en fiabilité — ça, c'est de la capacité. Décider de ce qui mérite d'être construit, préserver l'intégrité conceptuelle, faire évoluer ce qu'une organisation optimise — rien de tout cela ne figure sur la feuille de route d'un modèle, parce que ce ne sont pas des problèmes de modèle. Et soyez prudent avec les progrès des benchmarks comme preuve : les benchmarks passent à côté de l'essentiel du travail réel, et le travail réel est précisément celui qui est sous-spécifié et chargé d'intention.

Alors voici mon pari, noir sur blanc : les outils vont devenir nettement meilleurs pour les développeurs individuels et les petites équipes au goût sûr, et les logiciels grand public s'amélioreront marginalement, si tant est qu'ils s'améliorent — parce que la contrainte, là-bas, n'a jamais été le code. Si cela paraît pessimiste, ça ne l'est pas. Cela signifie que le levier se trouve entre vos mains et dans votre organigramme, et non dans la prochaine version d'un labo.

Un jardinier taille un bonsaï sur un établi ensoleillé, avec des outils à main.
La qualité logicielle reste un problème d'entretien, pas un problème de production.

Ce qui améliore réellement la qualité logicielle

Si la génération est bon marché et la vérification chère, la réponse rationnelle est de déplacer l'investissement. Concrètement :

  • Traitez les tests et les types comme une infrastructure de production. Les tests basés sur les propriétés, les vérifications d'invariants et une CI rapide sont ce qui transforme une génération bon marché en génération bon marché et correcte. Budgétez-les comme vous budgétez le calcul.
  • Écrivez la spécification avant le prompt. La spécification est désormais l'artefact le plus rentable qu'une équipe produit, car c'est ce que le modèle ne peut pas fournir et ce à quoi les relecteurs se réfèrent.
  • Utilisez l'IA là où elle est réellement forte : prototypes en terrain vierge, migrations, boilerplate, outillage personnel, exploration rapide d'un espace de conception. Méfiez-vous-en dans les chemins legacy porteurs de charge où l'intention n'est pas documentée.
  • Protégez le temps de conception. Quand la vélocité de génération triple, la pression est de remplir la feuille de route trois fois plus. Résistez. Décider, c'est le travail.

Le goulot d'étranglement n'a jamais été la frappe. Il a toujours été la décision — et la preuve.

La question de Blow a une réponse, et elle est porteuse d'espoir si on la lit correctement. Les logiciels se ressemblent parce que leur qualité a toujours été conditionnée par la décision, la vérification et le soin — et les assistants de code IA, malgré leur réelle utilité, accélèrent la partie qui n'a jamais été lente. Les outils pour améliorer les logiciels sont donc toujours les mêmes : le goût, la spécification et la discipline de la preuve. Les modèles ont simplement rendu impossible de continuer à faire semblant du contraire.