Zum Hauptinhalt springen
Skills erweitern das, was Claude tun kann. Erstellen Sie eine SKILL.md-Datei mit Anweisungen, und Claude fügt sie zu seinem Toolkit hinzu. Claude verwendet Skills, wenn sie relevant sind, oder Sie können einen direkt mit /skill-name aufrufen.
Für integrierte Befehle wie /help und /compact siehe die Referenz für integrierte Befehle.Benutzerdefinierte Befehle wurden in Skills zusammengeführt. Eine Datei unter .claude/commands/deploy.md und ein Skill unter .claude/skills/deploy/SKILL.md erstellen beide /deploy und funktionieren auf die gleiche Weise. Ihre vorhandenen .claude/commands/-Dateien funktionieren weiterhin. Skills fügen optionale Funktionen hinzu: ein Verzeichnis für unterstützende Dateien, Frontmatter zum Steuern, wer einen Skill aufruft, und die Möglichkeit für Claude, sie automatisch zu laden, wenn sie relevant sind.
Claude Code Skills folgen dem Agent Skills offenen Standard, der über mehrere KI-Tools funktioniert. Claude Code erweitert den Standard mit zusätzlichen Funktionen wie Invocation Control, Subagent-Ausführung und dynamischer Kontexteinspritzung.

​
Gebündelte Skills

Gebündelte Skills werden mit Claude Code ausgeliefert und sind in jeder Sitzung verfügbar. Im Gegensatz zu integrierten Befehlen, die direkt feste Logik ausführen, sind gebündelte Skills prompt-basiert: Sie geben Claude ein detailliertes Playbook und lassen es die Arbeit mit seinen Tools orchestrieren. Das bedeutet, dass gebündelte Skills parallele Agenten spawnen, Dateien lesen und sich an Ihre Codebasis anpassen können. Sie rufen gebündelte Skills auf die gleiche Weise auf wie jeden anderen Skill: Geben Sie / gefolgt vom Skill-Namen ein. In der Tabelle unten zeigt <arg> ein erforderliches Argument und [arg] ein optionales an.
SkillZweck
/batch <instruction>Orchestrieren Sie großflächige Änderungen über eine Codebasis hinweg parallel. Recherchiert die Codebasis, zerlegt die Arbeit in 5 bis 30 unabhängige Einheiten und präsentiert einen Plan. Nach Genehmigung spawnt es einen Hintergrund-Agent pro Einheit in einem isolierten git worktree. Jeder Agent implementiert seine Einheit, führt Tests aus und öffnet einen Pull Request. Erfordert ein Git-Repository. Beispiel: /batch migrate src/ from Solid to React
/claude-apiLaden Sie Claude API-Referenzmaterial für die Sprache Ihres Projekts (Python, TypeScript, Java, Go, Ruby, C#, PHP oder cURL) und Agent SDK-Referenz für Python und TypeScript. Behandelt Tool-Nutzung, Streaming, Batches, strukturierte Ausgaben und häufige Fallstricke. Wird auch automatisch aktiviert, wenn Ihr Code anthropic, @anthropic-ai/sdk oder claude_agent_sdk importiert
/debug [description]Aktivieren Sie Debug-Protokollierung für die aktuelle Sitzung und beheben Sie Probleme durch Lesen des Sitzungs-Debug-Protokolls. Debug-Protokollierung ist standardmäßig deaktiviert, es sei denn, Sie haben mit claude --debug gestartet, daher startet die Ausführung von /debug während einer Sitzung die Erfassung von Protokollen ab diesem Punkt. Beschreiben Sie optional das Problem, um die Analyse zu fokussieren
/loop [interval] <prompt>Führen Sie einen Prompt wiederholt in einem Intervall aus, während die Sitzung offen bleibt. Nützlich zum Abfragen einer Bereitstellung, Überwachen eines PR oder periodischen Neuausführen eines anderen Skills. Beispiel: /loop 5m check if the deploy finished. Siehe Prompts nach Zeitplan ausführen
/simplify [focus]Überprüfen Sie Ihre kürzlich geänderten Dateien auf Code-Wiederverwendung, Qualität und Effizienzprobleme und beheben Sie diese. Spawnt drei Review-Agenten parallel, aggregiert ihre Erkenntnisse und wendet Fixes an. Übergeben Sie Text, um sich auf spezifische Bedenken zu konzentrieren: /simplify focus on memory efficiency

​
Erste Schritte

​
Erstellen Sie Ihren ersten Skill

Dieses Beispiel erstellt einen Skill, der Claude beibringt, Code mit visuellen Diagrammen und Analogien zu erklären. Da er Standard-Frontmatter verwendet, kann Claude ihn automatisch laden, wenn Sie fragen, wie etwas funktioniert, oder Sie können ihn direkt mit /explain-code aufrufen.
1

Erstellen Sie das Skill-Verzeichnis

Erstellen Sie ein Verzeichnis für den Skill in Ihrem persönlichen Skills-Ordner. Persönliche Skills sind über alle Ihre Projekte hinweg verfügbar.
mkdir -p ~/.claude/skills/explain-code
2

Schreiben Sie SKILL.md

Jeder Skill benötigt eine SKILL.md-Datei mit zwei Teilen: YAML-Frontmatter (zwischen ----Markierungen), das Claude mitteilt, wann der Skill verwendet werden soll, und Markdown-Inhalt mit Anweisungen, die Claude befolgt, wenn der Skill aufgerufen wird. Das name-Feld wird zum /slash-command, und die description hilft Claude zu entscheiden, wann der Skill automatisch geladen werden soll.Erstellen Sie ~/.claude/skills/explain-code/SKILL.md:
---
name: explain-code
description: Explains code with visual diagrams and analogies. Use when explaining how code works, teaching about a codebase, or when the user asks "how does this work?"
---

When explaining code, always include:

1. **Start with an analogy**: Compare the code to something from everyday life
2. **Draw a diagram**: Use ASCII art to show the flow, structure, or relationships
3. **Walk through the code**: Explain step-by-step what happens
4. **Highlight a gotcha**: What's a common mistake or misconception?

Keep explanations conversational. For complex concepts, use multiple analogies.
3

Testen Sie den Skill

Sie können ihn auf zwei Arten testen:Lassen Sie Claude ihn automatisch aufrufen, indem Sie etwas eingeben, das der Beschreibung entspricht:
How does this code work?
Oder rufen Sie ihn direkt auf mit dem Skill-Namen:
/explain-code src/auth/login.ts
In beiden Fällen sollte Claude eine Analogie und ein ASCII-Diagramm in seiner Erklärung enthalten.

​
Wo Skills leben

Wo Sie einen Skill speichern, bestimmt, wer ihn verwenden kann:
OrtPfadGilt für
UnternehmenSiehe verwaltete EinstellungenAlle Benutzer in Ihrer Organisation
Persönlich~/.claude/skills/<skill-name>/SKILL.mdAlle Ihre Projekte
Projekt.claude/skills/<skill-name>/SKILL.mdNur dieses Projekt
Plugin<plugin>/skills/<skill-name>/SKILL.mdWo das Plugin aktiviert ist
Wenn Skills auf verschiedenen Ebenen denselben Namen haben, gewinnen Orte mit höherer Priorität: Unternehmen > Persönlich > Projekt. Plugin-Skills verwenden einen plugin-name:skill-name-Namespace, sodass sie nicht mit anderen Ebenen in Konflikt geraten können. Wenn Sie Dateien in .claude/commands/ haben, funktionieren diese auf die gleiche Weise, aber wenn ein Skill und ein Befehl denselben Namen haben, hat der Skill Vorrang.

​
Automatische Erkennung aus verschachtelten Verzeichnissen

Wenn Sie mit Dateien in Unterverzeichnissen arbeiten, erkennt Claude Code automatisch Skills aus verschachtelten .claude/skills/-Verzeichnissen. Wenn Sie beispielsweise eine Datei in packages/frontend/ bearbeiten, sucht Claude Code auch nach Skills in packages/frontend/.claude/skills/. Dies unterstützt Monorepo-Setups, bei denen Pakete ihre eigenen Skills haben. Jeder Skill ist ein Verzeichnis mit SKILL.md als Einstiegspunkt: 
my-skill/
├── SKILL.md           # Main instructions (required)
├── template.md        # Template for Claude to fill in
├── examples/
│   └── sample.md      # Example output showing expected format
└── scripts/
    └── validate.sh    # Script Claude can execute
Die SKILL.md enthält die Hauptanweisungen und ist erforderlich. Andere Dateien sind optional und ermöglichen es Ihnen, leistungsfähigere Skills zu erstellen: Vorlagen für Claude zum Ausfüllen, Beispielausgaben, die das erwartete Format zeigen, Scripts, die Claude ausführen kann, oder detaillierte Referenzdokumentation. Verweisen Sie auf diese Dateien von Ihrer SKILL.md aus, damit Claude weiß, was sie enthalten und wann sie geladen werden sollen. Siehe Unterstützende Dateien hinzufügen für weitere Details.
Dateien in .claude/commands/ funktionieren weiterhin und unterstützen das gleiche Frontmatter. Skills werden empfohlen, da sie zusätzliche Funktionen wie unterstützende Dateien unterstützen.

​
Skills aus zusätzlichen Verzeichnissen

Skills, die in .claude/skills/ in Verzeichnissen definiert sind, die über --add-dir hinzugefügt wurden, werden automatisch geladen und von der Live-Änderungserkennung aufgegriffen, sodass Sie sie während einer Sitzung bearbeiten können, ohne neu zu starten.
CLAUDE.md-Dateien aus --add-dir-Verzeichnissen werden standardmäßig nicht geladen. Um sie zu laden, setzen Sie CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1. Siehe Aus zusätzlichen Verzeichnissen laden.

​
Skills konfigurieren

Skills werden durch YAML-Frontmatter oben in SKILL.md und den Markdown-Inhalt, der folgt, konfiguriert.

​
Arten von Skill-Inhalten

Skill-Dateien können beliebige Anweisungen enthalten, aber das Nachdenken darüber, wie Sie sie aufrufen möchten, hilft zu leiten, was Sie einbeziehen: Referenzinhalt fügt Wissen hinzu, das Claude auf Ihre aktuelle Arbeit anwendet. Konventionen, Muster, Stilhandbücher, Domänenwissen. Dieser Inhalt wird inline ausgeführt, sodass Claude ihn neben Ihrem Gesprächskontext verwenden kann. 
---
name: api-conventions
description: API design patterns for this codebase
---

When writing API endpoints:
- Use RESTful naming conventions
- Return consistent error formats
- Include request validation
Task-Inhalt gibt Claude Schritt-für-Schritt-Anweisungen für eine bestimmte Aktion, wie Bereitstellungen, Commits oder Code-Generierung. Dies sind oft Aktionen, die Sie direkt mit /skill-name aufrufen möchten, anstatt Claude entscheiden zu lassen, wann sie ausgeführt werden. Fügen Sie disable-model-invocation: true hinzu, um zu verhindern, dass Claude sie automatisch auslöst. 
---
name: deploy
description: Deploy the application to production
context: fork
disable-model-invocation: true
---

Deploy the application:
1. Run the test suite
2. Build the application
3. Push to the deployment target
Ihre SKILL.md kann alles enthalten, aber das Nachdenken darüber, wie Sie den Skill aufrufen möchten (von Ihnen, von Claude oder von beiden) und wo Sie ihn ausführen möchten (inline oder in einem Subagent) hilft zu leiten, was Sie einbeziehen. Für komplexe Skills können Sie auch unterstützende Dateien hinzufügen, um den Hauptskill fokussiert zu halten.

​
Frontmatter-Referenz

Über den Markdown-Inhalt hinaus können Sie das Skill-Verhalten mit YAML-Frontmatter-Feldern zwischen ----Markierungen oben in Ihrer SKILL.md-Datei konfigurieren: 
---
name: my-skill
description: What this skill does
disable-model-invocation: true
allowed-tools: Read, Grep
---

Your skill instructions here...
Alle Felder sind optional. Nur description wird empfohlen, damit Claude weiß, wann der Skill verwendet werden soll.
FeldErforderlichBeschreibung
nameNeinAnzeigename für den Skill. Falls weggelassen, wird der Verzeichnisname verwendet. Nur Kleinbuchstaben, Zahlen und Bindestriche (max. 64 Zeichen).
descriptionEmpfohlenWas der Skill tut und wann er verwendet werden soll. Claude verwendet dies, um zu entscheiden, wann der Skill angewendet werden soll. Falls weggelassen, wird der erste Absatz des Markdown-Inhalts verwendet.
argument-hintNeinHinweis, der während der Autovervollständigung angezeigt wird, um erwartete Argumente anzuzeigen. Beispiel: [issue-number] oder [filename] [format].
disable-model-invocationNeinSetzen Sie auf true, um zu verhindern, dass Claude diesen Skill automatisch lädt. Verwenden Sie für Workflows, die Sie manuell mit /name auslösen möchten. Standard: false.
user-invocableNeinSetzen Sie auf false, um aus dem /-Menü auszublenden. Verwenden Sie für Hintergrundwissen, das Benutzer nicht direkt aufrufen sollten. Standard: true.
allowed-toolsNeinTools, die Claude ohne Genehmigung verwenden kann, wenn dieser Skill aktiv ist.
modelNeinModell, das verwendet werden soll, wenn dieser Skill aktiv ist.
effortNeinAnstrengungsstufe wenn dieser Skill aktiv ist. Überschreibt die Anstrengungsstufe der Sitzung. Standard: erbt von Sitzung. Optionen: low, medium, high, max (nur Opus 4.6).
contextNeinSetzen Sie auf fork, um in einem verzweigten Subagent-Kontext ausgeführt zu werden.
agentNeinWelcher Subagent-Typ verwendet werden soll, wenn context: fork gesetzt ist.
hooksNeinHooks, die auf den Lebenszyklus dieses Skills beschränkt sind. Siehe Hooks in Skills und Agenten für das Konfigurationsformat.

​
Verfügbare String-Substitutionen

Skills unterstützen String-Substitution für dynamische Werte im Skill-Inhalt:
VariableBeschreibung
$ARGUMENTSAlle Argumente, die beim Aufrufen des Skills übergeben werden. Wenn $ARGUMENTS nicht im Inhalt vorhanden ist, werden Argumente als ARGUMENTS: <value> angehängt.
$ARGUMENTS[N]Greifen Sie auf ein bestimmtes Argument nach 0-basiertem Index zu, z. B. $ARGUMENTS[0] für das erste Argument.
$NKurzform für $ARGUMENTS[N], z. B. $0 für das erste Argument oder $1 für das zweite.
${CLAUDE_SESSION_ID}Die aktuelle Sitzungs-ID. Nützlich zum Protokollieren, Erstellen sitzungsspezifischer Dateien oder Korrelieren der Skill-Ausgabe mit Sitzungen.
${CLAUDE_SKILL_DIR}Das Verzeichnis, das die SKILL.md-Datei des Skills enthält. Für Plugin-Skills ist dies das Skill-Unterverzeichnis im Plugin, nicht das Plugin-Root. Verwenden Sie dies in Bash-Injektionsbefehlen, um auf Scripts oder Dateien zu verweisen, die mit dem Skill gebündelt sind, unabhängig vom aktuellen Arbeitsverzeichnis.
Beispiel mit Substitutionen: 
---
name: session-logger
description: Log activity for this session
---

Log the following to logs/${CLAUDE_SESSION_ID}.log:

$ARGUMENTS

​
Unterstützende Dateien hinzufügen

Skills können mehrere Dateien in ihrem Verzeichnis enthalten. Dies hält SKILL.md auf das Wesentliche konzentriert, während Claude detailliertes Referenzmaterial nur bei Bedarf abrufen kann. Große Referenzdokumente, API-Spezifikationen oder Beispielsammlungen müssen nicht jedes Mal geladen werden, wenn der Skill ausgeführt wird. 
my-skill/
├── SKILL.md (required - overview and navigation)
├── reference.md (detailed API docs - loaded when needed)
├── examples.md (usage examples - loaded when needed)
└── scripts/
    └── helper.py (utility script - executed, not loaded)
Verweisen Sie auf unterstützende Dateien von SKILL.md aus, damit Claude weiß, was jede Datei enthält und wann sie geladen werden soll: 
## Additional resources

- For complete API details, see [reference.md](reference.md)
- For usage examples, see [examples.md](examples.md)
Halten Sie SKILL.md unter 500 Zeilen. Verschieben Sie detailliertes Referenzmaterial in separate Dateien.

​
Steuern Sie, wer einen Skill aufruft

Standardmäßig können sowohl Sie als auch Claude jeden Skill aufrufen. Sie können /skill-name eingeben, um ihn direkt aufzurufen, und Claude kann ihn automatisch laden, wenn er für Ihr Gespräch relevant ist. Zwei Frontmatter-Felder ermöglichen es Ihnen, dies einzuschränken:
  • disable-model-invocation: true: Nur Sie können den Skill aufrufen. Verwenden Sie dies für Workflows mit Nebenwirkungen oder die Sie zeitlich steuern möchten, wie /commit, /deploy oder /send-slack-message. Sie möchten nicht, dass Claude bereitstellt, weil Ihr Code bereit aussieht.
  • user-invocable: false: Nur Claude kann den Skill aufrufen. Verwenden Sie dies für Hintergrundwissen, das nicht als Befehl umsetzbar ist. Ein legacy-system-context-Skill erklärt, wie ein altes System funktioniert. Claude sollte dies kennen, wenn es relevant ist, aber /legacy-system-context ist keine aussagekräftige Aktion für Benutzer.
Dieses Beispiel erstellt einen Deploy-Skill, den nur Sie auslösen können. Das disable-model-invocation: true-Feld verhindert, dass Claude ihn automatisch ausführt: 
---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
---

Deploy $ARGUMENTS to production:

1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded
Hier ist, wie die beiden Felder Aufrufe und Kontextladung beeinflussen:
FrontmatterSie können aufrufenClaude kann aufrufenWann in Kontext geladen
(Standard)JaJaBeschreibung immer im Kontext, vollständiger Skill wird beim Aufrufen geladen
disable-model-invocation: trueJaNeinBeschreibung nicht im Kontext, vollständiger Skill wird geladen, wenn Sie aufrufen
user-invocable: falseNeinJaBeschreibung immer im Kontext, vollständiger Skill wird beim Aufrufen geladen
In einer regulären Sitzung werden Skill-Beschreibungen in den Kontext geladen, damit Claude weiß, was verfügbar ist, aber vollständiger Skill-Inhalt wird nur beim Aufrufen geladen. Subagenten mit vorgeladenen Skills funktionieren anders: Der vollständige Skill-Inhalt wird beim Start eingespritzt.

​
Beschränken Sie den Tool-Zugriff

Verwenden Sie das allowed-tools-Feld, um zu begrenzen, welche Tools Claude verwenden kann, wenn ein Skill aktiv ist. Dieser Skill erstellt einen schreibgeschützten Modus, in dem Claude Dateien erkunden, aber nicht ändern kann: 
---
name: safe-reader
description: Read files without making changes
allowed-tools: Read, Grep, Glob
---

​
Argumente an Skills übergeben

Sowohl Sie als auch Claude können Argumente beim Aufrufen eines Skills übergeben. Argumente sind über den $ARGUMENTS-Platzhalter verfügbar. Dieser Skill behebt ein GitHub-Problem nach Nummer. Der $ARGUMENTS-Platzhalter wird durch alles ersetzt, was dem Skill-Namen folgt: 
---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.

1. Read the issue description
2. Understand the requirements
3. Implement the fix
4. Write tests
5. Create a commit
Wenn Sie /fix-issue 123 ausführen, erhält Claude ‘Fix GitHub issue 123 following our coding standards…” Wenn Sie einen Skill mit Argumenten aufrufen, aber der Skill $ARGUMENTS nicht enthält, hängt Claude Code ARGUMENTS: <your input> am Ende des Skill-Inhalts an, damit Claude immer noch sieht, was Sie eingegeben haben. Um auf einzelne Argumente nach Position zuzugreifen, verwenden Sie $ARGUMENTS[N] oder die kürzere Form $N: 
---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $ARGUMENTS[0] component from $ARGUMENTS[1] to $ARGUMENTS[2].
Preserve all existing behavior and tests.
Wenn Sie /migrate-component SearchBar React Vue ausführen, wird $ARGUMENTS[0] durch SearchBar, $ARGUMENTS[1] durch React und $ARGUMENTS[2] durch Vue ersetzt. Der gleiche Skill mit der $N-Kurzform: 
---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.

​
Fortgeschrittene Muster

​
Dynamischen Kontext einspritzen

Die !`<command>` Syntax führt Shell-Befehle aus, bevor der Skill-Inhalt an Claude gesendet wird. Die Befehlsausgabe ersetzt den Platzhalter, sodass Claude tatsächliche Daten erhält, nicht den Befehl selbst. Dieser Skill fasst einen Pull Request zusammen, indem er Live-PR-Daten mit der GitHub CLI abruft. Die !`gh pr diff` und andere Befehle werden zuerst ausgeführt, und ihre Ausgabe wird in den Prompt eingefügt: 
---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...
Wenn dieser Skill ausgeführt wird:
  1. Jeder !`<command>` wird sofort ausgeführt (bevor Claude etwas sieht)
  2. Die Ausgabe ersetzt den Platzhalter im Skill-Inhalt
  3. Claude erhält den vollständig gerenderten Prompt mit tatsächlichen PR-Daten
Dies ist Vorverarbeitung, nicht etwas, das Claude ausführt. Claude sieht nur das Endergebnis.
Um erweitertes Denken in einem Skill zu aktivieren, fügen Sie das Wort „ultrathink” irgendwo in Ihren Skill-Inhalt ein.

​
Skills in einem Subagent ausführen

Fügen Sie context: fork zu Ihrem Frontmatter hinzu, wenn Sie möchten, dass ein Skill isoliert ausgeführt wird. Der Skill-Inhalt wird zum Prompt, der den Subagent antreibt. Er hat keinen Zugriff auf Ihren Gesprächsverlauf.
context: fork macht nur Sinn für Skills mit expliziten Anweisungen. Wenn Ihr Skill Richtlinien wie „verwenden Sie diese API-Konventionen” ohne eine Aufgabe enthält, erhält der Subagent die Richtlinien, aber keinen umsetzbaren Prompt, und gibt ohne aussagekräftige Ausgabe zurück.
Skills und Subagenten funktionieren in zwei Richtungen zusammen:
AnsatzSystem-PromptAufgabeLädt auch
Skill mit context: forkVom Agent-Typ (Explore, Plan, etc.)SKILL.md-InhaltCLAUDE.md
Subagent mit skills-FeldSubagent-Markdown-BodyClaudes DelegationsnachrichtVorgeladene Skills + CLAUDE.md
Mit context: fork schreiben Sie die Aufgabe in Ihren Skill und wählen einen Agent-Typ aus, um sie auszuführen. Für das Inverse (Definieren eines benutzerdefinierten Subagenten, der Skills als Referenzmaterial verwendet), siehe Subagenten.

​
Beispiel: Research-Skill mit Explore-Agent

Dieser Skill führt Recherchen in einem verzweigten Explore-Agent aus. Der Skill-Inhalt wird zur Aufgabe, und der Agent bietet schreibgeschützte Tools, die für die Codebase-Erkundung optimiert sind: 
---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references
Wenn dieser Skill ausgeführt wird:
  1. Ein neuer isolierter Kontext wird erstellt
  2. Der Subagent erhält den Skill-Inhalt als seinen Prompt („Research $ARGUMENTS thoroughly…”)
  3. Das agent-Feld bestimmt die Ausführungsumgebung (Modell, Tools und Berechtigungen)
  4. Ergebnisse werden zusammengefasst und an Ihr Hauptgespräch zurückgegeben
Das agent-Feld gibt an, welche Subagent-Konfiguration verwendet werden soll. Optionen umfassen integrierte Agenten (Explore, Plan, general-purpose) oder jeden benutzerdefinierten Subagenten aus .claude/agents/. Falls weggelassen, wird general-purpose verwendet.

​
Beschränken Sie Claudes Skill-Zugriff

Standardmäßig kann Claude jeden Skill aufrufen, der nicht disable-model-invocation: true gesetzt hat. Skills, die allowed-tools definieren, gewähren Claude Zugriff auf diese Tools ohne Genehmigung pro Verwendung, wenn der Skill aktiv ist. Ihre Berechtigungseinstellungen regeln weiterhin das Baseline-Genehmigungsverhalten für alle anderen Tools. Integrierte Befehle wie /compact und /init sind nicht über das Skill-Tool verfügbar. Drei Möglichkeiten, um zu steuern, welche Skills Claude aufrufen kann: Deaktivieren Sie alle Skills, indem Sie das Skill-Tool in /permissions ablehnen: 
# Add to deny rules:
Skill
Erlauben oder verweigern Sie bestimmte Skills mit Berechtigungsregeln: 
# Allow only specific skills
Skill(commit)
Skill(review-pr *)

# Deny specific skills
Skill(deploy *)
Berechtigungssyntax: Skill(name) für exakte Übereinstimmung, Skill(name *) für Präfixübereinstimmung mit beliebigen Argumenten. Verstecken Sie einzelne Skills, indem Sie disable-model-invocation: true zu ihrem Frontmatter hinzufügen. Dies entfernt den Skill vollständig aus Claudes Kontext.
Das user-invocable-Feld steuert nur die Menüsichtbarkeit, nicht den Skill-Tool-Zugriff. Verwenden Sie disable-model-invocation: true, um die programmgesteuerte Aufrufe zu blockieren.

​
Skills teilen

Skills können je nach Ihrer Zielgruppe in verschiedenen Bereichen verteilt werden:
  • Projekt-Skills: Committen Sie .claude/skills/ zur Versionskontrolle
  • Plugins: Erstellen Sie ein skills/-Verzeichnis in Ihrem Plugin
  • Verwaltet: Stellen Sie organisationsweit über verwaltete Einstellungen bereit

​
Visuelle Ausgabe generieren

Skills können Scripts in jeder Sprache bündeln und ausführen, was Claude Funktionen gibt, die über das hinausgehen, was in einem einzelnen Prompt möglich ist. Ein leistungsstarkes Muster ist die Generierung visueller Ausgabe: interaktive HTML-Dateien, die in Ihrem Browser geöffnet werden, um Daten zu erkunden, zu debuggen oder Berichte zu erstellen. Dieses Beispiel erstellt einen Codebase-Explorer: eine interaktive Baumansicht, in der Sie Verzeichnisse erweitern und reduzieren, Dateigröße auf einen Blick sehen und Dateitypen nach Farbe identifizieren können. Erstellen Sie das Skill-Verzeichnis: 
mkdir -p ~/.claude/skills/codebase-visualizer/scripts
Erstellen Sie ~/.claude/skills/codebase-visualizer/SKILL.md. Die Beschreibung teilt Claude mit, wann dieser Skill aktiviert werden soll, und die Anweisungen teilen Claude mit, das gebündelte Script auszuführen: 
---
name: codebase-visualizer
description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.
allowed-tools: Bash(python *)
---

# Codebase Visualizer

Generate an interactive HTML tree view that shows your project's file structure with collapsible directories.

## Usage

Run the visualization script from your project root:

```bash
python ~/.claude/skills/codebase-visualizer/scripts/visualize.py .
```

This creates `codebase-map.html` in the current directory and opens it in your default browser.

## What the visualization shows

- **Collapsible directories**: Click folders to expand/collapse
- **File sizes**: Displayed next to each file
- **Colors**: Different colors for different file types
- **Directory totals**: Shows aggregate size of each folder
Erstellen Sie ~/.claude/skills/codebase-visualizer/scripts/visualize.py. Dieses Script scannt einen Verzeichnisbaum und generiert eine eigenständige HTML-Datei mit:
  • Eine Zusammenfassungs-Seitenleiste, die Dateianzahl, Verzeichnisanzahl, Gesamtgröße und Anzahl der Dateitypen anzeigt
  • Ein Balkendiagramm, das die Codebasis nach Dateityp aufschlüsselt (Top 8 nach Größe)
  • Einen zusammenklappbaren Baum, in dem Sie Verzeichnisse erweitern und reduzieren können, mit farbcodierten Dateityp-Indikatoren
Das Script erfordert Python, verwendet aber nur integrierte Bibliotheken, daher müssen keine Pakete installiert werden: 
#!/usr/bin/env python3
"""Generate an interactive collapsible tree visualization of a codebase."""

import json
import sys
import webbrowser
from pathlib import Path
from collections import Counter

IGNORE = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'dist', 'build'}

def scan(path: Path, stats: dict) -> dict:
    result = {"name": path.name, "children": [], "size": 0}
    try:
        for item in sorted(path.iterdir()):
            if item.name in IGNORE or item.name.startswith('.'):
                continue
            if item.is_file():
                size = item.stat().st_size
                ext = item.suffix.lower() or '(no ext)'
                result["children"].append({"name": item.name, "size": size, "ext": ext})
                result["size"] += size
                stats["files"] += 1
                stats["extensions"][ext] += 1
                stats["ext_sizes"][ext] += size
            elif item.is_dir():
                stats["dirs"] += 1
                child = scan(item, stats)
                if child["children"]:
                    result["children"].append(child)
                    result["size"] += child["size"]
    except PermissionError:
        pass
    return result

def generate_html(data: dict, stats: dict, output: Path) -> None:
    ext_sizes = stats["ext_sizes"]
    total_size = sum(ext_sizes.values()) or 1
    sorted_exts = sorted(ext_sizes.items(), key=lambda x: -x[1])[:8]
    colors = {
        '.js': '#f7df1e', '.ts': '#3178c6', '.py': '#3776ab', '.go': '#00add8',
        '.rs': '#dea584', '.rb': '#cc342d', '.css': '#264de4', '.html': '#e34c26',
        '.json': '#6b7280', '.md': '#083fa1', '.yaml': '#cb171e', '.yml': '#cb171e',
        '.mdx': '#083fa1', '.tsx': '#3178c6', '.jsx': '#61dafb', '.sh': '#4eaa25',
    }
    lang_bars = "".join(
        f'<div class="bar-row"><span class="bar-label">{ext}</span>'
        f'<div class="bar" style="width:{(size/total_size)*100}%;background:{colors.get(ext,"#6b7280")}"></div>'
        f'<span class="bar-pct">{(size/total_size)*100:.1f}%</span></div>'
        for ext, size in sorted_exts
    )
    def fmt(b):
        if b < 1024: return f"{b} B"
        if b < 1048576: return f"{b/1024:.1f} KB"
        return f"{b/1048576:.1f} MB"

    html = f'''<!DOCTYPE html>
<html><head>
  <meta charset="utf-8"><title>Codebase Explorer</title>
  <style>
    body {{ font: 14px/1.5 system-ui, sans-serif; margin: 0; background: #1a1a2e; color: #eee; }}
    .container {{ display: flex; height: 100vh; }}
    .sidebar {{ width: 280px; background: #252542; padding: 20px; border-right: 1px solid #3d3d5c; overflow-y: auto; flex-shrink: 0; }}
    .main {{ flex: 1; padding: 20px; overflow-y: auto; }}
    h1 {{ margin: 0 0 10px 0; font-size: 18px; }}
    h2 {{ margin: 20px 0 10px 0; font-size: 14px; color: #888; text-transform: uppercase; }}
    .stat {{ display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #3d3d5c; }}
    .stat-value {{ font-weight: bold; }}
    .bar-row {{ display: flex; align-items: center; margin: 6px 0; }}
    .bar-label {{ width: 55px; font-size: 12px; color: #aaa; }}
    .bar {{ height: 18px; border-radius: 3px; }}
    .bar-pct {{ margin-left: 8px; font-size: 12px; color: #666; }}
    .tree {{ list-style: none; padding-left: 20px; }}
    details {{ cursor: pointer; }}
    summary {{ padding: 4px 8px; border-radius: 4px; }}
    summary:hover {{ background: #2d2d44; }}
    .folder {{ color: #ffd700; }}
    .file {{ display: flex; align-items: center; padding: 4px 8px; border-radius: 4px; }}
    .file:hover {{ background: #2d2d44; }}
    .size {{ color: #888; margin-left: auto; font-size: 12px; }}
    .dot {{ width: 8px; height: 8px; border-radius: 50%; margin-right: 8px; }}
  </style>
</head><body>
  <div class="container">
    <div class="sidebar">
      <h1>📊 Summary</h1>
      <div class="stat"><span>Files</span><span class="stat-value">{stats["files"]:,}</span></div>
      <div class="stat"><span>Directories</span><span class="stat-value">{stats["dirs"]:,}</span></div>
      <div class="stat"><span>Total size</span><span class="stat-value">{fmt(data["size"])}</span></div>
      <div class="stat"><span>File types</span><span class="stat-value">{len(stats["extensions"])}</span></div>
      <h2>By file type</h2>
      {lang_bars}
    </div>
    <div class="main">
      <h1>📁 {data["name"]}</h1>
      <ul class="tree" id="root"></ul>
    </div>
  </div>
  <script>
    const data = {json.dumps(data)};
    const colors = {json.dumps(colors)};
    function fmt(b) {{ if (b < 1024) return b + ' B'; if (b < 1048576) return (b/1024).toFixed(1) + ' KB'; return (b/1048576).toFixed(1) + ' MB'; }}
    function render(node, parent) {{
      if (node.children) {{
        const det = document.createElement('details');
        det.open = parent === document.getElementById('root');
        det.innerHTML = `<summary><span class="folder">📁 ${{node.name}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;
        const ul = document.createElement('ul'); ul.className = 'tree';
        node.children.sort((a,b) => (b.children?1:0)-(a.children?1:0) || a.name.localeCompare(b.name));
        node.children.forEach(c => render(c, ul));
        det.appendChild(ul);
        const li = document.createElement('li'); li.appendChild(det); parent.appendChild(li);
      }} else {{
        const li = document.createElement('li'); li.className = 'file';
        li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{node.name}}<span class="size">${{fmt(node.size)}}</span>`;
        parent.appendChild(li);
      }}
    }}
    data.children.forEach(c => render(c, document.getElementById('root')));
  </script>
</body></html>'''
    output.write_text(html)

if __name__ == '__main__':
    target = Path(sys.argv[1] if len(sys.argv) > 1 else '.').resolve()
    stats = {"files": 0, "dirs": 0, "extensions": Counter(), "ext_sizes": Counter()}
    data = scan(target, stats)
    out = Path('codebase-map.html')
    generate_html(data, stats, out)
    print(f'Generated {out.absolute()}')
    webbrowser.open(f'file://{out.absolute()}')
Um zu testen, öffnen Sie Claude Code in einem beliebigen Projekt und fragen Sie „Visualize this codebase.” Claude führt das Script aus, generiert codebase-map.html und öffnet es in Ihrem Browser. Dieses Muster funktioniert für jede visuelle Ausgabe: Abhängigkeitsgraphen, Test-Coverage-Berichte, API-Dokumentation oder Datenbankschema-Visualisierungen. Das gebündelte Script erledigt die schwere Arbeit, während Claude die Orchestrierung übernimmt.

​
Fehlerbehebung

​
Skill wird nicht ausgelöst

Wenn Claude Ihren Skill nicht verwendet, wenn erwartet:
  1. Überprüfen Sie, ob die Beschreibung Schlüsselwörter enthält, die Benutzer natürlicherweise sagen würden
  2. Überprüfen Sie, ob der Skill in What skills are available? angezeigt wird
  3. Versuchen Sie, Ihre Anfrage umzuformulieren, um die Beschreibung besser zu treffen
  4. Rufen Sie ihn direkt mit /skill-name auf, wenn der Skill vom Benutzer aufgerufen werden kann

​
Skill wird zu oft ausgelöst

Wenn Claude Ihren Skill verwendet, wenn Sie das nicht möchten:
  1. Machen Sie die Beschreibung spezifischer
  2. Fügen Sie disable-model-invocation: true hinzu, wenn Sie nur manuelle Aufrufe möchten

​
Claude sieht nicht alle meine Skills

Skill-Beschreibungen werden in den Kontext geladen, damit Claude weiß, was verfügbar ist. Wenn Sie viele Skills haben, können sie das Zeichenbudget überschreiten. Das Budget skaliert dynamisch bei 2% des Kontextfensters, mit einem Fallback von 16.000 Zeichen. Führen Sie /context aus, um auf eine Warnung über ausgeschlossene Skills zu prüfen. Um das Limit zu überschreiben, setzen Sie die Umgebungsvariable SLASH_COMMAND_TOOL_CHAR_BUDGET.

​
Verwandte Ressourcen

  • Subagenten: Delegieren Sie Aufgaben an spezialisierte Agenten
  • Plugins: Packen und verteilen Sie Skills mit anderen Erweiterungen
  • Hooks: Automatisieren Sie Workflows um Tool-Ereignisse
  • Memory: Verwalten Sie CLAUDE.md-Dateien für persistenten Kontext
  • Integrierte Befehle: Referenz für integrierte /-Befehle
  • Berechtigungen: Steuern Sie Tool- und Skill-Zugriff