PodcastsHear the voice. See the shape of the thought.

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

Tao en Dwarkesh gebruiken Keplers ontdekking van de planetenbeweging als lens om te bekijken wat AI werkelijk verandert in de wetenschap. Tao stelt dat het genereren van hypothesen nu vrijwel gratis is, waardoor de knelpunten verschuiven naar evaluatie, peer review en de tand des tijds. Huidige AI's winnen op breedte — elke standaardtechniek uitproberen op elk probleem — terwijl mensen winnen op diepte, voortbouwend op deelresultaten. Hybride configuraties zullen de wiskunde daardoor nog minstens een decennium domineren. ## [00:00] Kepler was een hoge-temperatuur-LLM Tao vertelt hoe Kepler tot zijn drie wetten van de planetenbeweging kwam. Kepler begon met een verkeerde maar mooie theorie — Platonische lichamen ingeschreven tussen de planetenbanen — en liet die pas los na jarenlang zwoegen met Tycho Brahes gestolen blote-oogwaarnemingen. De ellipsen, het gelijkevlakkenwet en de wet van de periodekwadraten kwamen voort uit decennialange data-analyse; Newtons verklaring volgde een eeuw later. Dwarkesh framing: Kepler lijkt op een hoge-temperatuur-LLM die willekeurige verbanden test op een verifieerbare dataset. Tao is het eens met de mechanica maar plaatst vraagtekens bij het knelpunt. Ideeëngeneratie was al goedkoop — Kepler had geen tekort aan theorieën. Wat hij nodig had, was Brahes ordes-van-grootte betere data en het geduld om ideeën die de data weerlegde te verwerpen. > *Maar zoals je zegt, het moet worden aangevuld met een even grote hoeveelheid verificatie, anders is het rommel.* ## [11:44] Hoe herken je een nieuw unificerend concept te midden van bergen AI-rommel? Tao: als AI ideeëngeneratie vrijwel gratis heeft gemaakt, worden peer review en de tand des tijds de nieuwe beperking. Tijdschriften verdrinken al in AI-gegenereerde inzendingen. De status van een idee hangt af van wat latere wetenschap ermee doet — Copernicus was minder nauwkeurig dan Ptolemaeus totdat Kepler het plaatje compleet maakte — dus de beoordeling valt moeilijk te automatiseren vanuit het moment zelf. Dwarkesh vraagt hoe de wetenschap een Bell-Labs-achtig unificerend concept zou herkennen (Shannons bit, de transformer) verstopt in miljoenen middelmatige papers. Tao's antwoord wijst op het deel dat menselijk kan blijven: wetenschappers produceren niet alleen theorieën, ze vertellen verhalen die andere wetenschappers overtuigen jaren te investeren in vervolgwerk. Darwins proza deed het werk dat Newtons Latijnse vergelijkingen niet deden. > *AI heeft de kosten van ideeëngeneratie vrijwel naar nul gedrukt, op een manier die sterk lijkt op hoe het internet de communicatiekosten naar bijna nul heeft gebracht.* ## [26:10] De deductieve overhang Tao over het onderbenutte signaal in bestaande data. Astronomie is al eeuwen de discipline die maximale informatie uit minimale data haalt — ook de reden dat kwantitatieve hedgefondsen bij voorkeur astronomie-doctorandi aannemen. Als favoriet voorbeeld noemt hij onderzoekers die bijhielden hoe vaak wetenschappers de papers die ze citeren ook echt lezen, door te traceren welke typefouten zich door citatieketens verspreidden. Hij stelt voor om dezelfde sociologie-van-de-wetenschap-aanpak toe te passen op AI-vooruitgang zelf — door citatiepatronen, conferentieverwijzingen en andere voetafdrukken te analyseren om te detecteren of een resultaat werkelijk vooruitgang betekende, in plaats van de tand des tijds dat langzaam te laten doen. > *Een conclusie was dat de deductieve overhang in veel vakgebieden veel groter kan zijn dan mensen beseffen.* ## [30:31] Selectiebias in gerapporteerde AI-ontdekkingen AI heeft ongeveer 50 van de circa 1.100 Erdős-problemen opgelost, en plateaude daarna. Tao legt het selectie-effect uit: die 50 hadden vrijwel geen literatuur — één obscure techniek plus één bekend resultaat was genoeg, en AI-tools zijn uitstekend in "elke standaardcombinatie uitproberen." Wanneer het probleem voor 80% al gedaan is met bestaande methoden, ruimt AI het op. Wanneer het echt een nieuwe techniek vereist, stokt het, en het slagingspercentage bij systematisch afzoeken is 1-2% per probleem. Tao's metafoor: AI-tools zijn springrobots losgelaten in een berglandschap, in het donker. Ze kunnen korte muren nemen die mensen niet bereiken, maar ze kunnen geen steunpunt grijpen, daar blijven, en omhoog trekken vanuit gedeeltelijke vooruitgang. De bullish lezing — zodra AI's een bepaald niveau bereiken, kun je een miljoen parallelle kopieën op een miljoen problemen loslaten, wat geen menselijke gemeenschap kan — is ook de structurele reden waarom de wetenschap nieuwe paradigma's nodig heeft die breedte werkelijk benutten. > *Ze blinken uit in breedte, en mensen blinken uit in diepte, menselijke experts tenminste.* ## [46:43] AI maakt papers rijker en breder, maar niet dieper Tao over zijn eigen werkwijze: papers bevatten nu meer code, meer figuren en diepgaandere literatuuroverzichten, omdat de ondersteunende taken ongeveer 5 keer goedkoper zijn geworden. De eigenlijke kern — het hardste deel van een probleem oplossen — speelt zich nog steeds af met pen en papier. Hij zou zichzelf niet graag "2 keer productiever" noemen, omdat de maatstaf niet eendimensionaal is; wat veranderde is het type paper dat hij schrijft, niet de snelheid waarmee hij de vraag beantwoordt waarmee hij begon. Het onderscheid tussen slimheid en intelligentie komt op hetzelfde neer. Wanneer twee mensen samenwerken aan een wiskundig probleem, wordt elke mislukte poging een steunpunt voor de volgende. Met huidige AI's vergeet een nieuwe sessie wat de vorige had uitgewerkt. De cumulatieve optrek-stap ontbreekt — alleen brute trial-and-error en uiteindelijke absorptie in de volgende trainingsronde. > *Het heeft de papers rijker en breder gemaakt, maar niet noodzakelijkerwijs dieper.* ## [53:00] Als AI een probleem oplost, kunnen mensen er dan inzicht uit halen? Zou een AI de Riemann-hypothese in Lean kunnen bewijzen terwijl wij er niets van leren? Tao maakt zich geen zorgen. Lean heeft de eigenschap dat elk bewijs atomair kan worden ontleed — elk lemma kan afzonderlijk worden bekeken, verwijderd en getest. Zelfs een gegenereerd bewijs van 3.000 regels wordt zo ruw materiaal: andere AI's kunnen het herstructureren voor elegantie, andere mensen kunnen de conceptuele inhoud extraheren, en het artefact blijft nuttig ook al was de oorspronkelijke afleiding ondoorzichtig. Hij voorspelt een hele beroepsgroep van wiskundigen wier taak het is om grote Lean-gegenereerde bewijzen uit elkaar te halen en de ideeën erin te vinden — een soort bewijs-archeologie, met zowel menselijk oordeel als AI-ablatie-tools. > *Je haalt veel meer uit het samenspel van mensen die samenwerken met deze tools.* ## [59:20] We hebben een semi-formele taal nodig voor de manier waarop wetenschappers echt met elkaar praten Dwarkesh vraagt hoe een semi-formele taal voor wiskundige strategieën — in tegenstelling tot wiskundige bewijzen — eruit zou zien. Tao traceert de vraag via Gauss' priemgetalstelling — de eerste grote statistische veronderstelling in de wiskunde, afgeleid uit ruwe data voordat enig bewijs bestond — en via de tweelingepriemveronderstelling, die wiskundigen geloven omdat het stochastisch model van de priemgetallen het voorspelt. Wiskunde heeft zowel rigoureuze bewijzen als rigoureuze heuristieken; alleen de bewijskant is geformaliseerd tot iets wat Lean kan controleren. De reden waarom de heuristische kant nog niet geformaliseerd is: elke RL-controleerbare beoordelaar wordt een doelwit voor exploitatie, en het subjectieve aspect van "dit argument is overtuigend" laat geen hackbaar raamwerk toe. Tao zou graag een manier zien om conjecture-generatie en strategiekeuze op grote schaal te benchmarken, mogelijk door kleine AI's in speelgoed-wiskundige universa te laten opereren en te kijken welke strategieën naar voren komen. > *Er is een subjectief aspect van wetenschap dat we niet weten hoe we het kunnen vatten op een manier die AI er op een nuttige manier in kan invoegen.* ## [69:48] Hoe Terry zijn tijd besteedt Tao over hoe hij nieuwe deelgebieden absorbeert. Hij beschouwt zichzelf als een vos in de zin van Berlin — een beetje van alles, af en toe een egel wanneer nodig. De drijfveer is een completionistische obsessie: als een andere wiskundige een resultaat kan bewijzen met een techniek die hij niet kent, moet hij achterhalen wat de truc was. (Hij moest om dezelfde reden stoppen met videospelletjes.) Samenwerking met andere wiskundigen is het belangrijkste middel, en dingen opschrijven op zijn blog is de geheugensteun die hij ontwikkelde nadat hij herhaaldelijk argumenten was vergeten zes maanden nadat hij ze had afgeleid. In zijn agenda laat Tao bewust ruimte voor toeval. Hij zou het erg vinden zijn tijd zo strak te optimaliseren dat hij nooit in een vergadering belandt buiten zijn comfortzone. Het jaar dat hij doorbracht aan het Institute for Advanced Study bevestigde de val — twee weken puur onderzoek waren geweldig, daarna raakte hij door zijn inspiratie heen. De toevallige ontdekking op de volgende bibliotheekplank, het informele gangesprek en de vergadering die hij tegenzin bijwoonde, deden meer werk dan ze leken. > *Die toevallige interacties lijken misschien niet optimaal, maar ze zijn eigenlijk heel belangrijk.* ## [77:05] Menselijke-AI-hybriden zullen de wiskunde nog veel langer domineren Wanneer doet AI de wiskunde zelfstandig? Tao herformuleert — AI doet al wiskunde die mensen niet kunnen, met rekenmachines, alleen op een ander front. Binnen ongeveer een decennium verwacht hij dat veel van wat promovendi nu doen — standaardtechnieken toepassen, literatuur doorploegen — naar AI verschuift, maar het vakgebied zal een niveau omhoog gaan zoals het deed toen computeralgebrasystemen symbolische integratie overnamen. Genetica eindigde niet toen sequencing goedkoop werd; het schaalde op naar ecosystemen. Wiskunde zal hetzelfde doen. Zijn advies aan studenten die nu met wiskunde beginnen: ga uit van verandering, maar haal je diploma op de oude manier — er is voorlopig nog geen alternatief voor wiskunde leren via de traditionele weg. Blijf tegelijkertijd aanpasbaar genoeg om volledig nieuwe onderzoekswijzen te omarmen zodra ze verschijnen, inclusief die nog niet bestaan. Het bijzondere feit is dat een middelbare scholier met AI-tools en Lean vandaag al kan bijdragen aan echt wiskundig onderzoek, wat vijf jaar geleden niet mogelijk was. > *Ik geloof inderdaad dat menselijke-AI-hybriden de wiskunde nog veel langer zullen domineren.* ## Entiteiten - **Terence Tao** (Persoon): Veldsmederij-medaillist (2006), wiskundige aan UCLA, schrijft regelmatig over de rol van AI in wiskundig onderzoek. - **Dwarkesh Patel** (Persoon): Presentator van de Dwarkesh Podcast; uitgebreide interviews over AI, wetenschap en technologie. - **Johannes Kepler** (Persoon): Astronoom (1571-1630) die de drie wetten van de planetenbeweging afleidde uit de waarnemingen van Tycho Brahe. - **Tycho Brahe** (Persoon): Deense blote-oogastronoom wiens decennialange planetaire waarnemingen de dataset vormden die Kepler nodig had. - **Lean** (Software): Bewijs-assistent waarin wiskundige bewijzen worden geformaliseerd en atomair kunnen worden gecontroleerd, ontleed en getest. - **Erdős-problemen** (Concept): De circa 1.100 open problemen gesteld door Paul Erdős; AI heeft er ongeveer 50 opgelost, vrijwel allemaal met nauwelijks bestaande literatuur. - **De deductieve overhang** (Concept): Het idee dat bestaande data al veel meer afleidbare kennis bevat dan ooit is geëxtraheerd, met astronomie als modelgeval. - **Riemann-hypothese** (Concept): Onopgeloste veronderstelling over de verdeling van priemgetallen; het testgeval voor de vraag of een AI-bewijs de wiskundige kennis van mensen zou vergroten.

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.