Agentic coding met Claude Code

Van autocomplete naar agency

Jarenlang was mijn verhaal over AI-ondersteund programmeren hetzelfde als dat van iedereen: tab-complete suggesties in de editor, af en toe een “leg deze functie uit”-prompt, en een vaag gevoel dat er meer moest zijn. Toen begon ik Claude Code te gebruiken - een agentic codingtool die in de terminal draait - en de manier waarop ik software bouw veranderde fundamenteel.

Dit bericht is een praktische blik op wat agentic coding in de dagelijkse praktijk werkelijk betekent, waar het uitblinkt en waar je scherp moet blijven.

Wat is agentic coding?

Het woord “agentic” wordt veel rondgestrooid, dus laat me specifiek zijn. Traditionele code-assistenten zoals GitHub Copilot werken in een suggestielus: jij typt, het model voorspelt de volgende paar regels, jij accepteert of verwerpt. Het contextvenster is klein - meestal het huidige bestand en misschien een of twee open tabs.

Agentic coding is anders. Het model voorspelt niet alleen je volgende regel; het redeneert over je verzoek, leest bestanden door het hele project, voert shell-commando’s uit en itereert op zijn eigen output. Het heeft toegang tot tools - bestandszoeken, grep, de terminal - en het bepaalt zelf welke het gebruikt en in welke volgorde om een doel te bereiken.

Het praktische verschil is enorm. In plaats van “maak deze functiesignatuur af” kun je zeggen “voeg een dark-mode toggle toe die de systeemvoorkeur van de gebruiker respecteert en de keuze opslaat in localStorage” en kijken hoe de agent je bestaande thema-setup leest, de juiste componenten vindt, de wijzigingen doorvoert en verifieert dat de build nog steeds slaagt.

Mijn setup

Mijn workflow is eenvoudig:

• Claude Code draaiend in de terminal naast VS Code
• Een CLAUDE.md-bestand in de projectroot dat Claude persistente context geeft - buildcommando’s, architectuurnotities, conventies en bestandsstructuur
• Standaard Git-workflow - Claude maakt wijzigingen, ik review diffs voordat ik commit

Het CLAUDE.md-patroon is het vermelden waard. Het is een gewoon Markdown-bestand dat automatisch in de context van Claude wordt geladen. Het mijne bevat doorgaans:

// Voorbeeld van wat ik in CLAUDE.md zet (als gestructureerde notities, geen code)
// - Build: npm run dev / npm run build
// - Stack: SvelteKit 2, TailwindCSS, TypeScript, mdsvex
// - Components: src/lib/components/ui/ (shadcn-svelte pattern)
// - Data: src/lib/data/resume.ts (single config object)
// - Formatting: tabs, no trailing commas, print width 100

Dit betekent dat Claude de conventies van het project al kent voordat ik mijn eerste vraag stel. Geen herhaaldelijk uitleggen van de stack bij elke sessie.

Een praktisch workflowvoorbeeld

Hier is een concreet scenario van deze portfoliosite. Ik wilde twee placeholder-blogposts vervangen door echte content, wat het volgende inhield:

1. Het Categories-type uitbreiden met nieuwe waarden
2. Syntax highlighting-talen toevoegen aan de Shiki-configuratie
3. Oude bestanden verwijderen en nieuwe Markdown-posts aanmaken
4. Verifiëren dat de build nog steeds slaagt

Zonder agentic coding zou ik context-switchen tussen bestanden, de Shiki API opzoeken, handmatig verifiëren dat de typewijzigingen doorwerken. Met Claude Code zag het gesprek er ongeveer zo uit:

# Ik: "Vervang de voorbeeld-blogposts door twee echte posts over
# agentic coding en self-hosting AI. Update het Categories type
# en voeg bash/yaml syntax highlighting toe."

# Claude: leest types.ts, svelte.config.js, bestaande posts
# → bewerkt Categories union
# → voegt talen toe aan Shiki config
# → verwijdert oude posts, maakt nieuwe aan
# → voert npm run check uit ter verificatie

De agent handelde de multi-bestandscoördinatie af. Ik reviewde elke wijziging voordat ik committe. De hele operatie kostte een fractie van de tijd die het handmatig zou kosten - niet omdat typen langzaam is, maar omdat de cognitieve overhead van context-switchen tussen bestanden je tijd werkelijk opeet.

Wat goed werkt

Na enkele maanden dagelijks gebruik zijn dit de patronen waarbij agentic coding de meeste waarde levert:

Multi-bestandsrefactoring. Een component hernoemen, de imports door de hele codebase bijwerken en de tests aanpassen - de agent handelt de saaie coördinatie af terwijl jij je focust op of de refactoringrichting klopt.

Patroonherkenning door een codebase. “Zoek overal waar we authenticatiefouten afhandelen en zorg dat we consistent zijn” is een natuurlijke-taal code review die handmatig een uur greppen zou kosten.

Onbekende code uitleggen. Spring je in een nieuwe codebase of de broncode van een dependency? Vraag Claude om de relevante bestanden te lezen en de dataflow uit te leggen. Het kan door meerdere bestanden heen traceren en je een samenhangend verhaal geven.

Boilerplate met context. Anders dan snippets of templates genereert de agent boilerplate die al is afgestemd op de conventies van je project - correcte importpaden, overeenkomende naamgevingspatronen, consistente foutafhandeling.

Waar je scherp moet blijven

Agentic coding is krachtig, maar het is geen automatische piloot. Hier heb ik geleerd om op te letten:

Review altijd de diff. Claude is goed, maar kan af en toe subtiele problemen introduceren - een onnodige dependency, een net niet kloppende type assertion, of een patroon dat werkt maar niet idiomatisch is voor je codebase. De diff-review is niet onderhandelbaar.

Beveiligingsoverwegingen. Wees doordacht over welke context de agent toegang toe heeft. Plak geen API-keys in prompts. Review code die authenticatie, autorisatie of gebruikersinvoer raakt met extra zorg - dezelfde nauwkeurigheid die je aan de PR van een junior developer zou geven.

Weet wanneer je het zelf moet doen. Sommige taken zijn oprecht makkelijker om met de hand te doen - een snelle one-liner fix, een CSS-tweak die je in de browser kunt zien, of een beslissing die productcontext vereist die de agent niet heeft. Agentic coding is een tool, geen verplichting.

Behoud je mentale model. Het grootste risico is niet slechte code - het is dat je je begrip van je eigen codebase verliest. Als de agent een wijziging heeft gemaakt en je kunt niet uitleggen waarom het werkt, stop dan en begrijp het voordat je verdergaat.

Afsluitende gedachten

Agentic coding vervangt geen ontwikkelaars. Het verandert wat “code schrijven” in de praktijk betekent. Minder tijd aan mechanische taken, meer tijd aan architectuur, ontwerp en de afwegingen die daadwerkelijk een mens vereisen.

Vooral voor senior engineers is het een productiviteitsvermenigvuldiger. Je weet al hoe goede code eruitziet - nu heb je een agent die die visie sneller kan uitvoeren dan je vingers kunnen typen. De vaardigheid verschuift van “code schrijven” naar “code aansturen” - en eerlijk gezegd zat daar altijd al het meeste van de waarde.

Als je het nog niet hebt geprobeerd, begin dan klein. Pak een refactoringtaak op die je hebt uitgesteld, stel een CLAUDE.md in met je projectcontext en kijk wat er gebeurt. Je zult misschien verrast zijn hoe natuurlijk het aanvoelt.