Claude Code-agents: een praktische gids voor autonome codeworkflows

Als iemand me vraagt wat Claude Code anders maakt dan ChatGPT of GitHub Copilot, begin ik niet met het taalmodel. Ik begin met de workflow.

Stel je voor dat je een terminal opent in een Git-repository en één enkele prompt typt:

Add request validation to every FastAPI endpoint,
write tests for the new validation logic, update the documentation, 
and commit everything using a descriptive Git commit message.

In plaats van tientallen vervolgvragen te stellen, begint Claude Code te werken. 

Het doorzoekt je project om de API-structuur te begrijpen, identificeert elke endpoint, bewerkt de juiste bestanden, genereert tests, verhelpt eventuele fouten, werkt je documentatie bij en maakt een Git-commit met een samenvatting van de wijzigingen.

Vanuit jouw perspectief voelt het minder als chatten met een AI en meer als werk toewijzen aan een capabele teamgenoot. 

Die verschuiving is wat Claude Code-agents zo spannend maakt.

De functie die dit mogelijk maakt, is Claude Code-subagents. In plaats van één AI-sessie te dwingen over een hele repository te redeneren, kan Claude Code gespecialiseerde werkers starten die verschillende delen van het project onderzoeken, implementatieplannen opstellen of zelfstandig code aanpassen voordat ze terugrapporteren aan de hoofdsessie. 

In plaats van te proberen elk probleem binnen één gesprek op te lossen, kan Claude Code werk delegeren aan gespecialiseerde agents. 

De drie belangrijkste agenttypen zijn: 

• Explore, dat zich richt op het verkennen van projecten
• Plan, dat zich richt op het opstellen van implementatieplannen, en
• Algemeen, dat wordt gebruikt voor het bewerken van code en het uitvoeren van commando's.

Ik merk dat dit mijn aanpak van development verandert. In plaats van te vragen: "Kan de AI deze functie schrijven?" vraag ik mezelf: "Wat is het grootste stuk werk dat ik veilig kan overdragen?" 

Aan het eind van deze gids weet je hoe je Claude Code-agents effectief inzet, wanneer elk subagenttype logisch is, hoe je persistente projectgeheugen configureert met CLAUDE.md, en hoe je autonome workflows bouwt die tijd besparen zonder controle op te geven. 

Vereisten

Deze gids gaat ervan uit dat je je prettig voelt met het gebruik van een terminal en navigeren door mappen met basisopdrachten zoals cd, ls of dir. 

Je hoeft geen Bash-expert te zijn, maar je moet je comfortabel voelen met werken vanaf de command line.

Je hebt ook nodig:

• Node.js geïnstalleerd op je machine
• Een Anthropic API-sleutel
• Een Git-repository om mee te experimenteren
• Basiskennis van Python, JavaScript of een andere programmeertaal

Als Claude Code helemaal nieuw voor je is, raad ik ook aan om Claude Code: A Guide With Practical Examples te lezen voordat je in subagents duikt.

Wat zijn Claude Code-agents?

Claude Code-agents zijn autonome werkers die meerstaps softwareontwikkelingstaken afronden met behulp van je lokale repository, terminal en ontwikkeltools. 

In tegenstelling tot ChatGPT of Claude Chat kan Claude Code bestanden inspecteren, Bash-commando's uitvoeren, broncode bewerken en zijn eigen werk verifiëren voordat het een resultaat teruggeeft.

De meeste AI-codeassistenten volgen nog steeds een conversationele workflow. 

Je stelt een vraag, ontvangt een antwoord en besluit vervolgens wat je daarna doet. 

Dat werkt goed voor het schrijven van een SQL-query of het uitleggen van een scikit-learn-pijplijn, maar begint te haperen wanneer een taak 20 bestanden beslaat, verschillende terminalcommando's vereist of afhankelijk is van het begrijpen van een onbekende repository.

Claude Code pakt die problemen anders aan. 

Omdat het direct binnen je Git-repository werkt, kan het de code onderzoeken voordat het beslissingen neemt. In plaats van je te vragen bestanden in een chatvenster te plakken, leest het zelf het project en verzamelt het de benodigde context.

Stel dat je vraagt:

Replace every custom customer ID validator with Pydantic models, 
update the FastAPI endpoints, rewrite the affected pytest tests, 
and summarize the migration.

Een traditionele chatbot zal waarschijnlijk voorbeeldcode genereren en om meer informatie vragen. 

Claude Code doorzoekt de repository, identificeert de bestaande validatielogica, bewerkt de relevante bestanden, draait de testset, verhelpt eventuele regressies die het introduceerde en rapporteert het afgeronde werk.

Die verschuiving van vragen beantwoorden naar doelstellingen afronden maakt agentisch coderen met Claude Code anders in het dagelijkse werk.

Hoe werkt de agentlus? 

Elke Claude Code-agent volgt dezelfde besliscyclus: informatie lezen, beslissen wat de volgende stap is, handelen en vervolgens het resultaat evalueren voordat het proces zich herhaalt. 

De lus is simpel, maar door die tientallen keren te herhalen kan een agent herstellen van fouten in plaats van te stoppen na één mislukte poging.

Stel je voor dat je Claude Code vraagt om een falende testset te repareren. De workflow ziet er meestal ongeveer zo uit:

Diagram dat laat zien hoe Claude Code te werk gaat bij het oplossen van falende tests

Dit is volgens mij het eenvoudigste mentale model om Claude Code te begrijpen. 

De agent probeert niet het hele probleem in één stap op te lossen. Hij neemt een reeks kleine beslissingen op basis van wat er na de vorige actie gebeurde.

Een subagent volgt exact dezelfde lus, maar doet dat in zijn eigen geïsoleerde context. 

Dat onderscheid is belangrijk omdat een toolaanroep één actie uitvoert, terwijl een subagent tientallen redeneerstappen kan besteden aan één doel voordat hij terugrapporteert.

Waarom gebruikt Claude Code subagents? 

Claude Code gebruikt subagents omdat grote repositories zelden in één werkcontext passen. Een monorepo met Python-services, React-apps, SQL-migraties en Terraform-configuratie bevat veel meer informatie dan één agent in één keer zou moeten beredeneren. 

In plaats van de repository als één enorme taak te behandelen, delegeert Claude Code gerichte onderzoeken aan gespecialiseerde werkers. 

De ene Explore-agent kan de authenticatie analyseren, een andere de databasemodellen inspecteren, terwijl een derde de API-routes bekijkt. De orkestrator combineert die bevindingen voordat hij beslist wat de volgende stap is.

Deze architectuur heeft nog een praktisch voordeel: veel onderzoeken gebeuren parallel. 

In plaats van zelf elke map te lezen of te wachten tot één agent de hele repository inspecteert, kunnen meerdere subagents verschillende gebieden tegelijk verkennen.

Je ziet dit patroon door de rest van de tutorial. Explore-agents verzamelen informatie, Plan-agents organiseren de implementatie en algemene agents voeren het daadwerkelijke ontwikkelwerk uit.

Als je een bredere introductie wilt in hoe autonome AI-systemen werken buiten Claude Code, biedt het DataCamp-artikel LLM Agents Explained: Architecture, Frameworks, and Use Cases een uitstekend conceptueel overzicht.

Hoe installeer en stel je Claude Code in? 

Voordat we Claude Code-agents kunnen gebruiken, hebben we eerst een werkende installatie nodig. 

Gelukkig kost starten slechts een paar minuten.

Claude Code installeren

Claude Code wordt verspreid als een npm-pakket, dus je hebt Node.js nodig op je machine. Voor instructies raad ik aan de npm-documentatie over installatiemethoden voor Node.js en npm te volgen.

Installeer Claude Code globaal met:

npm install -g @anthropic-ai/claude-code

Maak vervolgens een Anthropic API-sleutel aan in de Anthropic Console en voeg die toe aan je omgeving.

Op macOS of Linux:

export ANTHROPIC_API_KEY="your_api_key_here"

Op Windows PowerShell:

$env:ANTHROPIC_API_KEY="your_api_key_here"

Om te verifiëren dat alles correct is geïnstalleerd, voer je uit:

claude --version

Als Claude Code de geïnstalleerde versie toont, ben je klaar om te beginnen.

Op dit punt is het ook de moeite waard om te bevestigen dat Git beschikbaar is, aangezien veel Claude Code-workflows het lezen van repositorygeschiedenis, het maken van commits of het vergelijken van wijzigingen omvatten. 

Als je geen Git hebt, volg dan de installatie-instructies voor Git om te beginnen.

Beide commando's zouden succesvol moeten uitvoeren voordat je doorgaat.

Je eerste Claude Code-sessie

Ga met Claude Code geïnstalleerd naar een Git-project met cd my-project.

Start daarna Claude Code: claude.

Voordat je vraagt om code te schrijven, neem een paar minuten om te leren hoe het een repository verkent. Ik begin meestal met prompts als:

• "Wat doet deze repository?"
• "Leg de architectuur uit."
• "Vind elke TODO-opmerking."
• "Welke modules bevatten de kern van de businesslogica?"
• "Hoe is authenticatie geïmplementeerd?"

Die vragen leveren geen nieuwe features op, maar geven Claude Code dezelfde context die een nieuwe teamgenoot zou verzamelen voordat hij code schrijft. 

Ik merk dat 2 à 3 minuten investeren in verkenning meestal betere implementaties oplevert dan direct in een featureverzoek duiken.

De volgende stap is het configureren van persistent projectgeheugen met CLAUDE.md. Naar mijn ervaring heeft geen enkel bestand op de lange termijn meer impact op de kwaliteit van het werk van Claude Code.

Waarom is CLAUDE.md het belangrijkste bestand voor Claude Code?

CLAUDE.md is een persistent instructiebestand dat Claude vertelt over je voorkeuren en hoe je project werkt voordat het aan een taak begint te redeneren. 

In plaats van je techstack, codeerconventies en ontwikkelworkflow elke keer opnieuw uit te leggen wanneer je een nieuwe sessie opent, documenteer je ze één keer en laat je elke toekomstige agent voortbouwen op die gedeelde context.

Als mensen voor het eerst over Claude Code-agents horen, focussen ze meestal op prompts. Ik denk dat dat achterstevoren is. 

Een goed geschreven CLAUDE.md doet meer voor de kwaliteit van je resultaten dan eindeloos de formulering van prompts verfijnen, omdat elke agent met hetzelfde begrip van je project begint.

Denk na over hoe je een nieuwe engineer zou onboarden. 

Je zou waarschijnlijk niet beginnen met het overhandigen van een Jira-ticket. Je zou de repository uitleggen, laten zien hoe je de testset draait, een paar codeerconventies aanwijzen en waarschuwen voor de delen van de codebase die je niet moet aanraken. 

CLAUDE.md dient precies hetzelfde doel.

De payoff wordt nog duidelijker zodra je autonome workflows van Claude Code gaat gebruiken.

Een agent waarvan verwacht wordt dat hij zelfstandig werkt, heeft betrouwbare projectcontext nodig. 

Zonder dat besteedt Claude Code tijd aan het opnieuw ontdekken van informatie of aanname die mogelijk niet overeenkomen met de standaarden van jouw team.

Wat moet je in je CLAUDE.md zetten?

Een goede CLAUDE.md is geen vervanging voor je projectdocumentatie of je README.md. Het is een verzameling instructies die Claude Code herhaaldelijk nodig heeft tijdens het lezen van code, schrijven van features en draaien van ontwikkeltools.

Ik deel de mijne meestal op in vijf secties: projectoverzicht, techstack, codeerconventies, veelgebruikte commando's en mappen om te vermijden. Ik loop ze elk kort langs.

Projectoverzicht

Begin met een korte beschrijving van wat het project daadwerkelijk doet.

Customer analytics platform built with FastAPI.
The application serves machine learning predictions through REST APIs.
Production deployments run through GitHub Actions.

Die drie regels vertellen Claude Code meteen dat het werkt met FastAPI, GitHub Actions en een machine learning-applicatie in plaats van een generieke Python-repository.

Technologiestack

Noem vervolgens letterlijk gewoon de belangrijkste libraries en frameworks die het project definiëren.

Python 3.12
FastAPI
Pydantic v2
SQLAlchemy
PostgreSQL
Pytest
Ruff

Ik voeg altijd versienummers toe wanneer die ertoe doen. 

De aanbevolen aanpak voor Pydantic v2 verschilt van Pydantic v1, en Claude Code zou niet hoeven te raden welke API je gebruikt. 

Dit is vooral belangrijk als je een oudere package gebruikt, zodat het niet uitgaat van verkeerde aannames.

Codeerconventies

Deze sectie legt de regels vast die je jezelf vaak hoort herhalen.

Always use type hints.
Prefer dependency injection.
Write tests for every new feature.
Keep business logic separate from API routes.
Reuse existing utility functions before creating new ones.

Merk op dat dit praktische engineeringregels zijn en geen stijlafspraken. 

Claude Code kan formattering meestal afleiden uit bestaande bestanden, maar weet niet automatisch dat jouw team verwacht dat elke endpoint dependency injection gebruikt of dat elke feature een pytest-test bevat.

Veelgebruikte commando's

Claude Code valideert zijn eigen werk vaak door ontwikkelcommando's uit te voeren. Het exact geven van de commando's die jouw team gebruikt voorkomt onnodig trial-and-error. 

Dit kan van alles zijn, zoals specifieke task-acties of CI-scripts.

pytest
Run one test file:
pytest tests/test_api.py
Lint:
ruff check .
Format:
ruff format .
Start the development server:
uvicorn app.main:app --reload

Deze sectie is vooral handig bij repositories met custom scripts, Docker-workflows of tools zoals poetry, uv of tox.

Bestanden en mappen om te vermijden

Elke repository heeft bestanden die niet automatisch moeten veranderen.

Voorbeelden zijn:

Never edit generated files.
Do not modify Alembic migrations.
Avoid changing Terraform configuration unless requested.
Do not update dependency versions automatically.

Ik merk dat deze sectie meer fouten voorkomt dan bijna elke andere. Eén zin die Claude Code vertelt om van gegenereerde code af te blijven is veel goedkoper dan het reviewen van tientallen onnodige bestandswijzigingen.

Een voorbeeld van CLAUDE.md

Hier is een vereenvoudigd voorbeeld voor een Python API-project. 

Let op hoe ik markdown-opmaak gebruik om dingen leesbaarder te maken en Claude meer context te geven.

# Project Overview

Customer analytics platform built with FastAPI.

## Technology

- Python 3.12
- FastAPI
- PostgreSQL
- SQLAlchemy
- Pydantic v2
- Pytest
- Ruff

## Coding Standards

- Use type hints everywhere.
- Write tests for new features.
- Prefer dependency injection.
- Keep business logic separate from API routes.

## Common Commands

pytest
ruff check .
ruff format .

## Avoid Editing

generated/
alembic/versions/
terraform/

Maak je geen zorgen dat je eerste versie perfect is. 

Mijn eigen CLAUDE.md is meerdere keren veranderd sinds ik terugkerende instructies opmerkte die het waard waren om te documenteren. Behandel het als broncode, niet als documentatie die nooit verandert. 

Als je dieper wilt duiken in het schrijven van effectieve instructiebestanden, behandelt DataCamp's Writing the Best CLAUDE.md: A Complete Guide for Claude Code grotere voorbeelden en geavanceerdere patronen.

Moet je een projectniveau- of gebruikersniveau-CLAUDE.md gebruiken?

Claude Code ondersteunt twee scopes voor persistente instructies. Het verschil begrijpen houdt projectregels gescheiden van je persoonlijke voorkeuren.

Projectniveau-CLAUDE.md

Een bestand op projectniveau staat in de repository.

	my-project/
	│
	├── CLAUDE.md
	├── app/
	├── tests/
	└── pyproject.toml

Alles in dit bestand geldt alleen voor die repository. Ik gebruik het voor technologiekeuzes, testcommando's, codeerconventies, mappenstructuur en repositoryspecifieke regels. 

Omdat het bestand naast de broncode leeft, krijgt elke bijdrager dezelfde instructies na het clonen van het project. Zie het als het geven van een handleiding aan elke agent voordat ze beginnen.

Gebruikersniveau-CLAUDE.md

Claude Code ondersteunt ook een globaal configuratiebestand.

Dit bestand volgt je van project naar project. Ik zie het als mijn persoonlijke bedieningshandleiding in plaats van projectdocumentatie.

Mijn bestand op gebruikersniveau kan bijvoorbeeld instructies bevatten zoals:

Explain architectural trade-offs.
Suggest performance improvements when appropriate.
Default to Python examples unless another language is requested.
Keep explanations concise.

Die voorkeuren zijn logisch, ongeacht of ik met FastAPI, React of PyTorch werk.

Hoe de twee bestanden samenwerken

Een detail dat mij in het begin verwarde bij het gebruik van Claude Code is dat deze bestanden niet wederzijds exclusief zijn. 

Het CLAUDE.md op gebruikersniveau wordt eerst geladen, daarna voegt het CLAUDE.md op projectniveau repositoryspecifieke instructies toe.

Ik zie het als een hiërarchie. 

Het globale bestand definieert hoe ik graag werk. Het projectbestand legt uit hoe deze repository werkt. 

Samen geven ze elke agent zowel persoonlijke voorkeuren als projectcontext voordat hij begint te redeneren.

Claude Code combineert voorkeuren op gebruikersniveau met projectspecifieke instructies voordat het aan een taak begint.

Wat zijn de drie typen Claude Code-subagents?

Claude Code gebruikt drie gespecialiseerde subagenttypen omdat verschillende ontwikkelingstaken verschillende tools vereisen. 

Een agent die een repository onderzoekt, heeft geen toestemming nodig om bestanden te bewerken, terwijl een agent die een feature implementeert waarschijnlijk toegang nodig heeft tot Bash, Git en je testset.

Toen ik Claude Code net begon te gebruiken, greep ik elke keer naar de algemene agent omdat die de meest capabele optie leek. 

Na een tijdje realiseerde ik me dat ik meer tijd en tokens besteedde dan nodig was. De meeste workflows worden sneller als je eerst verkent, daarna plant en pas als laatste implementeert.

Vergelijking van de drie Claude Code-subagents

De namen zijn best beschrijvend, maar elke agent vervult een eigen rol in een grotere workflow.

Wat is een Claude Code Explore-agent?

Een Claude Code Explore-agent is een read-only onderzoeker die een repository doorzoekt en samenvat wat hij vindt, zonder bestanden te wijzigen.

Dit is de agent die ik het vaakst gebruik bij het openen van een onbekend project. In plaats van zelf door tientallen Python-modules of JavaScript-componenten te scrollen, vraag ik de Explore-agent om uit te leggen hoe een subsysteem werkt en me te wijzen op de relevante bestanden.

Goede use-cases zijn onder meer:

• Vinden waar authenticatie is geïmplementeerd
• Een request door meerdere services volgen
• Logging of foutafhandeling auditen
• Verouderde API's lokaliseren
• Een pakket of map samenvatten
• Gedupliceerde businesslogica identificeren

Omdat Explore-agents geen bestanden kunnen bewerken of shellcommando's uitvoeren, zijn het ook de veiligste agents om parallel te draaien.

Een grondigheidsniveau kiezen

Explore-agents ondersteunen verschillende onderzoeksdieptes.

Als ik alleen een functie hoef te lokaliseren, gebruik ik de snelste instelling. Als ik me voorbereid op een refactor over meerdere pakketten, loont het meestal om nog een minuut te wachten voor een dieper onderzoek.

Wat is een Claude Code Plan-agent?

Een Claude Code Plan-agent analyseert een gevraagde wijziging en levert een implementatiestrategie op zonder de repository te wijzigen.

Ik sla deze stap bijna nooit over. Een extra minuut besteden aan het reviewen van een plan is veel goedkoper dan halverwege een implementatie ontdekken dat een ander subsysteem afhankelijk is van de code die je verandert.

Een typisch plan bevat:

• Bestanden die moeten veranderen
• Aanbevolen implementatievolgorde
• Afhankelijkheden en integratiepunten
• Teststrategie
• Risico's of aannames

Na het reviewen van het plan kun je het verfijnen of het direct doorgeven aan een algemene agent.

DataCamp's Claude Code Plan Mode: Design Review-First Refactoring Loops gaat veel dieper in op deze review-first-workflow.

Wat is een algemene Claude Code-agent?

Een algemene agent kan bestanden lezen, broncode bewerken, Bash-commando's uitvoeren, tests draaien en doorgaan met werken totdat het gevraagde doel is behaald.

Dit is de agent die daadwerkelijk software bouwt. Hij heeft toegang tot dezelfde repositorycontext als de andere agents, maar heeft ook toestemming om wijzigingen aan te brengen en zijn werk te verifiëren.

Typische taken zijn:

• Nieuwe features implementeren
• Meerdere modules refactoren
• Afhankelijkheden migreren
• Documentatie bijwerken
• Wijzigingen coördineren over meerdere pakketten

Algemene agents verbruiken meer tokens omdat ze aanzienlijk meer werk uitvoeren. 

Dat is nog een reden waarom ik het patroon Explore → Plan → Implement fijn vind. 

De goedkopere agents beantwoorden de vroege vragen, waardoor het duurdere implementatiewerk pas komt wanneer de weg vooruit duidelijk is.

Op dit punt hebben we de onderdelen besproken die Claude Code-agents succesvol maken: persistent projectgeheugen via CLAUDE.md en gespecialiseerde subagents voor onderzoek, planning en implementatie. 

Vervolgens zetten we die onderdelen samen door complete agentische workflows te bouwen die je direct in je eigen projecten kunt gebruiken.

Je eerste Claude Code-agentworkflows uitvoeren

De beste manier om het meeste uit Claude Code te halen, is door het een doel te geven in plaats van te vragen om losse componenten.

Ik ben uitgekomen op een eenvoudige workflow die goed werkt voor Python-projecten, datascience-repositories en webapplicaties:

1. Verken de repository.
2. Maak een plan.
3. Review het plan.
4. Implementeer de wijzigingen.
5. Verifieer de resultaten.

Dat proces is niet verplicht, maar het weerspiegelt hoe ervaren engineers grotere wijzigingen aanpakken. 

Een minuut besteden aan het begrijpen van de repository bespaart meestal meerdere minuten aan het corrigeren van onnodige bewerkingen later. 

Een grondigere prompt maken, zelfs een uur nemen om die prompt te fine-tunen, kan je later uren werk besparen.

Workflow 1: Een onbekende codebase verkennen

Een Explore-agent is de beste plek om te beginnen als je een nieuwe repository erft of terugkeert naar een project dat je maanden niet hebt aangeraakt. 

In plaats van mappen handmatig te lezen, vraag je Claude Code om de architectuur te onderzoeken en samen te vatten wat belangrijk is.

Bijvoorbeeld:

Use an Explore agent to explain how authentication works. 
Identify the main modules involved, summarize the request flow, 
and highlight any technical debt or TODO comments.

Het resultaat wordt geen muur van gekopieerde broncode. In plaats daarvan krijg je meestal een beknopte uitleg van de authenticatiestroom, de betrokken bestanden en de gebieden die aandacht verdienen. 

Ik gebruik die samenvatting vaak als startpunt voor de volgende taak in plaats van opnieuw een prompt te schrijven.

Workflow 2: Plan voordat je implementeert

Zodra je de repository begrijpt, vraag je een Plan-agent om het ontwerp van de implementatie te maken voordat je code schrijft. 

Dit is een van de gemakkelijkste gewoonten om aan te nemen, en het heeft me al meerdere keren behoed voor refactors die de verkeerde kant op zouden zijn gegaan.

Een prompt kan er zo uitzien:

Create an implementation plan for adding role-based access control.
Identify the files that should change, potential risks,
dependencies, and a recommended implementation order.
Do not modify any code.

Review het plan voordat je verder gaat. Als alles redelijk lijkt, kun je dat plan direct aan een algemene agent geven. 

Zo niet, dan is het veel makkelijker om een ontwerpdokument aan te passen dan om wijzigingen in een dozijn bestanden ongedaan te maken.

Een geweldige manier om van deze stap te profiteren, is een andere Claude Code-sessie gebruiken om het werk van de eerste te reviewen. Een simpele prompt kan gaan:

This is my current goal: to add role-based access control to this repository. 
Take a look at this existing implementation plan and do an adversarial review.
Once done, create a report that summarizes the strong and weak points of the plan.

Workflow 3: Repositoryverkenning paralleliseren

Een van mijn favoriete functies van Claude Code is dat verkenning niet sequentieel hoeft te gebeuren. Als je project meerdere onafhankelijke subsystemen bevat, kun je die tegelijk onderzoeken.

Je kunt bijvoorbeeld één Explore-agent starten om de API-laag te inspecteren, een andere om de databasemodellen te reviewen en een derde om de machine learning-pijplijn te bekijken. 

Terwijl die agents onafhankelijk werken, combineert de orkestrator hun bevindingen in één antwoord.

Ik gebruik parallelle agents niet voor elke taak, maar ze passen goed bij grote monorepo's of volwassen applicaties met veel services. In plaats van te wachten op één lang onderzoek, kun je de repository vaak veel sneller begrijpen omdat meerdere delen van het project gelijktijdig worden geanalyseerd.

De beste manier om dit te doen is één grote agent te gebruiken om meerdere agents te orkestreren. 

Deze agentische orkestratie is een geweldige manier om parallel werk te laten doen zonder meerdere sessies die allemaal in één context gedeeld worden. 

Een goede prompt kan er zo uitzien:

I want you to look at the following components: 
Inspect the API layer, review the DB models, and examine the ML pipeline. 
Look for weaknesses. 
I want this done in parallel, so spawn subagents using Opus/Sonnet models 
in order to do this work and have each generate a concise report and share out 
one master document that outlines the work needed to be done.

Best practices voor Claude Code-agents

De meeste problemen die mensen met Claude Code tegenkomen, worden niet veroorzaakt door het model. Ze worden veroorzaakt door vage prompts, ontbrekende projectcontext of vragen om een probleem op te lossen dat het niet volledig begrijpt.

Na regelmatig gebruik van Claude Code zijn dit de gewoonten die de grootste impact hadden op mijn resultaten.

Schrijf prompts die agents kunnen uitvoeren

Claude Code presteert het best wanneer doel, scope en succeskritria expliciet zijn. 

In plaats van het einddoel in brede termen te beschrijven, vertel je de agent precies welke repository hij moet inspecteren, welke bestanden hij moet wijzigen en hoe je weet dat de taak voltooid is.

Bijvoorbeeld:

❌ Vaag Verbeter de API.

✅ Specifiek Werk de FastAPI-authenticatie-endpoints bij naar Pydantic v2-validatie, genereer of update de relevante pytest-tests, draai de testset en vat elk gewijzigd bestand samen.

De tweede prompt geeft Claude Code een duidelijk doel, grenzen en een manier om succes te verifiëren. Dat leidt meestal tot minder vervolgpompts en minder handmatige schoonmaak.

Beheer context voordat het een probleem wordt

Lange gesprekken verzamelen uiteindelijk zoveel context dat Claude Code tokens besteedt aan het onthouden van eerdere discussies in plaats van te redeneren over de huidige taak.

Gebruik in dat geval /compact om het gesprek samen te vatten en de belangrijke context te behouden. Ik merk dat het beter is om vroeg te compacteren dan te wachten tot de prestaties merkbaar afnemen.

Een goede CLAUDE.md helpt hier ook, omdat projectconventies niet elke sessie herhaald hoeven te worden. Claude Code laadt die context automatisch, waardoor er meer tijd overblijft voor het werk dat je vraagt.

Voor meer advies over contextbeheer, testgestuurde ontwikkeling en promptontwerp, zie Claude Code Best Practices: Planning, Context Transfer, TDD.

Denk aan tokenkosten

Niet elke taak heeft een algemene agent nodig.

Als je alleen hoeft te vinden waar een functie is gedefinieerd, is een Explore-agent meestal sneller en goedkoper. 

Als je een grote architecturwijziging reviewt, geeft een Plan-agent je vaak genoeg informatie zonder de repository te wijzigen.

Bewaar algemene agents voor taken die echt uitvoering vereisen. Dingen zoals bestanden bewerken, Bash-commando's uitvoeren of tests draaien. De agent matchen met de taak houdt zowel looptijd als tokengebruik onder controle.

Weet wanneer je geen agents moet gebruiken

Claude Code-agents introduceren wat overhead omdat er context- en tokenuitwisseling is. 

Ze onderzoeken de repository, redeneren door de taak en verifiëren hun werk. Voor heel kleine wijzigingen is die overhead niet altijd de moeite waard.

Je hebt waarschijnlijk geen agent nodig om:

• Eén variabele te hernoemen.
• Een typefout in een Markdown-bestand te herstellen.
• Een Python-foutmelding uit te leggen.
• Snel een SQL-vraag te beantwoorden.

In die situaties is een normale Claude Code-conversatie of zelfs een handmatige wijziging vaak sneller. Ik stel mezelf meestal één vraag voordat ik een agent start: Zou ik meer tijd besteden aan het uitleggen van deze taak dan aan het zelf doen? Is het antwoord ja, dan hou ik het simpel.

Slotgedachten

Claude Code-agents veranderen de rol die AI speelt tijdens softwareontwikkeling. In plaats van losse snippets te genereren kunnen ze complexere problemen aanpakken, zoals repositories onderzoeken, implementaties ontwerpen, code aanpassen, tests uitvoeren en meerstapsdoelen doorlopen met relatief weinig toezicht.

De grootste les die ik heb geleerd, is dat betere workflows belangrijker zijn dan betere prompts. 

Een duidelijke CLAUDE.md, een paar minuten repositoryverkenning en een doordacht implementatieplan leveren consequent betere resultaten op dan direct in codegeneratie duiken.

Naarmate je meer tijd met Claude Code doorbrengt, ontwikkel je waarschijnlijk je eigen workflow. De mijne begint bijna altijd hetzelfde: eerst verkennen, dan plannen, als laatste implementeren.

Het is een simpele gewoonte, maar het heeft me ontelbare reviewrondes bespaard en me geholpen autonome workflows veel meer te vertrouwen dan toen ik er net mee begon.

Als je meer wilt leren over de bredere ideeën achter autonome systemen, raad ik de volgende bronnen aan:

• Introduction to AI Agents 
• Introduction to Claude Models 
• Claude Code Hooks: A Practical Guide to Workflow Automation 
• Claude Agent SDK Tutorial: Create Agents Using Claude Sonnet 4.5 
• How to Build Claude Code Plugins 
• Claude Code 2.1: A Guide With Practical Examples 
• Model Context Protocol (MCP): A Guide With Demo Project 
• AI Agents with Hugging Face smolagent