J’ai commencé à programmer à 12 ans, à écrire des RAT et des chevaux de Troie en Delphi, parce que c’est ce que faisaient les gamins roumains en 2002. À 21 ans j’étais diplômé de lettres et je construisais des CRM de zéro en PHP. Pas de diplôme d’informatique, pas de bootcamp, pas de mentor. Juste une connexion internet de merde, Notepad++ et une obsession qui m’empêchait de dormir.
J’ai appris à scraper des sites en construisant des sites de leech, des clones parasites qui pompaient les bases de données d’autres sites et tournaient sur des VPS à un dollar ou chez des hébergeurs gratuits. Ça voulait dire inspecter du HTML à la main, écrire des regex à s’en faire saigner les yeux, gérer des problèmes d’encodage, du rate limiting, des cookies de session. Le réseau, je le connaissais déjà pour avoir écrit des chevaux de Troie gamin: ports, sockets, connexions, toute la merde que tu apprends quand tu essaies de faire rentrer un reverse shell à la maison à travers un pare-feu. J’ai appris la concurrence parce que mon scraper était trop lent et qu’il a fallu que je comprenne comment lancer plusieurs trucs à la fois sans corrompre l’état partagé.
Chacune de ces leçons est venue de la douleur. Des heures de débogage. Des jours bloqué sur un truc qui s’est avéré être un point-virgule manquant ou un mauvais numéro de port. La douleur était le programme. La galère était le prof.
Maintenant un développeur junior se cogne au même mur, colle l’erreur dans Claude ou ChatGPT, récupère le correctif en dix secondes et passe à la suite. Zéro apprentissage. La douleur a été sautée. Et la douleur ÉTAIT l’éducation.
Le Problème de la Calculatrice
C’est comme donner une calculatrice à quelqu’un avant qu’il comprenne la multiplication. Ouais il obtient la bonne réponse, mais il n’a aucune intuition pour savoir quand la réponse est fausse. Tu lui demandes « 7 fois 8 égale 312? » et il hausse les épaules, parce qu’il n’a jamais construit le ressenti au ventre qui devrait lui faire dire « ça a pas l’air juste ».
Les outils d’IA marchent pareil. Un nouveau développeur prompte Claude, obtient du code qui marche, le livre, se sent génial. Mais à la seconde où un truc casse d’une façon que l’IA ne peut pas réparer, et ce moment arrive TOUJOURS, il est complètement démuni. Aucun modèle mental de ce qui se passe réellement. Aucune capacité à raisonner sur le code qu’il fait tourner. Aucune intuition, même pas sur où commencer à chercher.
Quand mon scraper casse, je sais exactement où regarder, parce que je comprends chaque couche: la requête HTTP, le parsing de la réponse, l’encodage, la gestion de session, le rate limiting. J’ai construit cette compréhension en passant des centaines d’heures à me planter d’abord.
Le scraper d’un nouveau développeur casse et il recolle l’erreur dans ChatGPT en priant. Ça marche 80% du temps. Les 20% restants il est complètement baisé.
La Salle de Sport Avec un Robot
C’est comme aller à la salle mais avoir un robot qui soulève les poids à ta place. Ouais le poids a bougé, mais tes muscles n’ont pas poussé. Tu ressors avec la même allure qu’en entrant.
Les développeurs qui ont appris avant l’IA ont dû soulever chaque poids eux-mêmes. Chaque bug corrigé à la main. Chaque décision d’architecture prise par essais et erreurs. Chaque script de déploiement écrit à la main après la troisième fois où tu as foiré un déploiement manuel. C’est comme ça qu’on se fait du muscle d’ingénieur.
Maintenant il y a une génération de développeurs qui n’ont jamais écrit une boucle for de zéro sans l’aide d’une IA. Jamais débogué une regex à la main. Jamais passé quatre heures à comprendre pourquoi leur code est décalé de un. Jamais eu à RÉFLÉCHIR à ce que fait vraiment une fonction, parce qu’ils peuvent juste demander à la machine de leur expliquer.
Ils peuvent produire du code. Ils peuvent livrer des fonctionnalités. Ils peuvent passer les revues de code parce que le code généré par IA a l’air correct. Mais ils ne savent pas déboguer. Ils ne savent pas architecturer. Ils ne savent pas raisonner sur des systèmes. Parce qu’ils ont sauté la partie où on apprend ces choses, celle où tout est cassé et où il faut comprendre pourquoi.
Le Problème de l’Entretien
Les entreprises ne font plus la différence. Deux candidats passent un entretien. Les deux savent « construire un scraper ». Les deux savent « monter une API REST ». Les deux savent « écrire des tests unitaires ». L’un comprend vraiment ce qu’il construit. L’autre est un proxy pour un LLM.
Bonne chance pour deviner lequel est lequel dans un screening technique de 45 minutes où le candidat a Copilot ouvert dans son IDE.
Et l’ironie est épaisse: tout le système d’entretiens FAANG était déjà cassé avant l’IA. Faire dessiner des arbres rouge-noir et du quicksort au tableau à des développeurs, pour des postes où la plus grosse table fait 2000 lignes et où l’endpoint le plus lourd est appelé deux fois par jour. Il y a un type quelque part qui bosse Leetcode pendant six mois pour décrocher un job où le vrai boulot c’est câbler des API entre elles et comprendre pourquoi l’environnement de staging est cassé le mardi.
Maintenant ajoute l’IA à ce bordel. Les questions au tableau sont inutiles parce qu’un candidat peut s’entraîner avec une IA jusqu’à mémoriser chaque motif. Les projets à la maison sont inutiles parce qu’une IA peut générer une solution complète en quelques minutes. Les sessions de pair programming sont inutiles parce que le candidat ne fait que traduire entre l’intervieweur et son modèle mental de ce qu’il faut demander à Claude.
La seule chose qui marche encore, c’est s’asseoir avec quelqu’un et le regarder déboguer un vrai problème en temps réel sans outils. Et presque personne ne le fait, parce que ça prend trop de temps et que ça ne passe pas à l’échelle.
Le Milieu Évidé
C’est ici que ça devient vraiment sombre. Le chemin du junior au senior a toujours été: galérer pendant des années, construire une compréhension profonde par la douleur, et finir par développer l’intuition et la pensée systémique qui font de toi un senior. Ce chemin exigeait la galère. Enlève la galère et le chemin disparaît.
Alors qu’est-ce qui se passe dans dix ans? Une toute petite élite d’ingénieurs seniors qui ont appris avant l’IA et comprennent vraiment les fondamentaux. Un énorme réservoir de juniors qui sont en gros des opérateurs d’IA, productifs quand les outils marchent, impuissants quand ils ne marchent pas. Et rien entre les deux, parce que plus personne ne fait le trajet de l’un à l’autre.
L’échelle de l’apprentissage se fait remonter. Pas par malveillance, personne n’a planifié ça. Mais l’effet est le même. L’outil qui te rend productif aujourd’hui est exactement celui qui t’empêche de devenir vraiment compétent demain.
Et tu ne peux pas dire à un gamin de 20 ans « n’utilise pas l’IA, galère à la main pendant cinq ans d’abord ». C’est comme dire à quelqu’un en 2005 « n’utilise pas Google, va à la bibliothèque ». Il ne le fera pas. Pourquoi il le ferait? Le choix rationnel pour n’importe quel individu, c’est d’utiliser les outils les plus puissants disponibles. Le problème, c’est que ce qui est rationnel pour l’individu est catastrophique pour la profession.
Ce Qui Compte Encore
Les développeurs qui survivront à ça ne sont pas ceux qui écrivent le plus de code. L’IA fait déjà ça mieux que la plupart des humains. Les survivants sont ceux qui comprennent POURQUOI les choses marchent.
Comprendre le POURQUOI, c’est ce qui te permet de:
- Déboguer des problèmes que l’IA ne peut pas résoudre parce qu’elle n’a jamais vu cette combinaison précise de pannes
- Architecturer des systèmes qui ne s’effondrent pas quand les besoins changent
- Évaluer du code généré par IA et attraper les bugs subtils qui ont l’air corrects mais ne le sont pas
- Prendre des décisions qui exigent de comprendre les compromis entre approches, pas juste de choisir la première qui compile
- Savoir que la suggestion de l’IA est fausse parce que ton ventre te dit « ce chiffre a pas l’air juste »
Cette intuition ne vient qu’en le faisant à la dure d’abord. Il n’y a pas de raccourci. Aucune IA ne peut te la donner. Elle se gagne par des années passées dans la merde à démêler les choses.
L’Avantage de l’Autodidacte
Voilà le retournement que personne n’avait vu venir: les développeurs autodidactes ont peut-être le plus gros avantage de l’ère IA. Pas malgré le fait d’avoir appris à la dure, mais à cause de ça.
On n’avait pas de programme. Personne ne nous a tendu un parcours d’apprentissage. On a attrapé les problèmes à la gorge et on a démêlé les choses parce qu’on en avait envie, pas parce qu’un syllabus nous le disait. Cette habitude, être sincèrement curieux, vouloir comprendre comment les choses marchent vraiment, ne pas être satisfait tant qu’on n’a pas remonté le problème à sa racine, c’est exactement cette habitude qui survit à la disruption de l’IA.
Le diplômé d’informatique qui a mémorisé des structures de données pour les examens n’a jamais développé cette habitude. Il a appris QUOI faire, pas COMMENT penser. Quand ses motifs mémorisés ne collent pas au problème, il est coincé. Quand ceux de l’autodidacte ne collent pas, il creuse plus profond, parce que c’est tout ce qu’il a jamais fait.
L’intérêt est le seul avantage compétitif durable en informatique. Tout le reste peut être appris, copié ou automatisé. Mais on ne peut pas automatiser le fait d’en avoir quelque chose à foutre.
La Vérité Inconfortable
90% des systèmes en production n’auront jamais besoin du genre de connaissance profonde dont je parle. La plupart des applis métier pourraient tourner sur du bubblesort, sans index en base, avec SELECT * sur chaque table, et personne ne remarquerait rien, parce que la plus grosse table fait 847 lignes et que la base ne transpire même pas.
Pour ces systèmes-là, les développeurs assistés par IA font l’affaire. Mieux que l’affaire, ils sont plus rapides et moins chers. Le code marche, les fonctionnalités partent, l’entreprise se fout de comment la saucisse est faite.
Le problème, ce sont les 10% restants. Les systèmes qui comptent vraiment. Les plateformes financières qui traitent du vrai argent. L’infrastructure dont les gens dépendent. Les systèmes de sécurité qui n’ont pas droit aux bugs subtils. Les systèmes où « ça marche 80% du temps » ne suffit pas et où les 20% d’échec coûtent des millions.
Ces systèmes ont besoin d’ingénieurs qui comprennent les fondamentaux. Et on est sur le point d’en manquer sévèrement, parce que la filière qui les produisait vient d’être remplacée par un raccourci qui produit quelque chose d’identique en surface mais qui s’effrite sous la pression.
Les ingénieurs seniors d’aujourd’hui ont été forgés dans le feu du débogage manuel, du code écrit à la main et des années d’apprentissage douloureux. Quand on partira à la retraite, qui nous remplace? Le développeur qui copie-colle de la sortie d’IA depuis dix ans? Ce n’est pas un ingénieur senior. C’est un rédacteur de prompts très expérimenté.
Et l’industrie n’a pas l’air de s’en soucier. Parce que là, aujourd’hui, le développeur assisté par IA livre des fonctionnalités plus vite. Le retour sur investissement est superbe dans le rapport trimestriel. La dette technique est invisible jusqu’à ce qu’elle ne le soit plus. Et d’ici là ce sera le problème de quelqu’un d’autre.
Comme d’habitude. Juste plus vite maintenant.