Claude mit Skills erweitern

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. Erstellen Sie einen Skill, wenn Sie immer wieder die gleichen Anweisungen, eine Checkliste oder ein mehrstufiges Verfahren in den Chat einfügen, oder wenn ein Abschnitt von CLAUDE.md zu einem Verfahren statt zu einer Tatsache geworden ist. Im Gegensatz zu CLAUDE.md-Inhalten wird der Body eines Skills nur geladen, wenn er verwendet wird, sodass lange Referenzmaterialien fast nichts kosten, bis Sie sie benötigen.

Für integrierte Befehle wie /help und /compact sowie gebündelte Skills wie /debug und /simplify siehe die Befehlsreferenz.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

Claude Code wird mit einer Reihe von gebündelten Skills ausgeliefert, die in jeder Sitzung verfügbar sind, einschließlich /simplify, /batch, /debug, /loop und /claude-api. Im Gegensatz zu den meisten integrierten Befehlen, die direkt feste Logik ausführen, sind gebündelte Skills prompt-basiert: Sie geben Claude detaillierte Anweisungen und lassen es die Arbeit mit seinen Tools orchestrieren. Sie rufen sie auf die gleiche Weise auf wie jeden anderen Skill, indem Sie / gefolgt vom Skill-Namen eingeben. Gebündelte Skills sind in der Befehlsreferenz neben integrierten Befehlen aufgelistet und mit Skill in der Spalte „Zweck” gekennzeichnet.

Erste Schritte

Erstellen Sie Ihren ersten Skill

Dieses Beispiel erstellt einen Skill, der die nicht committeten Änderungen in Ihrem Git-Repository zusammenfasst und alles Riskante kennzeichnet. Es zieht den Live-Diff in den Prompt, bevor Claude ihn liest, sodass die Antwort in Ihrem tatsächlichen Arbeitsbaum verankert ist, anstatt auf dem zu basieren, was Claude aus offenen Dateien erraten kann. Claude lädt den Skill automatisch, wenn Sie nach Ihren Änderungen fragen, oder Sie können ihn direkt mit /summarize-changes aufrufen.

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/summarize-changes

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 ausgeführt wird. Das Verzeichnisname wird zum Befehl, den Sie eingeben, und die description hilft Claude zu entscheiden, wann der Skill automatisch geladen werden soll.Speichern Sie dies unter ~/.claude/skills/summarize-changes/SKILL.md:

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

Die Zeile !`git diff HEAD` verwendet dynamische Kontextinjektion: Claude Code führt den Befehl aus und ersetzt die Zeile mit seiner Ausgabe, bevor Claude den Skill-Inhalt sieht, sodass die Anweisungen mit dem aktuellen Diff bereits inline ankommen.

Testen Sie den Skill

Öffnen Sie ein Git-Projekt, nehmen Sie eine kleine Änderung an einer beliebigen Datei vor, und starten Sie Claude Code, indem Sie claude ausführen. Sie können den Skill auf zwei Arten testen.Lassen Sie Claude ihn automatisch aufrufen, indem Sie etwas eingeben, das der Beschreibung entspricht:

What did I change?

Oder rufen Sie ihn direkt auf mit dem Skill-Namen:

/summarize-changes

In beiden Fällen sollte Claude mit einer kurzen Zusammenfassung Ihrer Änderung und einer Liste von Risiken antworten.

Wo Skills leben

Wo Sie einen Skill speichern, bestimmt, wer ihn verwenden kann:

Ort	Pfad	Gilt für
Unternehmen	Siehe verwaltete Einstellungen	Alle Benutzer in Ihrer Organisation
Persönlich	`~/.claude/skills/<skill-name>/SKILL.md`	Alle Ihre Projekte
Projekt	`.claude/skills/<skill-name>/SKILL.md`	Nur dieses Projekt
Plugin	`<plugin>/skills/<skill-name>/SKILL.md`	Wo das Plugin aktiviert ist

Wenn Skills auf verschiedenen Ebenen denselben Namen haben, gewinnt Unternehmen gegenüber Persönlich, und Persönlich gewinnt gegenüber 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.

Live-Änderungserkennung

Claude Code überwacht Skill-Verzeichnisse auf Dateiänderungen. Das Hinzufügen, Bearbeiten oder Entfernen eines Skills unter ~/.claude/skills/, dem Projekt .claude/skills/ oder einem .claude/skills/ in einem --add-dir-Verzeichnis wird in der aktuellen Sitzung wirksam, ohne Claude Code neu zu starten. Das Erstellen eines Skill-Verzeichnisses auf oberster Ebene, das nicht vorhanden war, als die Sitzung gestartet wurde, erfordert einen Neustart von Claude Code, damit das neue Verzeichnis überwacht werden kann.

Automatische Erkennung aus übergeordneten und verschachtelten Verzeichnissen

Projekt-Skills werden aus .claude/skills/ in Ihrem Startverzeichnis und in jedem übergeordneten Verzeichnis bis zur Repository-Root geladen, sodass das Starten von Claude in einem Unterverzeichnis immer noch Skills erfasst, die in der Root definiert sind. Wenn Sie mit Dateien in Unterverzeichnissen unter Ihrem Startverzeichnis arbeiten, erkennt Claude Code auch Skills aus verschachtelten .claude/skills/-Verzeichnissen bei Bedarf. 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

Das Flag --add-dir gewährt Dateizugriff statt Konfigurationserkennung, aber Skills sind eine Ausnahme: .claude/skills/ in einem hinzugefügten Verzeichnis wird automatisch geladen. Siehe Live-Änderungserkennung für die Aufnahme von Änderungen während einer Sitzung. Andere .claude/-Konfigurationen wie Subagenten, Befehle und Ausgabestile werden nicht aus zusätzlichen Verzeichnissen geladen. Siehe die Ausnahmetabelle für die vollständige Liste dessen, was geladen wird und was nicht, sowie die empfohlenen Wege zum Teilen von Konfigurationen über Projekte hinweg.

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. Halten Sie den Text selbst prägnant. Sobald ein Skill geladen ist, bleibt sein Inhalt über Züge hinweg im Kontext, sodass jede Zeile eine wiederkehrende Token-Kosten darstellt. Geben Sie an, was zu tun ist, anstatt zu erzählen, wie oder warum, und wenden Sie denselben Prägnanz-Test an, den Sie für CLAUDE.md-Inhalt verwenden würden.

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.

Feld	Erforderlich	Beschreibung
`name`	Nein	Anzeigename für den Skill. Falls weggelassen, wird der Verzeichnisname verwendet. Nur Kleinbuchstaben, Zahlen und Bindestriche (max. 64 Zeichen).
`description`	Empfohlen	Was 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. Stellen Sie den wichtigsten Anwendungsfall an den Anfang: Der kombinierte Text `description` und `when_to_use` wird in der Skill-Auflistung bei 1.536 Zeichen gekürzt, um die Kontextnutzung zu reduzieren.
`when_to_use`	Nein	Zusätzlicher Kontext für den Zeitpunkt, zu dem Claude den Skill aufrufen sollte, z. B. Trigger-Phrasen oder Beispielanfragen. An `description` in der Skill-Auflistung angehängt und zählt zur 1.536-Zeichen-Obergrenze.
`argument-hint`	Nein	Hinweis, der während der Autovervollständigung angezeigt wird, um erwartete Argumente anzuzeigen. Beispiel: `[issue-number]` oder `[filename] [format]`.
`arguments`	Nein	Benannte positionelle Argumente für `$name`-Substitution im Skill-Inhalt. Akzeptiert eine durch Leerzeichen getrennte Zeichenkette oder eine YAML-Liste. Namen werden in Reihenfolge auf Argumentpositionen abgebildet.
`disable-model-invocation`	Nein	Setzen 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. Verhindert auch, dass der Skill in Subagenten vorgeladen wird. Standard: `false`.
`user-invocable`	Nein	Setzen Sie auf `false`, um aus dem `/`-Menü auszublenden. Verwenden Sie für Hintergrundwissen, das Benutzer nicht direkt aufrufen sollten. Standard: `true`.
`allowed-tools`	Nein	Tools, die Claude ohne Genehmigung verwenden kann, wenn dieser Skill aktiv ist. Akzeptiert eine durch Leerzeichen getrennte Zeichenkette oder eine YAML-Liste.
`model`	Nein	Modell, das verwendet werden soll, wenn dieser Skill aktiv ist. Die Überschreibung gilt für den Rest des aktuellen Zuges und wird nicht in den Einstellungen gespeichert; das Sitzungsmodell wird bei Ihrer nächsten Eingabe fortgesetzt. Akzeptiert die gleichen Werte wie `/model` oder `inherit`, um das aktive Modell beizubehalten.
`effort`	Nein	Anstrengungsstufe wenn dieser Skill aktiv ist. Überschreibt die Anstrengungsstufe der Sitzung. Standard: erbt von Sitzung. Optionen: `low`, `medium`, `high`, `xhigh`, `max`; verfügbare Stufen hängen vom Modell ab.
`context`	Nein	Setzen Sie auf `fork`, um in einem verzweigten Subagent-Kontext ausgeführt zu werden.
`agent`	Nein	Welcher Subagent-Typ verwendet werden soll, wenn `context: fork` gesetzt ist.
`hooks`	Nein	Hooks, die auf den Lebenszyklus dieses Skills beschränkt sind. Siehe Hooks in Skills und Agenten für das Konfigurationsformat.
`paths`	Nein	Glob-Muster, die begrenzen, wann dieser Skill aktiviert wird. Akzeptiert eine kommagetrennte Zeichenkette oder eine YAML-Liste. Wenn gesetzt, lädt Claude den Skill automatisch nur, wenn mit Dateien arbeitet, die den Mustern entsprechen. Verwendet das gleiche Format wie pfadspezifische Regeln.
`shell`	Nein	Shell, die für !`command` und ```! Blöcke in diesem Skill verwendet werden soll. Akzeptiert `bash` (Standard) oder `powershell`. Das Setzen von `powershell` führt Inline-Shell-Befehle über PowerShell unter Windows aus. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`.

Verfügbare String-Substitutionen

Skills unterstützen String-Substitution für dynamische Werte im Skill-Inhalt:

Variable	Beschreibung
`$ARGUMENTS`	Alle 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.
`$N`	Kurzform für `$ARGUMENTS[N]`, z. B. `$0` für das erste Argument oder `$1` für das zweite.
`$name`	Benanntes Argument, das in der `arguments`-Frontmatter-Liste deklariert ist. Namen werden in Reihenfolge auf Positionen abgebildet, daher wird mit `arguments: [issue, branch]` der Platzhalter `$issue` zum ersten Argument erweitert und `$branch` zum zweiten.
`${CLAUDE_SESSION_ID}`	Die aktuelle Sitzungs-ID. Nützlich zum Protokollieren, Erstellen sitzungsspezifischer Dateien oder Korrelieren der Skill-Ausgabe mit Sitzungen.
`${CLAUDE_EFFORT}`	Die aktuelle Anstrengungsstufe: `low`, `medium`, `high`, `xhigh` oder `max`. Verwenden Sie dies, um Skill-Anweisungen an die aktive Anstrengungseinstellung anzupassen.
`${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.

Indizierte Argumente verwenden Shell-ähnliche Anführungszeichen, daher müssen Sie mehrteilige Werte in Anführungszeichen setzen, um sie als einzelnes Argument zu übergeben. Zum Beispiel macht /my-skill "hello world" second $0 zu hello world und $1 zu second. Der $ARGUMENTS-Platzhalter wird immer zur vollständigen Argumentzeichenkette erweitert, wie eingegeben. 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:

Frontmatter	Sie können aufrufen	Claude kann aufrufen	Wann in Kontext geladen
(Standard)	Ja	Ja	Beschreibung immer im Kontext, vollständiger Skill wird beim Aufrufen geladen
`disable-model-invocation: true`	Ja	Nein	Beschreibung nicht im Kontext, vollständiger Skill wird geladen, wenn Sie aufrufen
`user-invocable: false`	Nein	Ja	Beschreibung 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.

Skill-Inhalts-Lebenszyklus

Wenn Sie oder Claude einen Skill aufrufen, wird der gerenderte SKILL.md-Inhalt als einzelne Nachricht in das Gespräch eingegeben und bleibt dort für den Rest der Sitzung. Claude Code liest die Skill-Datei bei späteren Zügen nicht erneut, daher schreiben Sie Anleitung, die während einer Aufgabe gelten sollte, als stehende Anweisungen statt als einmalige Schritte. Auto-Komprimierung trägt aufgerufene Skills innerhalb eines Token-Budgets weiter. Wenn das Gespräch zusammengefasst wird, um Kontext freizugeben, hängt Claude Code die neueste Aufrufe jedes Skills nach der Zusammenfassung wieder an und behält die ersten 5.000 Token jedes Skills. Wieder angehängte Skills teilen sich ein kombiniertes Budget von 25.000 Token. Claude Code füllt dieses Budget ab dem zuletzt aufgerufenen Skill, sodass ältere Skills vollständig gelöscht werden können, wenn Sie viele in einer Sitzung aufgerufen haben. Wenn ein Skill das Verhalten nach der ersten Antwort nicht mehr zu beeinflussen scheint, ist der Inhalt normalerweise immer noch vorhanden und das Modell wählt andere Tools oder Ansätze. Stärken Sie die description und Anweisungen des Skills, damit das Modell es weiterhin bevorzugt, oder verwenden Sie Hooks, um Verhalten deterministisch zu erzwingen. Wenn der Skill groß ist oder Sie mehrere andere danach aufgerufen haben, rufen Sie ihn nach der Komprimierung erneut auf, um den vollständigen Inhalt wiederherzustellen.

Tools für einen Skill vorab genehmigen

Das allowed-tools-Feld gewährt Berechtigung für die aufgelisteten Tools, während der Skill aktiv ist, sodass Claude sie verwenden kann, ohne Sie um Genehmigung zu bitten. Es schränkt nicht ein, welche Tools verfügbar sind: Jedes Tool bleibt aufrufbar, und Ihre Berechtigungseinstellungen regeln weiterhin Tools, die nicht aufgelistet sind. Für Skills, die in das Verzeichnis .claude/skills/ eines Projekts eingecheckt werden, tritt allowed-tools in Kraft, nachdem Sie den Workspace-Trust-Dialog für diesen Ordner akzeptiert haben, genauso wie Berechtigungsregeln in .claude/settings.json. Überprüfen Sie Projekt-Skills vor dem Vertrauen in ein Repository, da ein Skill sich selbst breiten Tool-Zugriff gewähren kann. Dieser Skill lässt Claude Git-Befehle ohne Genehmigung pro Verwendung ausführen, wenn Sie ihn aufrufen:

---
name: commit
description: Stage and commit the current changes
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *) Bash(git status *)
---

Um einen Skill daran zu hindern, bestimmte Tools zu verwenden, fügen Sie stattdessen Ablehnungsregeln in Ihren Berechtigungseinstellungen hinzu.

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:

Jeder !`<command>` wird sofort ausgeführt (bevor Claude etwas sieht)
Die Ausgabe ersetzt den Platzhalter im Skill-Inhalt
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. Die Substitution wird einmal über die ursprüngliche Datei ausgeführt. Die Befehlsausgabe wird als Klartext eingefügt und wird nicht erneut auf weitere !`<command>` Platzhalter gescannt, sodass ein Befehl keinen Platzhalter für einen späteren Durchgang ausgeben kann. Für mehrzeilige Befehle verwenden Sie einen Codeblock, der mit ```! statt der Inline-Form geöffnet wird:

## Environment
```!
node --version
npm --version
git status --short
```

Um dieses Verhalten für Skills und benutzerdefinierte Befehle aus Benutzer-, Projekt-, Plugin- oder zusätzlichen Verzeichnis-Quellen zu deaktivieren, setzen Sie "disableSkillShellExecution": true in Einstellungen. Jeder Befehl wird stattdessen durch [shell command execution disabled by policy] ersetzt. Gebündelte und verwaltete Skills sind nicht betroffen. Diese Einstellung ist am nützlichsten in verwalteten Einstellungen, wo Benutzer sie nicht überschreiben können.

Um tiefere Überlegungen zu anfordern, wenn ein Skill ausgeführt wird, fügen Sie ultrathink irgendwo im Skill-Inhalt ein. Siehe Verwenden Sie ultrathink für einmalige tiefe Überlegungen.

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:

Ansatz	System-Prompt	Aufgabe	Lädt auch
Skill mit `context: fork`	Vom Agent-Typ (`Explore`, `Plan`, etc.)	SKILL.md-Inhalt	CLAUDE.md
Subagent mit `skills`-Feld	Subagent-Markdown-Body	Claudes Delegationsnachricht	Vorgeladene 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:

Ein neuer isolierter Kontext wird erstellt
Der Subagent erhält den Skill-Inhalt als seinen Prompt („Research $ARGUMENTS thoroughly…”)
Das agent-Feld bestimmt die Ausführungsumgebung (Modell, Tools und Berechtigungen)
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. Einige integrierte Befehle sind auch über das Skill-Tool verfügbar, einschließlich /init, /review und /security-review. Andere integrierte Befehle wie /compact sind nicht 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.

Skill-Sichtbarkeit aus Einstellungen überschreiben

Die skillOverrides-Einstellung steuert die Skill-Sichtbarkeit aus Ihren Einstellungen statt aus dem Frontmatter des Skills selbst. Verwenden Sie sie für Skills, deren SKILL.md Sie nicht bearbeiten möchten, z. B. solche, die in ein gemeinsames Projekt-Repository eingecheckt sind oder von einem MCP-Server bereitgestellt werden. Das /skills-Menü schreibt es für Sie: Markieren Sie einen Skill und drücken Sie Space, um die Zustände zu durchlaufen, dann Enter, um in .claude/settings.local.json zu speichern. Jeder Schlüssel ist ein Skill-Name und jeder Wert ist einer von vier Zuständen:

Wert	Aufgelistet für Claude	Im `/`-Menü
`"on"`	Name und Beschreibung	Ja
`"name-only"`	Nur Name	Ja
`"user-invocable-only"`	Versteckt	Ja
`"off"`	Versteckt	Versteckt

Ein Skill, der in skillOverrides fehlt, wird als "on" behandelt. Das folgende Beispiel reduziert einen Skill auf seinen Namen und deaktiviert einen anderen vollständig:

{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}

Plugin-Skills sind nicht von skillOverrides betroffen. Verwalten Sie diese stattdessen über /plugin.

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

Speichern Sie dies unter ~/.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. Der Script-Pfad verwendet ${CLAUDE_SKILL_DIR}, damit er korrekt aufgelöst wird, unabhängig davon, ob der Skill auf persönlicher, Projekt- oder Plugin-Ebene installiert ist:

---
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(python3 *)
---

# 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
python3 ${CLAUDE_SKILL_DIR}/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

Speichern Sie dies unter ~/.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 3, 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 html import escape
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>📁 {escape(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 esc(s) {{ return s.replace(/[&<>"']/g, c => ({{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}}[c])); }}
    function render(node, parent) {{
      if (node.children) {{
        const det = document.createElement('details');
        det.open = parent === document.getElementById('root');
        det.innerHTML = `<summary><span class="folder">📁 ${{esc(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>${{esc(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:

Überprüfen Sie, ob die Beschreibung Schlüsselwörter enthält, die Benutzer natürlicherweise sagen würden
Überprüfen Sie, ob der Skill in What skills are available? angezeigt wird
Versuchen Sie, Ihre Anfrage umzuformulieren, um die Beschreibung besser zu treffen
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:

Machen Sie die Beschreibung spezifischer
Fügen Sie disable-model-invocation: true hinzu, wenn Sie nur manuelle Aufrufe möchten

Skill-Beschreibungen werden gekürzt

Skill-Beschreibungen werden in den Kontext geladen, damit Claude weiß, was verfügbar ist. Alle Skill-Namen sind immer enthalten, aber wenn Sie viele Skills haben, werden Beschreibungen gekürzt, um in das Zeichenbudget zu passen, was die Schlüsselwörter entfernen kann, die Claude benötigt, um Ihre Anfrage zu erfüllen. Das Budget skaliert bei 1% des Kontextfensters des Modells. Wenn es überläuft, werden Beschreibungen für die Skills, die Sie am wenigsten aufrufen, zuerst gelöscht, sodass die Skills, die Sie tatsächlich verwenden, ihren vollständigen Text behalten. Führen Sie /doctor aus, um zu sehen, ob das Budget überläuft und welche Skills betroffen sind. Um das Budget zu erhöhen, setzen Sie die Einstellung skillListingBudgetFraction (z. B. 0.02 = 2%) oder die Umgebungsvariable SLASH_COMMAND_TOOL_CHAR_BUDGET auf eine feste Zeichenanzahl. Um Budget für andere Skills freizugeben, setzen Sie Einträge mit niedriger Priorität auf "name-only" in skillOverrides, damit sie ohne Beschreibung aufgelistet werden. Sie können auch den Text description und when_to_use an der Quelle kürzen: Stellen Sie den wichtigsten Anwendungsfall an den Anfang, da der kombinierte Text jedes Eintrags unabhängig vom Budget auf 1.536 Zeichen begrenzt ist. Die Obergrenze ist mit maxSkillDescriptionChars konfigurierbar.

Agenten und parallele Arbeit

Werkzeuge und Plugins

Automatisierung

Fehlerbehebung

Gebündelte Skills

Erste Schritte

Erstellen Sie Ihren ersten Skill

Wo Skills leben

Live-Änderungserkennung

Automatische Erkennung aus übergeordneten und verschachtelten Verzeichnissen

Skills aus zusätzlichen Verzeichnissen

Skills konfigurieren

Arten von Skill-Inhalten

Frontmatter-Referenz

Verfügbare String-Substitutionen

Unterstützende Dateien hinzufügen

Steuern Sie, wer einen Skill aufruft

Skill-Inhalts-Lebenszyklus

Tools für einen Skill vorab genehmigen

Argumente an Skills übergeben

Fortgeschrittene Muster

Dynamischen Kontext einspritzen

Skills in einem Subagent ausführen

Beispiel: Research-Skill mit Explore-Agent

Beschränken Sie Claudes Skill-Zugriff

Skill-Sichtbarkeit aus Einstellungen überschreiben

Skills teilen

Visuelle Ausgabe generieren

Fehlerbehebung

Skill wird nicht ausgelöst

Skill wird zu oft ausgelöst

Skill-Beschreibungen werden gekürzt

Verwandte Ressourcen

Agenten und parallele Arbeit

Werkzeuge und Plugins

Automatisierung

Fehlerbehebung

Documentation Index

​Gebündelte Skills

​Erste Schritte

​Erstellen Sie Ihren ersten Skill

​Wo Skills leben

​Live-Änderungserkennung

​Automatische Erkennung aus übergeordneten und verschachtelten Verzeichnissen

​Skills aus zusätzlichen Verzeichnissen

​Skills konfigurieren

​Arten von Skill-Inhalten

​Frontmatter-Referenz

​Verfügbare String-Substitutionen

​Unterstützende Dateien hinzufügen

​Steuern Sie, wer einen Skill aufruft

​Skill-Inhalts-Lebenszyklus

​Tools für einen Skill vorab genehmigen

​Argumente an Skills übergeben

​Fortgeschrittene Muster

​Dynamischen Kontext einspritzen

​Skills in einem Subagent ausführen

​Beispiel: Research-Skill mit Explore-Agent

​Beschränken Sie Claudes Skill-Zugriff

​Skill-Sichtbarkeit aus Einstellungen überschreiben

​Skills teilen

​Visuelle Ausgabe generieren

​Fehlerbehebung

​Skill wird nicht ausgelöst

​Skill wird zu oft ausgelöst

​Skill-Beschreibungen werden gekürzt

​Verwandte Ressourcen

Gebündelte Skills

Erste Schritte

Erstellen Sie Ihren ersten Skill

Wo Skills leben

Live-Änderungserkennung

Automatische Erkennung aus übergeordneten und verschachtelten Verzeichnissen

Skills aus zusätzlichen Verzeichnissen

Skills konfigurieren

Arten von Skill-Inhalten

Frontmatter-Referenz

Verfügbare String-Substitutionen

Unterstützende Dateien hinzufügen

Steuern Sie, wer einen Skill aufruft

Skill-Inhalts-Lebenszyklus

Tools für einen Skill vorab genehmigen

Argumente an Skills übergeben

Fortgeschrittene Muster

Dynamischen Kontext einspritzen

Skills in einem Subagent ausführen

Beispiel: Research-Skill mit Explore-Agent

Beschränken Sie Claudes Skill-Zugriff

Skill-Sichtbarkeit aus Einstellungen überschreiben

Skills teilen

Visuelle Ausgabe generieren

Fehlerbehebung

Skill wird nicht ausgelöst

Skill wird zu oft ausgelöst

Skill-Beschreibungen werden gekürzt

Verwandte Ressourcen