PodcastsHear the voice. See the shape of the thought.

Claude Code wordt geleverd met ingebouwde subagents, maar aangepaste exemplaren laten je gespecialiseerd gedrag instellen voor specifieke taken. Deze tutorial maakt een code-review-subagent vanaf nul — met het `/agents`-commando, toolselectie, modelkeuze en de velden in het configuratiebestand die bepalen wanneer en hoe Claude delegeert. ## [00:03] Wat aangepaste subagents zijn Claude Code bevat ingebouwde subagents, maar je kunt ook je eigen maken die gespecialiseerd zijn in bepaalde taken. Een aangepaste subagent is een markdown-bestand met YAML front matter: de front matter vertelt Claude wanneer naar die agent te routeren en welke mogelijkheden hij heeft, terwijl de markdown-body de systeemprompt is waaronder de subagent draait. > *"Custom sub aents are markdown files with YAML front matter. These markdown files contain configuration that helps claude understand when to use the sub aent and provides directions to the sub aent itself."* ## [00:28] Een subagent aanmaken met /agents Het `/agents`-commando opent het agentbeheerpaneel. "Nieuwe agent aanmaken" stelt twee vragen: scope (huidig project of gedeeld over alle projecten op de machine) en generatiemethode. De aanbevolen aanpak is om Claude de agent automatisch te laten genereren — de verteller typt een gewoon-taalverzoek voor een subagent die codekwaliteit en beveiligingsproblemen beoordeelt, en Claude doet de rest. > *"Now, the easiest way to create a sub agent is with the / agents command. Next, you can create a sub agent manually, but we recommend using claw code to automatically generate it for you."* ## [00:56] Tools, model en kleur instellen Voordat Claude het bestand schrijft, kies je welke tools de subagent mag gebruiken. Een code-review-agent heeft strikt genomen geen bewerkingstools nodig, maar uitvoering ingeschakeld laten maakt het makkelijker om wijzigingen te inspecteren. Na de tools kies je het model: haiku voor snelheid, opus voor diepgang, sonnet voor het midden. De laatste keuze is een kleur — die verschijnt in de UI zodat je de subagent in één oogopslag herkent. > *"Now, given that our sub agent is only responsible for reviewing code, you might decide to disallow tools for editing, but I'll leave an execution to allow the sub agent to more easily identify pending changes."* ## [01:43] Het configuratiebestand begrijpen Het gegenereerde bestand wordt opgeslagen in het project op het pad dat in het overzichtsvenster wordt getoond. Vier velden zijn het belangrijkst. `name` is de unieke identifier — je kunt er naar verwijzen door `@agent-code-quality-reviewer` in een bericht te typen. `description` is wat Claude leest om te beslissen of het delegeert; dit moet op één regel staan (escaped `\n`-tekens zijn letterlijk). "Proactively" toevoegen aan de description zorgt dat Claude vaker naar de agent grijpt; voorbeeldgesprekken toevoegen maakt de routering nauwkeuriger. `tools` weerspiegelt de toegang die tijdens de generatie is verleend, maar kan direct in het bestand worden bewerkt. > *"If you want Claude to use the sub agent automatically more often, add in the word proactively to the description."* ## [02:41] De systeemprompt en hoe Claude die gebruikt Het veld `model` accepteert `haiku`, `sonnet`, `opus` of `inherit` — `inherit` laat de subagent draaien op hetzelfde model als het bovenliggende gesprek. Alles onder de front matter is de systeemprompt: die begeleidt de subagent bij zijn taak en geeft aan hoe resultaten teruggestuurd moeten worden naar de hoofdagent. > *"The system prompt will provide guidance to the sub agent, helping it understand how to complete its task and how it should return information back to the main agent."* ## [03:15] Je subagent testen Na het opslaan van de configuratie maak je wat codewijzigingen en vraag je Claude om ze te beoordelen. Als de subagent niet triggert wanneer verwacht, is het veld `description` de eerste plek om aan te passen — specifiekere voorbeelden scherpen Claudes gevoel aan voor wanneer te delegeren. > *"If the sub agent isn't being used when you expect, check your description. Adding more specific examples helps Claude understand when to delegate."* ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): enige presentator van dit aflevering; vertelt de Claude Code-subagents-tutorialserie op het officiële YouTube-kanaal van Anthropic - **Claude Code** (Software): Anthropics AI-codeerassistent; ondersteunt zowel ingebouwde als door gebruikers gemaakte aangepaste subagents - **Aangepaste subagent** (Concept): een markdown-bestand met YAML front matter dat Claude Code configureert om specifieke taken te delegeren aan een gespecialiseerde agentinstantie - **/agents command** (Concept): Claude Code UI-toegangspunt voor het aanmaken en beheren van subagents; biedt project- of globale scope - **Systeemprompt** (Concept): de markdown-body van een subagent-configuratiebestand; biedt taakinstructies en uitvoerformaatinstructies aan de subagent tijdens runtime - **Anthropic** (Organisatie): maker van Claude en het Claude Code-platform

Deze tutorial uit de Claude Code-serie van Anthropic beschrijft vier concrete patronen die betrouwbare subagenten onderscheiden van subagenten die afdwalen, vastlopen of bestanden aanraken die ze niet zouden mogen aanraken. De verteller doorloopt elk patroon aan de hand van een code-reviewer en een webzoeksubagent als doorlopende voorbeelden, en laat precies zien welke instellingen je aanpast en waarom. ## [00:03] Subagentgedrag sturen via naam en beschrijving Elk bericht dat naar de hoofdagent wordt gestuurd, bevat in de systeemprompt de naam en beschrijving van elke geregistreerde subagent. De beschrijving vervult daarmee twee functies: ze vertelt de orchestrator *wanneer* de subagent te starten en dient als sjabloon voor het schrijven van de invoerprompt. De tutorial demonstreert dit met een code-reviewersubagent. In de oorspronkelijke configuratie schrijft de orchestrator een generieke prompt waarmee de subagent zelf `git diff` uitvoert. Door de beschrijving te wijzigen naar "je moet de agent exact vertellen welke bestanden je wilt laten reviewen", verschuift de bestandsselectie naar de orchestrator — de volgende keer is de invoerprompt merkbaar specifieker. Hetzelfde principe werkt voor webzoeksubagenten: "geef bronnen terug die geciteerd kunnen worden" aan de beschrijving toevoegen zorgt ervoor dat de hoofdagent die instructie automatisch meeneemt bij het delegeren. > *"Als je beter wilt bepalen wanneer de hoofdagent automatisch een subagent start, moet je de naam en beschrijving aanpassen."* ## [01:41] Uitvoerformaten definiëren De verteller wijst uitvoerformaat aan als de verbetering met de grootste individuele impact. Zonder formaat heeft een subagent geen duidelijk signaal dat hij klaar is — hij blijft doorlopen, bouwt context op en verbruikt tokens. Een gestructureerd uitvoerformaat creëert een natuurlijk stoppunt. De subagent weet dat hij klaar is zodra de verplichte velden zijn ingevuld. Concreet betekent dit een expliciet schema toevoegen — een samenvattingsblok, een lijst met bevindingen, een statusveld — rechtstreeks in de systeemprompt van de subagent. > *"Zonder een gedefinieerd uitvoerformaat worstelen subagenten om te bepalen wanneer er genoeg onderzoek is gedaan en lopen ze doorgaans veel langer door dan subagenten die wél een uitvoerformaat krijgen."* ## [02:04] Obstakels melden in de samenvatting Wanneer een subagent een probleem oplost — een afhankelijkheidsconflict, een commando dat onverwachte flags nodig heeft, een eigenaardigheid in de omgeving — heeft de hoofdagent die informatie nodig, anders loopt hij bij de volgende stap tegen dezelfde muur. De oplossing is obstakelmelding verplicht stellen in het uitvoerformaat zelf. De verteller somt de categorieën op die altijd naar boven moeten komen: tegengekomen obstakels, installatieproblemen, ontdekte workarounds, commando's die speciale flags of configuratie nodig hadden, en imports of afhankelijkheden die problemen veroorzaakten. Door deze in het verplichte uitvoerschema op te nemen, erft de hoofdagent de moeilijk verworven kennis van de subagent in plaats van die opnieuw te moeten ontdekken. > *"Anders moet de hoofdagent dezelfde oplossingen opnieuw ontdekken: tegengekomen obstakels, installatieproblemen, ontdekte workarounds of omgevingseigenaardigheden, commando's die speciale flags of configuratie nodig hadden, afhankelijkheden of imports die problemen veroorzaakten."* ## [02:42] Toegang tot tools beperken per rol Toegangscontrole voor tools is niet alleen een veiligheidsmaatregel — het is ook een helderheidsgereedschap. Een alleen-lezen subagent met uitsluitend `glob`, `grep` en `read` kan bestanden niet per ongeluk wijzigen, waardoor zijn rol ondubbelzinnig is voor iedereen die de configuratie leest. De verteller koppelt drie toegangsniveaus aan drie subagentrol: een onderzoekssubagent krijgt alleen-lezentoegang omdat verkennen van de codebase nooit schrijven vereist; een reviewer krijgt `bash` voor `git diff` maar nog steeds geen bestandsbewerkingstools; alleen subagenten die expliciet de taak hebben code te wijzigen — zoals een subagent die CSS-updates toepast — krijgen `edit` en `write`. Met meerdere subagenten in gebruik wordt de toollijst een machineleesbare samenvatting van wat elke subagent geacht wordt te doen. > *"Geef edit en write alleen aan subagenten die daadwerkelijk je code moeten aanpassen, zoals een stylingagent die CSS-updates toepast."* ## [03:27] Vier patronen voor effectieve subagenten De tutorial sluit af met een eénzin-samenvatting van alle vier patronen: gestructureerde uitvoer, obstakelmelding, specifieke beschrijvingen en beperkte toegang tot tools. Elk patroon versterkt de andere — nauwkeurige beschrijvingen verminderen ambiguïteit in invoerprompts, uitvoerformaten creëren stoppunten, obstakelmelding behoudt context over agentgrenzen heen, en minimale toegang tot tools voorkomt neveneffecten die eventuele resterende ambiguïteit zouden versterken. > *"Effectieve subagenten gebruiken dus gestructureerde uitvoer, melden obstakels, hebben specifieke beschrijvingen en beperken de toegang tot tools."* ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): presentator van de Claude Code-subagenten-tutorialserie, namens Anthropic - **Claude Code** (Software): het agentische coderingstool van Anthropic dat subagenten orkestreert voor meerstaps engineeringtaken - **Subagent** (Concept): een gespecialiseerde Claude-instantie gestart door een orchestratoragent, met een eigen systeemprompt, toegang tot tools en invoerprompt - **Output format** (Concept): een verplicht schema gedefinieerd in de systeemprompt van een subagent dat een stopconditie creëert en de informatie structureert die naar de hoofdagent wordt teruggegeven - **Obstacle reporting** (Concept): een patroon waarbij subagenten workarounds, afhankelijkheidsproblemen en omgevingseigenaardigheden in hun uitvoer rapporteren, zodat de orchestrator ze niet opnieuw hoeft te ontdekken - **Tool access scoping** (Concept): elke subagent beperken tot alleen de tools die zijn rol vereist — alleen-lezen voor onderzoek, bash voor review, edit/write alleen voor agenten die bestanden moeten wijzigen - **Anthropic** (Organisatie): maker van Claude en het Claude Code-agentische codeerplatform

Subagenten zijn gespecialiseerde assistenten waaraan Claude Code taken kan delegeren — elk draait in een eigen geïsoleerd contextvenster, voert het werk autonoom uit en geeft vervolgens een beknopte samenvatting terug, terwijl de volledige tussentijdse trace wordt weggegooid. Deze tutorial van twee minuten van Anthropic legt uit waarom die isolatie belangrijk is om het hoofdcontextvenster bruikbaar te houden, illustreert de afweging aan de hand van een concreet code-onderzoeksscenario en geeft een overzicht van de ingebouwde subagenten waarmee Claude Code vandaag al wordt geleverd. ## [00:03] Wat subagenten zijn Een subagent draait in zijn eigen aparte gesprekscontextvenster, geïnitialiseerd met een aangepaste systeemprompt die jij definieert. De bovenliggende agent (Claude Code in de hoofdthread) geeft de subagent een taakomschrijving op basis van wat jij hebt gevraagd. De subagent werkt dit autonoom af en stuurt een samenvatting terug naar de hoofdthread — terwijl al het tussenliggende werk geïsoleerd blijft. > *"Sub-agents are specialized assistants that Claude can delegate tasks to."* Het cruciale ontwerppunt: zodra de subagent klaar is, wordt zijn volledige gespreksthread volledig weggegooid. Alleen de teruggestuurde samenvatting komt terecht in het hoofdgesprek. ## [00:24] Het contextvenster beheren Elke tool-aanroep die Claude in de hoofdthread doet — bestandslezingen, zoekopdrachten, functietracés — stapelt zich op in het hoofdcontextvenster. Bij een lange sessie loopt dat snel vol. Subagenten bestaan juist om afzonderlijke onderzoeks- of actietaken af te laden, zodat de kosten niet in het hoofdvenster terechtkomen. > *"Each sub-agent runs in its own conversation contacts window with a custom system prompt that you define."* De afweging is expliciet: het hoofdvenster houdt een schone context, maar verliest zicht op hoe de subagent tot zijn conclusies is gekomen en wat hij onderweg heeft ontdekt. Je krijgt het antwoord, niet de redeneerTrace. ## [01:13] Een concreet voorbeeld: het betaalsysteem Stel dat je Claude Code gebruikt om te achterhalen welke service terugbetalingen afhandelt in een onbekende codebase. Zonder subagent zou Claude misschien 15 bestanden lezen, meerdere zoekopdrachten uitvoeren en door meerdere functie-aanroepen heengaan — en dat alles vult het hoofdcontextvenster, ook al had je maar één feit nodig. > *"With a sub-agent, you get the answer without the journey."* De subagent verkent de codebase, vindt het antwoord en geeft een gerichte samenvatting terug — je hoofdcontext blijft schoon. Het verlies aan zichtbaarheid is de prijs: je ziet niet welke bestanden hij heeft gelezen of welke tracés hij heeft gevolgd. ## [02:00] De ingebouwde subagenten van Claude Code Claude Code wordt geleverd met drie direct inzetbare ingebouwde subagenten: - **Algemene subagent** — voor meerstapstaken die zowel verkenning als actie vereisen. - **Explore-subagent** — snel zoeken door codebases zonder de overhead van een volledige taakloop. - **Plan-subagent** — wordt uitgevoerd tijdens de planmodus om de codebase te onderzoeken en te analyseren voordat een plan aan jou wordt gepresenteerd. > *"And you can also create your own sub-agents with custom system prompts and tool access."* Naast deze drie kun je eigen subagenten definiëren met hun eigen systeemprompts en toollijsten, afgestemd op specifieke workflows. ## [02:30] Wanneer subagenten inzetten Subagenten lonen wanneer je een afgebakende, op zichzelf staande vraag of taak hebt die anders veel tussenliggende context in je hoofdvenster zou dumpen. > *"Sub-agents like Claude Code break work into focused pieces, keep your main context window clean, and bring back just what you need, whether you're using the built-in ones or creating your own."* Ze zijn het waardevolst bij langere Claude Code-sessies waar contextvensterdruk zich opstapelt — een deeltaak naar een subagent uitbesteden in plaats van hem door de hoofdthread te laten uitwaaieren, verlengt direct hoe lang een sessie effectief blijft. ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): verteller van de "Claude Code subagents"-tutorialserie geproduceerd door Anthropic - **Claude Code** (Software): de agentische codeerassistent van Anthropic; de hostomgeving waarin subagenten opereren - **Claude** (Software): het onderliggende AI-model dat Claude Code en zijn subagenten aanstuurt - **Subagent** (Concept): een gespecialiseerde assistent waaraan Claude Code taken delegeert, draaiend in een geïsoleerd contextvenster met een eigen systeemprompt - **Contextvenster** (Concept): de eindige tokenbuffer die alle gespreksgeschiedenis, tool-aanroepen en resultaten bevat; subagenten voorkomen dat het volloopt met tussenliggende informatie - **Algemene subagent** (Software): ingebouwde Claude Code-subagent voor meerstaps verkennings-en-actietaken - **Explore-subagent** (Software): ingebouwde Claude Code-subagent geoptimaliseerd voor snel zoeken door codebases - **Plan-subagent** (Software): ingebouwde Claude Code-subagent die de codebase onderzoekt tijdens de planmodus voordat een plan wordt gepresenteerd - **Anthropic** (Organisatie): maker van Claude en Claude Code; producent van deze tutorialserie

Claude Code skills zijn herbruikbare markdown-bestanden die gespecialiseerde kennis eenmalig vastleggen — Claude activeert ze daarna automatisch zodra een verzoek overeenkomt, zonder dat de gebruiker instructies hoeft te herhalen of een slash command hoeft te typen. Deze tutorial van drie minuten legt uit wat skills zijn, waar ze worden opgeslagen, hoe ze verschillen van CLAUDE.md-bestanden en het signaal dat aangeeft dat het tijd is om er een te schrijven. ## [00:03] Het herhalingsprobleem dat skills oplossen Elke keer dat je de codestandaarden van je team uitlegt, opnieuw beschrijft hoe je PR-feedback gestructureerd wilt hebben, of Claude herinnert aan je favoriete commit-berichtopmaak, herhaal je jezelf. De verteller opent met drie opeenvolgende voorbeelden om precies het wrijvingspunt te benoemen dat skills aanpakken. > *"Elke keer dat je de codestandaarden van je team aan Claude uitlegt, herhaal je jezelf."* ## [00:20] Wat een skill is en hoe Claude er een kiest Een skill is een markdown-bestand dat Claude eenmalig leert hoe iets gedaan moet worden. Claude slaat de instructie op en past die automatisch toe wanneer de situatie erom vraagt. In Claude Code is dat bestand SKILL.md. Het description-veld in dat bestand is het sleutelmechanisme: wanneer je Claude vraagt een PR te reviewen, vergelijkt hij jouw verzoek met alle beschikbare skill-beschrijvingen en activeert de bijpassende. > *"Claude leest jouw verzoek, vergelijkt het met alle beschikbare skill-beschrijvingen en activeert de overeenkomende."* ## [01:05] Waar je skills opslaat: persoonlijk versus project Skills leven op twee plaatsen, afhankelijk van wie ze nodig heeft. Persoonlijke skills gaan naar ~/.claude/skills en volgen je mee naar elk project: commit-berichtstijl, documentatieopmaak, hoe je code uitgelegd wilt hebben. Projectskills gaan naar .claude/skills in de root van de repository; iedereen die de repo kloont krijgt ze automatisch. Die tweede locatie is waar teamstandaarden leven: merkrichtlijnen, voorkeurslettertypen en kleuren voor webdesign. > *"Iedereen die de repository kloont krijgt deze skills automatisch."* ## [01:42] Skills versus CLAUDE.md: automatisch en context-efficiënt Claude Code biedt meerdere aanpassingslagen, en skills nemen een eigen niche in. CLAUDE.md-bestanden worden bij elk gesprek onvoorwaardelijk geladen — juist voor regels zoals altijd TypeScript strict mode gebruiken. Skills worden on demand geladen, alleen wanneer ze overeenkomen met het huidige verzoek, en alleen de naam en beschrijving komen op dat moment in de context. Het volledige skill-body laadt pas bij activatie. Zo blijft de PR-reviewchecklist buiten het contextvenster tijdens het debuggen en komt hij pas binnen wanneer je daadwerkelijk om een review vraagt. Slash commands moet je intypen; skills niet. > *"Skills zijn uniek omdat ze automatisch en taakspecifiek zijn."* ## [02:27] Wanneer je een skill schrijft Skills werken het best voor gespecialiseerde kennis gekoppeld aan specifieke taken: code-reviewstandaarden die je team hanteert, commit-berichtopmaak, merkrichtlijnen. De sluitende regel is direct en praktisch: als je jezelf betrapt op het steeds opnieuw uitleggen van hetzelfde aan Claude, is dat een skill die geschreven wil worden. > *"Als je jezelf betrapt op het steeds opnieuw uitleggen van hetzelfde aan Claude, nou, dat is een skill die geschreven wil worden."* ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): verteller en host van de Claude Code skills-tutorialserie - **Claude Code** (Software): AI-codeerassistent van Anthropic; de omgeving waar skills worden ontdekt en toegepast - **SKILL.md** (Concept): het markdown-bestand dat een skill definieert — bevat een naam, beschrijving en instructies voor Claude - **CLAUDE.md** (Concept): instructiebestand op project- of globaal niveau dat bij elk Claude Code-gesprek onvoorwaardelijk wordt geladen, in tegenstelling tot skills - **Anthropic** (Organisatie): maker van Claude en Claude Code

Een PR review skill die door één engineer wordt gebruikt is nuttig; diezelfde skill uitgerold over een heel team standaardiseert code reviews en zorgt voor een consistente ervaring door de hele organisatie. Deze tutorial doorloopt vier concrete distributiemethoden — repository-commits, plugins, enterprise managed settings en custom sub-agents — en legt precies uit wanneer elk van toepassing is. Het sub-agent-gedeelte bevat een niet voor de hand liggende kanttekening: sub-agents erven skills niet automatisch, en ingebouwde agents kunnen er helemaal niet bij. ## [00:01] Waarom delen de waarde van skills vergroot Een skill die bij één developer blijft doet zijn werk. Diezelfde skill naar een team uitrollen verankert standaarden, elimineert per-persoon variatie en zorgt dat elke review er hetzelfde uitziet en aanvoelt. De verteller opent met een direct contrast tussen individueel gebruik en gebruik op teamschaal, gevolgd door de vier deelmechanismen. > *"A PR review skill that only you use is helpful. The same skill shared across your team standardizes code review and provides a consistent experience amongst your organization which is much better."* ## [00:18] Skills vastleggen in je repository De methode met de minste wrijving: plaats skills in `.claude/skills` binnen de project-repo. Iedereen die de repository kloont krijgt die skills direct — geen installatiesstap, geen extra tooling. Updates komen via de gewone `git pull`-cyclus. Dit pad past bij teamcodeerstandaarden, projectspecifieke workflows en skills die verwijzen naar de eigen structuur van de codebase. > *"Anyone who clones the repository gets these skills automatically. No extra installation, it's just what you're doing already."* ## [00:45] Skills distribueren via plugins Plugins breiden Claude Code uit met aangepaste functionaliteit die verder reikt dan één project. Binnen het plugin-project weerspiegelt een `skills/`-map de structuur van `.claude/` — skillnaam, `SKILL.md`. Eenmaal gepubliceerd op een marketplace kan elke Claude Code-gebruiker de plugin downloaden en activeren. Dit kanaal is het beste voor skills die algemeen genoeg zijn om de bredere community te bedienen in plaats van de conventies van één team. > *"Think of plugins as ways to extend Claude Code with custom functionality, but designed to be shared across teams and projects."* ## [01:26] Organisatiebrede uitrol via managed settings Beheerders kunnen skills via managed settings naar elke developer in een organisatie pushen. Enterprise-skills krijgen de hoogste prioriteit: ze overschrijven persoonlijke, project- en plugin-skills met dezelfde naam. Het beoogde gebruik is voor verplichte standaarden — beveiligingsvereisten, compliance-workflows, codeerpraktijken die uniform moeten zijn. De verteller benadrukt het woord "moeten" expliciet: dit zijn geen suggesties. > *"This is for mandatory standards, security requirements, compliance workflows, or coding practices that must be consistent across the organization."* ## [01:52] Custom sub-agents en expliciet skills laden Sub-agents erven de skills van het hoofdgesprek niet. Ingebouwde agents (explorer, planner, verify) hebben helemaal geen toegang tot skills. Alleen custom sub-agents — gedefinieerd via een `agent.md`-bestand in `.claude/agents` — kunnen skills gebruiken, en dan alleen de skills die expliciet zijn opgesomd in het `skills:`-veld van dat bestand. Skills worden geladen wanneer de sub-agent start, niet op aanvraag, dus de lijst moet beknopt blijven: alleen skills die altijd relevant zijn voor het doel van de agent. De tutorial demonstreert het aanmaken van een sub-agent met de Claude Code sub-agent creator en het koppelen van skills aan een bestaand `agent.md`. > *"Built-in agents like the explorer, planner, and verify can't access skills at all. Only custom sub-agents you define can use them, and only when you explicitly list them."* ## [03:18] Samenvatting: de juiste distributiemethode kiezen De afsluiting koppelt elke methode aan zijn scenario: projectmappen voor teamtoegang, plugins voor cross-repository-deling, enterprise-uitrol voor organisatiebrede verplichte standaarden en expliciete sub-agent-skilllijsten voor geïsoleerde taakdelegatie. De sub-agent-herinnering klinkt opnieuw — vermeld alleen de skills die altijd relevant zijn voor het werk van een bepaalde agent, want ze worden bij opstarten geladen, niet lui. > *"Share skills through project directories for team access, plugins for cross-repository distribution, or enterprise deployment for organization-wide standards."* ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): enige presentator van de Claude Code skills-tutorialserie - **Claude Code** (Software): Anthropic's AI-codeerassistent; de runtime-omgeving waar skills worden gemaakt en uitgerold - **Skills** (Concept): herbruikbare instructiesets in `.claude/skills` die het gedrag van Claude Code uitbreiden - **Plugins** (Concept): distribueerbare pakketten die skills bundelen voor deling met teams en marketplace-gebruikers - **Managed settings** (Concept): enterprise-beheermechanisme om skills organisatiebreed met de hoogste prioriteitsoverschrijving te deployen - **Sub-agents** (Concept): aangepaste Claude Code-agents gedefinieerd via `agent.md` in `.claude/agents`; het enige agenttype dat skills kan laden, en alleen wanneer expliciet vermeld - **Anthropic** (Organisatie): bedrijf dat Claude Code heeft gebouwd en de Claude Code skills-tutorialserie produceert

Een tutorial van vier minuten uit de Claude Code skills-serie over de geavanceerde configuratievelden die een basisskill omzetten in een betrouwbaar, context-efficiënt gereedschap. De verteller doorloopt de volledige veldset van de agentskills.io-standaard — `name`, `description`, `allowed_tools`, `model` — en legt uit hoe je grotere skills structureert met progressive disclosure, zodat referentiemateriaal en scripts alleen geladen worden wanneer dat nodig is, niet bij elke aanroep. ## [00:02] Overzicht van geavanceerde skill-velden De agentskills.io open standaard definieert meerdere velden naast de verplichte `name` en `description`. `name` moet lowercase zijn met koppeltekens, maximaal 64 tekens, en moet overeenkomen met de mapnaam. `description` heeft een maximum van 1.024 tekens en is het primaire signaal dat Claude gebruikt voor skill-matching. Twee optionele velden ronden de configuratie af: `allowed_tools`, dat beperkt welke tools de skill kan aanroepen, en `model`, dat de skill koppelt aan een specifieke Claude-versie. > *"A basic skill works with just a name and description, but here are some other advanced tips that can make your skills really effective in Claude Code."* ## [00:39] Effectieve beschrijvingen schrijven Een vage beschrijving — "helpen met honden" — laat Claude raden naar scope en triggers. Een goede beschrijving beantwoordt precies twee vragen: wat doet deze skill, en wanneer moet Claude hem gebruiken? Zoekwoorden afstemmen op de natuurlijke formulering van gebruikersverzoeken is de manier om skills te repareren die niet triggeren. > *"A good description answers two questions. What does this skill do? And when should Claude use it?"* ## [01:20] Tools beperken met allowed_tools `allowed_tools` is het mechanisme om een skill te beperken tot een gedefinieerd oppervlak — bijvoorbeeld alleen-lezentoegang voor beveiligingsgevoelige workflows. Wanneer het veld is ingesteld, kan Claude alleen die tools aanroepen zonder toestemming te vragen; geen bewerken, schrijven of Bash. Het veld weglaten laat het normale rechtenmodel van Claude intact. > *"When this skill is active, Claude can only use those tools without asking permission. No editing, no writing, no bash commands."* ## [01:49] Progressive disclosure voor skills met meerdere bestanden Skills delen het contextvenster van Claude met het lopende gesprek. Alles in één `SKILL.md` van 20.000 regels proppen blaast de context bij elke aanroep op en maakt het bestand lastig te onderhouden. De oplossing: essentiële instructies in `SKILL.md` zetten en referentiemateriaal verplaatsen naar afzonderlijke bestanden die Claude alleen leest wanneer het verzoek van de gebruiker dat echt vereist. De standaard stelt drie ondersteunende mappen voor — `scripts/` voor uitvoerbare code, `references/` voor documentatie, en `assets/` voor afbeeldingen en templates. Een link in `SKILL.md` werkt als een inhoudsopgave-item; als het onderwerp nooit ter sprake komt, wordt het bestand nooit geladen. Scripts in de skill-map worden uitgevoerd zonder dat de broncode in de context geladen wordt — alleen hun uitvoer verbruikt tokens. De verteller raadt aan `SKILL.md` onder de 500 regels te houden; meer dan dat is een teken dat de skill gesplitst moet worden. > *"It's like having a table of contents in the context window rather than fitting the whole entire document in there."* ## [03:18] Terugblik: skill-metadata en best practices De tutorial sluit af met een herhaling van het volledige configuratie-oppervlak: `name` en `description` zijn verplicht; `allowed_tools` beperkt het tool-oppervlak; `model` fixeert de Claude-versie. Beschrijvingen hebben concrete werkwoorden en trigger-zinnen nodig om betrouwbaar te matchen. Voor grotere skills houdt progressive disclosure `SKILL.md` onder de 500 regels en stelt ondersteunende bestanden uit totdat ze echt nodig zijn. Scripts voeren uit zonder broncode te laden, wat de context slank houdt. > *"Scripts can execute without loading their contents, keeping context efficient."* ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): de enige host van deze tutorialserie, die de configuratie van Claude Code skills presenteert. - **Claude Code** (Software): de CLI-tool van Anthropic die skills laadt en uitvoert volgens de agentskills.io-standaard. - **agentskills.io** (Organisatie): open standaard die het skill-manifestschema definieert, inclusief `name`, `description`, `allowed_tools`, `model` en mapconventies. - **SKILL.md** (Concept): het primaire manifestbestand van een Claude Code skill; moet onder de 500 regels blijven met links naar ondersteunende bestanden. - **allowed_tools** (Concept): optioneel skill-veld dat specifieke Claude-tools op een whitelist zet, waarmee alleen-lezen- of sandbox-modi mogelijk worden. - **Progressive disclosure** (Concept): een skill met meerdere bestanden zo structureren dat referentiebestanden en scripts alleen in de context geladen worden wanneer het actieve verzoek dat vereist. - **Context window** (Concept): gedeeld tokenbudget tussen het gesprek en eventuele skill-bestanden die Claude laadt; de belangrijkste resource die progressive disclosure is ontworpen te besparen.

Deze tutorial van 3 minuten laat zien hoe je van nul af een persoonlijke Claude Code skill bouwt: maak een map aan met een SKILL.md-bestand, controleer of de skill bij het opstarten wordt geladen en zie hoe Claude hem toepast op een echte aanvraag. Het tweede deel legt uit hoe de skill-laadpipeline van Claude precies werkt — van de vier scanlocaties en de naamgerichte startpas tot de bevestigingspoort en de vierlaagsgewijze prioriteitsvolgorde die naamconflicten oplost. ## [00:03] Wat Dit Tutorial Bouwt De verteller begint met het concrete doel: een skill die Claude leert code uit te leggen met visuele diagrammen en analogieën. Na het bouwen laat de tutorial ook zien wat er intern gebeurt wanneer Claude een skill herkent en uitvoert. > *"Deze skill leert Claude hoe we willen dat hij code uitlegt met visuele diagrammen en analogieën."* ## [00:18] Het Skillbestand Aanmaken Persoonlijke skills staan in de homedirectory, niet in een project — dus de eerste stap is een nieuwe map aanmaken met de naam van de skill binnen `~/.claude/skills/`. Daarin gaat één enkel `SKILL.md`-bestand. Drie secties zijn essentieel: `name` (de identifier die Claude bij het opstarten opslaat), `description` (de matchcriteria die Claude gebruikt om te beslissen of de skill wordt aangeroepen) en alles na de tweede `---`-scheidingsteken (de instructies die Claude volgt wanneer de skill wordt geactiveerd). > *"Houd er rekening mee dat we een map aanmaken met de naam van de skill binnen de skills-directory."* ## [00:52] Je Skill Laden en Testen Claude Code scant skills bij het opstarten, niet op aanvraag — dus een sessieherstel is nodig nadat je het bestand hebt aangemaakt. Met `/skills` zou "PR description" (of welke skill je zojuist hebt gemaakt) in de lijst moeten staan. Om te testen maak je een branch aan met een paar wijzigingen en stuur je de gewone aanvraag "Write a PR description for my changes." Claude meldt dat hij de PR description-skill aanroept, leest de diff en schrijft telkens een beschrijving in hetzelfde formaat. > *"Claude laat je dan zien dat hij de PR description-skill gebruikt."* ## [01:25] Hoe Claude Skills Intern Laadt Bij het opstarten scant Claude Code vier locaties: enterprise beheerde instellingen, de persoonlijke `~/.claude/skills/`, de `.claude/`-directory van het project en geïnstalleerde plugins. Hij laadt alleen de `name` en `description` — niet de volledige inhoud. Wanneer een aanvraag binnenkomt, vergelijkt Claude die met de opgeslagen beschrijvingen; "leg uit wat deze functie doet" overlapt met "leg code uit met visuele diagrammen", dus de skill matcht. Vóórdat hij het volledige SKILL.md leest, vraagt Claude om bevestiging — zo weet de gebruiker welke context wordt geïnjecteerd. > *"Hij laadt alleen de naam en beschrijving van elke skill, niet de volledige inhoud. Dat is later belangrijk."* ## [02:02] Prioriteitsregels en Naamconflicten Een repository klonen die zelf skills meebrengt, kan naambotsingen veroorzaken. Claude lost dat op met een vaste prioriteitsvolgorde: enterprise (hoogste) → persoonlijk → project → plugins (laagste). Een enterprise `code-review`-skill wint het altijd van een persoonlijke `code-review`-skill. De praktische oplossing is beschrijvende namen: `security-review` of `frontend-pr-review` in plaats van het generieke `review`, zodat conflicten nooit ontstaan. > *"Als je bedrijf een enterprise code review-skill heeft en jij maakt een persoonlijke code review-skill, dan heeft de enterprise-versie voorrang."* ## [02:52] Skills Bijwerken en Verwijderen Een skill bijwerken is een directe bestandsbewerking: open de SKILL.md, pas aan wat nodig is en sla op. Een skill verwijderen betekent de map wissen. Beide handelingen vereisen een herstart van Claude Code voordat de wijziging van kracht wordt — de lijst met skills wordt eenmalig opgebouwd bij het starten van de sessie en wordt niet bewaakt op live wijzigingen. > *"Bewerk het skill.md-bestand om een skill bij te werken en herstart Claude Code voor de wijzigingen van kracht worden."* ## Entiteiten - **Anthropic Tutorial-verteller** (Persoon): de enige presentator die het skill-aanmaaktutorial voor de Claude Code skills-serie begeleidt - **Claude Code** (Software): Anthropic's CLI voor Claude; scant skills bij het opstarten en past ze toe wanneer gebruikersaanvragen overeenkomen met skill-beschrijvingen - **SKILL.md** (Concept): het enkele bestand dat een skill definieert — bevat YAML-frontmatter (name, description) en vrije instructietekst na de tweede `---`-scheidingsteken - **Skills** (Concept): herbruikbare, benoemde instructiereeksen die Claude een consistent gedragspatroon leren; opgeslagen als mappen met een SKILL.md-bestand - **Enterprise Skills** (Concept): door de organisatie beheerde skills die bovenaan de vierlaagsgewijze prioriteitsvolgorde staan en persoonlijke, project- en plugin-skills overschrijven - **Anthropic** (Organisatie): maker van Claude en Claude Code; produceert deze tutorialreeks op claude.com/resources/courses

Claude Code biedt ontwikkelaars vijf aparte aanpassingsopties — Skills, CLAUDE.md, subagents, hooks en MCP-servers — elk gebouwd voor een ander doel. Deze tutorial van drie minuten koppelt elke optie aan het juiste gebruik, zodat je niet naar Skills grijpt als CLAUDE.md voldoende is, of een hook instelt terwijl je eigenlijk een subagent nodig hebt. ## [00:02] Vijf aanpassingsopties, één beslissingsprobleem Claude Code heeft vijf manieren om het gedrag te sturen: Skills, CLAUDE.md, subagents, hooks en MCP-servers. De verteller noemt alle vijf in snelle volgorde en verschuift de vraag meteen van "wat zijn dit?" naar "welke hoort hier thuis?" > *"Ze lossen verschillende problemen op. Weten wanneer je elk gebruikt, voorkomt dat je het verkeerde bouwt."* De rest van de tutorial is in wezen een antwoord op die ene zin. ## [00:18] CLAUDE.md vs Skills: altijd actief vs op aanvraag CLAUDE.md is een bestand dat Claude aan het begin van elk gesprek leest, zonder activering. Het is de juiste plek voor projectbrede beperkingen die nooit vergeten mogen worden — frameworkkeuzes, codeerstijl, databaseregels. Skills laden daarentegen op aanvraag: je PR-reviewchecklist komt pas in de context als je daadwerkelijk om een review vraagt, niet terwijl je nieuwe code schrijft. > *"Gebruik Claude MD voor projectbrede standaarden die altijd gelden — beperkingen zoals het databaseschema nooit aanpassen, frameworkvoorkeuren en codeerstijl."* De scheidslijn is bestendigheid versus relevantie. Als de instructie voor elke prompt in het project moet gelden, hoort die in CLAUDE.md. Als die alleen soms nuttig is, hoort die in een Skill. ## [01:03] Skills vs Subagents: gedeelde context vs geïsoleerde uitvoering Skills injecteren kennis in het huidige gesprek — hun instructies sluiten aan bij de bestaande context. Subagents werken anders: ze ontvangen een taak, starten een aparte uitvoeringscontext, werken zelfstandig en leveren resultaten terug zonder het hoofdgesprek aan te raken. > *"Gebruik subagents wanneer je een taak wilt delegeren naar een aparte uitvoeringscontext. Je hebt andere tooltoegang nodig dan het hoofdgesprek biedt. Je wilt isolatie tussen gedelegeerd werk en je hoofdcontext."* Gebruik Skills als expertise de redenering van Claude gedurende een lopend gesprek moet sturen. Gebruik subagents als je een heldere grens wilt tussen de hoofdsessie en een gedelegeerde werkeenheid — andere tools, geen vermenging. ## [01:42] Hooks vs Skills: gebeurtenisgestuurd vs verzoekgestuurd Hooks vuren automatisch bij gebeurtenissen — een linter uitvoeren elke keer dat Claude een bestand opslaat, invoer valideren vóór een bepaalde toolaanroep. Ze worden niet geactiveerd door wat jij vraagt; ze worden geactiveerd door wat Claude doet. Skills zijn het tegenovergestelde: verzoekgestuurd, ze activeren wanneer een vraag bij hen past. > *"Een hook kan een linter uitvoeren elke keer dat Claude een bestand opslaat, of invoer valideren vóór bepaalde toolaanroepen. Ze zijn allemaal gebeurtenisgestuurd, terwijl skills verzoekgestuurd zijn. Ze activeren op basis van wat je vraagt."* Als het gedrag onvoorwaardelijk bij een systeemgebeurtenis moet plaatsvinden, is het een hook. Als het de manier waarop Claude denkt bij een vraag moet sturen, is het een Skill. ## [02:15] Alle vijf combineren voor uitgebreide aanpassing Een goed geconfigureerde Claude Code-omgeving gebruikt elk hulpmiddel voor zijn natuurlijke rol: CLAUDE.md voor altijd-actieve projectstandaarden, Skills voor taakspecifieke expertise die niet elke prompt moet vervuilen, hooks voor geautomatiseerde neveneffecten, subagents voor geïsoleerd gedelegeerd werk, en MCP-servers voor toegang tot externe tools. Het zijn geen alternatieven — ze vullen elkaar aan. > *"Dwing niet alles in skills als een andere optie beter past. Je kunt er meerdere tegelijk gebruiken."* Skills activeren automatisch wanneer een onderwerp relevant is; CLAUDE.md is altijd aanwezig; subagents draaien geïsoleerd; hooks vuren bij gebeurtenissen; MCP biedt externe tools. Kies de juiste laag voor elke behoefte en combineer ze vrij. ## Entiteiten - **Anthropic Tutorial Narrator** (Persoon): Presentator van deze Claude Code skills-tutorialserie, namens Anthropic. - **Claude Code** (Software): Anthropic's AI-gestuurde codeerassistent; het onderwerp van de tutorialserie. - **Skills** (Concept): Kennispakketten op aanvraag die activeren wanneer Claude een gebruikersverzoek herkent; injecteren instructies in de huidige gesprekscontext. - **CLAUDE.md** (Concept): Een configuratiebestand dat automatisch in elk Claude Code-gesprek laadt; gebruikt voor altijd-actieve projectbrede standaarden en beperkingen. - **Subagents** (Concept): Aparte uitvoeringscontexten die worden gestart om gedelegeerde taken geïsoleerd van het hoofdgesprek af te handelen. - **Hooks** (Concept): Gebeurtenisgestuurde automatisering die bij specifieke Claude-acties — zoals bestand opslaan of toolaanroepen — vuurt, onafhankelijk van gebruikersverzoeken. - **MCP Servers** (Software): Model Context Protocol-servers die externe tools leveren aan Claude Code-sessies. - **Anthropic** (Organisatie): Maker van Claude Code en uitgever van de Claude Code skills-tutorialserie.