Er is de laatste tijd veel geschreven over code lezen. De kop van 404 Media over hersenen die wegrotten. De Anthropic-studie waar de AI-groep 17% lager scoorde op begrip. Mijn eigen stuk met de stelling dat je de bug niet vindt als je de code niet schreef.
Overal een diagnose. Nergens een training.
Elk van die stukken eindigt hetzelfde: lezen is de vaardigheid die afstompt, dus bescherm hem. Prima. Maar bescherm hem hoe? "Lees aandachtiger" is geen plan. Dat is het programmeerequivalent van iemand vertellen dat hij "gewoon wat zelfverzekerder" moet zijn. Mooi bedoeld, nul herhalingen.
Dit is dus de andere helft. Niet waarom lezen ertoe doet. Hoe je er daadwerkelijk beter in wordt.
Lezen is een vaardigheid, en vaardigheden hebben oefeningen
Begin met een getal dat tientallen jaren ouder is dan AI. Robert Martin schatte de verhouding tussen tijd besteed aan code lezen en code schrijven op ongeveer tien tegen een. Tien. Voor elk uur dat je schrijft, lees je er tien: je eigen code van vorige maand, de PR van een collega, de library die je aan het debuggen bent, de stack trace om 3 uur 's nachts.
En hoeveel van je opleiding ging naar lezen? Bijna niets. De universiteit leerde je schrijven. De bootcamp leerde je schrijven. Elke tutorial die je ooit hebt gevolgd, gaf je een leeg bestand en zei: vul maar in. De meest gebruikte vaardigheid van het vak is precies de vaardigheid waar niemand je ooit in coachte.
Felienne Hermans schreef er een heel boek over, The Programmer's Brain. Haar kernpunt: code lezen is een cognitieve vaardigheid die draait op chunking, hetzelfde mechanisme waarmee een schaker één blik op het bord werpt en stellingen ziet in plaats van losse stukken. Een expert leest for (int i = 0; i < n; i++) niet teken voor teken. Die ziet in één oogopslag "loop over de array", omdat hij die vorm tienduizend keer heeft gezien. Beginners lezen letter voor letter en raken door hun werkgeheugen heen voor ze bij de body zijn.
Chunking is te trainen. Dat is de hele premisse achter haar code reading clubs: groepen die bij elkaar komen en code lezen, expres, als training. Niet om iets op te leveren. Om beter te worden in het zien van structuur.
Dat betekent dat lezen een spier is, geen talent dat je wel of niet hebt. En een spier die je kunt opbouwen, kun je ook laten wegteren.
AI verschoof de verhouding en pakte toen je herhalingen af
Dit is er veranderd. Die verhouding van tien tegen een ging toch al nooit omlaag. Nu is de code die je leest gegenereerd, dus lees je er nog meer van, en het is code die je niet zelf schreef, wat de lastigste soort is om te lezen. Ondertussen is het schrijven, het deel dat het instinct überhaupt opbouwde, precies het deel dat je uit handen gaf.
Meer lezen. Moeilijker lezen. Minder herhalingen. Alle lijnen wijzen tegelijk de verkeerde kant op.
Hier zie je het briljante papegaaienprobleem: het model schrijft code die er goed uitziet. Plausibele variabelenamen, logische structuur, de vorm van correcte code. Het verschil zien tussen plausibel en correct is een leesvaardigheid, en het is precies de vaardigheid die verslapt terwijl de hoeveelheid plausibel ogende code explodeert. Je moet beter lezen dan ooit, precies op het moment dat je minder oefent dan ooit.
Dus train het. Bewust. Dit is de sportschool.
De routine
Niets hiervan is exotisch. Het is saai zoals gewichtheffen saai is: de waarde zit in het herhaaldelijk doen, niet in één slimme sessie.
Elke dag een gemergede PR. Kies één echte pull request, van jezelf of van een vreemde, en lees hem voordat je de beschrijving leest. Voorspel puur op basis van de diff wat er veranderde en waarom. Daarna lees je de titel, de omschrijving, de reviewopmerkingen. Het gat tussen je voorspelling en de waarheid is precies wat je traint. GitHub is een oneindige voorraad, gratis.
Voorspel voor je runt. Pak een functie die je niet kent. Voordat je hem uitvoert of aan een AI vraagt, schrijf je in één zin op wat hij teruggeeft voor een bepaalde input. Draai hem dan. Had je gelijk? Dit is de oefening met de hoogste opbrengst, want hij dwingt je een echt model van de code te bouwen in plaats van te scannen tot het bekend aanvoelt. Bekend is niet begrepen.
Leg het uit met de AI dicht. Als een agent je code geeft met een nette uitleg erbij, sluit die uitleg. Leid hem zelf opnieuw af, hardop of in een comment, alsof je het aan een junior moet uitleggen. Lukt dat niet, dan begreep je het niet, je herkende het alleen. Dat is de regel dat je geen code shipt die je niet snapt, omgezet in een dagelijkse oefening in plaats van een controle bij de merge.
Lees code die je zelf nooit zou schrijven. Je comforttaal houdt je in chunks die je al bezit. Lees één keer per week iets buiten je stack: een Rust-parser, een game loop, wat gruwelijke Bash. Je leest traag en slecht, en dat is het punt. Dat is de spier onder belasting. De clubs van Hermans bestaan juist om dit samen te doen.
Volg één bug met de hand. Als er iets breekt, weersta de plakreflex en kies één bug per week die je zelf volgt. Volg bijvoorbeeld een gecontroleerde upload tot aan het wegschrijven: lees de stack trace van boven naar beneden, vorm een hypothese, controleer hem voordat een AI hem aanraakt. Het gevoel voor waar bugs zich verstoppen bouw je op door ze op de trage manier te vinden. De rest van de week mag de agent het zoekwerk doen, zolang de hypothese van jou blijft.
Vijf oefeningen. Je gaat ze niet alle vijf elke dag doen, en dat is prima. Kies er één. Twintig minuten. Het gaat om de frequentie, niet om het volume, net zoals één eerlijke set beter is dan een uur scrollen tussen de toestellen door.
Het mandaat dat niemand je geeft
De luchtvaart heeft dit uitgevogeld. Piloten die op de automatische piloot vertrouwen, verliezen situatiebewustzijn, dus de toezichthouder verplicht handmatige vlieguren. Niemand gaat handmatige leesuren voor jou verplichten. Er is geen toezichthouder. Je werkgever wil throughput dit kwartaal, en leesoefening levert dit kwartaal geen throughput op. Die betaalt zich uit op de dag dat er in productie iets stukgaat in gegenereerde code en jij de enige bent die het nog kunt volgen.
Het mandaat moet dus van jezelf komen. Lezen is een van de vier dingen die ik nu als eerste zou leren als beginnend developer, en het is degene met de goedkoopste dagelijkse herhalingen. Zet die twintig minuten in je agenda zoals je er een hardlooprondje in zou zetten. Bescherm ze net zo: eerst slecht, en daarna is het een gewoonte.
De reden om harder te trainen is niet dat AI slechter werd. Het is dat AI goed werd. Wanneer de machine vloeiende, plausibele, grotendeels correcte code sneller schrijft dan jij hem kunt lezen, is de lezer in de loop het enige dat tussen "ziet er goed uit" en "is goed" in staat. Die lezer ben jij. Lezen was altijd al de moeilijkere vaardigheid. Nu is het het hele vak.
De sportschool gaat niet dicht omdat je een heftruck kocht. Hij is juist de reden dat je nog steeds sterk genoeg moet zijn om op te vangen wat die heftruck laat vallen.