L’IA code de plus en plus vite. Nos équipes, elles, prennent l’eau.

SWE-bench est passé de 60 % à près de 100 % en un an. 88 % des organisations utilisent l’IA générative. Et pourtant, sur le terrain, beaucoup d’équipes n’arrivent toujours pas à dépasser le POC. Le vrai sujet de 2026 n’est plus la capacité des modèles, c’est l’écart entre ce que l’IA sait faire et ce que nos pratiques arrivent à en tirer.

L’illusion du « tout va plus vite »

Le 2026 AI Index de Stanford HAI confirme ce qu’on sent tous depuis quelques mois : l’IA n’a pas plafonné, elle s’accélère. Les modèles atteignent ou dépassent le niveau humain sur des questions scientifiques de niveau doctorat, et l’écart États-Unis/Chine est désormais de 2,7 points [1]. Quatre étudiants sur cinq utilisent l’IA générative au quotidien. L’adoption est massive, la capacité explose.

Et pourtant. Bassim Eledath le résume très bien : « la capacité de l’IA à coder dépasse notre capacité à la manier efficacement » [2]. Quand l’équipe d’Anthropic livre un produit comme Cowork en dix jours et qu’une autre équipe reste bloquée sur un POC cassé avec les mêmes modèles, ce n’est pas une question d’outil. C’est une question de pratique.

Les 8 niveaux d’ingénierie agentique

Eledath propose un modèle de maturité en 8 niveaux : tab complete, IDE agentique, context engineering, compounding engineering, MCPs et skills, sub-agents, agents en arrière-plan, multi-agents [2]. Ce qui m’a interpellé, c’est ce qu’il appelle l’« effet multijoueur ». Si tu es niveau 7 — tes agents en arrière-plan ouvrent des PRs pendant que tu dors — mais que ton repo exige l’approbation d’un collègue resté au niveau 2 à relire manuellement, ton débit est strangulé.

Autrement dit : la maturité IA d’une équipe est celle de son maillon le plus faible. C’est un sujet de leadership avant d’être un sujet de tooling.

La discipline qu’on a oubliée

Birgitta Böckeler met le doigt sur ce qu’elle appelle la « Frustration Loop » : générer, relire, « pas tout à fait ça », régénérer, relire, abandonner [3]. Le temps gagné à générer est consommé à corriger. L’IA produit ce qu’elle appelle « la moyenne d’Internet » — du code générique qui ne fit pas la stack, les conventions ou l’historique de l’équipe.

Sa proposition tient en une phrase : arrêter de traiter l’IA comme un outil et la traiter comme un teammate. Avec un junior, on fait de l’onboarding, on sketche au tableau blanc, on pose des standards. Avec l’IA, on saute toutes ces étapes — puis on s’étonne du résultat. Les cinq patterns qu’elle propose (knowledge priming, design-first collaboration, encoding standards…) ne sont pas une révolution. Ce sont juste les rituels qu’on a toujours appliqués entre humains, transposés à l’IA.

AI assistants are like junior developers with infinite energy but zero context.

Pendant ce temps, les canons à slop

À l’autre bout du spectre, Yoni Rechtman a un terme pour ces profils qu’on commence tous à croiser : les « slop cannons » [4]. Trois agents en parallèle par défaut, des PRs massives et confiantes, et un patch de suivi qui tombe dans les deux semaines. Ils ne peuvent pas expliquer leur propre diff. Ils font confiance au modèle plus qu’à leur reviewer.

Les chiffres font mal. En mars 2026, les agents IA ont généré environ 17 millions de PRs par mois sur GitHub, contre 4 millions en septembre 2025 — soit +325 % en six mois [4]. Le taux de PRs légitimes ? « 1 sur 10 », selon Xavier Portilla Edo de Voiceflow. CodeRabbit a analysé 470 PRs open source et trouvé que celles co-écrites par l’IA contiennent 1,7× plus d’issues, et 75 % d’erreurs de logique en plus. Et une étude METR sur 16 devs expérimentés a mesuré qu’ils se sentaient 20 % plus rapides… alors qu’ils étaient en réalité 19 % plus lents.

Un écart de 39 points entre le ressenti et la réalité. La sensation de productivité est devenue un produit en soi.

L’architecture n’a pas suivi

Michael Nygard pointe quelque chose que peu de gens veulent voir : les microservices étaient une réponse organisationnelle, pas une réponse technique [5]. On découpait le produit en petits services parce qu’on devait ajouter 100 développeurs et que la communication explosait. Aujourd’hui, on veut faire l’inverse : moins de développeurs, mais chacun avec son pod d’agents, propriétaires de plus gros morceaux de code.

Sauf que l’architecture qu’on a héritée est optimisée pour scaler out, pas scale down. Six mille services, des centaines de squads, personne ne sait comment ça marche. Les agents font monter les PRs et les LOC modifiées, mais les gros sujets — nouveaux marchés, produits transverses — n’avancent toujours pas. Et personne ne lève la main pour dire « mon service ne devrait plus exister » dans un climat de licenciements.

L’IA ne va pas juste changer notre façon d’écrire du code. Elle va forcer une refonte de nos frontières architecturales — et donc organisationnelles.

Le bateau en feu

C’est là qu’on devrait s’arrêter pour relire « Programming Still Sucks », de Ludicity [6]. Le texte est dur, parfois cynique, mais il dit la vérité que les rapports d’index ne disent pas. Le CEO revient d’un offsite où on lui a montré un agent qui code une feature en quatorze minutes, il y a cru, et il a annoncé au board qu’il pouvait couper 30 % de l’engineering au Q2.

« Tu t’es dit que les juniors s’adapteraient. Tu t’es dit que les seniors absorberaient. Tu as signé la liste. Tu savais. »

L’auteur rappelle ce qu’on perd quand on optimise pour l’output et qu’on abolit l’apprentissage : les juniors n’étaient pas valuables pour ce qu’ils produisaient, ils étaient valuables pour ce qu’ils allaient devenir — les seniors qui savent où sont enterrés les corps. Dans quelques années, on se demandera où sont passés les seniors. La réponse sera simple : on les a tués il y a trois ans, et plus personne ne se souvient.

Ce qu’on doit faire maintenant

Le AI Index nous dit que la capacité explose. Eledath nous donne un cadre pour grimper en maturité. Böckeler nous rappelle qu’il faut traiter l’IA comme un teammate, pas comme un distributeur. Rechtman nous montre ce qui arrive quand on confond volume et valeur. Nygard nous prévient que l’archi doit suivre. Et Ludicity nous rappelle qu’il y a des humains dans tout ça, qu’on est responsables, et qu’on le sait.

L’écart entre capacité et pratique n’est pas un problème de modèle. C’est un problème de management. C’est nous qui décidons quels rituels on garde, quelles boucles d’apprentissage on protège, quels juniors on forme malgré la pression. C’est nous qui choisissons entre niveau 2 et niveau 7 — et entre l’équipe et le canon à slop.

Si l’IA accélère tout, qu’est-ce qu’on accélère vraiment chez vous : la production, ou la dette ?

---

Sources

1. The 2026 AI Index Report | Stanford HAI
2. The 8 Levels of Agentic Engineering — Bassim Eledath
3. Patterns for Reducing Friction in AI-Assisted Development
4. The slop cannons in your engineering org
5. AI Versus Microservices
6. Programming Still Sucks. — Writing

Pour aller plus loin

• The Inference Shift — Ben Thompson sur la bascule du training vers l’inference, et pourquoi le compute AI devient hétérogène (Cerebras, Groq, etc.).
• Introducing Claude Platform on AWS — Anthropic débarque nativement sur AWS, signal fort sur la commoditisation de l’infra agentique.
• GitLab promises a different kind of layoff as biz pivots toward AI — Quand un acteur historique du DevOps réoriente son organisation autour de l’IA, ça raconte quelque chose du marché.
• The Emergent Self Loop — Une lecture plus systémique de la boucle d’apprentissage humain–IA et de ce qu’elle change dans la cognition collective.

Cet article a été rédigé en m’appuyant sur une IA pour m’aider à synthétiser et structurer ma veille. Les idées, le choix des sources et la relecture restent les miens.