Chapitre 12.4 — Monter TOI en niveau

⏱️ TL;DR — Le risque caché de l’IA : l’atrophie. Si tu délègues tout sans jamais comprendre, ton jugement se dégrade — et un architecte sans jugement ne pilote plus rien. Pour grandir avec l’IA au lieu de dépendre d’elle : ne merge jamais ce que tu ne comprends pas, lis les diffs du cœur métier, utilise l’agent comme prof (mode explicatif, skill /teach), et fais délibérément toi-même les parties dont tu veux maîtriser le raisonnement. L’objectif n’est pas de taper moins de code — c’est de mieux juger.

🎯 Objectifs

Reconnaître le risque d’atrophie des compétences.
Garder ton jugement affûté malgré la délégation.
Utiliser l’agent comme outil d’apprentissage.
Distinguer « déléguer la frappe » de « déléguer la compréhension ».

Le risque : l’atrophie du jugement

L’IA peut te rendre plus capable — ou t’atrophier, selon comment tu l’utilises. Si tu acceptes du code que tu ne comprends pas, session après session, deux choses se dégradent :

Ton jugement : tu ne sais plus distinguer un bon design d’un mauvais, un vrai finding d’un faux (P11) — donc tu ne peux plus garder le jugement (12.1), le rôle même de l’architecte.
Ta capacité à reprendre la main : le jour où l’agent bloque (et il bloque), tu es coincé, parce que tu n’as jamais compris ce que tu livrais.

Le partage est clair : délègue la frappe, jamais la compréhension. L’agent tape ; toi, tu comprends. C’est ce qui te fait grandir au lieu de te rendre dépendant.

Ne merge jamais ce que tu ne comprends pas

C’est la règle d’or de la croissance. Avant d’accepter un changement de cœur métier, tu dois pouvoir répondre : qu’est-ce que ça fait, et pourquoi ainsi ? Si tu ne peux pas, tu demandes (« explique-moi ce choix », « pourquoi cette approche plutôt qu’une autre ? ») avant de merger — pas après le bug.

⚠️ Piège — Le « ça a l’air de marcher, je merge » sur du code que tu ne comprends pas. Chaque merge aveugle est une dette de compréhension qui s’accumule. Un jour, tu ne sais plus comment ton propre produit fonctionne — et tu ne peux plus le faire évoluer sûrement. Comprendre ce que tu livres n’est pas optionnel pour un architecte ; c’est le métier.

L’agent comme prof

Retourne la situation : l’IA est le meilleur tuteur que tu aies jamais eu. Sers-t’en pour monter, pas seulement pour produire :

Mode explicatif (output style, 10.4) quand tu apprends : l’agent explique ses choix.
La skill /teach : apprendre un concept/une techno de façon suivie, à ton rythme.
Demande le pourquoi : « pourquoi des server actions ici ? », « quels compromis j’ignore ? ». Tu transformes chaque tâche en leçon.
Fais réfuter tes idées (pattern adversarial, 8.3) : « quels sont les meilleurs arguments contre mon approche ? » — pour muscler ton raisonnement, pas seulement obtenir un résultat.

💡 Réflexe d’architecte — Une fois par session au moins, apprends une chose que tu ne savais pas — un pattern, une raison, un compromis. L’IA rend l’apprentissage quasi gratuit : il suffit de demander pourquoi. Le dev qui produit sans jamais demander pourquoi stagne ; celui qui demande pourquoi à chaque tâche progresse à une vitesse folle. Utilise ce levier.

Fais délibérément les parties difficiles

Contre-intuitif mais essentiel : pour les compétences que tu veux vraiment maîtriser (un domaine, un pattern d’archi), fais-les parfois toi-même, à la main, même si l’agent irait plus vite. On n’apprend pas à raisonner en regardant quelqu’un raisonner ; on apprend en luttant avec le problème. Délègue le routinier ; garde pour toi, de temps en temps, le difficile que tu veux posséder.

🧭 Sur TaskFlow — Sur TaskFlow, tu peux laisser l’agent générer le CRUD routinier (tu comprends le pattern) mais concevoir toi-même la partie que tu veux maîtriser (disons la stratégie d’auth, ou le modèle de permissions), en te servant de l’agent comme sparring-partner (« critique mon approche ») plutôt que comme exécutant. Résultat : TaskFlow avance et toi tu montes sur ce qui compte pour ta carrière.

L’architecte grandit par le jugement

Récapitulons la posture : ta valeur ne se mesure pas au code que tu tapes (l’agent en tape plus et plus vite), mais au jugement que tu exerces — quel problème résoudre, quelle architecture, quel compromis, qu’est-ce qui est bon. Ce jugement se cultive en comprenant ce que tu livres et en apprenant à chaque tâche. L’IA est un accélérateur de croissance pour qui l’utilise comme prof, et un accélérateur d’atrophie pour qui l’utilise comme béquille. Choisis le premier.

✏️ Exercices

Exercice 1 — Le pourquoi systématique. Sur ta prochaine session, à chaque décision de l’agent que tu ne comprends pas entièrement, demande « pourquoi ainsi ? » avant d’accepter. Combien de « leçons » en une session ?

✅ Solution

Tu découvriras que beaucoup de choix que tu acceptais machinalement cachent un raisonnement (un compromis, une contrainte). Les expliciter t’apprend le pourquoi, pas juste le quoi. Une session devient une session de formation gratuite — c’est le meilleur usage « caché » de l’IA.

Exercice 2 — Possède le difficile. Choisis une compétence que tu veux vraiment maîtriser. Sur ta prochaine occasion, fais cette partie toi-même, en utilisant l’agent comme critique (« réfute mon approche ») et non comme exécutant. As-tu appris plus qu’en déléguant ?

✅ Solution

Lutter avec le problème (puis se faire challenger) ancre le raisonnement bien plus qu’en regardant l’agent le résoudre. Tu délègues le routinier pour libérer du temps sur le difficile que tu veux posséder. C’est ainsi qu’on utilise l’IA pour monter en niveau au lieu de plafonner.

🧠 Quiz de révision

1. Quel est le risque caché de l’IA pour le dev ?

L’atrophie du jugement : à force de merger sans comprendre, on perd la capacité de distinguer le bon du mauvais et de reprendre la main quand l’agent bloque. Un architecte sans jugement ne pilote plus.

2. Que délègue-t-on, que garde-t-on, pour grandir ?

On délègue la frappe ; on garde la compréhension. L’agent tape, toi tu comprends ce que tu livres — c’est ce qui affûte le jugement au lieu de créer de la dépendance.

3. Quelle est la règle d’or de la croissance ?

Ne jamais merger ce qu’on ne comprend pas. Si tu ne peux pas dire « ça fait X, ainsi parce que Y », tu demandes avant de merger, pas après le bug.

4. Comment utiliser l’agent comme prof ?

Mode explicatif, skill /teach, demander le pourquoi de chaque choix, et faire réfuter ses idées. On transforme chaque tâche en leçon — apprendre au moins une chose par session.

5. Pourquoi faire parfois soi-même les parties difficiles ?

Parce qu’on apprend à raisonner en luttant avec le problème, pas en regardant l’agent le résoudre. Pour les compétences qu’on veut posséder, on garde le difficile (agent en sparring-partner) et on délègue le routinier.

Chapitre suivant : Les checklists de l’architecte — la posture condensée en gestes quotidiens.