Pendant ce temps, les fondamentaux tiennent

La moitié du corpus 2025-2026 a parlé d'agents ; l'autre moitié de Kanban, d'error budget, de monolithe Rails et d'index Postgres, parfois sans prononcer le mot IA. Ce contrechamp porte deux thèses. La première : le métier continue — usine logicielle des Furets, monolithe Pennylane, capteur Sensome, SRE, orchestration déterministe — avec la même boîte à outils qu'avant la vague. La seconde, plus contre-intuitive : l'IA récompense activement les fondamentaux. Typage et TDD deviennent les harnais des agents, l'architecture hexagonale leur donne un cadre, le Lean fournit la grille de lecture, la qualité de la donnée fait le RAG. Les best practices survivent en changeant de justification. Car le métier n'a jamais été d'écrire du code : on est développeurs.

Cinq apprentissages durant, ce bilan a raconté une année de secousses : la bascule agentique, la boucle de contrôle qui craque, les juniors en suspens, la souveraineté redevenue concrète, l'humain qui résiste à la méthode. Il manquait le contrechamp. Car pendant que la moitié du corpus débattait de Claude Code, l'autre moitié parlait de Kanban, d'error budget, de monolithe Rails et d'index Postgres — parfois sans prononcer une seule fois le mot « IA ». Ce silence n'est pas un angle mort : c'est une donnée. Et il cache la trouvaille la plus contre-intuitive de l'année — l'IA ne périme pas les fondamentaux, elle les récompense.

Thèse 1 — Rien n'a bougé : le métier continue

La preuve la plus simple est une preuve par l'existence : des épisodes entiers, en pleine déferlante agentique, consacrés au métier tel qu'il se pratique depuis vingt ans — et passionnants précisément pour cela.

Geoffrey Bérard (Les Furets, #327) ouvre le bal avec l'usine logicielle : la partie répétable du métier — compiler, tester, packager, déployer — totalement automatisable, au service d'un artisanat qui, lui, ne l'est pas. La prédictibilité ne se souhaite pas, elle s'organise. Les Furets sont passés d'une mise en production par mois à une par jour avec une question de bon sens : si le process d'incident sait livrer le jour même, pourquoi ne pas l'utiliser tout le temps ? Pas un agent à l'horizon : de l'organisation, des standards, une definition of done.

Quentin de Metz (Pennylane, #332) enfonce le clou côté architecture. Pennylane sert près de 500 000 entreprises avec environ 250 ingénieurs sur un seul monolithe Ruby on Rails de 2 millions de lignes, mis en production toutes les quinze minutes. Sa thèse n'est pas que le monolithe est meilleur — c'est qu'aucun paradigme ne marche tout seul, et qu'il vaut mieux prendre ses risques là où il y a de la récompense : le business model, pas l'architecture. Et le contrepoint chiffré le plus froid du corpus sur l'IA : écrire du code ne représente qu'environ 15 % du travail, le doubler ne donne que 7 % de productivité.

Gor Lebedev (Sensome, #343) emmène le podcast là où la physique impose ses lois : un capteur trois fois plus fin qu'une feuille de papier, logé dans un guide neurovasculaire pour analyser les caillots d'AVC in situ. Dans ce monde-là, une erreur de design de puce coûte des mois, pas dix secondes dans un IDE ; on réfléchit en amont parce qu'on ne peut pas itérer. L'épisode ne mentionne ni copilote ni agent : c'est l'ingénierie dans sa version la plus fondamentale.

Kevin Davin (Gradle, #355) rappelle que DevOps est une philosophie, pas un poste, et que le SRE en est une implémentation : error budget, observabilité, boucles de feedback courtes. Son message central — éduquer les devs aux pratiques d'ops plutôt que les en protéger — est intemporel, et sa conclusion désarmante : une prod bien gérée doit être un sujet relaxant. Jean-Christophe Leducq (Digital Substrate, #348) attaque un invariant plus dérangeant : 70 à 80 % du code d'une application est de l'infrastructure logicielle sans rapport avec le métier, alors que 90 % de la valeur est dans le métier. Sa réponse, un « data OS » fortement typé et immuable, est un plaidoyer pour le génie logiciel à l'état pur. Loïc Mathieu (Kestra, #363) complète côté orchestration : workflows déclaratifs en YAML, patterns de migration sans Big Bang, et une demande client sans ambiguïté quand Bruno suggère un orchestrateur « intelligent » : ce que veulent les entreprises, c'est du déterminisme.

Le fil se prolonge partout. Nicolas Guillot (freelance, #340) martèle que les erreurs de débutant restent les mêmes et que l'architecture logicielle demeure le premier fondamental à transmettre. Adrien Cacciaguerra (CodSpeed, #337) démocratise les tests de performance en CI, contre les « silent killers », ces dégradations incrémentales invisibles. Houleymatou Baldé (Yeeso, #359) raconte une montée en compétences de zéro jusqu'à lead tech bâtie sur l'algorithmie avant le langage, le débuggeur et la documentation. Et les épisodes de transformation — Antoine Jacoutot (Believe, #328) et son refactoring total, Julien Briault (Restos du Cœur, #344) et son cloud souverain de récupération, Jean-Marc Léglise (indépendant, #345) et sa défense des estimations, Loïc Tosser (Kalvad, #354) qui rappelle qu'avant de migrer de cloud, on pose un index sur sa base — mobilisent tous la même boîte à outils, celle qui existait avant la vague et qui existera après.

Adnan Aita (Sharelock, #339) donne à cette thèse sa formulation théorique. Pour lui, les fondamentaux n'ont quasiment pas bougé en vingt, trente, quarante ans : TCP/UDP, IP, les couches OSI, les design patterns. Toute l'histoire de l'informatique est un empilement de couches d'abstraction, et à chaque étage les anciens ont accusé les nouveaux de ne pas être de « vrais » informaticiens. Les LLM ne seraient que la couche suivante — moins déterministe, concède-t-il, mais dans la droite ligne. Et c'est la culture générale technique, pas la maîtrise d'un framework, qui rend résilient quand le marché se contracte.

Thèse 2 — L'IA ne périme pas les fondamentaux : elle les récompense

On pourrait s'arrêter là et conclure à la coexistence pacifique : d'un côté la vague, de l'autre le socle. Ce serait passer à côté de la vraie découverte de l'année, qui s'est imposée épisode après épisode sans qu'aucun invité ne l'ait formulée seul : les fondamentaux ne survivent pas à l'IA par inertie. Ils sont activement récompensés par elle — et leur absence, activement punie.

Le premier indice vient de Quentin Adam (Clever Cloud, #341) : maintenant que le code ne coûte plus rien, la type safety et le TDD reviennent sur le devant de la scène. Rust est selon lui le langage qui a triomphé en génération LLM, parce que son compilateur verbeux engueule le modèle en boucle jusqu'à ce que le code soit correct, là où JavaScript laisse tout passer. Le paradoxe est complet — la pratique la plus « old school » devient le meilleur harnais du non-déterminisme.

Pierre Burgy (Strapi, #364) le confirme depuis l'édition de logiciels : le passage à TypeScript était un breaking change non négociable, précisément parce que les LLM sans typage codent à l'aveugle, comme les devs l'étaient avant eux. Typage, architecture par fichiers lisible, conventions : ce que Strapi exigeait pour ses contributeurs humains devient un prérequis pour les coding agents, dont l'éditeur a fait son nouveau persona cible.

Jocelyn N'takpe (ManoMano, #346) apporte le chiffre : une étude de Berkeley estime que 94 % des erreurs d'agents seraient évitables avec une simple phase de compilation. Son constat de terrain va plus loin : plus on cadre les agents, plus ils sont efficaces. L'architecture hexagonale, le DDD — ces patterns que l'humain trouvait verbeux — donnent à l'agent exactement le cadre dont il a besoin ; le TDD « fait encore plus qu'avant sens ». Tout ce que le craft prêchait depuis quinze ans pour des raisons humaines se trouve revalidé pour des raisons machines.

C'est la thèse de Julien Lepine (AWS, #351) : les best practices survivent à l'IA, mais changent de justification. Elles existaient parce que la contrainte centrale était l'humain ; elles restent parce que les agents eux-mêmes galèrent à recomprendre le code qu'ils ont généré. Mieux : c'est l'architecture contrainte héritée d'Amazon — codebases séparées par équipe, contrats d'interface stables — qui rend aujourd'hui possible la liberté donnée aux IA. L'API de S3 n'a pas changé depuis 2006 alors que le service a été réécrit des dizaines de fois. Et à l'échelle où la relecture exhaustive ne tient plus, la réponse d'AWS est plus de fondamentaux encore : modélisation formelle, raisonnement automatisé, analyse statique.

Yacine Hmito (Fabriq, #362) fournit la grille de lecture la plus inattendue du corpus : le Lean, système de pensée né dans les années 50, se révèle être l'outillage intellectuel le plus opérant de l'ère agentique. L'explosion du code généré s'analyse comme un problème de flux — on a multiplié par dix le débit du tuyau sans adapter l'aval, la review ; le code généré non relu est du stock, que le Lean proscrit. La réponse n'est pas de supprimer le contrôle qualité mais de pratiquer l'auto-qualité : identifier les mauvaises pièces, comprendre pourquoi, changer le système pour qu'elles ne se reproduisent plus. Sa hiérarchie stricte interdit exactement le mauvais trade-off que l'époque encourage : donner l'accès prod à un agent pour corriger un bug plus vite. Soixante-dix ans d'âge, pas une ride.

Le terrain confirme partout. Alexandre Gerlic (Alan, #371) n'a pu ouvrir la contribution au code aux designers, PM et équipes opérations que parce que les fondamentaux préexistaient : CI/CD éprouvée, linters, code review systématique — plus la code base est propre et bien testée, plus elle est facile à travailler pour l'IA. Pierre Lemaire (Hexa, #347), du fond du vibe coding le plus assumé, identifie ce qui survit au code jetable : la logique business, le data model, les fondamentaux d'architecture produit — le code se réécrit en trois jours, pas la pensée qui le structure. Julien Dubois (Microsoft/GitHub, #353) observe que Java, langage typé à l'écosystème massif, se retrouve avantagé par les LLM. Guillaume Lours (Docker, #360) ne contrôle ses agents que parce qu'il connaît son projet assez intimement pour les interrompre dès qu'ils dévient : la connaissance du système reste la condition de la délégation.

Même la donnée suit la règle. Guillaume Laforge (Google, #361) le dit sans détour : le nerf de la guerre du RAG, c'est la qualité de la donnée — leçon héritée de l'ère big data et de son illusion du data lake. Une modélisation propre vieille de dix ans, comme les blocs de Notion, devient un avantage concurrentiel à l'ère des agents. Adrien Cacciaguerra prolonge côté performance : quand le client de votre application est un agent, la rapidité d'exécution devient un facteur différenciant majeur. Et Gabriel de Marmiesse (Kyutai, #372) rappelle ce qu'il y a sous le capot : des multiplications de matrices, des floats IEEE dont le GPU ne garantit même pas l'ordre d'addition. La couche la plus haute de l'abstraction repose, comme toujours, sur la plus basse.

Reste la boucle de fermeture, et elle appartient à deux voix qui convergent. Adnan Aita pose que « Le métier de développeur ou d'ingénieur développeur n'a jamais été d'écrire du langage machine. Le métier, c'est de comprendre une problématique et de trouver une solution à cette problématique. » Bruno, qui avait pourtant ouvert l'épisode #339 avec la thèse inverse — le métier se complexifie —, finit par acter le point de convergence : le métier est en train de changer et, en même temps, de rester le même. On résout des problèmes. La formule définitive, il la reprend d'Antonio Goncalves en clôture du #357 : on n'est pas codeurs, on est avant tout des développeurs et des développeuses. C'est sur ce socle-là — le seul que ni la vague de cette année ni celle de la prochaine ne semblent pouvoir emporter — que peut s'écrire la suite. La suite, justement, appartient à Bruno.