Ik zat begin deze middag met een probleem. Ik wilde Claude Code een agent laten maken die ISO tests (dank je wel Monique) op mijn code kon doen. Zelfstandig, zonder mij te veel lastig te vallen. En natuurlijk met feedback. Maar wat Claude Code gaf was een skill, maar dat was volgens mij niet wat ik nodig had.

Dat bracht me op het agents versus skills concept wat ik nog steeds niet goed begrijp en volgens mij andere mensen ook niet: agents en skills zien er misschien op het oppervlak hetzelfde uit (allebei mappen met instructies), maar ze zijn totaal anders. Of eigenlijk liggen ze heel dicht bij elkaar in mijn hoofd. Een agent heeft bepaalde skills. Een tekstschrijver kan zelfstandig teksten schrijven en heeft de competenties om dat te doen. Maar waarom zijn die twee dan gescheiden? Het blijkt dus, het gaat niet zozeer om techniek als om je rol:

  • Met Skills ben jij de stuurman en Claude je copiloot.
  • Met Agents ben jij de projectleider en Claude is je team.

En de keuze bepaalt eigenlijk hoe je Claude Code gaat inzetten.

Een handleiding versus een collega

Skills zijn instructiehandboeken. Agents zijn zelfstandige specialisten.

Een Skill zit in een mapje met een SKILL.md bestand met richtlijnen, voorbeelden en referentiematerialen. Wanneer jij Claude iets vraagt, scant hij of een Skill relevant is. Zo ja, dan laadt hij ze in. Hij leest de instructies en volgt ze op. Ik wacht er ondertussen op totdat Claude klaar is.

Een Agent is anders. Het zijn Mini-Claude’s met hun eigen system prompt, toolset en afzonderlijke context window van 200.000 tokens. Agents zijn eigenlijk een team van experts: ze hebben elk hun eigen rol en functie. Ze gaan zelfstandig aan de slag, kunnen fouten herkennen, teruggaan, opnieuw proberen en itereren. Ze rapporteren terug met resultaten, niet met “ik ben klaar met je instructies volgen”.

Praktisch gesteld:

Een Skill zegt: “Hier staan de richtlijnen voor branding, volg ze netjes.”

Een Agent zegt: “Jij bent de design expert. Ga zelfstandig controleren of deze site aan onze brand guidelines voldoet. Rapporteer terug wat er mis is en wat je zou aanpassen.”

Waar het ingewikkelder wordt in mijn hoofd

Dit is het kernverschil. Maar nu wordt het interessant, want ik moet een keuze maken. En die keuze bepaalt eigenlijk hoe het werk gaat verlopen.

Ik merkte dat op het moment dat ik Claude Code vraag om bijvoorbeeld: “Controleer mijn code op performance issues.” Claude Code kan kiezen: Skill of Agent?

Als Claude een Skill maakt, laadt die in mijn huidige window. Claude leest de performance-checklist, volgt stap voor stap wat ik heb geschreven en geeft feedback. Het is snel, synchroon, en ik ben niet afhankelijk van agents die hun eigen gang gaan.

Als Claude een Agent maakt, maak ik eigenlijk een specialist aan die onafhankelijk werkt. Die Agent gaat mijn code analyseren, kan teruggaan en dieper graven, kan voorstellen testen, kan itereren. Ik hoef niet te wachten. Ik laat de Agent los en ga zelf verder met iets anders. De Agent rapporteert later.

Delegeren of dirigeren

Hier zit de echte beslissing. Het gaat niet zozeer om de techniek als om de werkwijze die ik prettig vind met AI-modellen. En dat is iets waar ik ook nog steeds aan moet wennen: wanneer wil ik nou eigenlijk een agent gebruiken en wanneer wil ik een skill gebruiken? Ik weet dat nog steeds niet heel goed. Maar langzaam zie ik wel een patroon.

Agents zijn voor exploratie en verbetering. Je zet ze in als je:

  • Werk wil delegeren
  • Iets complexs hebt dat iteratie nodig heeft
  • Parallel aan iets anders wil werken terwijl de Agent bezig is
  • Wil dat Claude zelfstandig onderzoekt, aanpassingen doet, fouten corrigeert
  • Meer specialisatie wil dan generieke hulp

Praktisch voorbeeld: ik heb een codebase met 50 bestanden en ik wil dat Claude die doorloopt, security issues vindt, patches voorstelt en die test. Ik kies dan voor een agent, want die gaat zelfstandig aan de slag. Ik kan ondertussen iets anders doen.

Skills zijn voor regels en standaarden. Je zet ze in als je:

  • In je main window bent
  • Wil dat Claude je wat slimmer maakt terwijl je aan het stuur zit
  • Het werk synchroon kan (in- en uitvoer in één keer)
  • Bereid bent om te wachten
  • Jezelf de “denker” wil blijven en Claude de “assistent”

Praktisch voorbeeld: ik heb brand guidelines geschreven en ik wil dat Claude die altijd toepast bij documenten. Ik kies dan voor een skill. Claude leert het, past het toe als het nodig is.

Neo in de Matrix

De fout die ik bijna maakte

Dus ik wilde een ISO-test agent. Claude Code maakte een Skill. Ik zat even te denken: kan ik niet gewoon een Agent maken die die ISO-Skill inlaadt?

Een agent die een Skill inlaadt is dubbel werk. Je agent zou in feite zeggen: “Wacht, laat me eerst deze handleiding lezen” en dan de instructies volgen. Dat kost dus extra tokens voor iets wat eigenlijk niet nodig is. Dan kan ik net zo goed zelf dat handboek lezen en het werk zelf doen. “Laat maar, ik doe het zelf wel” - en dan ben je sneller klaar.

Waar ze wel samenwerken

Nou, er is één scenario waar het wel voordelig is. Niet voor dezelfde taak, maar complementair.

Stel je de Ticket-beheerder agent voor. Die Agent doet iets groots: aanvragen verwerken, prioriteiten stellen, bepalen wie het gaat oppakken. En incidenteel heeft die Agent iets nodig wat in een Skill staat. Bijvoorbeeld: “Zorg ervoor dat alle output aan onze schrijfstijl voldoet.”

Dan kan de Ticket-beheerder agent die Schrijfstijl-Skill inladen wanneer nodig. Dat is niet dubbel werk, dat is praktisch. De Agent delegeert een onderdeel van zijn taak naar gespecialiseerde instructies.

Dit illustreert eigenlijk een belangrijke nuance: Skills zijn voor “volg de regels” - je wilt consistency en standaarden. Agents zijn voor “maak het beter” - je wilt dat iemand nadenkt, itereert, verbetert. De Ticket-beheerder hoeft niet na te denken over schrijfstijl (daar zijn regels voor), maar wel over wat de beste aanpak is om tickets op te lossen.

De mindset shift

Ik dacht eerst, Claude Code is een assistent die me helpt. Ik zit aan het stuur en Claude voert uit.

Maar met agents gebeurt er iets anders. Je gaat delegeren. Je zet specialisten in. Je hebt minder controle per moment, maar je hebt meer output totaal. Omdat agents parallel kunnen werken. Omdat ze zelfstandig kunnen itereren. Omdat ze context ruimte hebben om écht diep te gaan.

Skills passen in het “Claude helpt me” model. Je bent stuurman. Claude is copiloot.

Agents passen in het “ik delegeer werk” model. Je bent projectleider. Claude je team.

En gaandeweg ontdekte ik nog iets: je kunt deze twee ook combineren in je workflow. Je zet Agents in voor de exploratie en verbetering. Laat ze het werk beter maken, dieper graven. En als je tevreden bent met het resultaat, vertaal je die kennis naar Skills. Die worden dan de regels en standaarden die je altijd wilt toepassen. Agents voor de vraag “hoe maken we dit beter?”, Skills voor de regel “dit doen we altijd zo”.

De volgende stap

Ik ga mijn ISO-test Skill omzetten naar een Agent. Niet omdat het technisch beter is, maar omdat ik wil dat die zelfstandig code doorloopt, fouten markeert, voorstellen test en rapporteert. Ik wil delegeren. Ik wil dat die specialist eigenaarschap neemt.

Dus: heb je werk dat complex is? Dat iteratie nodig heeft? Dat je parallel wilt doen? Maak een Agent.

Heb je werk dat consistent moet en deel van je standaardproces? Maak een Skill.

De keuze bepaalt eigenlijk hoe je Claude Code gaat ervaren. Of je Claude als assistent voelt, of als team.