L'IA, les juniors et moi. Et si j'étais juste un vieux con ?

Ma première boîte vendait un produit de logs distribués. L’argument de vente principal (répété dans chaque démo, chaque call client, chaque board deck), c’était : pas de base de données. Les DB, c’est lent. C’est ce que disaient nos vieux utilisateurs. C’est ce que disait notre vieux CEO. Les vrais, les purs, les durs, ils font du flat file et du mmap sur des fichiers bruts.

Le produit ramait.

Mon mentor, un type brillant, le genre à résoudre un bug entre deux parties de Guild Wars, a eu le génie et le culot de faire quelque chose de très simple. Il a planqué un SQLite dans la codebase C++. Discrètement. Sans demander la permission. Et d’un coup, les problèmes de performance qu’on traînait depuis des mois ont disparu.

La base de données qu’il ne fallait surtout pas utiliser a réglé tous nos problèmes. Les vieux cons avaient tort.

Dans d’autres boîtes, on m’avait dit de ne pas utiliser internet pour apprendre. “RTFM” : Read The Fucking Manual. Tout est dans la doc. Stack Overflow, c’est pour les feignasses. Google, c’est du bruit. Des vieux cons qui confondaient leur parcours d’apprentissage avec le seul parcours possible.

Je me demande souvent si je ne suis pas en train de faire exactement la même chose.

Vendredi soir. Un diff de 400 lignes généré par Claude. Les tests passent. Le linter est content. Le code est propre. Presque trop propre, cette propreté sans aspérité qui signale l’IA. J’ai scrollé, approuvé mentalement chaque bloc, et puis quelque chose m’a arrêté. Pas une erreur. Pas un bug. Une abstraction. Le code introduisait un service object là où un simple appel dans le contrôleur suffisait. Propre, oui. Mais faux.

Je n’aurais pas su dire pourquoi tout de suite. Juste un signal faible, un truc qui gratte. Vingt ans de code dans les doigts qui disaient non, pas comme ça.

Ça, c’est du jugement. Mais d’où vient-il, exactement ? Et est-ce qu’il se construit encore de la même façon ?

Quand j’ai commencé à coder, le 10x engineer c’était un type précis. Celui qui connaissait les raccourcis obscurs de vim, qui résolvait en une heure ce qui prenait une semaine aux autres. La vitesse comme vertu cardinale. Les lignes par jour comme unité de mesure.

La machine tape plus vite que n’importe lequel d’entre nous. Elle connaît toutes les APIs. Elle ne dort pas. Si le 10x se mesurait en débit, la course est terminée. Ce qui reste, c’est le jugement.

Anthropic a publié une étude sur l’impact de l’IA sur l’apprentissage du code.¹ Les développeur·euses qui utilisent l’IA ont scoré 17 % plus bas sur les questions de compréhension que celles et ceux qui codaient à la main. L’écart le plus marqué : le debugging. Exactement les compétences dont on a besoin pour attraper ce que l’IA rate.

Les chercheur·euses ont un nom pour ça : le supervision paradox. Superviser l’IA demande précisément les compétences que l’usage de l’IA érode.

(L’ironie de citer une étude d’Anthropic pour questionner l’usage de Claude ne m’échappe pas. 🙃)

The wisdom to know what not to build. Le jugement, ce n’est pas glamour. Ce n’est pas une PR de 2 000 lignes. C’est la capacité de dire non plus souvent que oui. De regarder un diff parfait et de sentir que l’abstraction est de trop. Ce qui reste, c’est le taste. Et le taste ne se génère pas.

Mais voilà le problème : le taste ne se transmet pas non plus. Il se construit. Et on ne sait pas encore par quels chemins.

Le code de l’IA est propre. Souvent plus propre que le mien. Et c’est justement le problème. Quand un·e collègue écrit du code bancal, la vigilance se déclenche naturellement : les aspérités du code humain sont des prises pour l’œil. Quand la machine écrit du code élégant, la vigilance s’éteint. La confiance monte avec l’apparence. Et l’apparence, c’est ce que la machine fait de mieux.

J’ai écrit dans un article précédent que je lisais les diffs de moins en moins attentivement. Que j’acceptais des implémentations dont je comprenais l’intention mais pas toujours le détail. Charity Majors a une formule pour ça :

Simple. Tranchant. Et de plus en plus difficile à respecter.

Alors.

Les juniors d’aujourd’hui apprennent à gérer l’IA plutôt qu’à coder. Dans dix ans, qui restera pour dire non, pas comme ça ? C’est la question qui traîne dans cet article depuis des semaines et qui m’empêchait de le publier. Parce que derrière elle, il y en a une autre.

Et si le jugement se construisait autrement, pas moins ?

Les développeur·euses qui ont appris avec Stack Overflow n’ont pas appris avec des man pages et des bouquins O’Reilly. Et iels codent très bien. Mon mentor avait appris le C++ dans des bouquins que je n’ai jamais ouverts. Il n’avait pas appris comme moi. Il avait appris quand même.

Amplify existing expertise. Le mot clé, c’est existing. Si ce qu’on a, c’est vingt ans de jugement accumulé : des bugs à 23h, des migrations foirées, des refactors trois fois plus longs que prévu, l’IA amplifie le jugement. Si ce qu’on a, c’est deux ans de prompts et aucune heure de debug à la main… l’IA amplifie quoi ?

Déroulons le fil. Un·e junior·e de 2026 qui accepte un diff. Puis un autre. Puis un qui casse en prod. Qui revient au diff, le relit, et voit ce qu’iel n’avait pas vu. Qui accepte un autre diff, et cette fois hésite. Qui refuse le suivant sans savoir exactement pourquoi. Juste un truc qui gratte. Vingt ans de diffs dans les yeux plutôt que vingt ans de code dans les doigts.

Je ne sais pas. Honnêtement. Le sentier change. Peut-être que la destination reste la même. Peut-être pas. On verra dans dix ans qui avait raison. Les vieux cons ou les nouveaux.

(En attendant, je continue à lire mes diffs. Plus attentivement qu’hier. 🙃)