Claude Code Meesterschap Deel 5: Skills

Je hebt aangepaste commando's gebouwd. Ze zijn geweldig voor workflows die je expliciet activeert—/review, /commit, /deploy. Maar hoe zit het met kennis die Claude automatisch moet toepassen, zonder dat jij eraan hoeft te denken om het aan te roepen?

Dat is wat Skills doen. Het zijn gespecialiseerde kennismodules die Claude ontdekt en laadt wanneer relevant, niet wanneer jij ze expliciet aanroept. Zie Commands als gereedschap dat je oppakt; Skills zijn expertise die Claude ontwikkelt.

Commands vs Skills: Wat is het Verschil?

Het onderscheid is belangrijk omdat het bepaalt hoe je je automatisering structureert.

Slash Commands (uit Deel 4):

• Je roept ze expliciet aan: /review, /commit
• Worden direct geladen wanneer je ze aanroept
• Ideaal voor workflows die je bewust wilt activeren
• Eenvoudige markdown-bestanden met optionele frontmatter

Skills:

• Claude roept ze automatisch aan wanneer je verzoek matcht
• Lazy-loaded—bij het opstarten wordt alleen de beschrijving gelezen, volledige inhoud laadt bij gebruik
• Ideaal voor standaarden, patronen en gespecialiseerde kennis die Claude altijd moet toepassen
• Kunnen ondersteunende bestanden, voorbeelden en uitvoerbare scripts bundelen

Hier is het mentale model: Commands zijn werkwoorden (dingen die je doet), Skills zijn expertise (dingen die Claude weet).

Wanneer je zegt "review deze PR," wil je misschien dat Claude:

1. Je /review-commando uitvoert (expliciete actie)
2. De code-reviewstandaarden van je team toepast vanuit een Skill (automatische kennis)

Beide hebben hun plek.

Hoe Skills Echt Werken

De magie van Skills is progressieve onthulling (progressive disclosure). Dit is de flow:

Bij het opstarten: Claude leest alleen de name en description van het SKILL.md-bestand van elke Skill. Minimale overhead.

Wanneer je een verzoek doet: Claude matcht je verzoek tegen Skill-beschrijvingen. Als er een match is, vraagt het: "Ik heb een Skill gevonden die kan helpen. Wil je dat ik die gebruik?"

Na bevestiging: De volledige SKILL.md-inhoud wordt in de context geladen. Ondersteunende bestanden worden alleen geladen als Claude ze nodig heeft tijdens de uitvoering.

Dit betekent dat je tientallen Skills kunt hebben zonder prestatieverliezen. Ze worden on-demand geladen, niet vooraf.

Tip: Schrijf Skill-beschrijvingen met trefwoorden die gebruikers van nature zouden zeggen. "Helpt met documenten" zal niet triggeren. "Review pull requests met OWASP-beveiligingsrichtlijnen en teamopmaakstandaarden" wel.

Skill-bestandsstructuur

Skills staan in mappen met een verplicht SKILL.md-bestand:

.claude/skills/
└── code-review/
    ├── SKILL.md           # Verplicht - instructies en frontmatter
    ├── examples/          # Optioneel - voorbeelduitvoer
    │   ├── good-review.md
    │   └── bad-review.md
    ├── templates/         # Optioneel - uitvoertemplates
    │   └── review-template.md
    └── scripts/           # Optioneel - uitvoerbare helpers
        └── lint-check.sh

Belangrijke beperkingen:

• SKILL.md is verplicht (hoofdlettergevoelige bestandsnaam)
• Houd SKILL.md onder de 500 regels voor optimale prestaties
• Ondersteunende bestanden worden ontdekt via links in SKILL.md
• Scripts voeren uit zonder hun broncode in de context te laden—alleen de uitvoer verbruikt tokens

Waar Skills Staan

Skills volgen een hiërarchie—hogere niveaus overschrijven lagere:

Enterprise — Beheerde instellingen voor alle gebruikers in de organisatie (hoogste prioriteit)

Persoonlijk — ~/.claude/skills/ — Jouw Skills, beschikbaar in alle projecten

Project — .claude/skills/ — Team-Skills, ingecheckt in git

Plugin — skills/ in de plugin-map — Beschikbaar voor iedereen die de plugin geïnstalleerd heeft

De verdeling is vergelijkbaar met Commands: persoonlijke Skills volgen je overal, project-Skills worden gedeeld met je team.

Het SKILL.md-template

Hier is de anatomie van een goed gestructureerde Skill:

---
Name: code-review
Description: "Review pull requests using OWASP security guidelines, performance best practices, and team formatting standards"
Allowed-tools: Read, Grep, Glob
Model: claude-sonnet-4-5-20250929
---
# Code Review Standards

## Purpose
Apply consistent code review standards across all PRs.

## When to Use
- Reviewing pull requests
- Checking code for security issues
- Validating against team conventions

## Instructions

### Security Checks
1. SQL injection vulnerabilities
2. XSS attack vectors
3. Authentication bypasses
4. Sensitive data exposure

### Performance Checks
1. N+1 query patterns
2. Unnecessary re-renders
3. Memory leaks
4. Blocking operations

### Style Checks
1. Naming conventions per team standards
2. Function length (max 50 lines)
3. Cyclomatic complexity

## Output Format
Organize findings by severity:
- 🚨 Critical (blocks merge)
- ⚠️ Warnings (should fix)
- 💡 Suggestions (nice to have)

## Examples
See ./examples/good-review.md for proper format.

Frontmatter-opties

Skills ondersteunen krachtige configuratie via YAML-frontmatter:

name (verplicht) — Skill-identificatie. Alleen kleine letters, cijfers, koppeltekens. Max 64 tekens.

description (verplicht) — Wat het doet en wanneer het te gebruiken. Max 1024 tekens. Dit is hoe Claude verzoeken matcht aan Skills—maak het beschrijvend.

allowed-tools — Tools die Claude mag gebruiken zonder toestemmingsprompts wanneer deze Skill actief is. Kommagescheiden of als YAML-lijst.

model — Overschrijf het model wanneer deze Skill draait. Handig voor complexe redeneertaken.

context — Stel in op fork om in een geïsoleerde subagent-context te draaien met een aparte gespreksgeschiedenis.

agent — Agenttype wanneer context: fork is ingesteld. Opties: Explore, Plan, general-purpose, of aangepast.

hooks — Definieer Skill-specifieke hooks: PreToolUse, PostToolUse, Stop.

user-invocable — Stel in op false om te verbergen uit het /-menu terwijl automatische ontdekking nog steeds werkt.

disable-model-invocation — Stel in op true om te voorkomen dat Claude het programmatisch aanroept (maar nog steeds zichtbaar in het menu).

Je Eerste Skill Maken

Laten we een praktische Skill bouwen: een TDD-gids (Test-Driven Development, testgestuurde ontwikkeling) die Claude automatisch toepast wanneer je tests schrijft.

Stap 1: Maak de Map Aan

Mkdir -p .claude/skills/tdd

Stap 2: Maak SKILL.md

Cat > .claude/skills/tdd/SKILL.md << 'EOF'
---
Name: tdd
Description: "Apply test-driven development workflow when writing tests, implementing features with tests, or following red-green-refactor cycle"
Allowed-tools: Read, Write, Edit, Bash(npm test:*), Bash(bun test:*)
---
# Test-Driven Development

## Purpose
Guide development through proper TDD: Red → Green → Refactor.

## When to Use
- When user asks to "add a feature with tests"
- When user mentions "TDD" or "test-driven"
- When creating new functionality that requires tests
- When user asks to implement something "the right way"

## The TDD Cycle

### Phase 1: Red (Write Failing Test)
1. Understand the requirement fully
2. Write the simplest test that fails
3. Verify the test fails for the RIGHT reason
4. DO NOT write implementation yet

### Phase 2: Green (Make It Pass)
1. Write minimal code to pass the test
2. No extra features, no edge cases yet
3. Ugly code is acceptable—just make it green

### Phase 3: Refactor (Clean Up)
1. Improve code quality
2. Remove duplication
3. Better naming
4. Tests MUST stay green

### Repeat
For each new behavior, start the cycle again.

## Anti-Patterns to Avoid
- Writing implementation before tests
- Writing multiple tests at once
- Refactoring while tests are red
- Skipping the refactor phase

## Example Session
See ./examples/tdd-session.md for a complete walkthrough.
EOF

Stap 3: Voeg een Voorbeeld Toe

Mkdir -p .claude/skills/tdd/examples
Cat > .claude/skills/tdd/examples/tdd-session.md << 'EOF'
# TDD Session: Adding Email Validation

## Requirement
Validate email format in user registration.

## Cycle 1: Basic Validation

### Red
```typescript
// user.test.ts
It('should reject invalid email format', () => {
  expect(() => new User('notanemail')).toThrow('Invalid email');
});
```
Run: `npm test` → FAILS (User doesn't validate emails yet)

### Green
```typescript
// user.ts
Constructor(email: string) {
  if (!email.includes('@')) {
    throw new Error('Invalid email');
  }
  this.email = email;
}
```
Run: `npm test` → PASSES

### Refactor
Extract validation:
```typescript
Private validateEmail(email: string): void {
  if (!email.includes('@')) {
    throw new Error('Invalid email');
  }
}
```

## Cycle 2: Domain Validation

### Red
```typescript
It('should reject email without domain', () => {
  expect(() => new User('test@')).toThrow('Invalid email');
});
```
...continue cycle...
EOF

Stap 4: Gebruik Het

Wanneer je nu zegt "laten we e-mailvalidatie toevoegen met goede tests," zal Claude:

1. Herkennen dat dit matcht met de TDD Skill-beschrijving
2. Vragen of je de TDD Skill wilt gebruiken
3. Automatisch de Red → Green → Refactor-cyclus volgen

De Superpowers-collectie

De populairste Skills-bibliotheek is obra/superpowers met 16.500+ sterren. Het is uitvoerig getest en dekt veelvoorkomende ontwikkelworkflows.

Installatie

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Of kloon rechtstreeks:

Git clone https://github.com/obra/superpowers.git ~/.claude/skills/superpowers

Let op: Skills gebruiken map-namespacing vergelijkbaar met hoe commando's zijn georganiseerd in Deel 4. Dezelfde organisatiepatronen zijn van toepassing—submappen creëren namespaces voor betere organisatie.

Belangrijke Meegeleverde Skills

/superpowers:brainstorm — Gestructureerd brainstormen voordat je aan complexe features begint. Gebruik dit voordat je in de code duikt.

/superpowers:write-plan — Maak implementatieplannen voor migraties of refactors over meerdere bestanden.

/superpowers:execute-plan — Voer plannen uit in gecontroleerde batches met checkpoints.

/superpowers:tdd — Testgestuurde ontwikkeling met de volledige Red/Green/Refactor-cyclus.

/superpowers:debug — Systematisch debuggen met het traceren van de oorzaak.

Waarom Het Werkt

Superpowers is niet zomaar een verzameling prompts—het zijn productie-bewezen patronen. De TDD Skill bevat bijvoorbeeld:

• Anti-patroondetectie (tests schrijven na de code)
• Async-testpatronen
• Juiste assertiestructuur
• Refactoring-triggers

Deze patronen komen voort uit praktijkgebruik door duizenden ontwikkelaars.

Praktische Skill-ideeën

Hier zijn Skills die het waard zijn om te bouwen voor je team:

API-documentatie — Pas automatisch jouw API-documentatiestandaarden toe wanneer Claude endpoints schrijft of bijwerkt.

Foutafhandeling — Dwing consistente foutafhandelingspatronen af (je ApiError-klasse, logformaat, gebruikersgerichte berichten).

Database-patronen — Pas de conventies van je team toe voor queries, transacties en migraties.

Beveiligingsreview — Controleer automatisch op OWASP Top 10-problemen bij het reviewen van code.

Componentpatronen — Dwing de structuur en naamgeving van je React/Vue/Svelte-componenten af.

Commitberichten — Pas automatisch het conventional commit-formaat toe.

Skills + Scripts: De Krachtige Combinatie

Hier is iets dat te weinig wordt benut: Skills kunnen uitvoerbare scripts bundelen die draaien zonder hun broncode in de context te laden.

.claude/skills/security-audit/
├── SKILL.md
└── scripts/
    ├── check-dependencies.sh
    ├── scan-secrets.py
    └── validate-permissions.js

In je SKILL.md:

## Available Scripts

Run these for automated checks:
- `./scripts/check-dependencies.sh` - Scan for vulnerable packages
- `./scripts/scan-secrets.py` - Find hardcoded secrets
- `./scripts/validate-permissions.js` - Check file permissions

Claude kan deze scripts uitvoeren, maar alleen de uitvoer verbruikt context—niet de broncode van het script. Dit is perfect voor complexe validatielogica die betrouwbaarder is als geteste code dan als door een LLM gegenereerde commando's.

Skills vs Commands: Wanneer Welke Gebruiken

Gebruik Commands wanneer:

• Je expliciete controle wilt over wanneer iets draait
• De workflow door de gebruiker geïnitieerd wordt (deploy, commit, genereren)
• Je argumenten moet doorgeven ($ARGUMENTS, $1, $2)
• De actie discreet en op zichzelf staand is

Gebruik Skills wanneer:

• Kennis automatisch moet worden toegepast op basis van context
• Je consistente standaarden wilt zonder te onthouden ze aan te roepen
• De expertise meerdere soorten verzoeken bestrijkt
• Je teamkennis vastlegt die Claude altijd moet hebben

Gebruik beide samen:

• /review-commando triggert de review
• code-review Skill levert de standaarden om toe te passen

Skill-beschikbaarheid

Skills vereisen een betaald abonnement:

• Pro, Max, Team, Enterprise — Volledige Skills-ondersteuning
• Gratis tier — Geen Skills

Als je op een gratis abonnement zit en teamkennis wilt vastleggen, gebruik dan de .claude/rules/-map uit Deel 3. Rules worden altijd geladen; Skills worden lazy-loaded.

Skills Ontdekken

GitHub Topics:

Https://github.com/topics/claude-skills

Community-collecties:

• obra/superpowers — Kernpatronen voor ontwikkeling
• obra/superpowers-skills — Door de community bijgedragen Skills
• SkillsMP — Marktplaats voor Claude/ChatGPT Skills

De Agent Skills Specification — Uitgebracht in december 2025 als open standaard. OpenAI heeft hetzelfde formaat overgenomen voor Codex CLI en ChatGPT, dus Skills die je bouwt voor Claude werken ook met andere tools.

Wat Komt er Hierna

Skills geven Claude gespecialiseerde kennis die automatisch activeert. Maar wat als je Claude meerdere dingen tegelijk wilt laten doen? Wat als één taak zou profiteren van parallelle uitvoering?

Dan komen Subagents in beeld. In Deel 6: Subagents verkennen we hoe je gespecialiseerde agents kunt spawnen die parallel werken—tests draaien terwijl documentatie wordt gegenereerd terwijl beveiligingsproblemen worden gecontroleerd, allemaal tegelijk.