Claude Skills Maken: Complete Handleiding (2026)

1. Wat zijn Claude Skills? (En hoe verschillen ze van prompts)

Voordat je iets gaat bouwen, is het handig om precies te begrijpen wat een Skill op technisch niveau inhoudt, hoe het verschilt van een prompt, en waar het past binnen het bredere Anthropic Claude-ecosysteem. Dit onderdeel legt de basis waarop de rest voortbouwt.

Wat is een Claude Skill precies?

Een Claude Skill is een op zichzelf staande, benoemde en van een versie voorziene eenheid van instructies die Claude op afroep kan gebruiken. In de praktijk is het gewoon een map. In de eenvoudigste vorm is een skill een map met daarin een SKILL.md-bestand, en dat bestand moet beginnen met YAML-frontmatter met een aantal verplichte gegevens: name en description.

Die map is het hele verhaal. Er zit geen apart model achter, geen eigen binary, geen betaalde uitbreiding. Skills zijn geen modellen, geen plugins zoals je die van WordPress kent, en ook geen betaalde add-ons. Het zijn open-source markdown-instructies plus eventuele bijbehorende bestanden. Dit is goed om vroeg te beseffen, want het verandert hoe je naar het werk kijkt. Je bent geen systeem aan het programmeren. Je schrijft documentatie die zo helder en zo goed afgebakend is dat Claude hem elke keer perfect kan volgen.

Skills duiken op twee plekken op. In de Claude API kun je gebruikmaken van de kant-en-klare skills van Anthropic, en kun je zelf gemaakte skills uploaden via de Claude API, en het maken van een skill is simpel: gewoon een map met een SKILL.md-bestand met YAML-frontmatter en instructies. In Claude Code staan ze in een map binnen je project of plugin. Je maakt een skills-map aan in de root van je plugin of project en voegt daar skill-mappen met SKILL.md-bestanden aan toe. Claude vindt en gebruikt ze dan automatisch zodra de plugin geïnstalleerd is.

Er is ook een openbare registry met voorbeelden. Anthropic beheert een open repository met Skills die laten zien wat er allemaal mogelijk is. Deze repository bevat skills die de reikwijdte van Claude's skills-systeem demonstreren, van creatieve toepassingen zoals kunst, muziek en design tot technische taken zoals het testen van webapps en het genereren van MCP-servers, tot zakelijke workflows. Een waardevolle bron als je zelf aan de slag gaat.

Het beste beeld dat je erbij kunt houden: als prompts plaknotitjes zijn die je krabbelt en weer weggooit, dan zijn Skills gedocumenteerde standaardprocedures. Een plaknotitje herinnert één persoon één keer aan iets. Een standaardprocedure standaardiseert hoe iedereen een taak uitvoert, blijvend, met een duidelijke eigenaar en een versienummer.

Een paar begrippen om nu goed in je hoofd te prenten, want ze komen steeds terug in deze gids:

• SKILL.md: het verplichte bestand dat de kern vormt van elke Skill. Let op de hoofdletters in de bestandsnaam zoals Anthropic die gebruikt, al hebben mensen het vaak losjes over "het skill.md-bestand".
• Frontmatter: het YAML-blok bovenaan het bestand met metadata zoals name en description.
• Skill body: de Markdown-instructies onder de frontmatter.
• Skill builder: de manier waarop je de skill bouwt, of dat nu via een template, de API, of een map in Claude Code is.
• Invocatie: het moment waarop Claude bepaalt dat een Skill relevant is en deze inlaadt.
• Skill scope: hoe smal of breed het doel van de Skill is.

Draai je de hele week met Claude in meerdere repo's om je Skill-library te testen? Dan zit je al gauw aan een Max 20x-abonnement van $200/maand, gefactureerd in USD. Met Bleap betaal je tegen de echte wisselkoers, 0% wisselkoersen, en krijg je 20% cashback op je Claude-, ChatGPT- en Gemini-verlengingen, zonder dat je een kaartabonnement nodig hebt. Vraag de Bleap-kaart aan →

Claude Prompts vs Skills: de belangrijkste verschillen

Mensen vragen vaak waarom ze niet gewoon een goede prompt kunnen blijven gebruiken. Soms is dat ook prima. Maar zodra een taak herhaald wordt, gedeeld wordt, of bedrijfskritisch is, wint een Skill op vrijwel elk vlak. Hieronder de uitsplitsing.

Blijvendheid. Een prompt bestaat alleen binnen het gespreksmoment waarin hij wordt geplakt. Zodra de sessie eindigt, is hij verdwenen. Een Skill blijft bestaan over sessies en gebruikers heen. Hij wordt opgeslagen, geïndexeerd en is beschikbaar wanneer hij relevant is.

Vindbaarheid. Dit is het subtiele punt. Claude kan een prompt pas zien nadat iemand hem heeft ingevoerd. Een Skill daarentegen presenteert zichzelf. Bij het opstarten laadt de agent alvast de naam en beschrijving van elke geïnstalleerde skill in het systeemprompt, zodat Claude precies genoeg informatie heeft om te weten wanneer een skill gebruikt moet worden, zonder dat alles meteen in de context hoeft te staan. Claude beslist zelf actief wanneer een Skill wordt ingezet. Een prompt die hij nog nooit heeft gezien, kan hij nooit uit zichzelf inzetten.

Herbruikbaarheid. Een Skill kan worden aangeroepen door elke geautoriseerde gebruiker of subagent, zonder dat iemand tekst hoeft te kopiëren en plakken. Een prompt moet handmatig gedeeld en opnieuw gedeeld worden, en verliest daarbij elke keer een beetje van zijn oorspronkelijke vorm.

Versiebeheer. Skills kunnen in de loop van de tijd worden doorontwikkeld en bijgehouden. Losse prompts in gebruikersberichten kunnen op geen enkele zinvolle manier van versies worden voorzien.

Tool-integratie. Skills kunnen scripts en referentiemateriaal bundelen en precies beschrijven hoe en wanneer je die moet gebruiken. Prompts kunnen die structuur van nature niet dragen.

Samenstelbaarheid. Skills kunnen verwijzen naar andere bronnen en worden gekoppeld aan subagents voor gedelegeerd werk. Prompts zijn op zichzelf staande brokken tekst.

Hier is een vergelijking op acht punten naast elkaar:

Wanneer gebruik je een prompt en wanneer bouw je een Skill? Het beslissingskader is simpel. Gebruik een prompt voor eenmalige, verkennende of sterk contextgebonden verzoeken. Bouw een Skill zodra een taak regelmatig terugkomt, consistente output moet leveren, door meerdere mensen wordt gebruikt, of kennis vastlegt die je anders elke sessie opnieuw zou moeten uitleggen. Merk je dat je dezelfde instructies twee keer plakt? Dan is dat je signaal.

Waar Skills passen binnen het Anthropic Claude-ecosysteem

Skills bestaan niet op zichzelf. Als je begrijpt hoe ze zich verhouden tot de rest van het Claude-ecosysteem, voorkom je dat je een Skill bouwt voor iets dat een ander mechanisme al beter afhandelt.

Skills versus Projects. In Claude.ai groeperen Projects gesprekken en bestanden rond een gezamenlijk doel. Skills verrijken Projects door herbruikbare procedurele kennis toe te voegen, maar het zijn niet dezelfde dingen. Een Project is een werkruimte. Een Skill is een vaardigheid die je binnen die werkruimte of daarbuiten kunt inzetten.

Skills versus MCP. Dit onderscheid is belangrijk. Het Model Context Protocol is de connectiviteitslaag, de manier waarop Claude externe tools, databronnen en diensten benadert. Skills vormen de instructielaag: ze vertellen Claude hoe en wanneer te handelen. Vaak gebruik je beide samen: MCP verbindt Claude met je database, en een Skill geeft Claude de exacte procedure voor het opvragen en opmaken van die data. Een van Anthropic's voorbeeld-Skills gaat zelfs over het genereren van MCP-servers, wat laat zien hoe nauw deze twee concepten met elkaar verweven zijn.

Skills versus subagents. Skills kunnen worden ingebouwd in aangepaste subagents, zodat een gespecialiseerde agent een uitbestede taak volledig geïsoleerd afhandelt. Je kunt Skills met je team delen door ze naar een repository te committen, ze verspreiden via plugins, organisatiebreed uitrollen, en Skills koppelen aan aangepaste subagents voor geïsoleerde, deskundige taakdelegatie. De Skill levert de expertise; de subagent zorgt voor de geïsoleerde uitvoeringsomgeving.

Skills versus de API. Skills zijn niet gebonden aan de chatinterface. Ze zijn programmatisch toegankelijk, en juist dat maakt ze bruikbaar voor productieautomatisering, CI-pipelines en ingebouwde productfuncties.

Skills versus de contexthiërarchie. Wanneer Claude reageert, weegt het de systeemprompt, de geladen Skill-inhoud, de berichten van de gebruiker en eventuele tool-resultaten tegen elkaar af. Skills staan boven het individuele bericht, maar onder de onwrikbare systeemniveau-vangrails. Als je deze hiërarchie kent, kun je Skills schrijven die gedrag sturen zonder tegen Claudes standaardinstellingen in te gaan.

Waarom Claude Skills een gamechanger zijn voor AI-automatisering

De strategische waarde van Skills stapelt zich op. Hier komt de winst vandaan.

Prompt drift voorkomen. Wanneer een team gebruikmaakt van een gedeelde Skill, werkt iedereen met dezelfde, gezaghebbende instructies. Geen gedoe meer over "welke versie van de prompt gebruik jij nu?" De Skill is de bron van waarheid.

Toegankelijker voor iedereen. Een goed gebouwde Skill zorgt ervoor dat ook niet-technische collega's kunnen profiteren van geavanceerde automatisering. Ze hoeven niet te weten hoe je een systeemprompt van 400 woorden schrijft. Ze beschrijven gewoon wat ze willen, en Claude pakt de juiste Skill erbij.

Minder verspilling van de context window. Dit is het technische geniale aan het ontwerp. Skills gebruiken een systeem met drie laadniveaus om de context efficiënt te beheren, en dankzij deze progressieve onthulling kun je veel verschillende skills installeren om complexe taken uit te voeren zonder je context window vol te proppen. Statische instructies blijven buiten het gesprek totdat ze echt nodig zijn.

Het cumulatieve bibliotheekeffect. Elke Skill die je bouwt, maakt de volgende waardevoller, omdat Skills gebruik kunnen maken van gedeelde resources en samen workflows kunnen vormen. Een team met 40 goed afgebakende Skills heeft echt een heel ander vermogen dan een team dat prompts zit te plakken en knippen. Eén team dat tientallen Skills draait, meldde dat de overhead voor alle 40 skills samen ongeveer 1.500 tokens bedraagt, waarbij alleen de relevante skill wordt uitgeklapt op het moment dat het nodig is.

Praktijkvoorbeelden. Het patroon duikt overal op: geautomatiseerde codereviews, draaiboeken voor klantenservice, data-normalisatie, contentkwaliteitscontrole, het genereren van merkconforme documenten en onderzoekssynthese. De kracht van skills zit in hun vermogen om institutionele kennis vast te leggen, output te standaardiseren en complexe workflows met meerdere stappen af te handelen, iets waar je anders steeds opnieuw uitleg voor nodig zou hebben of waarvoor je zou moeten investeren in een custom agent.

De productiviteitsgedachte is simpel. Elke keer dat een kenniswerker dezelfde context opnieuw moet uitleggen aan een AI, is dat verspilde tijd, en het is tijd die slecht schaalt binnen een team. Gestructureerde, herbruikbare workflows nemen die verspilling weg. De exacte besparingen hangen af van jouw workflows, dus wees gerust kritisch op specifieke percentages die je online tegenkomt, maar de richting is duidelijk: minder herhaling, meer consistentie, meer slagkracht.

2. Hoe Claude Skills werken: architectuur, content-levenscyclus en skill-types

Nu je weet wat Skills zijn en waarom ze belangrijk zijn, tillen we de motorkap op. Als je de architectuur en levenscyclus begrijpt, weet je het verschil tussen Skills schrijven die betrouwbaar geactiveerd worden en Skills schrijven die ongebruikt blijven liggen omdat Claude nooit doorheeft dat ze relevant zijn.

De Claude Skill-architectuur in het kort

Op hoofdlijnen werkt het zo: een gebruiker of agent doet een verzoek, Claude checkt de metadata van alle geïnstalleerde Skills, bepaalt of er eentje relevant is, laadt bij een match de volledige inhoud van die Skill in de context, en genereert vervolgens een antwoord dat met die inhoud verrijkt is. Je kunt het je voorstellen als Gebruiker of Agent → scan van skill-metadata → relevantiebeslissing → content laden → verrijkt antwoord.

Elke Skill bestaat uit drie conceptuele lagen:

• Definitie. Wat de Skill is: naam, beschrijving, versie en metadata. Dit ziet Claude altijd.
• Content. Wat de Skill de context in laadt: de volledige instructies, voorbeelden en eventuele bijbehorende bronnen. Dit wordt alleen geladen wanneer nodig.
• Uitvoering. Hoe Claude de geladen content daadwerkelijk gebruikt om de taak uit te voeren, inclusief eventuele scripts of tools waar de Skill naar verwijst.

Waar worden Skills opgeslagen? Dat hangt af van je setup. In Claude Code staan ze in een skills/-map in je project of plugin. Via de API worden ze geüpload naar opslag die door Anthropic wordt beheerd. Teams bewaren de definitieve versies meestal in hun eigen Git-repository en verspreiden ze vandaaruit.

Hoe "weet" Claude dat een Skill bestaat? Via de metadata-laag die altijd geladen is. De YAML-frontmatter wordt altijd geladen in Claude's systeemprompt, wat ongeveer 100 tokens per skill kost, ongeacht hoeveel skills er geïnstalleerd zijn. Deze metadata-laag geeft Claude precies genoeg informatie om te bepalen of de skill relevant is voor de huidige taak, zonder de volledige inhoud te hoeven laden. Die 100 tokens zijn de prijs die je betaalt om een Skill vindbaar te maken, en daarom schaalt dit ontwerp probleemloos naar tientallen Skills.

Tot slot zijn er twee manieren waarop een Skill wordt aangeroepen. Impliciete aanroep is wanneer Claude zelf beslist dat een Skill relevant is, op basis van de beschrijving en het verzoek van de gebruiker. Expliciete aanroep is wanneer een gebruiker of agent de Skill rechtstreeks bij naam noemt. Beide zijn geldig; de balans daartussen bepaal je zelf wanneer je de beschrijving schrijft.

De levenscyclus van Skill-content

Een Skill doorloopt een voorspelbare levenscyclus, van idee tot productie en daarna. Als je elke fase en de bijbehorende valkuilen begrijpt, bespaar je jezelf uren aan gedebug.

Fase 1, Opstellen. Je schrijft het SKILL.md-bestand en eventuele ondersteunende bestanden. Hier wordt het merendeel van de kwaliteit gewonnen of verloren. Valkuil: beginnen met schrijven voordat je het probleem duidelijk hebt gedefinieerd. Verduidelijk eerst welk probleem je skill oplost, want sterke skills pakken concrete behoeften aan met meetbare resultaten.

Fase 2, Publiceren. Je zet de Skill vast op de plek waar Claude die zal lezen: een map, de API, of een CI/CD-pipeline. Valkuil: publiceren op de verkeerde locatie of vergeten de plugin te installeren, waardoor Claude de Skill nooit ontdekt.

Fase 3, Indexeren. Claude laadt de metadata van de Skill bij het opstarten in de systeemprompt. Valkuil: ervan uitgaan dat een net toegevoegde Skill midden in een sessie beschikbaar is zonder herstart of herlaadactie.

Fase 4, aanroepen. Claude vergelijkt een verzoek met de Skill-beschrijving en besluit die te gebruiken. Valkuil: de beschrijving is te smal, waardoor Claude de Skill nooit activeert.

Fase 5, injectie. De volledige inhoud van SKILL.md wordt in de context geladen. De eigenlijke inhoud van het bestand vormt het tweede detailniveau: als Claude denkt dat de skill relevant is voor de huidige taak, laadt het de skill door de volledige SKILL.md in de context te lezen. Valkuil: een te grote inhoud die context opslokt en de belangrijke instructies begraaft.

Fase 6, uitvoering. Claude verwerkt de verrijkte context en genereert zijn antwoord, waarbij eventuele scripts waar de Skill naar verwijst worden uitgevoerd. Valkuil: instructies die botsen met Claude's standaardgedrag, wat inconsistente output oplevert.

Fase 7, iteratie. Je versioneert, bewerkt en publiceert opnieuw. Valkuil: een Skill aanpassen zonder de versie te verhogen, waardoor niemand weet welk gedrag ze krijgen.

De nuttigste gewoonte hierbij is om triggering en uitvoering als afzonderlijke zaken te testen. Test triggering en uitvoering los van elkaar: als skills niet geactiveerd worden, maak je beschrijving breder en voeg je gebruikssituaties toe, en als de resultaten inconsistent zijn, maak je de instructies specifieker en voeg je validatiestappen toe. Dat zijn twee verschillende problemen met twee verschillende oplossingen, en ze als één probleem behandelen is precies waarom mensen in cirkels blijven ronddraaien.

Soorten Skill-inhoud

Niet elke Skill doet hetzelfde werk. Door te herkennen welk type je aan het bouwen bent, weet je hoe je de SKILL.md moet structureren.

Skills met alleen instructies leveren een set gedragsregels of een stapsgewijze procedure. Een checklist voor codereview is het klassieke voorbeeld: geen externe data, geen tools, gewoon een betrouwbaar proces dat Claude elke keer volgt.

Context-verrijkende Skills voegen domeinkennis, referentiedata of terminologie toe. Denk aan een Skill die de woordenlijst, producttaxonomie of merkstem van je bedrijf met zich meedraagt, zodat Claude de juiste taal spreekt zonder dat jij alles opnieuw hoeft uit te leggen.

Tool-activerende Skills beschrijven hoe en wanneer specifieke tools of scripts gebruikt moeten worden. Deze gaan vaak samen met MCP-koppelingen en wijzen Claude naar uitvoerbare hulpprogramma's in de map scripts/.

Template Skills leveren gestructureerde outputformaten: een JSON-schema, een rapportsjabloon, een code-scaffold. De waarde zit in consistentie van vorm, niet alleen in inhoud.

Hybride Skills combineren meerdere van bovenstaande in één geheel. Anthropics eigen Skills voor documentbewerking zijn hier een mooi voorbeeld van. Een van de skills die Claude's documentbewerkingsmogelijkheden aandrijft, speelt in op het feit dat Claude al veel weet over het begrijpen van PDF's, maar beperkt is in het direct bewerken ervan, zoals het invullen van een formulier, deze PDF-skill geeft Claude die nieuwe mogelijkheden. Dat is een mix van instructies, tools en templates.

Het juiste type kiezen. Vraag jezelf af wat de taak eigenlijk nodig heeft. Puur gedragsverandering? Alleen instructies. Kennis die ontbreekt? Context-verrijking. Moet er iets extern gebeuren? Tool-activering. Is een specifieke outputvorm nodig? Template. Meerdere tegelijk? Hybride, maar houd het zo gefocust mogelijk.

Hoe het type de structuur beïnvloedt. Skills die alleen instructies of templates bevatten, zijn meestal kort en passen volledig in de body van SKILL.md. Context-verrijkende en hybride Skills hebben vaak ondersteunende bestanden nodig, precies waar het systeem van progressive disclosure voor is ontworpen. Als vuistregel: houd de body van SKILL.md beperkt tot het essentiële en onder de 500 regels, en splits de inhoud op in aparte bestanden als je die grens nadert.

Hoe Claude besluit een Skill in te zetten

Dit is het onderdeel waar mensen het vaakst de fout ingaan, dus het verdient extra aandacht. Of een Skill wordt aangeroepen, hangt vooral af van het description-veld. Claude leest de beschrijving van elke geïnstalleerde Skill en vergelijkt die semantisch met het huidige verzoek. Krijg je die beschrijving goed voor elkaar, dan wordt de Skill betrouwbaar geactiveerd. Zit die fout, dan blijft zelfs de knapste Skill werkeloos aan de zijlijn staan.

Er is een bekend gedragspatroon waar je rekening mee moet houden. Claude heeft de neiging om skills ondermatig te activeren, ze dus niet te gebruiken terwijl ze wel nuttig zouden zijn. Om dit tegen te gaan kun je de beschrijvingen van je skills wat nadrukkelijker maken. Anthropic geeft zelf als advies om de situaties waarin een Skill geactiveerd moet worden expliciet te benoemen, ook de impliciete gevallen. In plaats van een kale eenregelige beschrijving zou je bijvoorbeeld kunnen toevoegen: "gebruik deze skill altijd wanneer de gebruiker dashboards, datavisualisatie, interne statistieken noemt, of op wat voor manier dan ook bedrijfsgegevens wil tonen, zelfs als er niet expliciet om een dashboard wordt gevraagd."

Expliciete aanroep werkt via directe verwijzing: een gebruiker of agent noemt de Skill bij naam, of een slash-commando activeert hem. Dit is de meest betrouwbare route, maar vereist wel dat degene die de aanroep doet weet dat de Skill bestaat.

Triggerzinnen en voorbeelden. Door voorbeeldzinnen en gebruikssituaties in je beschrijving op te nemen, wordt de semantische match scherper. Dit geeft Claude concrete aanwijzingen over wanneer iets relevant is. Het advies van Anthropic wanneer een Skill niet wordt geactiveerd is helder: als skills niet geactiveerd worden, maak je beschrijving dan breder en voeg gebruikssituaties toe.

Zekerheid en te vaak activeren. Het tegenovergestelde probleem is een beschrijving die zo breed is dat de Skill bij vrijwel alles wordt geactiveerd, waardoor hij zich ongevraagd in ongerelateerde gesprekken mengt. De oplossing is scope. Een strak afgebakende beschrijving met specifieke triggervoorwaarden activeert precies wanneer het moet, en blijft stil wanneer dat niet zo is.

Meerdere Skills en prioritering. Wanneer meerdere Skills kunnen matchen, weegt Claude de relevantie af. Prioriteitsconflicten zijn een reëel probleem waar je tegenaan kunt lopen, en een goed ontworpen Skill zorgt er juist voor dat twee Skills niet met elkaar concurreren doordat hun beschrijvingen overlappen.

Dynamische context. Runtime-variabelen, de specifieke bestanden die open staan, de gekoppelde tools, de bewoordingen van het verzoek: dit alles beïnvloedt welke Skill wordt geactiveerd. Een Skill die verwijst naar een database activeert bijvoorbeeld sneller als er ook echt een databaseverbinding actief is. Door hier goed rekening mee te houden bij het ontwerp, krijg je het gevoel dat een Skill precies "weet" wanneer hij moet ingrijpen.

Als je de hele dag Skills bouwt en test, vreet dat aan je Claude-abonnement. Claude Pro kost $20 per maand en Max ligt tussen de $100 en $200 per maand, gefactureerd in USD. Betaal met Bleap en je krijgt 0% wisselkoerskosten plus een vaste 20% cashback op Claude, ChatGPT en Gemini, zonder kaartabonnement. Vraag de Bleap-kaart aan →

3. Je eerste Claude Skill maken: een stapsgewijze handleiding

Genoeg theorie. Laten we samen een werkende Skill van begin tot eind bouwen. We gebruiken een praktisch voorbeeld, een Code Review Checklist Skill, en doorlopen elke stap, van de installatie tot een geslaagde eerste uitvoering.

Vereisten en omgeving instellen

Check eerst of je toegang hebt. Skills maken kan via Claude Code, de Claude API en Claude.ai, al is beheer op organisatieniveau nog volop in ontwikkeling. Volgens de huidige richtlijnen zijn skills in Claude.ai op dit moment per gebruiker individueel, maar komen beheer en delen op organisatieniveau er binnenkort aan. Het wordt aangeraden om alvast een gedeelde documentenmap met skill-specificaties op te zetten, zodat je klaar bent voor deze nieuwe functies en meteen al goede governance neerzet.

Voor betaalde toegang zijn de relevante Claude-abonnementen vrij overzichtelijk. De prijzen van Claude in 2026 zijn verdeeld over zeven niveaus: Free ($0), Pro ($20/maand), Claude Max 5x ($100/maand), Max 20x ($200/maand), Team Standard ($25/gebruiker/maand), Team Premium ($125/gebruiker/maand) en Enterprise (op maat). Bouw je Skills als onderdeel van een teamworkflow, dan geven de Team- en Enterprise-abonnementen je de beheerdersopties die je uiteindelijk nodig hebt. Werk je met programmatische automatisering, dan wordt de API apart per token gefactureerd.

Benodigde kennis. Eerlijk gezegd valt dat wel mee. Basiskennis van Markdown en een helder beeld van de taak die je wilt automatiseren. Meer heb je niet nodig.

Aanbevolen tools. VS Code met een Markdown-preview-extensie maakt het schrijven van SKILL.md een stuk prettiger. Met Git heb je vanaf dag één versiebeheer. Houd een aparte Claude-conversatie open die je uitsluitend gebruikt om te testen, los van je echte werk, zodat context je tests niet beïnvloedt.

Lokale ontwikkelmap. Richt een map in voordat je iets publiceert, zodat je Skills een nette plek hebben en er meteen een versiegeschiedenis is.

Drie manieren om een Skill te maken. Je kunt direct schrijven in een skills/-directory in Claude Code, uploaden via de Claude API, of starten vanuit Anthropic's template. Je kunt skills maken die Claude transformeren van algemene assistent naar gespecialiseerde expert, zowel met de skill creator template als handmatig. Om het jezelf makkelijk te maken, is het aan te raden om je SKILL.md-bestand met de template op te bouwen en van daaruit aan te passen.

Je Skill plannen voordat je ook maar één regel schrijft

Weersta de neiging om meteen je editor te openen. De beste Skills worden eerst gepland. Anthropic's gids is hier duidelijk over: identificeer twee of drie concrete use cases voordat je überhaupt bestanden aanraakt, en vraag jezelf af welke domeinkennis of best practices ingebouwd moeten worden die de gebruiker anders elke sessie opnieuw zou moeten uitleggen.

Beantwoord deze vijf vragen voordat je begint met schrijven:

1. Welke specifieke taak maakt deze Skill mogelijk? Voor ons voorbeeld: "Beoordeel een code diff aan de hand van de kwaliteitschecklist van ons team en lever een gestructureerd bevindingenrapport op."
2. Hoe weet Claude of een gebruiker wanneer deze Skill moet worden ingezet? Wanneer iemand een diff of pull request deelt, of om een code review vraagt.
3. Welke informatie moet in de context aanwezig zijn om de Skill te laten werken? De checklistcriteria en het outputformat. De code zelf komt van de gebruiker.
4. Welke tools heeft de Skill eventueel nodig? Voor een pure checklist: geen. Als er linters zouden draaien, zou toegang tot scripts nodig zijn.
5. Wie moet er toegang toe krijgen? Begin privé en breid uit naar het team zodra het zich bewezen heeft.

Maak het bereik smal, niet breed. Een Skill die "helpt met code" is nutteloos, omdat hij op alles reageert en niets specifieks oplevert. Een Skill die "Python pull requests beoordeelt aan de hand van de teamchecklist en bevindingen gegroepeerd op ernst oplevert" is precies, activeert correct en levert consistente waarde. Smaller wint bijna altijd.

Schrijf eerst de beschrijving, als een specificatie. Behandel de beschrijving als een specificatiedocument. Als je in twee of drie zinnen niet precies kunt beschrijven wat de Skill doet en wanneer hij geactiveerd moet worden, ben je nog niet klaar om de rest te schrijven.

Bepaal de minimaal haalbare Skill. Begin met de kleinste versie die waarde levert, breng die uit en verbeter daarna stap voor stap. Anthropic verwoordt het doel helder: aan het eind kun je een werkende skill in één zitting bouwen, en dat is precies wat de officiële gids belooft aan iedereen die de structuur correct volgt.

Stap 1: Zet je Skill-map op

Maak een map voor de Skill. De aanbevolen structuur:

code-review-checklist/
├── SKILL.md ← verplicht
├── references/ ← optionele achtergrondkennis
├── scripts/ ← optionele uitvoerbare hulpbestanden
└── assets/ ← optionele statische bestanden

Dit komt overeen met Anthropics eigen conventie. Binnen de skill-map bevindt zich een SKILL.md-bestand (verplicht) en optioneel een scripts/-map voor uitvoerbare code, een references/-map voor documentatie die Claude naar behoefte laadt, en een assets/-map voor templates en ondersteunende bestanden.

Naamgevingsconventies. Gebruik kebab-case voor mapnamen (code-review-checklist, niet CodeReviewChecklist). Gebruik een categorie-prefix zodat een grote verzameling overzichtelijk blijft: qa-, dev-, ops-, content-. Ons voorbeeld zou dan bijvoorbeeld dev-code-review-checklist heten.

Één map per Skill. Elke Skill zelfstandig houden is niet alleen netjes werken. Het betekent dat je Skills onafhankelijk van elkaar kunt versiebeheren, delen en verplaatsen, wat enorm veel oplevert zodra je er tientallen hebt. Elke skill staat volledig op zichzelf in zijn eigen map, met een SKILL.md-bestand dat de instructies en metadata bevat die Claude gebruikt.

Versiebeheer. Initialiseer Git in de map of de bovenliggende map, en gebruik Git-tags voor Skill-versies. Als je een Skill van 1.2.0 naar 1.3.0 upgradet, geef er dan een tag aan. Je toekomstige zelf, die aan het uitzoeken is waarom het gedrag afgelopen dinsdag ineens veranderde, zal je dankbaar zijn.

Stap 2: Schrijf het SKILL.md-bestand (minimaal haalbare versie)

Hier is een complete, werkende SKILL.md voor onze Code Review Checklist Skill. Dit is het volledige bestand, van frontmatter tot inhoud.

---
name: code-review-checklist
description: >
Beoordeelt code-diffs en pull requests aan de hand van de
kwaliteitschecklist van het team en geeft bevindingen terug,
gegroepeerd op ernst. Gebruik deze skill wanneer de gebruiker
een diff, een pull request, een codefragment ter beoordeling deelt,
of vraagt om een code review, kwaliteitscontrole of PR-feedback,
zelfs als ze niet expliciet het woord "checklist" gebruiken.
version: 1.0.0

# Code Review Checklist

Je voert een gestructureerde code review uit. Loop elk punt van de
onderstaande checklist na aan de hand van de code die de gebruiker aanlevert.

## Checklist

1. **Correctheid**, Doet de code wat hij beweert te doen? Signaleer logicafouten.
2. **Null- en foutafhandeling**, Worden edge cases en fouten netjes afgehandeld?
3. **Beveiliging**, Signaleer hardgecodeerde secrets, onveilige inputverwerking
of injectierisico's.
4. **Tests**, Is er voldoende testdekking voor de wijziging?
5. **Naamgeving en stijl**, Volgen namen onze conventies
(kebab-case bestanden, camelCase variabelen)?
6. **Leesbaarheid**, Zou een nieuwe collega dit binnen 60 seconden begrijpen?

## Outputformaat

Groepeer bevindingen onder drie kopjes: **Blokkerend**, **Zou moeten worden opgelost**,
en **Fijn om te hebben**. Verwijs bij elke bevinding naar de betreffende regel of
functie en geef een concrete, uitvoerbare aanbeveling in één regel. Sluit af met
een eindoordeel van één zin.

## Richtlijnen

- Als de code schoon is, zeg dat gewoon eerlijk. Verzin geen problemen.
- Wees specifiek. "Verbeter de foutafhandeling" is nutteloos;
"wrap de file read in een try/except" is nuttig.
- Herschrijf niet het hele bestand, tenzij daarom wordt gevraagd. Wijs op de fix.

Deze structuur volgt de template van Anthropic op de voet. De openbare template toont hetzelfde skelet: een naam en een duidelijke omschrijving van wat de skill doet en wanneer je hem gebruikt, een kop met instructies die Claude volgt zodra de skill actief is, een sectie met voorbeelden en een sectie met richtlijnen.

Laten we even markeren wat hier belangrijk is:

• De description doet het meeste werk. Merk op dat deze bewust "opdringerig" is: hij somt de situaties op die hem zouden moeten activeren en dekt expliciet ook het geval af waarin de gebruiker het woord "checklist" niet gebruikt. Dat voorkomt dat de skill te weinig geactiveerd wordt.
• De inhoud is een duidelijke procedure, geen vage suggestie. De items op de checklist zijn concreet en elk item is direct uitvoerbaar.
• Het uitvoerformaat ligt vast. Dat is precies wat "wat feedback" verandert in een consistent, vergelijkbaar rapport, elke keer weer.
• De richtlijnen sluiten achterdeurtjes af door Claude te vertellen dat hij geen problemen mag verzinnen en niet te veel mag herschrijven.

Veelgemaakte fouten in een eerste concept. Beschrijvingen die te summier zijn. Instructies die botsen met het standaardgedrag van Claude (bijvoorbeeld hem vragen om beknopt te zijn en vervolgens om gedetailleerde uitleg vragen). Content die uitdijt tot voorbij het punt van bruikbaarheid. En uitvoerformaten die impliciet blijven, wat tot wisselende resultaten leidt.

De hardop-lezen-test. Lees je SKILL.md hardop voor. Klinkt een zin voor jou verward of dubbelzinnig, dan zal die Claude ook in verwarring brengen. Helder schrijven is hier geen leuke bijkomstigheid; het is de hele technische opgave.

Stap 3: Publiceer de Skill

Hoe je publiceert, hangt af van je omgeving.

In Claude Code zet je de map gewoon in de skills/-map van je project en Claude pikt hem vanzelf op. Je maakt een skills-map aan in de root van je plugin of project en voegt daar skill-mappen met SKILL.md-bestanden aan toe. Zodra de plugin is geïnstalleerd, ontdekt en gebruikt Claude ze automatisch.

Via de API upload je de Skill-map met de Skills API. In de documentatie van Anthropic vind je hiervoor een speciale Skills API Quickstart.

In Claude.ai voeg je de Skill toe via de Skills-interface in je werkruimte, plak of upload je SKILL.md, en stel je het initiële toegangsniveau in. Let op: in Claude.ai zijn Skills op dit moment gekoppeld aan de individuele gebruiker, bredere deling staat nog op de roadmap.

Toegangsniveau instellen. Begin privé. Bewijs eerst dat de Skill op zichzelf goed werkt, voordat je hem deelt met een team of werkruimte. Het is veel makkelijker om later de toegang te verbreden dan om een kapotte Skill terug te draaien waar al tien mensen op vertrouwen.

Na publicatie volgt een korte indexeringsstap waarbij de metadata wordt geladen in de systeemprompt. In een lopende sessie moet je mogelijk de pagina vernieuwen of opnieuw beginnen voordat een nieuw toegevoegde Skill beschikbaar wordt.

Stap 4: Voer je eerste testaanroep uit

Open een nieuw gesprek. Dit is belangrijk. Een bestaand gesprek bevat context die kan verhullen of je Skill daadwerkelijk is geactiveerd, of dat Claude gewoon reageert op eerdere berichten.

Test eerst impliciete aanroep. Plak een code diff en zeg simpelweg: "Kun je dit reviewen?" Noem de Skill niet bij naam. Als je beschrijving goed is, zou Claude automatisch de Skill moeten pakken en output moeten geven in het door jou gedefinieerde formaat.

Test vervolgens expliciete aanroep. Verwijs direct naar de Skill en controleer of deze op verzoek wordt geactiveerd.

Interpreteer de reactie. Het duidelijkste signaal dat de Skill is geladen, is dat de output precies overeenkomt met je gedefinieerde formaat: bevindingen gegroepeerd onder Blokkerend, Zou moeten oplossen en Leuk om te hebben, met een oordeel in één zin. Krijg je in plaats daarvan algemene tekstuele feedback, dan is de Skill waarschijnlijk niet geactiveerd.

Vijf tekenen dat je Skill werkt:

1. De output volgt precies het door jou opgegeven formaat.
2. Claude past jouw specifieke checklist-punten toe, niet alleen algemene best practices.
3. Het houdt zich aan je richtlijnen (verzint geen problemen bij schone code).
4. Het wordt geactiveerd bij natuurlijke verzoeken, zonder dat je het er expliciet bij noemt.
5. Het gedrag blijft consistent bij herhaalde tests met verschillende input.

Als de activering onbetrouwbaar blijkt, denk dan aan de scheiding-van-verantwoordelijkheden-regel: los activeringsproblemen op door de beschrijving breder en scherper te maken; los problemen met de kwaliteit van de output op door specificiteit en validatiestappen toe te voegen aan de body.

Veelgemaakte beginnersfouten en hoe je ze oplost

Een handjevol fouten is verantwoordelijk voor het meeste beginnersleed.

Instructies die tegen het standaardgedrag van Claude ingaan. Als je Skill Claude vertelt zich anders te gedragen dan gebruikelijk, zonder duidelijke onderbouwing, krijg je wisselende resultaten. Oplossing: leg expliciet uit waarom de afwijking nodig is, en valideer dit.

Beschrijvingen die zo breed zijn dat de Skill overal op reageert. Een Skill die bij elk bericht afgaat, is erger dan nutteloos. Oplossing: baken de scope af en voeg specifieke triggervoorwaarden toe.

Verkeerd toegangsniveau vóór het delen. Iets teamsbreed publiceren voordat het getest is, of een kapotte Skill zichtbaar laten staan. Oplossing: begin privé en verbreed pas na validatie.

Overvolle bodies. Een opgeblazen SKILL.md verspilt context en verstopt de belangrijkste instructies. Oplossing: houd de body onder de 500 regels en zet ondersteunende details in references/. Zoals de richtlijn luidt: houd de body van SKILL.md bij de essentie en onder de 500 regels, en splits de inhoud op in aparte bestanden als je die grens nadert.

Geen edge cases testen. Een Skill die prima werkt in het standaardscenario maar vastloopt bij ongewone input, ondermijnt snel het vertrouwen. Oplossing: bouw een degelijke bibliotheek met testcases op. Maak een verzameling testcases die normaal gebruik, edge cases en verzoeken buiten de scope dekt.

4. De structuur van het SKILL.md-bestand: metadata, frontmatter en body

Je hebt inmiddels een werkende Skill gebouwd. Laten we nu dieper ingaan op het bestand zelf, want als je de structuur van SKILL.md onder de knie krijgt, til je je Skills naar een hoger niveau: van "werkt meestal wel" naar "werkt altijd, op schaal, binnen een heel team".

Het bestandsformaat van SKILL.md begrijpen

Waarom Markdown? Omdat het leesbaar is voor mensen, prettig werkt bij diffs in Git, overal ondersteund wordt en je dwingt om helder te schrijven. Markdown is bovendien de manier waarop Claude van nature "denkt" over gestructureerde tekst, dus instructies in Markdown volgt Claude vanzelf. Die keuze is bewust: Skills zijn net zo goed bedoeld om door mensen geschreven en gecontroleerd te worden als om door Claude uitgevoerd te worden.

De tweedelige structuur. Elk SKILL.md-bestand bestaat uit een YAML-frontmatterblok gevolgd door een Markdown-body. Een SKILL.md-bestand moet beginnen met YAML-frontmatter met een bestandsnaam en beschrijving, die bij het opstarten in de systeemprompt wordt geladen. De frontmatter is metadata; de body bevat de instructies.

Hoe de twee onderdelen verschillend worden behandeld. Dit is de kern van de architectuur van progressieve onthulling. De frontmatter wordt altijd geladen. De body wordt alleen geladen wanneer dat relevant is. De YAML-frontmatter wordt altijd meegenomen in Claude's systeemprompt en kost ongeveer 100 tokens per skill, genoeg voor Claude om te bepalen of iets relevant is, zonder meteen de hele inhoud te laden. De body van SKILL.md wordt pas geladen zodra Claude vaststelt dat de skill relevant is, en die bevat dan de volledige instructies, stapsgewijze workflows, voorbeelden en tips voor het oplossen van problemen.

Bestandsgroottelimieten. Er is geen keiharde universele grens, maar de praktische richtlijn is een body van minder dan 500 regels. Kom je daarboven, dan kun je beter content opsplitsen in references/-bestanden die Claude on demand inlaadt. Anthropic heeft hier speciaal een derde disclosure-niveau voor bedacht: wanneer een Skill te groot wordt voor één enkele SKILL.md, vangen de ondersteunende bestanden de overflow op. Naarmate skills complexer worden, kunnen ze te veel context bevatten om in één SKILL.md te passen.

Encoding en opmaak. Gebruik UTF-8 encoding en standaard regeleindes. Houd je Markdown netjes en goed gestructureerd, want de structuur zelf is voor Claude een signaal over hoe informatie geprioriteerd moet worden.

Wat het bestand bevat versus wat Claude ontvangt. Dat is niet hetzelfde. Het bestand bevat alles: frontmatter, body en verwijzingen naar resources. Wat Claude op een gegeven moment daadwerkelijk ontvangt, hangt af van het disclosure-niveau. Bij het opstarten ontvangt Claude alleen jouw ~100-token metadata. Bij aanroep ontvangt het de body. Verwezen bestanden leest het alleen als de body dat aangeeft. Als je hier bij het ontwerpen rekening mee houdt, maakt dat het verschil tussen een efficiënte Skill en eentje die stilletjes context verspilt.

YAML Frontmatter: Elk Veld Uitgelegd

De frontmatter is klein maar cruciaal. Twee velden zijn verplicht (name en description); de rest is optioneel maar waardevol als je opschaalt. Hier is het complete overzicht.

name, de canonieke identifier voor de Skill. Gebruik kebab-case, houd het beschrijvend, en zorg dat het uniek is binnen je workspace, zodat er geen twijfel bestaat over welke Skill het betreft. code-review-checklist is goed; helper is dat niet. De naam is zowel een label voor mensen als, bij expliciete aanroep, de term die mensen gebruiken.

version, semantische versienummering in de vorm MAJOR.MINOR.PATCH. Verhoog de PATCH voor kleine fixes en verduidelijkingen, de MINOR voor nieuwe functionaliteit die achterwaarts compatibel blijft, en de MAJOR voor wijzigingen die bestaand gedrag zo veranderen dat huidige gebruikers ervan kunnen schrikken. Versienummering zorgt ervoor dat een team precies weet welk gedrag ze kunnen verwachten, en vormt de ruggengraat van veilig itereren. Zorg dat je bij het opnieuw publiceren de versie ook tagt in Git, zodat de bestandsgeschiedenis en het versienummer synchroon blijven lopen.

description, veruit het belangrijkste veld. Dit stuurt de aanroep-routering via semantische matching, en dit veld wordt altijd geladen, het moet dus die ~100 tokens waard zijn. Richtlijnen die in de praktijk werken:

• Streef naar ongeveer 100 tot 200 woorden. Lang genoeg om specifiek te zijn, kort genoeg om binnen het altijd-geladen budget te blijven.
• Schrijf voor semantische gelijkenis, niet voor keyword stuffing. Beschrijf de situaties waarin de Skill van pas komt, niet een lijst met steekwoorden.
• Wees "pusherig" om ondertriggering tegen te gaan. Benoem expliciet de triggerscenario's, inclusief de impliciete. Denk aan Anthropics voorbeeld waarin expliciet wordt aangegeven dat een dashboard-Skill moet afgaan zodra een gebruiker het heeft over datavisualisatie of interne metrics, zelfs als er niet letterlijk om een dashboard wordt gevraagd.
• Een sterke beschrijving luidt: "Beoordeelt code diffs en pull requests aan de hand van de kwaliteitschecklist van het team en geeft bevindingen terug, gegroepeerd op ernst. Gebruik dit altijd wanneer de gebruiker een diff, PR of codefragment deelt ter review." Een zwakke beschrijving luidt: "Helpt met code." De eerste triggert correct; de tweede triggert op alles of nergens.

author, toekenning aan een individu of team. Dit is belangrijker dan het lijkt. Het legt verantwoordelijkheid vast (wie is eigenaar van deze Skill en bij wie moet je zijn als er iets misgaat) en ondersteunt governance naarmate je bibliotheek groeit.

tags, een taxonomiestrategie om dingen terug te vinden in grote bibliotheken. Aanbevolen categorieën: domein (security, data, content), functie (review, generation, analysis), doelgroep (engineering, support, marketing), en volwassenheid (experimental, stable, deprecated). Consistent taggen is precies wat een bibliotheek met 40 Skills overzichtelijk houdt in plaats van chaotisch.

trigger_phrases, een optionele reeks voorbeelduitingen die de Skill zouden moeten activeren. Deze scherpen de invocation scoring aan door Claude concrete aanknopingspunten te geven. Vijf tot tien is de ideale hoeveelheid: genoeg om de belangrijkste formuleringen te dekken, maar niet zoveel dat je gewoon de description herhaalt. Let op: ondersteuning voor dit veld verschilt per omgeving, dus check het huidige schema voor jouw setup; als het geen formeel veld is, verwerk dan vergelijkbare voorbeelden in de description zelf.

arguments, definities voor dynamische input die aanroepers aan de Skill doorgeven. Elk argument specificeert doorgaans een naam, een type, of het verplicht of optioneel is, en een standaardwaarde. Argumenten maken een Skill flexibel: een Skill voor het genereren van rapporten zou bijvoorbeeld een format-argument kunnen hebben (standaard markdown) of een severity_threshold. Houd de set argumenten minimaal en goed gedocumenteerd, want elk argument is weer iets dat een aanroeper moet begrijpen en weer een pad dat jij moet testen.

Een effectief SKILL.md-bestand schrijven

In de body zit de daadwerkelijke expertise, en de manier waarop je die schrijft bepaalt rechtstreeks hoe betrouwbaar Claude de taak uitvoert.

Stem de begeleiding af op de vrijheid van de taak. Anthropic gebruikt hier een treffende analogie. Zie Claude als iemand die een pad verkent: een smalle brug met afgronden vraagt om specifieke vangrails (weinig vrijheid), terwijl een open veld talloze routes toelaat (veel vrijheid). Stem de begeleiding van je Skill dus af op het terrein. Een Skill die compliance controleert heeft strakke, voorgeschreven stappen nodig. Een Skill voor brainstormen mag juist veel meer ruimte laten. Beperk creatieve taken niet te veel en geef risicovolle taken niet te weinig kaders.

Structureer de body op een voorspelbare manier. Een betrouwbaar patroon is: een taakomschrijving in één regel, een stapsgewijze procedure, een vast outputformaat en een richtlijnensectie die mazen dichttimmert. Anthropics eigen workflowvoorbeelden volgen deze opzet en eindigen met een kwaliteitscontrole: schrijf een concept volgens de structuur van de koppen en de toonrichtlijnen, en doorloop daarna de kwaliteitschecklist voordat je het concept oplevert.

Voeg voorbeelden en validatie toe. Concrete voorbeelden geven Claude houvast, en expliciete validatiestappen vangen fouten op voordat ze de gebruiker bereiken. Als resultaten inconsistent zijn, zit de oplossing vrijwel altijd in meer specificiteit en meer validatie, niet in meer tekst.

Houd het compact. Elke regel die je toevoegt, wordt bij aanroep in de context geladen. Het advies van onder de 500 regels is niet zomaar gekozen; het beschermt je contextbudget en voorkomt dat de belangrijke instructies verwateren.

Ondersteunende bestanden gebruiken: referenties, scripts en assets

Met de optionele mappen houd je SKILL.md compact, terwijl Claude toch toegang heeft tot meer informatie wanneer dat nodig is. Dit is het derde niveau van progressive disclosure.

references/ bevat documentatie die Claude op verzoek inlaadt: gedetailleerde specificaties, lange naslagtabellen, stijlgidsen. De body verwijst naar deze bestanden en Claude leest ze alleen als de taak erom vraagt. Zo kun je een Skill met een omvangrijke kennisbank gebruiken zonder dat je bij elke aanroep de contextkosten betaalt.

scripts/ bevat uitvoerbare hulpmiddelen. Als een Skill iets deterministisch moet doen, zoals een linter draaien, een bestand parsen of een API aanroepen, is een script betrouwbaarder dan Claude vragen het werk te simuleren. De body vertelt Claude wanneer en hoe elk script uitgevoerd moet worden.

assets/ bevat statische bestanden: templates, schema's, boilerplate, afbeeldingen. Een Skill voor documentgeneratie bewaart hier bijvoorbeeld zijn rapportsjabloon.

Het onderliggende principe is elegant. Om skills te activeren hoef je alleen een SKILL.md-bestand te schrijven met aangepaste instructies voor je agent, en een skill is een map die een SKILL.md-bestand bevat met daarnaast overzichtelijke mappen met instructies, scripts en resources die agents extra mogelijkheden geven. Begin met alleen het SKILL.md-bestand en voeg pas extra mappen toe zodra de body écht te groot wordt voor één bestand.

Toegangsbeheer en verpakking voor teams

Twee praktische zaken maken het plaatje compleet: wie een Skill mag gebruiken, en hoe je hem verspreidt.

Toegangsbeheer. Stel toegangsniveaus bewust in. Privé tijdens ontwikkeling en testen, team- of workspace-niveau zodra iets bewezen werkt. Omdat Claude.ai Skills momenteel koppelt aan individuele gebruikers, doen teams er goed aan om ondertussen een gedeelde specificatie-repository bij te houden. Het is aan te raden om een gedeelde documentrepository met skill-specificaties op te zetten: zo bereid je je organisatie voor op toekomstige functies én leg je nu al een goede basis voor governance.

Verpakken en verspreiden. Zodra een Skill goed staat, moet je hem netjes verspreiden in plaats van bestanden rond te sturen. De volwassen aanpak is Git plus plugins plus enterprise-instellingen. Je kunt skills delen met je team door ze naar een repository te committen, ze breder verspreiden via plugins, en organisatiebreed uitrollen met enterprise managed settings. Voor governance op grote schaal krijgen Enterprise-klanten extra ondersteuning. Enterprise-klanten kunnen samenwerken met het customer success-team van Anthropic om extra implementatiemogelijkheden en governance-kaders te verkennen.

Testen vóór verspreiding. Verspreid nooit een Skill die je niet hebt getest aan de hand van een realistische reeks voorbeelden. Denk aan het normale gebruikspad, de randgevallen, en vooral ook de verzoeken die buiten het toepassingsgebied vallen en de Skill dus niet zouden moeten activeren. Juist die laatste categorie zorgt ervoor dat jij te veel activering ontdekt vóórdat je teamgenoten dat doen.

5. Geavanceerde patronen: MCP-integratie, subagents en tool-goedkeuring

Zodra je vertrouwd bent met losse Skills, komt de echte meerwaarde uit de combinatie met de rest van het Claude-platform. In dit deel bespreken we de patronen waarmee een Skill-bibliotheek verandert in echte automatisering.

MCP-integratie met Claude Skills

Het Model Context Protocol verbindt Claude met externe systemen: databases, API's, opslagsystemen, interne tools. Skills en MCP vullen elkaar aan, ze concurreren niet met elkaar. MCP zorgt voor de verbinding; de Skill levert de werkwijze om die verbinding goed te benutten.

Een concreet voorbeeld: MCP koppelt Claude aan je analytics-database. Op zichzelf kan Claude die bevragen, maar het kent je tabelconventies niet, weet niet hoe jij belangrijke metrics definieert en ook niet in welk format je team rapportages verwacht. Een Skill vult dat allemaal aan. Het vertelt Claude in welke tabellen welke data staat, hoe "actieve gebruiker" binnen jouw organisatie wordt gedefinieerd en precies hoe de output vormgegeven moet worden. Samen maken ze van een kale verbinding een betrouwbare analist.

De voorbeeldbibliotheek van Anthropic bevat zelfs het genereren van een MCP-server als een van de gedemonstreerde Skills, wat mooi laat zien hoe natuurlijk deze twee lagen op elkaar aansluiten. Ga er bij het ontwerpen van een tool-activerende Skill van uit dat MCP het transport verzorgt, en richt je SKILL.md op de beslissingslogica: wanneer je de tool inschakelt, welke parameters je meegeeft en hoe je het resultaat controleert.

Claude Subagents en Skill-delegatie

Met subagents kun je een afgebakende taak delegeren aan een apart agent met zijn eigen, geïsoleerde context. Door een subagent te combineren met een Skill krijg je een specialist voor een specifieke klus, zonder dat je hoofdgesprek daardoor rommelig wordt.

Dit patroon is krachtig voor pipelines met meerdere stappen. Denk aan een release-workflow: één subagent, uitgerust met een code review Skill, beoordeelt de diff; een andere, uitgerust met een changelog Skill, stelt release notes op; een derde, uitgerust met een QA Skill, genereert een testplan. Elke subagent draait geïsoleerd, met alleen de context die hij nodig heeft. Anthropic beschrijft precies deze mogelijkheid. Je kunt Skills koppelen aan aangepaste subagents voor geïsoleerde, gespecialiseerde taakdelegatie, en er is een uitgebreide troubleshooting-gids voor het diagnosticeren van problemen, van skills die niet activeren tot prioriteitsconflicten en runtime-fouten.

Het voordeel is tweeledig: een schonere context (het hoofdgesprek wordt niet vervuild door de werknotities van de subagent) en duidelijkere specialisatie (elke subagent doet één ding goed). De prijs die je daarvoor betaalt is coördinatiecomplexiteit, dus grijp naar subagents wanneer een taak écht baat heeft bij isolatie, niet zomaar voor alles.

Claude Tool-goedkeuring en toegangsbeheer

Wanneer een Skill Claude de mogelijkheid geeft om tools te gebruiken, vooral tools die daadwerkelijk actie ondernemen zoals het versturen van e-mails, schrijven naar een database, of het aanroepen van een betaalde API, wordt toolgoedkeuring een kwestie die direct met veiligheid te maken heeft. Het uitgangspunt is least privilege: een Skill zou alleen de specifieke tools moeten ontgrendelen die hij écht nodig heeft, en acties met echte gevolgen zouden om bevestiging moeten vragen.

Ontwerp je tool-activerende Skills zo dat alleen-lezen bewerkingen vrij kunnen doorstromen, maar schrijf- of destructieve bewerkingen pauzeren voor goedkeuring. Documenteer in de body van SKILL.md precies welke tools de Skill gebruikt en onder welke voorwaarden, zodat zowel Claude als een menselijke reviewer de impact ervan begrijpen. Dit is ook waar het author-veld en duidelijke versiebeheer hun waarde bewijzen: wanneer een Skill acties kan uitvoeren, wil je onmiskenbare duidelijkheid over wie de eigenaar is en welke versie er live staat.

Voor organisaties sluit dit aan op enterprise managed settings, waarbij beheerders kunnen bepalen welke Skills en tools voor wie beschikbaar zijn. Behandel tool-goedkeuring vanaf het begin als onderdeel van het Skill-ontwerp, niet als iets dat je er achteraf aan plakt. Een Skill die kan handelen, is een Skill die schade kan aanrichten als hij verkeerd wordt geactiveerd, nog een reden om beschrijvingen strak af te bakenen en verzoeken buiten de scope grondig te testen.

Skills testen en kwaliteitsborging op schaal

Eén Skill testen is makkelijk. Kwaliteit bewaken over een groeiende bibliotheek vraagt discipline. Drie werkwijzen maken hierbij het verschil.

Houd triggertests gescheiden van uitvoeringstests. Zoals eerder aangegeven, zijn dit twee verschillende soorten fouten. Onderhoud voor elk aparte testcases: één set die controleert of de Skill afgaat (en niet afgaat wanneer dat niet zou moeten), en een andere die de kwaliteit van de output controleert zodra hij dat wel doet. Test triggering en uitvoering los van elkaar; activeren skills niet, verbreed dan je beschrijving en voeg use cases toe, en zijn de resultaten inconsistent, voeg dan meer specificiteit toe aan de instructies en bouw validatiestappen in.

Bouw een fatsoenlijke bibliotheek met testcases. Houd voor elke Skill gedocumenteerde cases bij die normaal gebruik, edge cases en verzoeken buiten de scope dekken. Draai ze telkens wanneer je de Skill wijzigt. Zo vang je regressies af voordat ze bij gebruikers terechtkomen, en dit is verreweg de waardevolste gewoonte voor een volwassen wordende bibliotheek.

Let op prioriteitsconflicten. Naarmate je bibliotheek groeit, gaan twee Skills met overlappende beschrijvingen met elkaar concurreren. Onderdeel van QA op schaal is het controleren van beschrijvingen op overlap en het aanscherpen van de scope, zodat elke Skill duidelijk zijn eigen terrein heeft. De troubleshooting-handleidingen van Anthropic noemen prioriteitsconflicten expliciet als bekende categorie, dus houd er rekening mee en ontwerp je Skills er tegen bestand.

Draai je de hele week met Claude in meerdere repo's om je Skill-library te testen? Dan zit je al gauw aan een Max 20x-abonnement van $200/maand, gefactureerd in USD. Met Bleap betaal je tegen de echte wisselkoers, 0% wisselkoersen, en krijg je 20% cashback op je Claude-, ChatGPT- en Gemini-verlengingen, zonder dat je een kaartabonnement nodig hebt. Vraag de Bleap-kaart aan →

6. Best practices voor productie en de slimme manier om voor Claude te betalen

Je hebt nu alles wat je nodig hebt om Skills te bouwen, structureren en combineren. Er blijven nog twee dingen over die het verschil maken tussen een hobbyproject en een echte productiepraktijk: operationele discipline, en het optimaliseren van wat je voor je Claude-abonnement betaalt.

Checklist voor best practices in productie

• Houd het bereik smal. Elke Skill moet één ding goed doen. Een smal bereik betekent betrouwbare triggering en consistente output.
• Schrijf pushy beschrijvingen. Voorkom ondertriggering door expliciet de scenario's te benoemen die de Skill moeten activeren, inclusief de impliciete gevallen.
• Houd de body slank. Onder de 500 regels, met details verplaatst naar references/. Bescherm je contextbudget.
• Versieer alles. Semantische versienummering plus Git-tags, zodat iedereen weet welk gedrag actief is.
• Test in drie categorieën. Normaal, edge case en buiten bereik, waarbij je triggering en uitvoering apart test.
• Beheer toegang bewust. Begin privé, verbreed pas na validatie. Geef tools zo min mogelijk rechten.
• Onderhoud een spec-repository. Zeker zolang organisatiebrede deling nog in ontwikkeling is, houdt een gedeelde spec-repo het team op één lijn en bereidt het je voor op beheerde instellingen.
• Documenteer eigenaarschap. Gebruik het veld author, zodat elke Skill een duidelijke eigenaar heeft.

Houd je hieraan, dan bouw je een Skills-bibliotheek die in waarde blijft groeien in plaats van technische schuld op te stapelen.

De kostenkant: voor Claude betalen zonder geld te verliezen

Hier komt het deel dat de meeste gidsen liever niet vermelden. Skills bouwen betekent betalen voor Claude, en Claude-abonnementen worden in USD gefactureerd. Claude Pro kost $20 per maand (of $17 per maand bij jaarlijkse facturering), en Claude Max ligt tussen de $100 en $200 per maand. Voor teams begint het Team-abonnement bij $25 per gebruiker per maand, met $150 per maand voor premium seats inclusief de Claude Code-ontwikkelomgeving.

Zit je in de EER en betaal je voor een USD-abonnement met een gangbare Europese kaart? Dan verlies je bij elke verlenging stiekem geld. De meeste kaarten rekenen 2-3% buitenlandse transactiekosten bovenop een opgeblazen wisselkoers. Bij een Max-abonnement van omgerekend €200 loopt die 2-3% al snel op tot zo'n €4 tot €6 per maand, oftewel €48 tot €72 per jaar, alleen al aan wisselkoerskosten. Bij een team van vijf op Team-seats loopt dat lek nog veel harder vol.

Hier komt Bleap om de hoek kijken. Bleap is geen AI-tool en gaat je Skills niet voor je bouwen. Het is een fintech-kaartbedrijf, en de slimme manier om te betalen voor de AI-abonnementen waar deze gids over gaat. Twee concrete voordelen zijn hier direct van toepassing:

• 0% wisselkoerskosten op USD-abonnementen. Je betaalt je Claude Pro-, Max- of Team-factuur tegen de echte wisselkoers, zonder buitenlandse transactiekosten en zonder weekendopslag. Het geld dat anders naar FX-kosten zou gaan, blijft gewoon in je zak.
• 20% cashback op Claude, ChatGPT en Gemini. Bleap geeft een vaste 20% cashback (uitbetaald in USDC) op abonnementen bij deze drie specifieke AI-tools. Bij een Claude Pro-abonnement van $20 per maand is dat elke maand weer echt geld terug, en bij een Max-abonnement van $200 per maand loopt dat aanzienlijk verder op.

Het is een self-custodial Mastercard-debitcard die je overal kunt gebruiken waar Mastercard wordt geaccepteerd, zonder een eigen maandelijks abonnement. Je hoeft nergens iets voor op te geven: je houdt volledige controle over je geld, je betaalt je AI-facturen precies zoals voorheen, en je stopt met geld verliezen aan wisselkosten terwijl je cashback verdient op de drie grootste AI-abonnementen. Voor iedereen die Claude serieus genoeg gebruikt om er Skills mee te bouwen, is dat een simpele optimalisatie.

Even eerlijk zijn: de vaste 20% cashback geldt specifiek voor Claude, ChatGPT en Gemini. Voor andere AI-tools profiteer je nog wel van 0% wisselkosten bij facturering in USD, maar dan zonder de 20% cashback. En de spaarkluizen van Bleap, die 3,65% AER (Steady, laagste risico) en 3,83% AER (Dynamic, laag risico) opleveren in USD met een minimum van $1 en 0% opnamekosten, zijn een apart kenmerk dat het waard is om te kennen als je wilt dat je overtollige saldo aan het werk blijft terwijl jij aan het bouwen bent.

Veelgestelde vragen

Wat is een Claude Skill precies?

Een Claude Skill is een op zichzelf staande, herbruikbare instructie-eenheid die Claude naar behoefte laadt om een specifieke taak betrouwbaar uit te voeren. Skills zijn mappen met instructies, scripts en bronnen die Claude dynamisch inlaadt om beter te presteren op gespecialiseerde taken, waarmee Claude leert hoe het bepaalde taken op een herhaalbare manier kan uitvoeren. Technisch gezien is het gewoon een map met een SKILL.md-bestand met YAML-frontmatter en Markdown-instructies, plus optionele aanvullende mappen.

Wat is het verschil tussen een skill.md-bestand en een prompt?

Een prompt bestaat maar voor één gespreksmoment en verdwijnt daarna weer. Een SKILL.md-bestand daarentegen is permanent, versiebeheerd, vindbaar en herbruikbaar. Het belangrijkste structurele verschil is dat Claude actief weet dat een Skill bestaat, omdat de agent bij het opstarten de naam en beschrijving van elke geïnstalleerde skill alvast inlaadt in zijn systeemprompt. Claude kan nooit teruggrijpen op een prompt die niet is getoond, maar kan wel automatisch een relevante Skill erbij pakken.

Moet ik kunnen programmeren om Claude Skills te bouwen?

Nee. Skills draaien in de kern om schrijven en configureren. Het zijn geen modellen of betaalde extra's, maar open-source markdown-instructies met eventueel wat ondersteunende bestanden. Als je duidelijke instructies in Markdown kunt schrijven en goed nadenkt over wanneer een taak zou moeten worden geactiveerd, kun je een Skill van productiekwaliteit bouwen. Scripts zijn optioneel en alleen nodig voor taken die om een vaste, voorspelbare uitvoering vragen.

Hoe bepaalt Claude wanneer een Skill wordt gebruikt?

Claude vergelijkt het huidige verzoek met het description-veld van elke geïnstalleerde Skill op basis van semantische overeenkomst. Omdat Claude de neiging heeft om Skills te weinig te activeren, dus ze niet te gebruiken terwijl ze wel nuttig zouden zijn, raadt Anthropic aan om beschrijvingen te schrijven die expliciet de scenario's opsommen waarin de Skill geactiveerd moet worden, inclusief impliciete gevallen. Een sterke, specifieke en enigszins pushende beschrijving is veruit de belangrijkste factor voor betrouwbare aanroeping.

Hoe lang moet een SKILL.md-bestand zijn?

Houd de inhoud beknopt. Het praktische advies is om de body van SKILL.md tot de essentie te beperken en onder de 500 regels te houden, en als je die grens nadert, splits de inhoud dan op in aparte bestanden. De frontmatter, die altijd wordt geladen, is piepklein, ongeveer 100 tokens, terwijl de body alleen wordt geladen wanneer de Skill wordt aangeroepen. Een compacte body beschermt dus je contextbudget en zorgt ervoor dat de belangrijke instructies niet verwateren.

Hoe verhouden Skills zich tot MCP en subagents?

Het zijn aanvullende lagen. MCP is de connectiviteitslaag die Claude verbindt met externe tools en data; een Skill is de instructielaag die Claude vertelt hoe die verbinding gebruikt moet worden. Subagents voegen isolatie toe, en je kunt Skills inbouwen in aangepaste subagents voor geïsoleerde, gespecialiseerde taakuitvoering. Een veelvoorkomend patroon in productieomgevingen combineert alle drie: MCP verbindt de data, een Skill definieert de procedure, en een subagent voert het uit in een schone context.

Kan ik Skills delen met mijn hele team?

Steeds meer wel, al is de tooling nog volop in ontwikkeling. In Claude.ai zijn Skills momenteel gekoppeld aan de individuele gebruiker, maar organisatiebrede beheer- en deelfuncties komen er binnenkort aan. Tot die tijd kun je Skills delen via een Git-repository, verspreiden via plugins, en organisatiebreed uitrollen met enterprise-beheerinstellingen. Door nu al een gedeelde spec-repository bij te houden, ben je goed voorbereid op de beheerfuncties die eraan komen.

Hoeveel kost het om Claude te gebruiken voor het bouwen van Skills?

Het aanmaken van Skills zelf valt onder de Claude-abonnementen. Claude-prijzen in 2026 lopen uiteen van Free ($0), Pro ($20/maand), Max 5x ($100/maand), Max 20x ($200/maand), Team Standard ($25/seat/maand), Team Premium ($125/seat/maand), tot Enterprise (op maat). Omdat dit allemaal in USD wordt afgerekend, kost betalen vanuit de EER met een kaart die 2-3% buitenlandse transactiekosten rekent je elke maand extra geld. Betaal je met Bleap, dan heb je 0% wisselkoerskosten én krijg je een vaste 20% cashback op je Claude-abonnement, waardoor er meer van je budget overblijft voor daadwerkelijk gebruik.

Wat is de meest gemaakte fout van beginners bij Skills?

Er zijn twee fouten die het vaakst voorkomen: een te vage beschrijving schrijven (waardoor de Skill of nooit, of juist altijd wordt geactiveerd) en de inhoud te veel volstoppen. De oplossing voor het triggerprobleem is een specifieke beschrijving met veel scenario's; de oplossing voor de kwaliteit van de output is meer specificiteit en validatie, niet meer tekst. En test altijd met een goede testset, want je moet een verzameling testcases opbouwen die normaal gebruik, randgevallen én verzoeken buiten de scope dekt.

Conclusie

Claude Skills maken van losse prompts een geoliede, herbruikbare automatisering. De kern is verrassend eenvoudig: een map, een SKILL.md-bestand met een duidelijke naam en een specifieke, net iets te opdringerige beschrijving, en een compacte set instructies die Claude alleen laadt wanneer het relevant is. Beheers dat, voeg MCP toe voor connectiviteit, subagents voor isolatie en gedisciplineerd testen voor betrouwbaarheid, en je hebt een Skills-bibliotheek die in waarde blijft groeien voor je hele team.

De technische inspanning is eigenlijk vooral schrijfwerk. Baken smal af, beschrijf precies, versioneer alles, en test in drie categorieën. Doe dat consequent en Claude is niet langer die algemene assistent aan wie je elke ochtend opnieuw alles moet uitleggen, maar wordt een gespecialiseerde expert die je workflows al kent.

Nog één praktische tip die niets met code te maken heeft, maar alles met je budget. Welk Claude-abonnement je ook gebruikt, en welke andere AI-tools je er ook naast gebruikt: betaal slim. Die abonnementen worden gefactureerd in USD, en een gewone kaart snoept stilletjes 2-3% af bij elke verlenging. Met Bleap sla je de wisselkoerskosten helemaal over, en op Claude, ChatGPT en Gemini krijg je een vaste 20% cashback op elke betaling, allemaal via een self-custodial Mastercard zonder eigen abonnement. Bouw geweldige Skills. Betaal er alleen niet te veel voor.

Je hebt je Claude-workflow geoptimaliseerd. Optimaliseer nu ook wat je betaalt om hem te draaien. Met Bleap betaal je 0% wisselkoerskosten op USD-abonnementen en krijg je een vaste 20% cashback op Claude, ChatGPT en Gemini, zonder maandelijkse kaartkosten en met volledige controle over je geld. Open een Bleap-account →

Bleaps 20% cashback geldt voor abonnementen op Claude, ChatGPT en Gemini, en wordt uitbetaald in USDC. Voor andere AI-tools geldt wel het voordeel van 0% wisselkoerskosten op USD-facturering, maar niet de 20% cashback. De genoemde Claude-prijzen zijn actueel per 2026 en worden bepaald door Anthropic, niet door Bleap; check de officiële prijspagina van Anthropic voor de meest recente tarieven.