Andrej Karpathy: Er Zijn Twee Soorten Programmeurs -- Zij Die Met AI Coderen, En Zij Die Worden Achtergelaten

Andrej Karpathy weet waar hij het over heeft. Voormalig directeur AI bij Tesla, vroeg onderzoeker bij OpenAI, maker van Stanfords legendarische computervisiecursus -- hij schrijft al meer dan tien jaar code en levert productie-AI-systemen op. Wanneer hij zegt dat zijn ontwikkelworkflow net de grootste transformatie in 20 jaar heeft doorgemaakt, is het de moeite waard om op te letten.

Zijn kernargument: tools zoals Deep Code zijn geen fancy autocomplete. Ze zijn een krachtsvermenigvuldiger. In dezelfde tijd die je voorheen besteedde, kun je tien keer zoveel opleveren als vroeger. Belangrijker nog: je kunt projecten aannemen die vroeger volledig buiten bereik leken. De AI maakt nog steeds fouten -- het over-engineert, doet foute aannames en geeft geen tegengas wanneer het dat zou moeten doen -- maar de nettowinst is onmiskenbaar. Hoe sneller je je aanpast, hoe groter je voorsprong.

De afgelopen weken heb ik veel code geschreven met Claude Code. Dit heb ik geleerd.

Codeerworkflow

De nieuwste golf van LLM-codeverbeteringen heeft mijn workflow op zijn kop gezet. In november was ik nog ongeveer 80% met de hand aan het typen met IDE-autocomplete en 20% agent. In december was het omgekeerd: 80% door de agent geschreven code, 20% dat ik dingen aan het opruimen was.

Ik ben nu vooral gewoon code aan het spreken. Ik beschrijf in gewoon Engels wat ik wil en kijk hoe het materialiseert. Het prikt eerlijk gezegd een beetje aan de programmeurego. Maar de mogelijkheid om tegelijkertijd over een hele codebase te werken -- refactoren, scaffolding, dingen aan elkaar knopen -- is te goed om te laten liggen. Zeker als je eenmaal het ritme te pakken hebt: de afstelling, een gevoel krijgen voor wat het goed doet en waar het de mist in gaat.

Dit is de grootste verschuiving in mijn ontwikkelworkflow in ruim 20 jaar code schrijven. En het gebeurde in een paar weken tijd. Ik schat dat een aanzienlijk deel van de ingenieurs (tweecijferige percentages) dit al doormaakt. Het grote publiek? Misschien lage eencijferige percentages hebben enig idee dat dit gebeurt.

IDE's / Agentzwermen / De Onvermijdelijkheid van Fouten

Twee verhalen doen de ronde: "IDE's zijn dood" en "zwermen autonome agents gaan alles afhandelen." Ik denk dat beide momenteel overdreven zijn.

Modellen maken nog steeds fouten. Als je echt om het project geeft, houd dan een oogje in het zeil. Ik houd een volledig IDE open in een zijvenster en observeer als een havik.

De fouten zijn nu wel anders. Geen syntaxfouten. Deze zijn sluwder -- conceptuele fouten, het soort dat een gehaaste junior-developer zou maken. Het model vult stilletjes aannames voor je in, krijgt ze verkeerd, controleert ze nooit, en bouwt gewoon op die foutieve premisse helemaal door.

Het beheert ook zijn eigen onzekerheid niet goed. Het stopt niet en vraagt "hé, wil je hier A of B?" Het signaleert inconsistenties niet. Het geeft zelden tegengas. Het is iets te graag bereid om te pleasen. Het eerst een plan laten schrijven en dat vervolgens laten uitvoeren, helpt enorm. Ik denk eerlijk gezegd dat er een echte behoefte is aan een lichtgewicht, inline planningsmodus.

Het houdt ook van over-engineeren. Overal lagen abstractie. Code die log aanvoelt. En het ruimt bijna nooit de dode code op die het zelf creëert.

Ik heb het gezien dat het een uitdijnde duizendregelige implementatie uitspuugde -- langzaam, broos, vol onnodige omwegen. Dan vraag ik: "Kunnen we dit niet op een eenvoudigere manier doen?" en het gaat meteen "Oh, natuurlijk!" en comprimeert het hele ding tot honderd regels.

Soms verwijdert of herschrijft het opmerkingen en code die niets met de taak te maken hadden, gewoon omdat het ze niet begreep of niet leuk vond. Ik heb letterlijk notities in mijn CLAUDE.md gezet om te zeggen dat het dit niet moet doen, en het gebeurt toch. Maar ondanks dat alles is de nettowinst enorm. Ik kan me werkelijk niet voorstellen dat ik terugga.

Iedereen vindt zijn eigen flow. De mijne: een paar Claude Code-sessies in Ghostty links, IDE rechts voor het lezen van code en het maken van chirurgische bewerkingen.

Volharding

Een agent zien worstelen met een probleem is eerlijk gezegd fascinerend. Het wordt niet moe. Het raakt niet ontmoedigd. Een mens had een uur geleden gezegd "laat maar, ik probeer het morgen opnieuw." Het gaat gewoon... door.

Soms kijk je toe hoe het worstelt wat eeuwig lijkt te duren. Dan, na 30 minuten, kraakt het het eindelijk. Op dat moment krijg je dit echte gevoel van "wauw, dit heeft een AGI-vibe."

Je beseft: mentale en fysieke uithoudingsvermogen is een kernflessenhals in het leveren van werk. LLM's hebben dat plafond er simpelweg afgeblazen.

Versnellingen

Het is moeilijk om een cijfer te plakken op hoeveel sneller LLM's je maken. Ik ben zeker sneller in de dingen die ik al deed. Maar de grotere verandering is dat ik nu dingen doe die ik überhaupt niet zou hebben geprobeerd.

Twee redenen:

1. Talloze kleine taken die vroeger "niet de moeite waard" voelden, zijn nu triviaal eenvoudig.
2. Codebases die ik zou hebben vermeden -- omdat ik de kennis of vaardigheden miste -- voelen plotseling benaderbaar.

Dus ja, het is versnelling. Maar meer dan dat is het uitbreiding. Het bereik van dingen waar ik toe in staat ben is gegroeid.

Hefboomwerking

Dit is een van de krachtigste dingen aan LLM's: ze zijn heel goed in het itereren in een lus totdat ze een doel bereiken dat je hebt gedefinieerd. Veel van die "AGI-achtige" momenten komen precies hieruit voort.

De sleutel: micromanage niet. Vertel het hoe succes eruitziet en laat het zelf het pad uitstippelen.

Je kunt het eerst tests laten schrijven en ze vervolgens zijn eigen tests laten doorstaan. Het via MCP aan een browser koppelen en het in een lus laten draaien. Een eenvoudig, overduidelijk correct algoritme schrijven en zeggen "optimaliseer nu voor prestaties terwijl je exact dezelfde resultaten behoudt."

De mentale verschuiving is van imperatief naar declaratief. In plaats van "doe A, dan B, dan C" zeg je "dit is hoe de uitkomst eruit moet zien." De agent itereert een paar rondes zelfstandig, en je krijgt gratis een extra laag hefboomwerking.

Plezier

Dit had ik niet verwacht, maar coderen is eigenlijk leuker geworden. Al het saaie invul-werk wordt door de agent geabsorbeerd. Wat overblijft zijn de creatieve onderdelen.

Ik kom ook veel minder vast te zitten. Vastzitten is vervelend. Nu is er bijna altijd een pad naar "samenwerken en in ieder geval wat vooruitgang boeken", wat het makkelijker maakt om gewoon te beginnen.

Dat gezegd hebbende, ik heb mensen ontmoet die het tegenovergestelde voelen -- LLM-coderen maakt hen ongelukkiger.

Op de lange termijn denk ik dat dit ingenieurs in twee kampen verdeelt: mensen die houden van het schrijven van code, en mensen die houden van het bouwen van dingen.

Verzwakking

Ik voel het nu al: mijn vermogen om code vanuit het niets te schrijven vervaagt langzaam. In de hersenen zijn "genereren" (code schrijven) en "discrimineren" (code lezen en reviewen) twee verschillende vaardigheden. Code schrijven vereist het memoriseren van een berg gedetailleerde syntax. Code lezen gaat om het begrijpen van logica en structuur. Dus zelfs als je generatiespier verzwakt, kun je nog steeds effectief code reviewen -- zien wat er niet klopt, de bugs vinden.

Slopacalyps

Ik bereid me voor: 2026 kan het jaar worden van de grote content-slop-explosie.

GitHub, Substack, arXiv, YouTube, Reddit -- elk digitaal contentplatform zal worden overstroomd met AI-gegenereerd materiaal. We zullen een golf van AI-gedreven productiviteitstheater zien, flitsende demo's die er geweldig uitzien maar niet standhouden. Verspreid daarin zullen ook echte, tastbare productiviteitswinsten zitten. Maar je zult ze moeten opgraven.

Vragen

Hoe ziet de 10x-ingenieur er in de toekomst uit? Zal de kloof tussen gemiddelde en topingenieurs nog groter worden? Mijn gok: veel breder.

Zullen generalisten specialisten gaan overtreffen? LLM's zijn uitzonderlijk goed in het invullen van details (het micro), maar zwakker in helikopterview-denken en langetermijnstrategie (het macro). Die scheefheid bevoordeelt mensen die het hele bord kunnen overzien.

Hoe zal coderen met LLM's over vijf jaar aanvoelen? StarCraft? Factorio? Een muziekstuk uitvoeren?

Hoeveel van de samenleving wordt eigenlijk geremd door digitaal kenniswerk?

Conclusie: Waar Brengt Dit Ons?

LLM-agentmogelijkheden -- met name Claude Code -- hebben rond december 2025 een drempel van algehele coherentie overschreden. Dat heeft een faseovergang in softwareontwikkeling in gang gezet. De manier waarop dingen gedaan worden verschilde in een ordegrootte, praktisch van de ene op de andere dag.

Op dit moment voelt het alsof intelligentie voorbij is geracet aan alles eromheen. Toolintegratie heeft niet bijgekregen. Teams hebben nieuwe workflows en samenwerkingspatronen nodig. De industrie is nog steeds aan het verteren wat er net is gebeurd.

2026 wordt intens. Iedereen haast zich om deze nieuwe capaciteit te absorberen en te internaliseren. Het venster staat nu wijd open. De mensen die dit vroeg doorhebben, gaan een enorme voorsprong hebben.