Kies je tussen een slash command, een skill, een subagent en een hook: een slash command is een herbruikbare prompt die je zelf aanroept, een skill is een procedure met echte domeinlogica of hulpbestanden erachter, een subagent is werk waarvan de tussenstappen je thread alleen maar vervuilen, en een hook is wat elke keer moet gebeuren, afgedwongen door code in plaats van door goede wil. CLAUDE.md is voor feiten en conventies, de context die altijd meelaadt, en daar horen garanties niet thuis. De twee assen eronder zijn of het gegarandeerd moet zijn, en of het een eigen context nodig heeft.
Claude Code geeft je nu zeven manieren om zijn gedrag te veranderen. CLAUDE.md, rules, skills, subagents, hooks, output styles, en de systeemprompt aanvullen. Anthropic zette ze allemaal op een rij in een post genaamd Steering Claude Code, en dat is een echt bruikbaar overzicht.
De meeste van die zeven kwamen binnen een paar maanden. De releasenotes uit Londen laten zien in welke volgorde ze verschenen, als je de chronologie achter dat overzicht zoekt.
Hij bevestigt ook stilletjes een probleem dat ik in vrijwel elke .claude-map van een team zie: mensen hebben alle zeven lagen en grijpen bijna elke keer naar de verkeerde. Een harde grens die als een beleefde regel in CLAUDE.md staat. Een eenmalige prompt-template gepromoveerd tot volwaardige skill. Een zoektaak die de hoofd-thread verstopt en een subagent had moeten zijn.
De features zijn niet het lastige. Het kiezen ertussen wel. Dus hier is dezelfde taak op vier manieren gebouwd, en de regel die daaruit volgt.
Eén taak, vier mechanismen
De taak: als ik klaar ben, moet de code geformatteerd zijn en de testsuite slagen voordat iets "af" mag heten.
Let op hoe verschillend de vier implementaties zijn, want dat verschil is de les.
Als slash command. Je schrijft een prompt-template in .claude/commands/wrap-up.md die zegt "formatteer de gewijzigde bestanden, draai de tests, en vat samen wat faalde". Je typt /wrap-up wanneer je het wil. Het is een opgeslagen prompt, meer niet. Het model leest het en doet het waarschijnlijk. Waarschijnlijk.
Als skill. Je bouwt een release-check-skill met een SKILL.md plus een helper-script dat de package-indeling van je monorepo kent, weet welke testgroepen bij welke gewijzigde paden horen, en hoe je de coverage-output leest. Claude laadt de skill op naam als het werk past, draait de procedure in de hoofd-thread waar je kunt meekijken en bijsturen, en trekt de helper-bestanden er pas bij als het nodig is. Dit verdient zijn plek wanneer de procedure echte logica heeft, niet alleen instructies.
Als subagent. Je definieert een test-analyst-subagent. Als de suite faalt, geef je hem de hele berg foutmeldingen en hij ploegt zich door de logs in zijn eigen context, en geeft drie regels samenvatting terug in plaats van 4.000 regels stacktraces in je sessie te dumpen. Het is isolatie: de rommel blijft in een andere kamer en alleen de conclusie komt terug.
Als hook. Je voegt een Stop-hook toe in settings.json die de formatter en het testcommando draait. Niet wanneer het model er zin in heeft. Elke keer dat de beurt probeert te eindigen. Falen de tests, dan zegt de hook dat, en mag het werk zichzelf niet "af" noemen.
Hetzelfde doel. Vier totaal verschillende tools. Merk op dat de slash command en de hook oppervlakkig op elkaar lijken (allebei "draai de checks") en juist tegenpolen zijn op het enige punt dat telt: de een vraagt, de ander dwingt af.
De regel die eruit volgt
Haal het detail weg en de keuze gaat over twee assen: moet het gegarandeerd zijn, en heeft het zijn eigen context nodig.
| Mechanisme | Grijp ernaar wanneer | Het herkenningspunt |
|---|---|---|
| Slash command | Je een herbruikbare prompt wil die je met de hand start | "Ik typ steeds dezelfde alinea naar Claude" |
| Skill | Er echte domeinlogica of helper-bestanden achter de procedure zitten | "Dit heeft een script en wat projectkennis nodig, niet alleen woorden" |
| Subagent | Het werk geïsoleerd is en de tussenoutput de thread zou verstoppen | "Ik geef alleen om het antwoord, niet om de 90 stappen ernaartoe" |
| Hook | Het elke keer moet gebeuren, afgedwongen door code, niet door goede wil | "Elke keer als X, altijd Y" |
Die laatste rij is degene die mensen het vaakst verkeerd doen. Schrijf je ooit "altijd" of "nooit" in een CLAUDE.md, dan heb je een hook gevonden. Een prompt-instructie is een suggestie die het model meestal wel opvolgt, maar niet gegarandeerd, en dat is precies het argument dat ik maakte in de hooks-gids: als iets gegarandeerd moet zijn, kan het niet in een prompt leven. CLAUDE.md is voor feiten en conventies, de altijd-geladen context die ik behandelde in het CLAUDE.md-stuk. Het is niet de plek waar garanties wonen.
Mensen struikelen ook over de grens tussen skill en subagent. Allebei bundelen ze een procedure. Het verschil is zichtbaarheid. Een skill draait in je hoofd-thread omdat je hem wil zien en bijsturen. Een subagent draait ergens anders omdat je dat juist niet wil, je wil alleen de samenvatting. Is de tussenoutput signaal, gebruik een skill. Is het ruis, gebruik een subagent. Hoe je een goede Claude Code-subagent schrijft is een post op zich.
Wat er in juni veranderde, en waarom dat hier uitmaakt
Twee updates deze maand maakten twee van deze tools scherper, en ze passen netjes op de regel hierboven.
Hooks kregen hersens. Sinds de changelog van half juni kunnen Stop- en SubagentStop-hooks hookSpecificOutput.additionalContext teruggeven om Claude informatie te voeren en de beurt door te laten lopen, in plaats van alleen hard te kunnen blokkeren met een fout. Dus de wrap-up-hook hierboven kan nu meer dan "tests faalden, ik stop". Hij kan de fout teruggeven als context en het model nog een poging laten doen. De hook is geen bakstenen muur meer, maar een scheidsrechter die ook kan praten.
Subagents kregen diepte. Sinds versie 2.1.172 kan een subagent zijn eigen subagents opstarten, tot vijf niveaus diep, waarbij foreground-ketens nu dezelfde limiet respecteren als background-ketens. Dat maakt het geval "geïsoleerd parallel werk" een stuk sterker. Je test-analyst kan uitwaaieren naar één sub-subagent per falende module en de resultaten samenvoegen, zonder dat ook maar één stacktrace je hoofdvenster raakt.
Beide veranderingen trekken dezelfde kant op. Hooks werden een betere afdwinger. Subagents werden een betere isolator. Geen van beide werd beter in het werk van de ander, en juist daarom klopt de beslisboom nog steeds. Meer diepte op een tool verandert niet waar de tool voor is.
De eerlijke faalmodus
Dit is wat er echt gebeurt. Iemand leert skills, raakt enthousiast, en maakt overal een skill van, inclusief de harde grenzen die hooks hadden moeten zijn en de wegwerp-prompts die slash commands hadden moeten zijn. Een half jaar later is hun .claude-map een museum van half-overlappende mechanismen dat niemand meer kan overzien, en de ene regel die echt elke keer moest gelden is een beleefd geformuleerde zin in CLAUDE.md die het model één run op de twintig negeert.
De kracht zat nooit in het hebben van zeven lagen. Hij zit in het kiezen van het mechanisme dat bij de klus past, dezelfde discipline waar ik op terugkom in het beste uit Claude Code halen. Meer lagen betekent alleen meer manieren om verkeerd te kiezen.
Dus voordat je de volgende slimme skill bouwt, stel je de twee vragen. Moet dit gegarandeerd zijn? Dan is het een hook. Heeft dit zijn eigen context nodig? Dan is het een subagent. Is het gewoon een prompt die je steeds opnieuw typt? Dan is het een slash command, en het was nooit een skill.
Meestal heb je niet de meest geavanceerde tool nodig. Je hebt degene nodig die past bij de vorm van het werk.