Van programmeren naar regisseren: hoe AI mijn werk compleet veranderde

Tot een paar jaar geleden zag mijn werkdag er klassiek uit. Veel documentatie lezen, nieuwe technieken uitpluizen, oude code doorspitten, testen, fixen en opnieuw proberen. Aan het eind van de dag sloot ik vaak tientallen StackOverflow-tabjes. Urenlang in een code-tunnel, volledig gefocust op één probleem tegelijk.

Features bouwen kostte makkelijk dagen. Soms langer. Niet omdat het concept ingewikkeld was, maar omdat alles handwerk was: zoeken, kopiëren, aanpassen en debuggen.

AI bestond al, maar speelde nauwelijks een serieuze rol.

Dat is in twee jaar volledig omgedraaid.

De eerste fase: AI als StackOverflow-vervanger

Ongeveer twee jaar geleden begon ik AI serieus te gebruiken. In het begin vooral als vervanging van StackOverflow en Google. Vragen stellen, snippets laten genereren en uitleg krijgen over libraries of foutmeldingen.

Het werkte redelijk, maar zelden in één keer goed. Net als bij StackOverflow moest ik de code meestal nog aanpassen, fixen en begrijpen wat er misging. De winst was beperkt: ruwweg een uur per werkdag.

Handig, maar nog geen echte gamechanger.

Nu: plannen, bijsturen, uitvoeren

Vandaag ziet mijn werkdag er compleet anders uit.

Mijn stack bestaat onder andere uit:

Claude Code met uitgebreide custom markdown skills
ChatGPT Codex voor checks en second opinions
Cron jobs die commits controleren
Opus 4.6
Soms agent teams

Mijn workflow is meestal:

AI een plan laten maken voor een feature
Dat plan lezen en beoordelen
Bijsturen en aanscherpen
Sparren over alternatieven
Het plan definitief maken
“Go”

Met een goed plan is het tegenwoordig vaak one-shot. Waar ik vorig jaar nog regelmatig moest ingrijpen, bouwt AI nu met een kloppend plan complete features zelfstandig.

Mijn rol bestaat vooral uit reviewen, bijsturen, architectuur bewaken, context vasthouden en kwaliteit afdwingen. Ondertussen draait de build door en kan ik letterlijk even koffie halen terwijl de code geschreven wordt.

Ik werk vaak aan drie projecten tegelijk, naast een paar hobbyprojecten. Dat was vroeger ondenkbaar.

Agent teams: van tool naar team

Sinds ongeveer een jaar gebruik ik agents serieus. Daarnaast heb ik een eigen OpenClaw-agent: een persoonlijke assistent (“Jennifer”).

Die houdt mijn agenda bij, rekent reistijd uit, waarschuwt wanneer ik moet vertrekken en boekt facturen in. Als solo developer heb ik nu functioneel gezien een volledig team om me heen.

Niet figuurlijk, maar praktisch.

Rapid prototyping is compleet veranderd

Vroeger betekende een prototype meestal een paar dagen werk. Nu is dat vaak een paar uur.

Ik bouw in een avond complete CRM’s met Kanban-boards, dashboards met animaties en interactieve demo’s. Bijvoorbeeld een sales dashboard met een Formule 1-auto die over een circuit rijdt, waarbij elke ronde staat voor het behalen van een target.

Vroeger deed ik dat niet, simpelweg omdat het te veel tijd kostte. Nu maak ik eerst een prototype, laat het aan de klant zien, krijg feedback en hoor vaak: “Leuk, ga maar bouwen.” Daarna gooi ik het prototype weg en bouw ik het systeem opnieuw, gestructureerd en onderhoudbaar.

Prototyping is nu vooral “vibe coden”: experimenteren, ideeën genereren en snel iets werkends neerzetten. Daarna begint pas het echte engineeringwerk. AI vervangt structuur niet.

Van programmeur naar software engineer

Ik zie mezelf niet meer als programmeur. Meer als software engineer, architect en regisseur.

Mijn belangrijkste skill is niet langer syntaxkennis, maar overzicht houden, patronen herkennen, structuur ontwerpen, grenzen bewaken en kwaliteit afdwingen.

Daarnaast is bijblijven cruciaal. Ik lees Reddit, test nieuwe tools en experimenteer ’s avonds. Niet om overal de beste in te zijn, maar om te weten wat mogelijk is en waar de grenzen liggen.

Kwaliteit: beter, maar niet vanzelf

De kwaliteit van AI-code wordt steeds beter. Ik hoef steeds minder te babysitten. Tegelijk blijft context een bottleneck: AI ziet nog niet het hele systeem.

Daarom blijven een paar dingen essentieel:

Goede skills en contextbestanden
Uitgebreide unit tests
Actief meekijken
De “thinking mode” lezen; vaak nuttiger dan de reply zelf
Niet blind mergen
DRY blijven afdwingen

AI schrijft snel code, maar geen goede software. Dat verschil blijft belangrijk.

Impact op business

De doorlooptijd is drastisch korter geworden. Niet omdat er minder werk is, maar omdat er veel meer werk gedaan wordt in dezelfde tijd. Backlogs verdwijnen en side-apps ontstaan overal.

Tegelijk ontstaat er nieuw werk: AI-slop opruimen, structuur herstellen en architectuur normaliseren. Dat begint nu al een apart specialisme te worden.

Grote systemen volledig zonder toezicht laten bouwen doe ik nog niet. Misschien over twee jaar, maar voorlopig niet.

Mentale impact

Het werken is leuker geworden, maar ook intensiever. Doordat AI parallel bouwt, ga je automatisch andere projecten openen, mails beantwoorden en andere delen van systemen aanpassen.

Met meerdere projecten tegelijk schakel je voortdurend tussen contexten. Dat is mentaal vermoeiend.

Daarnaast raak je snel afhankelijk. Als AI uitvalt, ligt een groot deel van mijn productiviteit stil. Terug willen naar vroeger wil ik echter niet. Debuggen is leuk als je het oplost, maar de uren ervoor blijven frustrerend.

Versneld leren

Een groot voordeel is dat leren extreem snel is geworden. Nieuwe frameworks, platforms of talen zijn geen maandenproject meer.

Met een goede prompt waarin ik expliciet vraag om uitleg en onderbouwing, kan ik in weken iets beheersen waar ik vroeger maanden over deed. Niet omdat AI het voor me doet, maar omdat het me begeleidt tijdens het bouwen.

Vooruitblik

Waar we over twee jaar staan, weet niemand. Wat ik wel zie, is dat juniors het lastig krijgen, daarna mediors en uiteindelijk seniors.

Niet-technici bouwen straks hun eigen software. Richting eind 2026 kunnen complete niet-techneuten functionele applicaties maken.

Of deze generatie AI ooit systemen bouwt die vijftien jaar meegaan, honderdduizenden requests per seconde aankunnen en perfect onderhoudbaar blijven, is nog maar de vraag. Dat moet zich nog bewijzen.

Conclusie

Mijn werk is verschoven van code schrijven naar systemen regisseren. Ik begeleid, stuur bij, bewaak kwaliteit en corrigeer waar nodig. AI bouwt.

Zonder AI kan ik niet meer werken, en eerlijk gezegd wil ik dat ook niet meer. Als solo developer heb ik nu functioneel gezien een volledig team tot mijn beschikking.

En dat verandert alles.

Deep dive: wat /insights onthult over mijn Claude Code-gebruik

Claude Code heeft sinds kort een nieuw commando: /insights. Dat analyseert je volledige gebruiksgeschiedenis en laat zien hoe je daadwerkelijk met AI werkt. Toen ik dit voor het eerst draaide, kreeg ik een vrij confronterend en tegelijk leerzaam beeld van mijn eigen workflow, gebaseerd op mijn Claude Code-data.

In iets meer dan een maand bleek onder andere:

Honderden sessies verspreid over meerdere projecten
Duizenden interacties met Claude
Meer dan honderdduizend regels code toegevoegd
Meer dan duizend bestanden aangeraakt
Regelmatig meerdere sessies tegelijk actief

Dat maakte duidelijk dat AI geen hulpmiddel meer is aan de rand van mijn werk, maar een structureel onderdeel van mijn ontwikkelproces.

Niet als autocomplete, maar als collega

Uit de analyse blijkt dat ik Claude niet gebruik als een slimme autocomplete, maar als een collega. Ik beschrijf problemen in gewoon Nederlands, vaak zoals ik dat ook bij een menselijke collega zou doen. Claude doorzoekt vervolgens de codebase, leest relevante bestanden en komt met een analyse of voorstel.

Het zwaartepunt ligt daarbij opvallend vaak op lezen en begrijpen. Het grootste deel van de acties bestaat uit bestanden openen, doorzoeken en context opbouwen, voordat er überhaupt code wordt aangepast.

Parallel werken: meerdere sessies tegelijk

Een groot deel van mijn werk gebeurt met meerdere Claude-sessies naast elkaar. Terwijl de ene sessie een refactoring uitvoert, draait in een andere sessie een bugfix of analyse. Dat werkt in de praktijk alsof je meerdere collega’s tegelijk aan het werk zet, ieder met een eigen focus.

Waar Claude het meeste waarde levert

Uit de data en praktijk komen een paar sterke punten naar voren:

Cross-stack debugging: van frontend tot database in één sessie
Grootschalige refactors over veel bestanden tegelijk
Tijdsintensief, saai werk zoals vertalingen, inventarisaties en migraties
Structurele taken die foutgevoelig zijn voor mensen

Vooral het kunnen volgen van een bug door meerdere lagen heen is iets wat vroeger veel handmatig werk kostte en nu grotendeels geautomatiseerd is.

Meta-engineering: beter leren samenwerken met AI

Een belangrijk deel van mijn tijd gaat inmiddels zitten in het verbeteren van hoe Claude voor mij werkt. Dat doe ik onder andere met:

Een uitgebreid CLAUDE.md-bestand met standaarden
Custom skills voor terugkerende taken
Reflectie op sessies
Automatische checks via hooks

Elke investering in betere instructies betaalt zich later terug in minder correctierondes en minder ruis.

Waar het misgaat

De /insights-data laat ook duidelijk zien waar het soms fout loopt:

Scope creep: een simpele bugfix groeit uit tot een halve refactor
Over-analyse zonder implementatie
Fouten in naamgeving en conventies

Dit dwingt tot explicieter aansturen en begrenzen. Zonder duidelijke kaders gaat AI te snel te breed.

Van cognitieve belasting naar orkestratie

De grootste winst zit niet alleen in snelheid, maar in mentale belasting. Waar ik vroeger alle context zelf moest vasthouden, kan ik nu taken delegeren aan Claude en op hoofdlijnen sturen.

De moeilijkheid is verschoven van uitvoering naar orkestratie: het sturen van processen, het bewaken van scope en het managen van kwaliteit.

De AI als extreem snelle junior

De beste metafoor blijft: Claude is een extreem snelle, brede junior developer. Het kan alles opzoeken, alles lezen en alles typen, maar heeft begeleiding nodig. Net als bij een echte junior zit de kracht niet in de tool, maar in hoe je ermee samenwerkt.

Van tool naar teamlid

De ontwikkeling is duidelijk: van AI als hulpmiddel naar AI als managed teamlid. Met agent teams, skills, hooks en headless workflows begint het steeds meer te lijken op een virtueel developmentteam dat continu beschikbaar is en meegroeit met mijn manier van werken.

Deze deep dive bevestigt wat ik in de praktijk al merkte: mijn productiviteit komt niet doordat AI voor mij programmeert, maar doordat het zoek-, lees- en uitvoerwerk overneemt, waardoor ik me kan richten op ontwerp, beslissingen en kwaliteitsbewaking.