← Wissen

AI Skills bauen und testen

Wie du wiederverwendbare, testbare und optimierbare AI-Anweisungen baust -- und warum das ein Game-Changer fuer Product Owner ist.

Kapitel 1

01Was ist ein Skill?

Ein Skill ist eine wiederverwendbare Anweisung, die Claude Code automatisch aktiviert, wenn sie zum Kontext passt -- ohne dass du einen Slash-Command tippen musst.

Datei-Struktur

Kern ist eine SKILL.md mit YAML-Frontmatter (Name, Description) und Markdown-Body. Dazu optional: scripts/, references/, assets/ -- ausfuehrbare Logik, Referenzdokumente und Templates.

Triggerung

Claude matched die description gegen den User-Input. Passt es? Skill wird geladen. Passt es nicht? Skill bleibt unsichtbar. Kein manueller Aufruf noetig.

Progressive Disclosure

Nur die Metadaten (Name + Description) sind immer im Kontext. Der Body wird erst geladen, wenn der Skill triggert. Das spart Tokens.

Verteilbar

Skills koennen als .skill-Dateien gepackt und geteilt werden -- inklusive gebundelter Ressourcen, Templates und Beispiele.

Anatomie einer SKILL.md

---
name: frontend-design
description: |
  Create distinctive, production-grade frontend interfaces.
  TRIGGER when: user asks to build web components, pages,
  or applications.
---

# Frontend Design Skill

## Principles
- Never use default Bootstrap/Tailwind look
- Start with layout structure before colors
- Mobile-first responsive design

## Process
1. Understand the intent -- ask clarifying questions
2. Generate complete, self-contained HTML
3. Use inline CSS, no external dependencies
...
Key Insight: Die Description ist der wichtigste Teil. Sie entscheidet, OB der Skill ueberhaupt aktiviert wird. Der Body entscheidet, WIE er ausgefuehrt wird. Der Skill Creator optimiert vor allem die Description.
Kapitel 2

02Skills vs. Prompts -- und wann was?

Skills sind keine besseren Prompts. Sie loesen ein anderes Problem. Die Frage ist nicht "entweder/oder", sondern "wann welches Werkzeug".

Dimension Prompt Skill
Aktivierung Manuell -- du tippst ihn jedes Mal Automatisch -- Claude erkennt den Kontext
Wiederverwendung Copy-Paste oder Slash-Command Einmal installiert, immer verfuegbar
Testbarkeit Trial-and-Error im Chat Eval-Framework mit Metriken + Vergleich
Optimierung Du aenderst manuell und hoffst Automatische Iteration mit Train/Test-Split
Token-Effizienz Immer im Kontext (auch wenn irrelevant) Nur geladen wenn getriggert
Teilbarkeit Textdatei weitergeben .skill-Paket mit Ressourcen + Evals
Versionierung Welche Version war das nochmal? Git-trackbar, Benchmark-Historie
Komplexitaet Niedrig -- Text schreiben Mittel -- Tooling lernen, Evals definieren

Entscheidungsmatrix: Wo Skill, wo Prompt?

SKILL

  • Wiederkehrende, komplexe Aufgaben
  • Team-weite Standards (Code Review, Frontend-Style)
  • Qualitaet muss messbar sein
  • Mehrere Agenten sollen gleich arbeiten
  • Du willst es mit anderen teilen

PROMPT

  • Einmalige oder seltene Aufgaben
  • Explorative Arbeit (noch kein klares Pattern)
  • Persoenliche Shortcuts (CLAUDE.md)
  • Einfache Anweisungen (unter 10 Zeilen)
  • Kontext-spezifisch, nicht uebertragbar

EVOLUTION

Der typische Weg: Du startest mit einem Prompt in deiner CLAUDE.md. Wenn er sich bewaehrt und du ihn staendig nutzt, extrahierst du ihn als Skill. Dann testest und optimierst du ihn mit dem Skill Creator. Das ist kein Entweder-Oder -- es ist eine Reifekurve.

PM-Analogie: Ein Prompt ist wie eine manuell erstellte Jira-Vorlage. Ein Skill ist wie ein Automation-Rule: einmal definiert, automatisch getriggert, messbar, teilbar.
Kapitel 3

03Einen Skill bauen -- Schritt fuer Schritt

Der Skill Creator ist selbst ein Plugin fuer Claude Code. Er fuehrt dich durch den Prozess: von der Idee bis zum getesteten, optimierten Skill.

Workflow im Ueberblick

Schritt 1 Beschreiben "Ich will einen Skill der..."
Schritt 2 Interview Skill Creator fragt nach
Schritt 3 SKILL.md Datei wird generiert
Schritt 4 Evals Testcases definieren
Schritt 5 Optimieren Iterativer Loop

1. Plugin installieren

/plugin install skill-creator@claude-plugins-official

Danach steht der Slash-Command /skill-creator zur Verfuegung -- plus die zugehoerigen Agenten und Skills.

2. Neuen Skill beschreiben

Sag Claude einfach, was der Skill tun soll. Der Skill Creator startet ein kurzes Interview:

> Ich will einen Skill, der bei Code Reviews automatisch
  auf Security-Probleme hinweist.

Skill Creator: "Welche Sprachen soll er abdecken?"
Skill Creator: "Soll er auch Fixes vorschlagen oder nur warnen?"
Skill Creator: "Gibt es spezifische OWASP-Kategorien?"

3. SKILL.md wird generiert

Aus deinen Antworten entsteht eine SKILL.md mit optimierter Description und detailliertem Body.

4. Eval-Set definieren

Du definierst Testcases in evals/evals.json:

[
  {
    "query": "Review this Express endpoint for SQL injection",
    "should_trigger": true
  },
  {
    "query": "Add a new button to the navbar",
    "should_trigger": false
  },
  {
    "query": "Check my auth middleware for vulnerabilities",
    "should_trigger": true
  },
  {
    "query": "Write a unit test for the calculator",
    "should_trigger": false
  }
]
Wichtig: Gute Evals haben beides -- Queries die triggern SOLLEN und Queries die NICHT triggern sollen. Nur so erkennst du Over- und Undertriggering.

5. Testen und Optimieren

Der Skill Creator fuehrt parallele Eval-Runs durch, bewertet die Ergebnisse und verbessert iterativ die Description. Details dazu im naechsten Kapitel.

Kapitel 4

04Unter der Haube: So funktioniert der Skill Creator

Der Skill Creator ist kein simples Template-Tool. Er nutzt ML-Evaluierungsmethoden -- Train/Test-Splits, blinde Vergleiche und iterative Optimierung.

Die drei Phasen

Phase 1: Create

Interview → SKILL.md generieren. Der Skill Creator achtet auf klare, imperative Descriptions und erklaert das "Warum" im Body.

Phase 2: Test

Parallele Runs mit und ohne Skill. 5 Schritte: Runs spawnen, Assertions entwerfen, Timing messen, Ergebnisse graden, Browser-Viewer oeffnen.

Phase 3: Improve -- Der iterative Loop

Das Herzstueck. Hier wird der Skill systematisch besser gemacht.

Der Optimierungs-Loop im Detail

Eval-Set aufteilen
80% Training / 20% Test (stratifiziert)
Eval durchfuehren
Parallele Runs pro Query, Trigger-Rate messen
Description verbessern
Claude mit Extended Thinking (10k Token Budget) analysiert Failures
Train + Test vergleichen
Training passt, Test nicht? → Overfitting erkannt!
Beste Version waehlen
Bis zu 5 Iterationen oder bis alles passt

Warum Train/Test-Split?

Ohne Test-Set wuerde der Optimierungs-Loop die Description so lange anpassen, bis sie genau fuer die bekannten Queries funktioniert -- aber fuer neue Queries versagt. Das nennt man Overfitting. Der Skill Creator erkennt das:

Gesund

Training-Score: 95%
Test-Score: 90%

Die Description generalisiert gut.

Overfitting

Training-Score: 100%
Test-Score: 60%

Die Description ist zu spezifisch auf die Trainings-Queries zugeschnitten.

Was genau wird optimiert?

Die description im YAML-Frontmatter. Sie ist der Matching-Schluessel. Der Improvement-Algorithmus:

  1. Analysiert welche Queries nicht getriggert haben (obwohl sie sollten)
  2. Analysiert welche Queries falsch getriggert haben (obwohl sie nicht sollten)
  3. Bekommt die komplette History vorheriger Versuche
  4. Generiert eine neue Description mit Fokus auf Generalisierung
  5. Haelt sich an max. 1024 Zeichen
Clever: Die Test-Scores werden aus der History entfernt, bevor sie dem Improvement-Modell uebergeben werden. So kann das Modell nicht auf die Test-Daten optimieren -- selbst indirekt nicht.
Kapitel 5

05Das Eval-System: 3 Agenten, blinder Vergleich

Der Skill Creator nutzt ein dreistufiges Bewertungssystem mit spezialisierten Agenten -- aehnlich wie ein kontrolliertes Experiment.

Die drei Bewertungs-Agenten

Grader Agent

Prueft Transkripte gegen Assertions. Jede Expectation wird einzeln bewertet: Pass oder Fail, keine Teilpunkte. Bewertet Content (Korrektheit, Vollstaendigkeit) und Structure (Organisation, Formatierung) auf einer 1-5 Skala.

Comparator Agent

Blind A/B-Test: Bekommt zwei Outputs, weiss aber nicht welcher vom Skill kommt und welcher ohne Skill erzeugt wurde. Vergleicht rein nach Qualitaet. Das verhindert Bias.

Analyzer Agent

Erklaert WARUM eine Version besser war als die andere. Identifiziert konkrete Staerken und Schwaechen. Dieses Feedback fliesst in die naechste Verbesserungs-Iteration ein.

Quantitative Metriken

Pass%
Expectations erfuellt
Sek.
Ausfuehrungszeit
Tokens
Verbrauch
Calls
Tool-Aufrufe

Der Benchmark-Vergleich: Mit Skill vs. Ohne Skill

Das System fuehrt identische Queries in zwei Konfigurationen aus:

Metrik Ohne Skill (Baseline) Mit Skill Delta
Pass Rate 62% 91% +29%
Zeit 34s 28s -6s
Tokens 4200 3800 -400
Tool Calls 8 5 -3

Beispielwerte zur Illustration. Echte Ergebnisse variieren.

Browser-Viewer: Alle Ergebnisse werden in einem interaktiven HTML-Report dargestellt -- Side-by-Side-Vergleiche, Grading mit Evidenz-Zitaten, und ein Feedback-Button fuer menschliches Review. Der Report aktualisiert sich live waehrend die Runs laufen.
Kapitel 5b

05bBundled Scripts -- Skills sind mehr als Markdown

Ein Skill ist nicht nur eine SKILL.md. Er kann ausfuehrbare Skripte, Templates und Referenz-Dateien mitbringen. Das macht Skills zu echten Werkzeugen.

Die drei Ressourcen-Typen

scripts/

Ausfuehrbarer Code (Python, Shell, JS) fuer deterministische oder repetitive Aufgaben. Claude ruft diese Scripts per Bash-Tool auf, statt den Code jedes Mal neu zu generieren.

references/

Dokumentation, Styleguides, API-Specs -- werden bei Bedarf in den Kontext geladen. Ideal fuer umfangreiche Referenzmaterialien, die nicht in die SKILL.md passen.

assets/

Dateien, die im Output verwendet werden: HTML-Templates, Icons, Fonts, Beispiel-Dateien. Werden nicht gelesen, sondern kopiert oder eingebettet.

Vollstaendige Skill-Struktur mit Scripts

my-skill/
├── SKILL.md                # Pflicht: Anweisungen + Frontmatter
├── scripts/
│   ├── analyze_data.py     # Deterministische Analyse
│   ├── generate_chart.py   # Visualisierung erzeugen
│   └── validate_input.sh   # Input-Validierung
├── references/
│   └── style-guide.md      # Wird in Kontext geladen
├── assets/
│   └── report_template.html# Output-Template
└── evals/
    └── evals.json          # Testcases

Wie Scripts in der SKILL.md referenziert werden

Die SKILL.md sagt Claude, WANN und WIE die Scripts aufgerufen werden sollen:

---
name: data-report
description: |
  Generate data analysis reports with charts.
  TRIGGER when: user asks for data analysis, reports, or dashboards.
---

# Data Report Skill

## Process
1. Read the data file the user provides
2. Run the analysis script:
   ```bash
   python scripts/analyze_data.py input.csv --format json
   ```
3. Generate charts from the analysis:
   ```bash
   python scripts/generate_chart.py analysis.json --output charts/
   ```
4. Combine results using the template in `assets/report_template.html`
Warum Scripts statt Code generieren? Wenn Claude bei 3 von 3 Test-Runs unabhaengig voneinander ein aehnliches Hilfs-Script schreibt (z.B. create_docx.py oder build_chart.py), ist das ein klares Signal: Dieses Script gehoert gebuendelt. Einmal schreiben, in scripts/ ablegen -- jede zukuenftige Ausfuehrung spart Zeit und Tokens.

Progressive Disclosure: 3 Lade-Stufen

Stufe Was Wann geladen Token-Impact
1. Metadata Name + Description Immer (bei jeder Nachricht) Minimal (~100 Woerter)
2. SKILL.md Body Anweisungen Wenn Skill triggert Moderat (<500 Zeilen ideal)
3. Bundled Resources Scripts, References, Assets Bei Bedarf (on-demand) Scripts: null (werden ausgefuehrt, nicht gelesen)
Key Insight: Scripts muessen nicht in den Kontext geladen werden -- sie werden direkt ausgefuehrt. Das heisst: ein Skill kann beliebig komplexe Logik in Scripts auslagern, ohne Tokens zu verbrauchen. Die SKILL.md enthaelt nur die Orchestrierung.

Konkretes Beispiel: Der Skill Creator selbst

Der Skill Creator ist das beste Beispiel fuer gebundelte Scripts. Er enthaelt 8 Python-Scripts:

Script Aufgabe
run_eval.py Eval-Runs parallel ausfuehren, Trigger-Rate messen
run_loop.py Iterativen Optimierungs-Loop steuern
improve_description.py Description mit Claude + Extended Thinking verbessern
aggregate_benchmark.py Benchmark-Statistiken aggregieren (Mean, StdDev, Min, Max)
generate_report.py Interaktiven HTML-Report generieren
quick_validate.py Skill-Struktur validieren (Name, Description, Dateien)
package_skill.py Skill als .skill-ZIP verpacken
utils.py Geteilte Hilfsfunktionen

Ohne diese Scripts waere der Skill Creator nur eine Anweisung. Mit den Scripts ist er ein vollstaendiges Werkzeug -- die SKILL.md orchestriert, die Scripts fuehren aus.

PM-Take: Scripts in Skills sind wie Microservices hinter einer API. Der User (Claude) sieht die Schnittstelle (SKILL.md), die Komplexitaet steckt in den Scripts. Das ist echte Modularitaet -- und der Grund, warum Skills fundamentally mehr koennen als Prompts.
Kapitel 6

06Lokal installieren und nutzen

Ja, der Skill Creator laesst sich komplett lokal betreiben. Hier ist, was du brauchst.

Voraussetzungen

Claude Code CLI

Installiert und authentifiziert. Der Skill Creator nutzt claude -p fuer die Eval-Runs im Hintergrund.

Python 3.10+

Die Eval-Skripte (run_eval.py, run_loop.py, improve_description.py) sind Python. Keine speziellen Packages noetig ausser anthropic SDK.

Anthropic API Key

Fuer den Improvement-Loop: improve_description.py nutzt die Claude API direkt mit Extended Thinking (10k Token Budget).

Node.js (optional)

Falls du den Browser-Viewer im Live-Modus nutzen willst (Auto-Refresh waehrend Runs laufen).

Installation

# Option 1: Als Plugin (empfohlen)
/plugin install skill-creator@claude-plugins-official

# Option 2: Manuell klonen
git clone https://github.com/anthropics/claude-plugins-official.git
cd claude-plugins-official/plugins/skill-creator

# Fuer den Improvement-Loop brauchst du:
pip install anthropic
export ANTHROPIC_API_KEY=sk-ant-...

Nutzung

# Neuen Skill erstellen (interaktiv)
/skill-creator

# Bestehenden Skill testen
/skill-creator test my-skill

# Skill optimieren (iterativer Loop)
/skill-creator improve my-skill

# Skill validieren
python3 quick_validate.py path/to/skill/

# Skill packen fuer Distribution
python3 package_skill.py path/to/skill/

Verzeichnis-Struktur nach dem Erstellen

my-skill/
├── SKILL.md              # Dein Skill
├── evals/
│   ├── evals.json        # Testcases
│   ├── runs/             # Eval-Ergebnisse
│   └── benchmark.json    # Aggregierte Metriken
└── resources/            # Gebundelte Dateien (optional)
Kapitel 7

07PM-Perspektive: Warum Skills dein AI-Tooling veraendern

Als Product Manager denkst du in Outcomes, nicht in Outputs. Skills bringen genau dieses Denken in die AI-Nutzung.

Was sich aendert

Von "Hoffen" zu "Messen"

Prompts sind Bauchgefuehl: "Klingt gut, passt schon." Skills haben Evals: du weisst exakt, wie oft sie triggern, wie gut die Ergebnisse sind, und ob Version 3 besser ist als Version 2.

Von "Einzelkaempfer" zu "Team-Standard"

Dein bester Prompt stirbt in deiner CLAUDE.md. Ein Skill ist ein Plugin -- installierbar, versionierbar, teilbar. Das Team arbeitet einheitlich.

Von "Manuell" zu "Automatisch"

Du vergisst manchmal, den richtigen Prompt zu verwenden. Ein Skill vergisst nie -- er triggert automatisch, wenn der Kontext stimmt.

Von "Einmal-Aufwand" zu "Compound Interest"

Jede Verbesserung am Skill wirkt bei jeder zukuenftigen Nutzung. 5 Minuten Eval-Optimierung sparen Stunden ueber Wochen.

Konkrete Anwendungsfaelle fuer PMs

Use Case Als Prompt Als Skill
User Story Format "Schreibe im Format: Als... will ich... damit..." Triggert automatisch bei Story-Erstellung, inkl. Akzeptanzkriterien-Template
Code Review Jedes Mal dran denken, Security-Checklist einzufuegen Erkennt Review-Kontext, checkt OWASP Top 10 automatisch
Meeting Notes "Fasse zusammen mit Action Items und Owners" Erkennt Transkripte, erstellt strukturierte Notes + Follow-ups
Stakeholder Update Template raussuchen, manuell befuellen Triggert bei "Update schreiben", kennt dein Format + Audience

Die groessere Perspektive

Skills sind Product Thinking fuer AI-Nutzung. Du definierst das gewuenschte Outcome (Description + Evals), misst ob es erreicht wird (Benchmarks), iterierst basierend auf Daten (Improvement Loop), und lieferst ein testbares Artefakt (SKILL.md + Evals). Das ist kein Prompt Engineering -- das ist Produkt-Entwicklung.

Was der Skill Creator lehrt -- auch ohne ihn zu nutzen

  1. Evals zuerst: Bevor du optimierst, definiere wie "gut" aussieht.
  2. Train/Test-Trennung: Teste nicht mit den Daten, auf denen du optimiert hast.
  3. Blinde Vergleiche: Lass den Comparator nicht wissen, welches "dein" Output ist.
  4. Iteriere auf Daten, nicht auf Gefuehl: Der Loop verbessert, was messbar schwach ist.
  5. Descriptions > Instructions: WANN ein Skill greift ist wichtiger als WAS er tut.
Bonus

08Was du sonst noch wissen solltest

Skills vs. Commands vs. Agents -- die drei Plugin-Bausteine

Skill

Automatisch getriggert basierend auf Description-Matching. Definiert in skills/SKILL.md. Fuer wiederkehrende Patterns.

Command

Manuell aufgerufen via /command-name. Definiert in commands/. Fuer explizite Aktionen.

Agent

Spezialisierter Sub-Agent mit eigenem Toolset. Definiert in agents/. Der Skill Creator nutzt z.B. separate Grader-, Comparator- und Analyzer-Agenten fuer die Evaluierung.

Validierungsregeln fuer Skills

  • Name: kebab-case, maximal 64 Zeichen
  • Description: Maximal 1024 Zeichen, keine spitzen Klammern (< >)
  • SKILL.md muss existieren -- ist die einzige Pflichtdatei
  • Compatibility-Feld (optional): maximal 500 Zeichen, definiert Voraussetzungen

Packaging und Distribution

Ein fertig optimierter Skill kann als .skill-Datei gepackt werden. Das ist ein ZIP-Archiv das automatisch __pycache__, node_modules, .pyc, .DS_Store und den evals/-Ordner ausschliesst. Andere koennen es installieren -- inklusive aller gebundelten Ressourcen und Templates.

Das Plugin-Oekosystem

Der Skill Creator ist eines von 30+ offiziellen Plugins im claude-plugins-official Repo. Weitere spannende Plugins:

  • frontend-design -- Production-grade UI ohne generisches Bootstrap-Look
  • code-review -- Strukturierte Code-Reviews
  • ralph-loop -- Recurring Tasks auf Intervall
  • playground -- Experimentierumgebung
  • agent-sdk-dev -- Custom Agents bauen