Agentic coding

Waar deze gids over gaat ​

Een groot deel van deze blog gaat over werken met coding agents, en dan vooral Claude Code. Daar zie ik dagelijks wat er gebeurt als je een model echte rechten geeft in een echte codebase. Soms gaat dat verbluffend goed. Soms zit je een uur later een refactor terug te draaien waar de agent bijzonder zeker van was.

Het verschil zit zelden in het model. Het zit in de structuur eromheen: wat de agent van je project weet, wat hij wel en niet mag, en hoe jij de sessie stuurt. Dat is ook de volgorde van deze gids.

Begin bij de instellingen ​

Standaardinstellingen zijn geschreven voor de gemiddelde gebruiker, en dat ben jij niet. Het beste uit Claude Code halen is het overzichtsstuk: van status line tot eigen skills, alles wat van een kale CLI een omgeving maakt waar je een dag in kunt werken. Lees dat stuk eerst als je verder niets leest.

Daarna komt geheugen. Elke sessie begint op nul, tenzij je dat zelf oplost. Het CLAUDE.md-bestand is hoe je projectcontext permanent maakt: je stack, je conventies, de valkuilen die de agent anders elke ochtend opnieuw ontdekt. Onderhoud het daarna ook, want verouderd geheugen is erger dan geen geheugen. Een regel die niet meer klopt, stuurt je agent met volle overtuiging de verkeerde kant op.

Rechten zijn de andere helft van je setup, en daar is de documentatie mager over. De gids over permissions is wat ik daar graag had gelezen, inclusief de dag dat 'default' 'Manual' werd, toen een hernoeming stilletjes de betekenis van een hele modus veranderde.

Regels die je kunt afdwingen ​

Hier zit de les die me de meeste tijd heeft gekost. Instructies in een prompt zijn suggesties. Het model weegt ze mee en kan ze op elk moment laten vallen. Als iets echt niet mag, wil je een mechanisme dat nee zegt ongeacht wat het model die beurt vindt. Daar zijn hooks voor, en daarom is het vriendelijk vragen aan je agent geen controle. Met collega's erbij wordt die vraag scherper: wat een repo in een team wel en niet afdwingt splitst de config die je kunt committen in het deel dat vanaf de eerste clone voor iedereen geldt en het deel dat wacht tot elke collega een dialoog accepteert. Zodra er collega's bij komen wordt die vraag scherper: wat een repo in een team wel en niet afdwingt zoekt uit welke delen van een ingecheckte .claude/ vanaf de eerste clone voor iedereen gelden, en welke delen daar niets liggen te doen tot ieder voor zich een dialoog accepteert.

De gereedschapskist is inmiddels flink: skills, subagents, hooks, slash commands en de varianten daartussen. Welke je pakt maakt uit. De keuzehulp bouwt dezelfde taak op vier manieren en laat zien waar elk mechanisme wint. Daarna zijn een goede skill schrijven en een goede subagent schrijven de twee schrijfgidsen: allebei bouwen ze wantrouwen tegen het model in de procedure zelf, met checkpoints op de plekken waar het misgaat.

De werkvorm ​

Gereedschap is de helft. De andere helft is hoe een sessie eruitziet: eerst een spec, context klein houden, tussentijds toetsen, review als harde poort voor de merge. Zo werk je met een agent loopt dat na van eerste gedachte tot gemergede commit, inclusief de vertrouwensgrenzen die bepalen wat een agent alleen mag afmaken.

Twee klussen verdienen een eigen aanpak. Legacy code refactoren begint bij characterization tests, want een agent kan geen gedrag behouden dat nergens is vastgelegd. En debuggen met een agent splitst het werk naar wie de informatie heeft die de zoekruimte verkleint, en dat ben jij meestal.

Die discipline voelt als overhead tot je ziet wat ze oplevert: het verschil tussen een agent die je werk versnelt en een agent die je werk vermenigvuldigt, fouten en al.

Een lange sessie eerlijk houden ​

Er zijn twee dingen die slijten als je uren doorwerkt, en voor allebei is er een knop. Plan mode is waar je het dure deel van het werk doet zolang je er nog op terug kunt komen, aan een plan dat inmiddels als bestand op schijf staat in plaats van als bericht in een chat. Context beheren is de andere knop, want het venster van een miljoen tokens haalde de dwang weg, niet het probleem. Het /doctor-commando is onderweg een context-audit geworden, en daarmee de snelste blik op wat je sessie eigenlijk meesleept.

Dan de knoppen om iets terug te draaien. Checkpoints en /rewind voor de beurt die de verkeerde kant op ging. Git worktrees voor als één sessie niet meer genoeg is, die je working tree isoleren terwijl alles wat pijn kan doen gedeeld blijft. En berichten tussen sessies voor als twee sessies bewust van elkaar moeten weten.

Welk model, en hoe hard het nadenkt ​

Modelkeuze is een routeringsvraag, geen geloofskwestie. Welk Claude-model voor welke programmeertaak is de verdeling die ik aanhoud, en Opus 5 is er en je effort-instellingen kloppen niet meer is wat daaronder veranderde. Wil je het mechanisme in plaats van de instellingen, dan staat in de agent is gewoon een loop het hele ding op één pagina.

Waar dit raakt aan kwaliteit ​

Hoe beter je setup, hoe meer code eruit komt, en hoe zwaarder de vraag weegt of die code er ook in mag. Alles wat een agent oplevert gaat door dezelfde poort als mensenwerk: snap je het, kun je het uitleggen, onderhoud je het over een jaar nog. Daarover gaat nooit code shippen die je niet snapt, en breder de hele gids over AI en codekwaliteit hieronder bij de verwante onderwerpen.

Hieronder staan eerst drie startpunten, daarna alles wat ik over dit onderwerp heb geschreven, nieuwste eerst.