Dans une étude de 2024, un étudiant termine son exercice de programmation. Il a réussi : 95 % de la tâche bouclée, le code tourne. En entretien, juste après, il lâche : « Honnêtement, je ne comprends rien au code. » Il vient pourtant de le produire. Avec l'IA, il a tout fini, et il n'a rien appris.
Cette phrase résume le piège le plus vicieux de notre époque. L'IA rend l'écriture de code tellement fluide qu'on peut traverser un apprentissage entier sans que le cerveau encode quoi que ce soit. On croit apprendre, on produit, et il ne reste rien. J'ai conçu une section de cours entière (Apprendre avec l'IA) autour de ce problème, et plus je creuse la littérature, plus je vois à quel point il est sous-estimé. Voici ce que dit vraiment la neuroscience, et comment apprendre à coder à l'ère de l'IA sans se faire avoir.
La dette cognitive, ou pourquoi tu ne te souviens de rien
En 2025, l'équipe de Nataliya Kosmyna au MIT Media Lab a branché des électrodes sur le crâne de 54 étudiants pendant qu'ils rédigeaient des essais. Trois groupes : cerveau seul, moteur de recherche, et ChatGPT. Le résultat est brutal. Dans le groupe IA, 83 % des participants étaient incapables de citer une seule phrase de ce qu'ils venaient d'écrire. Pas approximativement : rien du tout. L'EEG montrait une connectivité cérébrale effondrée, et le sentiment d'être l'auteur de son propre texte au plus bas.
Les chercheurs appellent ça la dette cognitive, par analogie avec la dette technique. Quand tu délègues ta réflexion à une machine, tu gagnes du temps maintenant, et tu paies plus tard sous forme de connaissances qui ne se sont jamais formées. Le mécanisme est simple et implacable : la mémoire à long terme se construit par l'effort de récupération. Si l'information arrive toute mâchée et qu'aucun effort n'est fourni pour la produire, l'hippocampe ne consolide rien vers le néocortex. Le code est passé sous tes yeux, jamais dans ta tête.
La règle contre-intuitive de l'apprentissage : plus c'est fluide sur le moment, moins ça reste après. La facilité ressentie n'est pas de l'apprentissage, c'est juste de la facilité.
L'illusion de compétence
Le deuxième danger est plus sournois, parce qu'il se déguise en réussite. En 2024, une étude intitulée The Widening Gap a observé 21 novices résolvant un problème avec GitHub Copilot. Taux de complétion : 95 %, contre 65 % dans une étude équivalente sans IA. Sur le papier, triomphe. Sauf que neuf des dix étudiants en difficulté n'auraient jamais fini sans l'IA, et croyaient avoir compris la solution bien plus qu'ils ne l'avaient comprise.
C'est l'illusion de compétence. Ton cerveau confond « je reconnais ce code, ça me paraît juste » avec « je sais produire ce code ». Reconnaître est infiniment plus facile que générer, et l'IA te met en permanence en situation de reconnaissance. Tu lis une solution, elle te semble évidente, tu hoches la tête, tu passes. Le sentiment de maîtrise est réel. La maîtrise, non. Et comme tu te sens compétent, tu n'éprouves jamais le besoin de t'entraîner pour de vrai.
Pourquoi c'est pire pour les débutants
Le titre de l'étude, l'écart qui se creuse, n'est pas innocent. L'IA ne profite pas à tout le monde de la même façon. Les développeurs déjà solides l'utilisent pour produire ce qu'ils savaient déjà vouloir, et surtout ils rejettent les mauvaises suggestions. Les chercheurs appellent ça l'expertise négative : savoir ce qu'il ne faut pas faire, reconnaître au premier coup d'œil une suggestion qui sent mauvais.
Les débutants, eux, n'ont pas ce filtre. Ils acceptent les suggestions de Copilot 34 % du temps, contre 24 % pour les plus à l'aise, y compris quand elles sont fausses. Ils plongent dans des impasses de débogage en s'éloignant de plus en plus de la solution, persuadés que l'IA a forcément raison. Résultat : l'IA accélère les forts et noie les faibles. Le fossé entre ceux qui savaient déjà raisonner et les autres se creuse au lieu de se combler.
La leçon est cruelle mais nette : l'IA est un amplificateur, pas un égalisateur. Elle multiplie ce que tu sais déjà faire. Si tu sais juger du code, elle te rend redoutable. Si tu ne sais pas encore, elle te donne l'illusion que ce n'est plus la peine d'apprendre.
Les 4 mécanismes pour vraiment apprendre
La bonne nouvelle, c'est que les remèdes sont connus, mesurés, et anciens. La science de l'apprentissage les appelle les difficultés désirables (Robert Bjork) : des frictions volontaires qui rendent l'apprentissage plus dur sur le moment et bien plus durable ensuite. Quatre comptent vraiment quand on apprend à coder avec l'IA.
1. La récupération active
Récupérer une information de ta propre mémoire la renforce bien plus que la relire. C'est l'effet le mieux établi de toute la psychologie cognitive. Concrètement : avant de demander à l'IA, essaie de répondre toi-même. Avant d'exécuter un bout de code, prédis ce qu'il va afficher. Ferme l'onglet et réécris la fonction de tête. Chaque fois que tu forces ton cerveau à produire au lieu de reconnaître, tu graves.
2. La répétition espacée
Un concept revu une fois s'oublie. Revu trois fois à intervalles croissants, il s'installe pour de bon. Le truc contre-intuitif : il faut laisser l'oubli commencer avant de réviser. Réviser quand tu as déjà tout en tête ne sert à rien ; réviser quand c'est en train de s'effacer, c'est là que la consolidation opère. Revoir une notion le lendemain, puis trois jours après, puis une semaine, bat n'importe quel bachotage.
3. L'effet de génération
Tenter de résoudre un problème avant de voir la solution améliore la rétention, même quand la tentative échoue. C'est l'échec productif de Manu Kapur. L'effort raté prépare le cerveau à encoder l'explication qui suit. C'est exactement l'inverse de ce que fait l'IA, qui te sert la solution avant que tu aies eu le temps de buter dessus. Inverse le réflexe : galère cinq minutes, puis demande.
4. L'expertise négative
Apprends à dire non au code de l'IA. La compétence centrale à l'ère des LLM n'est plus d'écrire du code, c'est de juger celui qu'on te propose. Lis chaque suggestion en te demandant « est-ce que je l'accepte, et pourquoi ? ». Cherche la faille de sécurité, l'effet de bord, le cas limite oublié. Rappelle-toi qu'une part importante du code généré contient des vulnérabilités. Le réflexe du reviewer, c'est ce qui sépare celui qui pilote l'IA de celui qui se fait piloter.
Comment je construis mes cours autour de ça
C'est exactement la philosophie de Coder avec l'IA et des projets appliqués : l'IA pond du code vite, tu le relis lentement, tu lui renvoies des instructions précises. Chaque projet montre les prompts réels, le code bancal du premier jet, puis la relecture qui durcit la sécurité, l'accessibilité et le contraste. On n'enseigne pas à déléguer, on enseigne à critiquer. C'est l'expertise négative transformée en habitude.
Mais en relisant la recherche, j'ai vu mes propres angles morts. Mes quiz tombent tout de suite après la leçon : ça teste la mémoire de travail, pas la mémoire durable. Mes exemples montrent souvent la solution avant l'effort. Je n'avais pas de vraie répétition espacée. Alors j'ajoute : un « prédis avant d'exécuter » dans l'éditeur, des questions de rappel libre où tu réexpliques avec tes mots, le retour des notions anciennes au fil des leçons, et un teach-back après chaque échange avec l'IA. Bref, j'injecte volontairement les frictions que mes propres cours, trop fluides, avaient gommées.
Conclusion
L'ironie de tout ça, c'est que l'outil censé démocratiser l'apprentissage du code peut creuser l'écart entre ceux qui savent déjà penser et ceux qui apprennent encore. L'IA ne te fera pas devenir développeur à ta place, pas plus qu'une calculatrice ne fait de toi un mathématicien. Elle amplifie un raisonnement qui doit déjà exister.
La vraie question n'a jamais été « est-ce que l'IA peut écrire ce code ? ». Bien sûr qu'elle peut. La question est : « après l'avoir lue, est-ce que je pourrais le réécrire seul ? ». Tant que la réponse est non, tu n'as rien appris, tu as juste emprunté. Et la dette, un jour, se paie.