4 4 

5# Claude mit Skills erweitern5# Claude mit Skills erweitern

6 6 

7> Erstellen, verwalten und teilen Sie Skills, um Claudes Funktionen in Claude Code zu erweitern. Umfasst benutzerdefinierte Befehle und gebündelte Skills.7> Erstellen, verwalten und teilen Sie Skills, um die Funktionen von Claude in Claude Code zu erweitern. Umfasst benutzerdefinierte Befehle und gebündelte Skills.

8 8 

9Skills 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.9Skills erweitern die Möglichkeiten von Claude. 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.

10 10 

11Erstellen 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.11Erstellen Sie einen Skill, wenn Sie dieselben Anweisungen, Checklisten oder mehrstufige Verfahren immer wieder 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 Text eines Skills nur geladen, wenn er verwendet wird, sodass umfangreiches Referenzmaterial fast nichts kostet, bis Sie es benötigen.

12 12 

13<Note>13<Note>

14 Für integrierte Befehle wie `/help` und `/compact` sowie gebündelte Skills wie `/debug` und `/code-review` siehe die [Befehlsreferenz](/docs/de/commands).14 Informationen zu integrierten Befehlen wie `/help` und `/compact` sowie zu gebündelten Skills wie `/debug` und `/code-review` finden Sie in der [Befehlsreferenz](/docs/de/commands).

15 15 

16 **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](#control-who-invokes-a-skill), und die Möglichkeit für Claude, sie automatisch zu laden, wenn sie relevant sind.16 **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 bieten optionale Funktionen: ein Verzeichnis für unterstützende Dateien, Frontmatter zur [Kontrolle, ob Sie oder Claude sie aufrufen](#control-who-invokes-a-skill), und die Möglichkeit für Claude, sie automatisch zu laden, wenn sie relevant sind.

17</Note>17</Note>

18 18 

19Claude Code Skills folgen dem [Agent Skills](https://agentskills.io) offenen Standard, der über mehrere KI-Tools funktioniert. Claude Code erweitert den Standard mit zusätzlichen Funktionen wie [Invocation Control](#control-who-invokes-a-skill), [Subagent-Ausführung](#run-skills-in-a-subagent) und [dynamischer Kontexteinspritzung](#inject-dynamic-context).19Claude Code Skills folgen dem [Agent Skills](https://agentskills.io) offenen Standard, der über mehrere KI-Tools hinweg funktioniert. Claude Code erweitert den Standard um zusätzliche Funktionen wie [Aufrufersteuerung](#control-who-invokes-a-skill), [Subagent-Ausführung](#run-skills-in-a-subagent) und [dynamische Kontexteinspeisung](#inject-dynamic-context). Siehe [Verwendung von Skill-Frontmatter außerhalb von Claude Code](#using-skill-frontmatter-outside-claude-code) für die Frontmatter-Felder, die Teil des Standards sind, und welche Claude Code-Erweiterungen sind.

20 20 

21<h2 id="bundled-skills">21<h2 id="bundled-skills">

22 Gebündelte Skills22 Gebündelte Skills

23</h2>23</h2>

24 24 

25Claude Code wird mit einer Reihe von gebündelten Skills ausgeliefert, die in jeder Sitzung verfügbar sind, sofern sie nicht mit der Einstellung [`disableBundledSkills`](/docs/de/settings#available-settings) deaktiviert werden, einschließlich `/doctor`, `/code-review`, `/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.25Claude Code enthält eine Reihe von gebündelten Skills wie `/doctor`, `/code-review`, `/batch`, `/debug`, `/loop` und `/claude-api`. Gebündelte Skills sind prompt-basiert: Sie geben Claude detaillierte Anweisungen und ermöglichen es ihm, die Arbeit mit seinen Tools zu orchestrieren. Die meisten integrierten Befehle führen stattdessen direkt eine feste Logik aus.

26 26 

27Die [`/doctor`](/docs/de/commands#all-commands) Setup-Überprüfung ist die eine Ausnahme zu `disableBundledSkills` in Claude Code v2.1.205 und später: Sie bleibt eingabbar, wenn die Einstellung aktiviert ist. Um sie auszublenden, setzen Sie die Umgebungsvariable `DISABLE_DOCTOR_COMMAND` oder einen [`skillOverrides`](#override-skill-visibility-from-settings) Eintrag von `"doctor": "off"`. Vor v2.1.205 war `/doctor` ein integrierter Befehl und kein gebündelter Skill.27Sie rufen einen gebündelten Skill auf die gleiche Weise auf wie jeden anderen Skill, indem Sie `/` gefolgt vom Skill-Namen eingeben. Claude ruft einige gebündelte Skills automatisch auf, wenn sie relevant sind; andere, einschließlich `/verify`, werden nur ausgeführt, wenn Sie sie aufrufen, was Ihnen die Kontrolle darüber gibt, wann diese längeren Überprüfungen Zeit und Token aufwenden.

28 28 

29Gebündelte Skills sind in der [Befehlsreferenz](/docs/de/commands) neben integrierten Befehlen aufgelistet und mit **Skill** in der Spalte „Zweck" gekennzeichnet.29Die meisten gebündelten Skills sind in jeder Sitzung verfügbar. Einige hängen von einer bestimmten Funktion ab: `/workflow-authoring` ist beispielsweise nur verfügbar, wenn [dynamische Workflows](/docs/de/workflows) aktiviert sind.

30 

31Um gebündelte Skills auszuschalten, verwenden Sie die Einstellung [`disableBundledSkills`](/docs/de/settings-reference#disablebundledskills), die jeden gebündelten Skill außer `/doctor` deaktiviert.

32 

33<Note>

34 Die Einrichtungsüberprüfung [`/doctor`](/docs/de/commands#all-commands) bleibt eingabbar, wenn `disableBundledSkills` aktiviert ist, in Claude Code v2.1.205 und später. Um sie auszublenden, setzen Sie die Umgebungsvariable `DISABLE_DOCTOR_COMMAND` oder einen [`skillOverrides`](#override-skill-visibility-from-settings)-Eintrag von `"doctor": "off"`. Vor v2.1.205 war `/doctor` ein integrierter Befehl und kein gebündelter Skill.

35</Note>

36 

37Gebündelte Skills werden zusammen mit integrierten Befehlen in der [Befehlsreferenz](/docs/de/commands) aufgelistet, gekennzeichnet mit **Skill** in der Spalte „Zweck".

30 38 

31<h3 id="run-and-verify-your-app">39<h3 id="run-and-verify-your-app">

32 Ihre App ausführen und überprüfen40 Führen Sie Ihre App aus und überprüfen Sie sie

33</h3>41</h3>

34 42 

35Drei gebündelte Skills arbeiten zusammen, um Ihre App zu starten und Änderungen gegen die laufende App zu bestätigen, anstatt nur Tests durchzuführen:43Drei gebündelte Skills arbeiten zusammen, um Ihre App zu starten und Änderungen gegen die laufende App zu bestätigen, anstatt nur gegen Tests:

36 44 

37| Skill | Zweck |45| Skill | Zweck |

38| :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ |46| :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------- |

39| `/run` | Starten und steuern Sie Ihre App, um eine Änderung in Aktion zu sehen |47| `/run` | Starten und steuern Sie Ihre App, um eine Änderung in Aktion zu sehen |

40| `/verify` | Erstellen und führen Sie Ihre App aus, um zu bestätigen, dass eine Codeänderung das tut, was sie soll, ohne auf Tests oder Typprüfungen zurückzugreifen |48| `/verify` | Erstellen und führen Sie Ihre App aus, um zu bestätigen, dass eine Codeänderung das tut, was sie soll, ohne auf Tests oder Typüberprüfungen zurückzugreifen |

41| `/run-skill-generator` | Lehren Sie `/run` und `/verify`, wie Sie Ihr Projekt erstellen und starten |49| `/run-skill-generator` | Lehren Sie `/run` und `/verify`, wie Sie Ihr Projekt erstellen und starten |

42 50 

43Alle drei Skills erfordern Claude Code v2.1.145 oder später.51`/run` und `/verify` funktionieren ohne Einrichtung. Sie leiten den Start von Ihrem Projekttyp ab (CLI, Server, TUI, Browser-gesteuert) und von dem, was sich in Ihrer README, `package.json` oder `Makefile` befindet. Diese Ableitung wird unzuverlässig für Projekte, die mehr als einen Standard-Start benötigen: eine Datenbank, eine Env-Datei, eine grafische Sitzung, einen mehrstufigen Build.

44 

45`/run` und `/verify` funktionieren ohne Einrichtung. Sie leiten den Start von Ihrem Projekttyp ab (CLI, Server, TUI, browsergesteuert) und von dem, was sich in Ihrer README, `package.json` oder `Makefile` befindet. Diese Ableitung wird unzuverlässig für Projekte, die mehr als einen Standard-Start benötigen: eine Datenbank, eine Env-Datei, eine grafische Sitzung, einen mehrstufigen Build.

46 52 

47`/run-skill-generator` zeichnet stattdessen das Rezept auf. Es bringt Ihre App aus einer sauberen Umgebung zum Laufen, erfasst, was funktioniert hat (die Installationsbefehle, die Umgebungsvariablen, das Startskript), und speichert es als projektspezifischen Skill unter `.claude/skills/run-<name>/`. Danach folgen `/run`, `/verify` und alle anderen Agenten im Repository dem aufgezeichneten Rezept, anstatt es neu zu entdecken. Führen Sie `/run-skill-generator` einmal pro Projekt aus, und erneut, wenn sich der Build- oder Startprozess ändert.53`/run-skill-generator` zeichnet stattdessen das Rezept auf. Es bringt Ihre App aus einer sauberen Umgebung zum Laufen, erfasst, was funktioniert hat (die Installationsbefehle, die Umgebungsvariablen, das Startskript), und speichert es als projektspezifischen Skill unter `.claude/skills/run-<name>/`. Danach folgen `/run`, `/verify` und alle anderen Agenten im Repository dem aufgezeichneten Rezept, anstatt es neu zu entdecken. Führen Sie `/run-skill-generator` einmal pro Projekt aus, und erneut, wenn sich der Build- oder Startprozess ändert.

48 54 

55`/verify` kann auch sein eigenes Rezept aufzeichnen. Wenn es Ihre App ohne ein aufgezeichnetes Rezept erstellen und steuern muss, schreibt es, was funktioniert hat, in `.claude/skills/verify/SKILL.md` im Repository-Root oder im betroffenen Paketverzeichnis in einem Monorepo, damit spätere Läufe und andere Agenten die gleichen Schritte befolgen. Im Repository-Root ersetzt das aufgezeichnete Skill den gebündelten `/verify`. Dies erfordert Claude Code v2.1.200 oder später.

56 

57Claude bearbeitet die aufgezeichnete Datei nur, wenn es einen Lauf falsch gesteuert hat, z. B. einen Befehl, der fehlgeschlagen ist, oder einen fehlenden Schritt, damit Sie die Datei ohne sitzungsspezifische Diffs committen können. Vor v2.1.205 sagte der gebündelte Skill Claude, dass es alles einbeziehen sollte, was ein Lauf gelernt hat, was häufige Merge-Konflikte verursachte.

58 

49<h2 id="getting-started">59<h2 id="getting-started">

50 Erste Schritte60 Erste Schritte

51</h2>61</h2>

52 62 

53<h3 id="create-your-first-skill">63<h3 id="create-your-first-skill">

54 Erstellen Sie Ihren ersten Skill64 Erstellen Sie Ihre erste Skill

55</h3>65</h3>

56 66 

57Dieses 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.67Dieses Beispiel erstellt eine Skill, die die nicht committeten Änderungen in Ihrem Git-Repository zusammenfasst und alles Riskante kennzeichnet. Sie zieht den Live-Diff in den Prompt, bevor Claude ihn liest, sodass die Antwort in Ihrem tatsächlichen Arbeitsbaum verankert ist, anstatt auf dem, was Claude aus offenen Dateien erraten kann. Claude lädt die Skill automatisch, wenn Sie nach Ihren Änderungen fragen, oder Sie können sie direkt mit `/summarize-changes` aufrufen.

58 68 

59<Steps>69<Steps>

60 <Step title="Erstellen Sie das Skill-Verzeichnis">70 <Step title="Erstellen Sie das Skill-Verzeichnis">

61 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.71 Erstellen Sie ein Verzeichnis für die Skill in Ihrem persönlichen Skills-Ordner. Persönliche Skills sind in allen Ihren Projekten verfügbar.

62 72 

63 ```bash theme={null}73 ```bash theme={null}

64 mkdir -p ~/.claude/skills/summarize-changes74 mkdir -p ~/.claude/skills/summarize-changes

66 </Step>76 </Step>

67 77 

68 <Step title="Schreiben Sie SKILL.md">78 <Step title="Schreiben Sie SKILL.md">

69 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.79 Jede Skill benötigt eine `SKILL.md`-Datei mit zwei Teilen: YAML-Frontmatter zwischen `---`-Markierungen, das Claude mitteilt, wann die Skill verwendet werden soll, und Markdown-Inhalt mit den Anweisungen, die Claude befolgt, wenn die Skill ausgeführt wird. Der Verzeichnisname wird zum Befehl, den Sie eingeben, und die `description` hilft Claude zu entscheiden, wann die Skill automatisch geladen werden soll.

70 80 

71 Speichern Sie dies unter `~/.claude/skills/summarize-changes/SKILL.md`:81 Speichern Sie dies unter `~/.claude/skills/summarize-changes/SKILL.md`:

72 82 

73 ```yaml theme={null}83 ```yaml theme={null}

74 ---84 ---

75 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.85 description: Fasst nicht committete Änderungen zusammen und kennzeichnet alles Riskante. Verwenden Sie dies, wenn der Benutzer fragt, was sich geändert hat, eine Commit-Nachricht möchte oder seinen Diff überprüfen möchte.

76 ---86 ---

77 87 

78 ## Current changes88 ## Aktuelle Änderungen

79 89 

80 !`git diff HEAD`90 !`git diff HEAD`

81 91 

82 ## Instructions92 ## Anweisungen

83 93 

84 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.94 Fassen Sie die obigen Änderungen in zwei oder drei Aufzählungspunkten zusammen, listen Sie dann alle Risiken auf, die Sie bemerken, wie fehlende Fehlerbehandlung, hartcodierte Werte oder Tests, die aktualisiert werden müssen. Wenn der Diff leer ist, sagen Sie, dass es keine nicht committeten Änderungen gibt.

85 ```95 ```

86 96 

87 Die Zeile `` !`git diff HEAD` `` verwendet [dynamische Kontextinjektion](#inject-dynamic-context): 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.97 Die Zeile `` !`git diff HEAD` `` verwendet [dynamische Kontextinjektion](#inject-dynamic-context): Claude Code führt den Befehl aus und ersetzt die Zeile durch seine Ausgabe, bevor Claude den Skill-Inhalt sieht, sodass die Anweisungen mit dem aktuellen Diff bereits inline ankommen.

88 </Step>98 </Step>

89 99 

90 <Step title="Testen Sie den Skill">100 <Step title="Testen Sie die Skill">

91 Ö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.101 Ö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 die Skill auf zwei Arten testen.

92 102 

93 **Lassen Sie Claude ihn automatisch aufrufen**, indem Sie etwas eingeben, das der Beschreibung entspricht:103 **Lassen Sie Claude sie automatisch aufrufen**, indem Sie etwas eingeben, das der Beschreibung entspricht:

94 104 

95 ```text theme={null}105 ```text theme={null}

96 What did I change?106 What did I change?

97 ```107 ```

98 108 

99 **Oder rufen Sie ihn direkt auf** mit dem Skill-Namen:109 **Oder rufen Sie sie direkt auf** mit dem Skill-Namen:

100 110 

101 ```text theme={null}111 ```text theme={null}

102 /summarize-changes112 /summarize-changes

106 </Step>116 </Step>

107</Steps>117</Steps>

108 118 

109<h3 id="where-skills-live">119<h2 id="where-skills-live">

110 Wo Skills leben120 Wählen Sie, wo Skills geladen werden

121</h2>

122 

123Wo Sie einen Skill speichern, entscheidet, welche Sessions ihn laden. Speichern Sie ihn in Ihrem Home-Verzeichnis, um ihn in jedem Projekt zu erhalten, committen Sie ihn in ein Repository, um ihn mit allen zu teilen, die dort arbeiten, oder verteilen Sie ihn über ein Plugin oder verwaltete Einstellungen, um ein ganzes Team zu erreichen.

124 

125| Speicherort | Pfad | Wird geladen in |

126| :----------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

127| Enterprise | `.claude/skills/<skill-name>/SKILL.md` im [Verzeichnis für verwaltete Einstellungen](/docs/de/managed-settings#delivery-mechanisms) | Alle Benutzer auf Maschinen, auf denen Ihre Organisation es bereitstellt |

128| Persönlich | `~/.claude/skills/<skill-name>/SKILL.md` | Alle Ihre Projekte auf dieser Maschine, aber nicht [Cowork- oder Cloud-Sessions](#skills-in-cowork-and-cloud-sessions) |

129| Projekt | `.claude/skills/<skill-name>/SKILL.md` | Sessions in diesem Repository. Committen Sie es, damit Ihr Team es auch erhält |

130| Verschachtelt | `<subdir>/.claude/skills/<skill-name>/SKILL.md` | Sessions, die in oder unter `<subdir>` gestartet werden. Eine Session, die darüber gestartet wird, lädt den Skill, sobald Claude an Dateien dort arbeitet. Siehe [Monorepos und Unterverzeichnisse](#discovery-from-parent-and-nested-directories) |

131| Zusätzliches Verzeichnis | `.claude/skills/<skill-name>/SKILL.md` in einem Verzeichnis, das Sie mit `--add-dir` übergeben | Diese Session. Siehe [Verzeichnisse außerhalb des Projekts](#skills-from-additional-directories) |

132| Plugin | `<plugin>/skills/<skill-name>/SKILL.md` | Überall dort, wo das [Plugin](/docs/de/plugins) aktiviert ist, als `/plugin-name:skill-name` |

133| claude.ai-Konto | Skills, die Sie in Ihren claude.ai-Einstellungen aktivieren | Cowork- und Cloud-Sessions. Siehe [Skills, die von claude.ai synchronisiert werden](#how-synced-skills-behave) für lokale Sessions |

134 

135Skill-Ordner folgen auch diesen Regeln:

136 

137* **Symverlinkte Ordner**: Ein `<skill-name>`-Eintrag am Enterprise-, Personal- oder Projekt-Speicherort kann ein Symlink zu einem Verzeichnis an anderer Stelle auf der Festplatte sein. Claude Code liest `SKILL.md` aus dem Ziel und lädt den Skill einmal, auch wenn mehrere Speicherorte auf dasselbe Ziel verweisen. Plugin-Skills [handhaben Symlinks anders](/docs/de/plugins-reference#share-files-within-a-marketplace-with-symlinks).

138* **Reservierter Name**: Benennen Sie einen Skill-Ordner nicht `synced`, in keiner Schreibweise. Claude Code verwendet `~/.claude/skills/synced/` für [Skills, die von claude.ai heruntergeladen werden](#where-synced-skills-load) und überspringt einen Skill, den Sie unter diesem Namen am Enterprise-, Personal- und Projekt-Speicherort erstellen.

139* **Befehlsdateien**: Eine Markdown-Datei in `.claude/commands/` ist das ältere Format und funktioniert immer noch. Sie unterstützt dieselbe [Frontmatter](#frontmatter-reference) außer `name` und `paths`, und Sie rufen sie nach ihrem Dateinamen auf. Bevorzugen Sie einen Skill für neue Arbeiten, da Skills auch [unterstützende Dateien](#add-supporting-files) unterstützen.

140* **Skill-Ordner als Plugin**: Fügen Sie eine `.claude-plugin/plugin.json` zu einem Skill-Ordner hinzu und er wird als [Plugin](/docs/de/plugins-reference#skills-directory-plugins) mit dem Namen `<name>@skills-dir` geladen, sodass er Agents, Hooks und MCP-Server bündeln kann. In einem Projekt's `.claude/skills/` ist dies erforderlich, um zuerst den Workspace-Trust-Dialog zu akzeptieren.

141 

142<h3 id="discovery-from-parent-and-nested-directories">

143 Skills in Monorepos und Unterverzeichnissen laden

144</h3>

145 

146Claude Code lädt Projekt-Skills aus `.claude/skills/` in dem Verzeichnis, in dem Sie ihn starten, und in jedem übergeordneten Verzeichnis bis zur Repository-Root, sodass das Starten in `packages/frontend/` immer noch Skills aufgreift, die in der Root definiert sind. Wenn Sie [die Session mit `/cd` verschieben](/docs/de/permissions#move-the-session-to-another-directory) auf v2.1.246 oder später, fügt Claude Code die Projekt-Skills des neuen Verzeichnisses hinzu.

147 

148Skills in einem `.claude/skills/`-Verzeichnis unterhalb des Ortes, an dem Sie gestartet haben, werden beim Start nicht geladen. Sie werden beim ersten Mal geladen, wenn Claude eine Datei in diesem Unterverzeichnis liest oder bearbeitet, und bleiben für den Rest der Session verfügbar. Bis dahin erscheinen sie nicht im `/`-Menü und Sie können sie nicht nach Name aufrufen. Um sie früher zu laden, führen Sie `/add-dir` mit dem Pfad des Unterverzeichnisses aus, was Claude Code v2.1.257 oder später erfordert.

149 

150Wenn ein verschachtelter Skill denselben Namen wie ein anderer Skill hat, bleiben beide verfügbar. Mit einem `deploy`-Skill in der Repository-Root und einem anderen in `apps/web/.claude/skills/`:

151 

152* `/deploy` führt den Root-Skill aus. Claude Code listet auch die verzeichnisqualifizierten Varianten für Claude auf, mit einer Anweisung, denjenigen aufzurufen, dessen Verzeichnis die Dateien enthält, an denen es arbeitet, sodass der verschachtelte Skill immer noch auf Arbeiten in `apps/web/` angewendet wird.

153* `/apps/web:deploy` führt den verschachtelten Skill eigenständig aus. Seine Beschreibung benennt das Verzeichnis, auf das es angewendet wird.

154 

155<h3 id="skills-from-additional-directories">

156 Skills aus einem Verzeichnis außerhalb des Projekts laden

111</h3>157</h3>

112 158 

113Wo Sie einen Skill speichern, bestimmt, wer ihn verwenden kann:159Wenn Sie ein Verzeichnis mit `--add-dir` oder `/add-dir` hinzufügen, lädt Claude Code die Skills in `.claude/skills/` dieses Verzeichnisses zusammen mit `.claude/commands/` und `.claude/agents/`. Verzeichnisse, die das Agent SDK durch [`additionalDirectories`](/docs/de/agent-sdk/typescript#options) in TypeScript oder [`add_dirs`](/docs/de/agent-sdk/python#claudeagentoptions) in Python hinzufügt, werden auf die gleiche Weise geladen, da das SDK sie als `--add-dir` übergibt. Die `permissions.additionalDirectories`-Einstellung in `settings.json` gewährt nur Dateizugriff und lädt keine dieser.

114 160 

115| Ort | Pfad | Gilt für |161Claude Code überwacht `.claude/skills/` in einem Verzeichnis, das Sie mit `--add-dir` beim Start übergeben, wie [Bearbeiten Sie einen Skill während einer Session](#live-change-detection) beschreibt. Es überwacht nicht das `.claude/commands/` oder `.claude/agents/` des hinzugefügten Verzeichnisses, daher starten Sie die Session nach dem Ändern einer Datei dort neu.

116| :---------- | :------------------------------------------------------------ | :---------------------------------- |

117| Unternehmen | Siehe [verwaltete Einstellungen](/docs/de/settings#settings-files) | Alle Benutzer in Ihrer Organisation |

118| Persönlich | `~/.claude/skills/<skill-name>/SKILL.md` | Alle Ihre Projekte |

119| Projekt | `.claude/skills/<skill-name>/SKILL.md` | Nur dieses Projekt |

120| Plugin | `<plugin>/skills/<skill-name>/SKILL.md` | Wo das Plugin aktiviert ist |

121 162 

122Wenn Skills auf verschiedenen Ebenen denselben Namen haben, gewinnt Unternehmen gegenüber Persönlich, und Persönlich gewinnt gegenüber Projekt. Ein Skill auf jeder dieser Ebenen setzt auch einen gebündelten Skill mit demselben Namen außer Kraft. Beispielsweise ersetzt ein `code-review`-Skill in Ihrem Projekt `.claude/skills/` den gebündelten `/code-review`. 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.163Diese Ladevorgänge hängen von der `project`-[Einstellungsquelle](/docs/de/agent-sdk/claude-code-features#control-filesystem-settings-with-settingsources) ab, die standardmäßig aktiviert ist. Eine [`strictPluginOnlyCustomization`](/docs/de/settings-reference#strictpluginonlycustomization)-Richtlinie, [Bare Mode](/docs/de/headless#start-faster-with-bare-mode) und [`--safe-mode`](/docs/de/cli-reference#cli-flags) beschränken sie weiter, wie diese Seiten beschreiben. Siehe [Zusätzliche Verzeichnisse gewähren Dateizugriff, keine Konfiguration](/docs/de/permissions#additional-directories-grant-file-access-not-configuration) für die vollständige Tabelle, was ein hinzugefügtes Verzeichnis lädt, einschließlich `CLAUDE.md` und Plugin-Einstellungen.

123 164 

124Skills werden auch aus verschachtelten `.claude/skills/`-Verzeichnissen unter Ihrem Arbeitsverzeichnis geladen. Wenn Claude eine Datei in einem Unterverzeichnis liest oder bearbeitet, werden Skills aus dem `.claude/skills/` dieses Unterverzeichnisses verfügbar. Dies ermöglicht es einem Monorepo-Paket, seine eigenen Skills bereitzustellen, die beim Arbeiten an diesem Paket gelten, auch wenn die Sitzung in der Repository-Root gestartet wurde.165<h3 id="resolve-skills-that-share-a-name">

166 Lösen Sie Skills auf, die denselben Namen haben

167</h3>

125 168 

126Wenn ein verschachtelter Skill denselben Namen wie ein anderer Skill hat, bleiben beide verfügbar. Beispielsweise mit einem `deploy`-Skill in der Projekt-Root und einem anderen in `apps/web/.claude/skills/`:169Wenn zwei Skills denselben Namen haben, entscheidet, woher jeder kommt, welcher `/name` ausführt. Die Tabelle behandelt die Enterprise-, Personal-, Projekt-, verschachtelte, Plugin- und claude.ai-Speicherorte, gebündelte Skills und Befehlsdateien:

127 170 

128* Der verschachtelte wird unter einem verzeichnisqualifizierten Namen angezeigt, `apps/web:deploy`.171| Gleicher Name in | Welcher wird ausgeführt |

129* Seine Beschreibung sagt, auf welches Verzeichnis er sich bezieht.172| :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

130* Claude wählt die Variante, die zu den Dateien passt, an denen er arbeitet.173| Zwei von Enterprise, Personal und Projekt | Enterprise über Personal, und Personal über Projekt. Mit `deploy` in beiden `~/.claude/skills/` und `.claude/skills/` des Projekts führt `/deploy` den persönlichen aus |

174| Einer dieser Speicherorte und ein [gebündelter Skill](#bundled-skills) | Ihr Skill ersetzt den gebündelten Befehl, aber nicht seine Aliase. Ein Projekt-`code-review`-Skill ersetzt `/code-review`, und der gebündelte Alias `/review` führt Ihren Skill nie aus |

175| Ein Skill und eine Datei in `.claude/commands/` | Der Skill |

176| Ein Projekt-Root-Skill und ein verschachtelter Skill | Beide werden geladen. Siehe [Monorepos und Unterverzeichnisse](#discovery-from-parent-and-nested-directories) |

177| Ein Plugin-Skill und ein Skill an einem der obigen Speicherorte | Beide werden geladen, da Plugin-Skills als `/plugin-name:skill-name` namensgebunden sind |

178| Einer der obigen und ein von claude.ai synchronisierter Skill | Der andere Skill oder Befehl. Siehe [Wenn ein synchronisierter Skill-Name mit einem anderen Befehl übereinstimmt](#when-a-synced-skill-name-matches-another-command) |

131 179 

132Wenn Sie `/deploy` eingeben, wird der Skill in der Projekt-Root ausgeführt. Geben Sie den qualifizierten Namen `/apps/web:deploy` ein, um die verschachtelte Variante explizit auszuführen.180<h3 id="skills-in-cowork-and-cloud-sessions">

181 Verwenden Sie Skills in Cowork- und Cloud-Sessions

182</h3>

133 183 

134Wenn Sie oder Claude den unqualifizierten Namen aufrufen, wird der Skill in der Projekt-Root geladen, und Claude Code fügt eine Liste der verzeichnisqualifizierten Varianten zu seinem Inhalt mit einer Anweisung hinzu, auch jede Variante aufzurufen, deren Verzeichnis die Dateien enthält, an denen Claude arbeitet. Ein verschachtelter Skill gilt daher immer noch für die Arbeit in seinem Verzeichnis, wenn nur der unqualifizierte Name aufgerufen wird. Erfordert Claude Code v2.1.203 oder später.184[Cowork](https://claude.com/product/cowork)-Sessions und [Cloud-Sessions](/docs/de/cloud-environments#what-carries-over-from-your-setup), einschließlich [Routinen](/docs/de/routines), lesen nicht `~/.claude/skills/` auf Ihrer Maschine. Sowohl interaktive als auch geplante Cowork-Sessions laden die Skills, die für Ihr claude.ai-Konto aktiviert sind, synchronisiert beim Session-Start; verwalten Sie sie über **Customize** in der Desktop-App-Seitenleiste oder in den Skill-Einstellungen auf claude.ai. Cloud-Sessions laden zusätzlich Projekt-Skills, die in `.claude/skills/` des geklonten Repositorys committet sind.

135 185 

136Ein `<skill-name>`-Eintrag an den Standorten Unternehmen, Persönlich oder Projekt kann ein Symlink zu einem Verzeichnis an anderer Stelle auf der Festplatte sein. Claude Code folgt dem Symlink und liest `SKILL.md` aus dem Zielverzeichnis, und wenn dasselbe Ziel von mehr als einem Ort aus erreichbar ist, lädt Claude Code den Skill einmal. Plugin-Skills handhaben Symlinks anders; siehe [Dateien in einem Marketplace mit Symlinks teilen](/docs/de/plugins-reference#share-files-within-a-marketplace-with-symlinks).186Wenn ein Skill nur in `~/.claude/skills/` auf Ihrer Maschine vorhanden ist, meldet Claude Code, dass der Skill nicht gefunden wurde, wenn eine [Routine](/docs/de/routines) ihn aufruft, da jede Routine-Ausführung als frische Remote-Session startet. Um einen persönlichen Skill in diesen Sessions verfügbar zu machen:

137 187 

138<Note>188* Für Cowork- und Cloud-Sessions aktivieren Sie den Skill für Ihr claude.ai-Konto.

139 Fügen Sie eine `.claude-plugin/plugin.json` zu einem Skill-Ordner hinzu und er wird als [Plugin](/docs/de/plugins-reference#skills-directory-plugins) mit dem Namen `<name>@skills-dir` geladen, sodass er Agenten, hooks und MCP-Server bündeln kann. In einem Projekt `.claude/skills/` ist dies erforderlich, um zuerst das Workspace-Trust-Dialogfeld zu akzeptieren.189* Für Cloud-Sessions können Sie den Skill stattdessen in `.claude/skills/` des Repositorys committen oder ihn in einem Plugin versenden, das in `.claude/settings.json` des Repositorys deklariert ist. Im Repo deklarierte Plugins [installieren beim Session-Start](/docs/de/cloud-environments#what-carries-over-from-your-setup); Plugins, die nur in Ihren Benutzereinstellungen aktiviert sind, werden nicht übertragen.

140</Note>190 

191[Desktop-geplante Aufgaben](/docs/de/desktop-scheduled-tasks) werden lokal auf Ihrer Maschine ausgeführt, daher laden sie `~/.claude/skills/`.

192 

193<h3 id="how-synced-skills-behave">

194 Skills, die von claude.ai synchronisiert werden

195</h3>

141 196 

142<h4 id="live-change-detection">197Dieser Abschnitt gilt für Sie, wenn Sie Skills für Ihr claude.ai-Konto aktiviert haben. In Cowork- und Cloud-Sessions lädt Claude Code diese Skills ohne Setup auf Ihrer Maschine. In jeder anderen Session auf Ihrer Maschine lädt Claude Code sie nur, nachdem Sie die Synchronisierung mit [`CLAUDE_CODE_SYNC_SKILLS`](/docs/de/env-vars#variables) in einem nicht-interaktiven Lauf aktivieren, wie [Wo synchronisierte Skills geladen werden](#where-synced-skills-load) beschreibt.

143 Live-Änderungserkennung198 

199Claude Code lädt einen synchronisierten Skill von Ihrem Konto herunter, anstatt eine Datei zu lesen, die Sie auf der Maschine geschrieben haben, auf der die Session läuft, daher wendet es Regeln auf synchronisierte Skills an, die nicht auf die Skills angewendet werden, die Sie in den [Skill-Speicherorten](#where-skills-live) speichern.

200 

201<h4 id="where-synced-skills-load">

202 Wo synchronisierte Skills geladen werden

144</h4>203</h4>

145 204 

146Claude 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.205In einer Cowork- oder Cloud-Session lädt Claude Code die Skills, die für Ihr claude.ai-Konto aktiviert sind, und [Skills in Cowork- und Cloud-Sessions](#skills-in-cowork-and-cloud-sessions) sagt, wie Sie wählen, welche Skills diese Sessions erhalten.

147 206 

148<Note>207In jeder anderen Session auf Ihrer Maschine lädt Claude Code sie nur, nachdem Sie sie einmal in einem nicht-interaktiven Lauf heruntergeladen haben:

149 Die Live-Änderungserkennung umfasst nur `SKILL.md`-Text. Für einen Skill-Ordner, der auch ein [Plugin](/docs/de/plugins-reference#skills-directory-plugins) ist, benötigen Änderungen an `hooks/`, `.mcp.json`, `agents/` und `output-styles/` `/reload-plugins`, um wirksam zu werden.208 

150</Note>209<Steps>

210 <Step title="Aktivieren Sie die Skills für Ihr claude.ai-Konto">

211 Aktivieren Sie jeden Skill, den Sie für Ihr claude.ai-Konto möchten, wie [Skills in Cowork- und Cloud-Sessions](#skills-in-cowork-and-cloud-sessions) beschreibt. Claude Code lädt nur die Skills herunter, die Sie aktiviert haben, und benötigt Ihre claude.ai-Anmeldung, um sie herunterzuladen.

212 </Step>

213 

214 <Step title="Führen Sie Claude Code im nicht-interaktiven Modus mit aktivierter Synchronisierung aus">

215 Claude Code lädt synchronisierte Skills nur, wenn Sie es im [nicht-interaktiven Modus](/docs/de/headless) mit dem `-p`-Flag ausführen und [`CLAUDE_CODE_SYNC_SKILLS`](/docs/de/env-vars#variables) auf `1` setzen. Der Prompt, den Sie übergeben, beeinflusst den Download nicht.

216 

217 ```bash theme={null}

218 CLAUDE_CODE_SYNC_SKILLS=1 claude -p "List the skills you have available"

219 ```

151 220 

152<h4 id="automatic-discovery-from-parent-and-nested-directories">221 Claude Code lädt die Skills in `~/.claude/skills/synced/` herunter, beantwortet den Prompt und beendet sich wie jeder andere nicht-interaktive Lauf. Die heruntergeladenen Skills bleiben nach dem Beenden auf der Festplatte, daher müssen Sie den Lauf nicht offen halten. Claude Code lädt Skills nur während eines Laufs mit gesetztem `CLAUDE_CODE_SYNC_SKILLS` herunter, daher führen Sie den Befehl erneut aus, nachdem Sie einen Skill auf claude.ai aktivieren oder ändern. Um zu ändern, wie lange der Lauf auf die Synchronisierung wartet, bevor er den Prompt beantwortet, setzen Sie [`CLAUDE_CODE_SYNC_SKILLS_WAIT_TIMEOUT_MS`](/docs/de/env-vars#variables).

153 Automatische Erkennung aus übergeordneten und verschachtelten Verzeichnissen222 </Step>

223 

224 <Step title="Bestätigen Sie, dass die Skills in einer lokalen Session geladen werden">

225 Starten Sie eine interaktive Session, ohne `CLAUDE_CODE_SYNC_SKILLS` gesetzt, und führen Sie `/skills` aus. Das Menü listet die heruntergeladenen Skills unter `claude.ai sync` auf. Jede lokale Session, die Sie danach mit derselben claude.ai-Anmeldung starten, lädt sie auch aus `~/.claude/skills/synced/`.

226 </Step>

227</Steps>

228 

229<h4 id="when-a-synced-skill-name-matches-another-command">

230 Wenn ein synchronisierter Skill-Name mit einem anderen Befehl übereinstimmt

154</h4>231</h4>

155 232 

156Projekt-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.233Claude Code überspringt einen synchronisierten Skill, dessen Name mit einem anderen Befehl übereinstimmt, und dieser andere Befehl wird ausgeführt. Der andere Befehl kann ein integrierter Befehl, ein [gebündelter Skill](#bundled-skills), ein Skill auf einer beliebigen [lokalen Ebene](#where-skills-live), ein Plugin-Skill, eine Datei in `.claude/commands/` oder ein [MCP-Prompt](/docs/de/mcp#use-mcp-prompts-as-commands) sein. Claude Code reserviert auch die Namen seiner eigenen integrierten Befehle und gebündelten Skills, auch wenn sie in Ihrer Session nicht verfügbar sind, zum Beispiel nachdem Sie gebündelte Skills ausgeschaltet haben, daher überspringt es einen synchronisierten Skill mit einem dieser Namen auch.

157 234 

158Jeder Skill ist ein Verzeichnis mit `SKILL.md` als Einstiegspunkt:235Claude Code kennzeichnet synchronisierte Skills, damit Sie sehen können, woher sie kommen. Das `/skills`-Menü und `/context` gruppieren synchronisierte Skills unter `claude.ai sync`, und das `/`-Befehlsmenü kennzeichnet sie als von claude.ai kommend.

159 236 

160```text theme={null}237Beim Vergleich von Namen ignoriert Claude Code Groß-/Kleinschreibung, Abstände und unsichtbare Zeichen und behandelt Kompatibilitätsformen wie Vollbreitenbuchstaben und Bindestrich-Varianten als ihre einfachen Äquivalente, daher kann ein synchronisiertes `Commit` nicht neben einem lokalen `commit` geladen werden. Ein Name, der sich nur durch einen ähnlich aussehenden Buchstaben aus einem anderen Alphabet unterscheidet, zählt als ein anderer Name, und das `claude.ai sync`-Label ist, wie Sie die beiden unterscheiden.

161my-skill/

162├── SKILL.md # Main instructions (required)

163├── template.md # Template for Claude to fill in

164├── examples/

165│ └── sample.md # Example output showing expected format

166└── scripts/

167 └── validate.sh # Script Claude can execute

168```

169 238 

170Die `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](#add-supporting-files) für weitere Details.239<h4 id="how-claude-code-handles-the-frontmatter-of-a-synced-skill">

240 Wie Claude Code die Frontmatter eines synchronisierten Skills handhabt

241</h4>

171 242 

172<Note>243Claude Code wendet zwei Regeln auf die Frontmatter eines synchronisierten Skills an:

173 Dateien in `.claude/commands/` funktionieren weiterhin und unterstützen das gleiche [Frontmatter](#frontmatter-reference). Skills werden empfohlen, da sie zusätzliche Funktionen wie unterstützende Dateien unterstützen.244 

174</Note>245* Claude Code respektiert die Frontmatter in jeder Art von Session, daher geht eine `allowed-tools`-Gewährung durch den normalen [Berechtigungsfluss](/docs/de/permissions).

246* Claude Code bereinigt den Anzeigetext, den der Skill liefert, wie seine Beschreibung. Es entfernt Steuerzeichen, und in Text, der Claude erreicht, wie die Beschreibung, escaped es auch spitzklammern, damit der Text nicht Claude Codes interne Formatierung imitieren kann.

175 247 

176<h4 id="skills-from-additional-directories">248<h4 id="how-claude-code-handles-the-body-of-a-synced-skill">

177 Skills aus zusätzlichen Verzeichnissen249 Wie Claude Code den Body eines synchronisierten Skills handhabt

178</h4>250</h4>

179 251 

180Das Flag `--add-dir` und der Befehl `/add-dir` [gewähren Dateizugriff](/docs/de/permissions#additional-directories-grant-file-access-not-configuration) statt Konfigurationserkennung, aber Skills sind eine Ausnahme: `.claude/skills/` in einem hinzugefügten Verzeichnis wird automatisch geladen. Diese Ausnahme gilt nur für `--add-dir` und `/add-dir`. Die Einstellung `permissions.additionalDirectories` in `settings.json` gewährt nur Dateizugriff und lädt keine Skills. Siehe [Live-Änderungserkennung](#live-change-detection) für die Aufnahme von Änderungen während einer Sitzung.252Was Claude Code mit dem Body eines synchronisierten Skills tut, hängt davon ab, wo die Session läuft:

181 253 

182Andere `.claude/`-Konfigurationen wie Befehle und Ausgabestile werden nicht aus zusätzlichen Verzeichnissen geladen. Siehe die [Ausnahmetabelle](/docs/de/permissions#additional-directories-grant-file-access-not-configuration) für die vollständige Liste dessen, was geladen wird und was nicht, sowie die empfohlenen Wege zum Teilen von Konfigurationen über Projekte hinweg.254* In einer Cloud-Session behält der Body das Verhalten, das ein lokaler Skill hat, da die Session in einem isolierten Container läuft.

255* In einer Cowork-Session auf Ihrem Desktop behält der Body das Verhalten eines lokalen Skills, außer dass Claude Code jede `!`-Befehlszeile durch den [`disableSkillShellExecution`-Platzhalter](#inject-dynamic-context) ersetzt, wie es für jeden Skill tut, den Sie dort liefern.

256* In jeder anderen Session auf Ihrer Maschine führt Claude Code keine [`!`-Befehle](#inject-dynamic-context) aus, hängt die Dateien nicht an, die `@`-Referenzen benennen, wie es für einen lokalen Skill tut, und ersetzt nicht die `${CLAUDE_PROJECT_DIR}`- und `${CLAUDE_SESSION_ID}`-Platzhalter, daher erreichen `@`-Referenzen und beide Platzhalter Claude als Literaltext. Eine `!`-Befehlszeile erreicht Claude auch als Literaltext oder als dieser Platzhalter, wenn `disableSkillShellExecution` aktiviert ist.

183 257 

184<Note>258<h3 id="live-change-detection">

185 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](/docs/de/memory#load-from-additional-directories).259 Bearbeiten Sie einen Skill während einer Session

186</Note>260</h3>

261 

262Claude Code überwacht Skill-Verzeichnisse auf Dateiänderungen, außer im [Bare Mode](/docs/de/headless#start-faster-with-bare-mode). Wenn Sie einen Skill unter `~/.claude/skills/`, dem Projekt `.claude/skills/` oder einem `.claude/skills/` in einem `--add-dir`-Verzeichnis hinzufügen, bearbeiten oder entfernen, nimmt Claude Code die Änderung in der aktuellen Session auf, ohne einen Neustart. Wenn Sie ein Top-Level-Skills-Verzeichnis erstellen, das beim Session-Start nicht vorhanden war, starten Sie Claude Code neu, damit es das neue Verzeichnis überwachen kann.

263 

264Die Live-Änderungserkennung deckt nur `SKILL.md`-Text ab. Für einen Skill-Ordner, der auch ein [Plugin](/docs/de/plugins-reference#skills-directory-plugins) ist, benötigen Änderungen an `hooks/`, `.mcp.json`, `agents/` und `output-styles/` `/reload-plugins`, um wirksam zu werden.

265 

266<h3 id="remove-a-skill">

267 Entfernen Sie einen Skill

268</h3>

269 

270Wie Sie einen Skill entfernen, hängt davon ab, woher er kommt:

271 

272* **Persönlicher oder Projekt-Skill**: Löschen Sie das Verzeichnis des Skills, `~/.claude/skills/<skill-name>/` oder `.claude/skills/<skill-name>/`. Claude Code [entfernt ihn aus `/skills` in der aktuellen Session](#live-change-detection); Inhalte, die Claude Code bereits daraus geladen hat, folgen dem [Skill-Content-Lebenszyklus](#skill-content-lifecycle).

273* **Enterprise-Skill**: Ein Administrator löscht das Verzeichnis des Skills aus `.claude/skills/` im [Verzeichnis für verwaltete Einstellungen](/docs/de/managed-settings#delivery-mechanisms), zum Beispiel `/etc/claude-code/.claude/skills/<skill-name>/` auf Linux.

274* **Plugin-Skill**: Deaktivieren oder deinstallieren Sie das Plugin, das ihn bereitstellt, aus dem `/plugin`-Menü oder mit `/plugin uninstall <plugin-name>@<marketplace-name>`. Claude Code entlädt die Skills des Plugins, nachdem Sie `/reload-plugins` ausführen oder neu starten; siehe [Wenden Sie Plugin-Änderungen an, ohne neu zu starten](/docs/de/discover-plugins#apply-plugin-changes-without-restarting).

275* **Von claude.ai synchronisierter Skill**: Schalten Sie den Skill für Ihr claude.ai-Konto aus, an derselben Stelle, an der Sie ihn [aktiviert haben](#skills-in-cowork-and-cloud-sessions). Claude Code entfernt ihn aus `~/.claude/skills/synced/` beim nächsten Mal, wenn es [Ihre Skills synchronisiert](#where-synced-skills-load). Wenn Sie das Verzeichnis stattdessen von Hand löschen, lädt die nächste Synchronisierung es erneut herunter, während der Skill auf claude.ai aktiviert bleibt.

276* **Gebündelter Skill**: Setzen Sie [`disableBundledSkills`](#bundled-skills) auf `true`, um jeden gebündelten Skill außer `/doctor` auszuschalten, oder setzen Sie einen Skill auf `"off"` in [`skillOverrides`](#override-skill-visibility-from-settings), um ihn auszublenden.

277 

278Um einen persönlichen oder Projekt-Skill zu behalten, aber Claude daran zu hindern, ihn von selbst aufzurufen, setzen Sie [`disable-model-invocation: true`](#control-who-invokes-a-skill) in seiner Frontmatter oder `"user-invocable-only"` in [`skillOverrides`](#override-skill-visibility-from-settings), wenn Sie die Datei nicht bearbeiten möchten.

187 279 

188<h2 id="configure-skills">280<h2 id="configure-skills">

189 Skills konfigurieren281 Fähigkeiten konfigurieren

190</h2>282</h2>

191 283 

192Skills werden durch YAML-Frontmatter oben in `SKILL.md` und den Markdown-Inhalt, der folgt, konfiguriert.284Fähigkeiten werden durch YAML-Frontmatter am Anfang von `SKILL.md` und den darauffolgenden Markdown-Inhalt konfiguriert.

193 285 

194<h3 id="types-of-skill-content">286<h3 id="types-of-skill-content">

195 Arten von Skill-Inhalten287 Arten von Fähigkeitsinhalten

196</h3>288</h3>

197 289 

198Skill-Dateien können beliebige Anweisungen enthalten, aber das Nachdenken darüber, wie Sie sie aufrufen möchten, hilft zu leiten, was Sie einbeziehen:290Fähigkeitsdateien können beliebige Anweisungen enthalten, aber das Nachdenken darüber, wie Sie sie aufrufen möchten, hilft bei der Entscheidung, was Sie einbeziehen:

199 291 

200**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.292**Referenzinhalte** fügen Wissen hinzu, das Claude auf Ihre aktuelle Arbeit anwendet. Konventionen, Muster, Stilrichtlinien, Domänenwissen. Dieser Inhalt wird inline ausgeführt, sodass Claude ihn zusammen mit Ihrem Gesprächskontext verwenden kann.

201 293 

202```yaml theme={null}294```yaml theme={null}

203---295---

211- Include request validation303- Include request validation

212```304```

213 305 

214**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.306**Aufgabeninhalte** geben 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. Das folgende Beispiel fügt `context: fork` hinzu, das die Fähigkeit in ihrem eigenen Subagent-Kontext ausführt; siehe [Fähigkeiten in einem Subagent ausführen](#run-skills-in-a-subagent).

215 307 

216```yaml theme={null}308```yaml theme={null}

217---309---

2273. Push to the deployment target3193. Push to the deployment target

228```320```

229 321 

230Ihre `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](#add-supporting-files), um den Hauptskill fokussiert zu halten.322Halten Sie den Text selbst prägnant. Sobald eine Fähigkeit geladen ist, bleibt ihr Inhalt [über Turns hinweg im Kontext](#skill-content-lifecycle), sodass jede Zeile wiederkehrende Token-Kosten verursacht. Geben Sie an, was zu tun ist, anstatt zu erzählen, wie oder warum, und wenden Sie denselben Prägnanztest an, den Sie für [CLAUDE.md-Inhalte](/docs/de/best-practices#write-an-effective-claude-md) verwenden würden.

231 

232Halten Sie den Text selbst prägnant. Sobald ein Skill geladen ist, bleibt sein Inhalt [über Züge hinweg im Kontext](#skill-content-lifecycle), 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](/docs/de/best-practices#write-an-effective-claude-md) verwenden würden.

233 323 

234<h3 id="frontmatter-reference">324<h3 id="frontmatter-reference">

235 Frontmatter-Referenz325 Frontmatter-Referenz

236</h3>326</h3>

237 327 

238Über den Markdown-Inhalt hinaus können Sie das Skill-Verhalten mit YAML-Frontmatter-Feldern zwischen `---`-Markierungen oben in Ihrer `SKILL.md`-Datei konfigurieren:328Über den Markdown-Inhalt hinaus können Sie das Verhalten von Fähigkeiten mithilfe von YAML-Frontmatter-Feldern zwischen `---`-Markierungen am Anfang Ihrer `SKILL.md`-Datei konfigurieren:

239 329 

240```yaml theme={null}330```yaml theme={null}

241---331---

248Your skill instructions here...338Your skill instructions here...

249```339```

250 340 

251Alle Felder sind optional. Nur `description` wird empfohlen, damit Claude weiß, wann der Skill verwendet werden soll.341Alle Felder sind optional. Nur `description` wird empfohlen, damit Claude weiß, wann die Fähigkeit verwendet werden soll.

342 

343Claude Code liest das Frontmatter nur, wenn die öffnende `---` die erste Zeile der Datei ist. Andernfalls behandelt es die gesamte Datei, einschließlich `---`-Markierungen, als Fähigkeitsinhalt.

344 

345Boolesche Felder akzeptieren `yes`, `no`, `on`, `off`, `1` und `0` in beliebiger Schreibweise, zusätzlich zu `true` und `false`. Vor v2.1.218 erkannte Claude Code nur `true` und `false`.

252 346 

253| Feld | Erforderlich | Beschreibung |347| Feld | Erforderlich | Beschreibung |

254| :------------------------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |348| :------------------------- | :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

255| `name` | Nein | Anzeigename, der in Skill-Auflistungen angezeigt wird. Standardmäßig der Verzeichnisname. Siehe [Wie ein Skill seinen Befehlsnamen erhält](#how-a-skill-gets-its-command-name), um zu verstehen, wie sich dies vom Namen unterscheidet, den Sie eingeben, um den Skill aufzurufen. |349| `name` | Nein | Anzeigename, der in Fähigkeitsauflistungen angezeigt wird. Standardmäßig der Verzeichnisname. Siehe [Wie eine Fähigkeit ihren Befehlsnamen erhält](#how-a-skill-gets-its-command-name), um zu sehen, wie das Feld mit dem Namen interagiert, den Sie eingeben, um die Fähigkeit aufzurufen. |

256| `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. |350| `description` | Empfohlen | Was die Fähigkeit tut und wann sie verwendet werden soll. Claude verwendet dies, um zu entscheiden, wann die Fähigkeit angewendet werden soll. Wenn weggelassen, wird der erste Absatz des Markdown-Inhalts verwendet. Setzen Sie den wichtigsten Anwendungsfall zuerst: Der kombinierte `description`- und `when_to_use`-Text wird in der Fähigkeitsauflistung auf 1.536 Zeichen gekürzt, um die Kontextnutzung zu reduzieren. |

257| `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. |351| `when_to_use` | Nein | Zusätzlicher Kontext für den Zeitpunkt, zu dem Claude die Fähigkeit aufrufen sollte, z. B. Trigger-Phrasen oder Beispielanfragen. An `description` in der Fähigkeitsauflistung angehängt und zählt zur 1.536-Zeichen-Obergrenze. |

258| `argument-hint` | Nein | Hinweis, der während der Autovervollständigung angezeigt wird, um erwartete Argumente anzuzeigen. Beispiel: `[issue-number]` oder `[filename] [format]`. |352| `argument-hint` | Nein | Hinweis, der während der Autovervollständigung angezeigt wird, um erwartete Argumente anzuzeigen. Beispiel: `[issue-number]` oder `[filename] [format]`. |

259| `arguments` | Nein | Benannte positionelle Argumente für [`$name`-Substitution](#available-string-substitutions) im Skill-Inhalt. Akzeptiert eine durch Leerzeichen getrennte Zeichenkette oder eine YAML-Liste. Namen werden in Reihenfolge auf Argumentpositionen abgebildet. |353| `arguments` | Nein | Benannte Positionsargumente für [`$name`-Substitution](#available-string-substitutions) im Fähigkeitsinhalt. Akzeptiert eine durch Leerzeichen getrennte Zeichenkette oder eine YAML-Liste. Namen werden in Reihenfolge Argumentpositionen zugeordnet. |

260| `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](/docs/de/sub-agents#preload-skills-into-subagents). Ab v2.1.196 verhindert dies auch, dass der Skill ausgeführt wird, wenn eine [geplante Aufgabe](/docs/de/scheduled-tasks) mit dem Skill als Eingabe ausgelöst wird. Standard: `false`. |354| `disable-model-invocation` | Nein | Setzen Sie auf `true`, um zu verhindern, dass Claude diese Fähigkeit automatisch lädt. Verwenden Sie für Workflows, die Sie manuell mit `/name` auslösen möchten. Verhindert auch, dass die Fähigkeit [in Subagents vorgeladen wird](/docs/de/sub-agents#preload-skills-into-subagents). Ab v2.1.196 verhindert dies auch, dass die Fähigkeit ausgeführt wird, wenn eine [geplante Aufgabe](/docs/de/scheduled-tasks) mit der Fähigkeit als Eingabeaufforderung ausgelöst wird. Standard: `false`. |

261| `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`. |355| `user-invocable` | Nein | Setzen Sie auf `false`, wenn nur Claude die Fähigkeit aufrufen sollte: Claude Code blendet sie aus dem `/`-Menü aus und führt sie nicht aus, wenn Sie `/name` eingeben. Verwenden Sie für Hintergrundwissen, das Benutzer nicht direkt aufrufen sollten. Standard: `true`. |

262| `allowed-tools` | Nein | Tools, die Claude ohne Genehmigung verwenden kann, wenn dieser Skill aktiv ist. Akzeptiert eine durch Leerzeichen oder Komma getrennte Zeichenkette oder eine YAML-Liste. |356| `allowed-tools` | Nein | Tools, die Claude ohne Genehmigung während des Turns verwenden kann, der diese Fähigkeit aufruft. Die Genehmigung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. Akzeptiert eine durch Leerzeichen oder Komma getrennte Zeichenkette oder eine YAML-Liste. Siehe [Tools für eine Fähigkeit vorab genehmigen](#pre-approve-tools-for-a-skill). |

263| `disallowed-tools` | Nein | Tools, die aus Claudes verfügbarem Pool entfernt werden, während dieser Skill aktiv ist. Verwenden Sie für autonome Skills, die niemals bestimmte Tools aufrufen sollten, wie `AskUserQuestion` für eine Hintergrund-Schleife. Akzeptiert eine durch Leerzeichen oder Komma getrennte Zeichenkette oder eine YAML-Liste. Die Einschränkung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. |357| `disallowed-tools` | Nein | Tools, die aus Claudes verfügbarem Pool entfernt werden, während diese Fähigkeit aktiv ist. Verwenden Sie für autonome Fähigkeiten, die niemals bestimmte Tools aufrufen sollten, z. B. `AskUserQuestion` für eine Hintergrundschleife. Akzeptiert eine durch Leerzeichen oder Komma getrennte Zeichenkette oder eine YAML-Liste. Die Einschränkung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. Wie Ablehnungsregeln kann das Feld [`EndConversation`](/docs/de/tools-reference#endconversation-tool-behavior) nicht entfernen, während ein anderes Tool verfügbar bleibt. |

264| `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`](/docs/de/model-config) oder `inherit`, um das aktive Modell beizubehalten. Ein Wert, der durch die [`availableModels`](/docs/de/model-config#restrict-model-selection)-Zulassungsliste Ihrer Organisation ausgeschlossen ist, wird nicht verwendet und die Sitzung behält ihr aktuelles Modell. |358| `model` | Nein | Modell, das verwendet werden soll, wenn diese Fähigkeit aktiv ist. Die Außerkraftsetzung gilt für den Rest des aktuellen Turns und wird nicht in den Einstellungen gespeichert; das Sitzungsmodell wird bei Ihrer nächsten Eingabeaufforderung fortgesetzt. Akzeptiert die gleichen Werte wie [`/model`](/docs/de/model-config), oder `inherit`, um das aktive Modell beizubehalten. Ein Wert, der durch die [`availableModels`](/docs/de/model-config#restrict-model-selection)-Zulassungsliste Ihrer Organisation ausgeschlossen ist, wird nicht verwendet und die Sitzung behält ihr aktuelles Modell. Mit `context: fork` setzt der Wert stattdessen das [Modell des verzweigten Subagents](#run-skills-in-a-subagent) und ein ausgeschlossener Wert folgt den [gleichen Regeln wie eine Subagent-Modellüberschreibung](/docs/de/model-config#restrict-model-selection). |

265| `effort` | Nein | [Anstrengungsstufe](/docs/de/model-config#adjust-effort-level) 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. |359| `effort` | Nein | [Aufwandsstufe](/docs/de/model-config#adjust-effort-level), wenn diese Fähigkeit aktiv ist. Überschreibt die Sitzungsaufwandsstufe. Standard: erbt von Sitzung. Optionen: `low`, `medium`, `high`, `xhigh`, `max`; verfügbare Stufen hängen vom Modell ab. |

266| `context` | Nein | Setzen Sie auf `fork`, um in einem verzweigten Subagent-Kontext ausgeführt zu werden. |360| `context` | Nein | Setzen Sie auf `fork`, um in einem verzweigten Subagent-Kontext ausgeführt zu werden. Siehe [Fähigkeiten in einem Subagent ausführen](#run-skills-in-a-subagent). |

267| `agent` | Nein | Welcher Subagent-Typ verwendet werden soll, wenn `context: fork` gesetzt ist. |361| `agent` | Nein | Welcher Subagent-Typ verwendet werden soll, wenn `context: fork` gesetzt ist. |

268| `hooks` | Nein | Hooks, die auf den Lebenszyklus dieses Skills beschränkt sind. Siehe [Hooks in Skills und Agenten](/docs/de/hooks#hooks-in-skills-and-agents) für das Konfigurationsformat. |362| `background` | Nein | Gilt nur mit `context: fork`. Setzen Sie auf `false`, um auf das Ergebnis des verzweigten Subagents im Turn zu warten, der die Fähigkeit aufgerufen hat, anstatt [es im Hintergrund auszuführen](#run-skills-in-a-subagent). Standard: `true`. Erfordert Claude Code v2.1.218 oder später. |

269| `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](/docs/de/memory#path-specific-rules). |363| `hooks` | Nein | Hooks, die Claude Code registriert, wenn die Fähigkeit aufgerufen wird, und die für den Rest der Sitzung weiterhin ausgeführt werden. Siehe [Hooks in Fähigkeiten und Agenten](/docs/de/hooks#hooks-in-skills-and-agents) für das Konfigurationsformat und die `once`-Option. |

270| `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`. |364| `paths` | Nein | Glob-Muster, die einschränken, wann diese Fähigkeit aktiviert wird. Akzeptiert eine durch Komma getrennte Zeichenkette oder eine YAML-Liste. Wenn gesetzt, lädt Claude die Fähigkeit automatisch nur, wenn mit Dateien arbeitet, die den Mustern entsprechen. Verwendet das gleiche Format wie [pfadspezifische Regeln](/docs/de/memory#path-specific-rules). |

365| `shell` | Nein | Shell, die für `` !`command` `` und ` ```! ` Blöcke in dieser Fähigkeit verwendet werden soll. Akzeptiert `bash` (Standard) oder `powershell`. Das Setzen von `powershell` führt Inline-Shell-Befehle über PowerShell aus, wenn das [PowerShell-Tool](/de/tools-reference#powershell-tool) aktiviert ist: Es ist standardmäßig unter Windows ohne Git Bash aktiviert, standardmäßig mit Git Bash für claude.ai und Console-Konten aktiviert, und benötigt `CLAUDE_CODE_USE_POWERSHELL_TOOL=1` in Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry-Sitzungen sowie auf macOS, Linux und WSL. Setzen Sie es auf `0`, um das Tool auszuschalten. |

366| `metadata` | Nein | Freie YAML-Zuordnung für Ihre eigenen Schlüssel-Wert-Daten, z. B. Berechtigung oder Katalogfelder, die von Ihrem eigenen Tooling aus `SKILL.md` gelesen werden. Claude Code handelt nicht nach ihrem Inhalt und verwirft einen Wert, der keine Zuordnung ist. Verwenden Sie keine Frontmatter-Feldnamen wie `paths` als Schlüssel erneut. |

367| `license` | Nein | Lizenz, die die Fähigkeit abdeckt. Teil der [Agent Skills](https://agentskills.io)-Spezifikation; siehe [Fähigkeits-Frontmatter außerhalb von Claude Code verwenden](#using-skill-frontmatter-outside-claude-code). Claude Code akzeptiert das Feld, handelt aber nicht danach. |

368| `compatibility` | Nein | Umgebungsanforderungen für die Fähigkeit, z. B. beabsichtigte Produkte oder Systemvoraussetzungen, wie in der [Agent Skills](https://agentskills.io)-Spezifikation definiert; siehe [Fähigkeits-Frontmatter außerhalb von Claude Code verwenden](#using-skill-frontmatter-outside-claude-code). Akzeptiert eine Zeichenkette von bis zu 500 Zeichen. Claude Code akzeptiert das Feld, handelt aber nicht danach. |

369 

370<h4 id="using-skill-frontmatter-outside-claude-code">

371 Fähigkeits-Frontmatter außerhalb von Claude Code verwenden

372</h4>

373 

374Claude Code akzeptiert jedes Feld in der obigen Tabelle. Außerhalb von Claude Code können Sie nur die Felder in der [Agent Skills](https://agentskills.io)-Spezifikation verwenden:

375 

376| Verteilungspfad | Frontmatter-Felder, die Sie verwenden können |

377| :----------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------- |

378| Claude Code-Fähigkeiten auf [beliebiger Ebene](#where-skills-live), einschließlich [Plugin](/docs/de/plugins)-Fähigkeiten | Jedes Feld in der obigen Tabelle |

379| claude.ai-Fähigkeits-Uploads, die Skills-API und Verpackung mit `package_skill.py` aus [anthropics/skills](https://github.com/anthropics/skills) | `name`, `description`, `license`, `compatibility`, `metadata`, `allowed-tools` |

380 

381Wenn Sie eine persönliche Fähigkeit für [Cowork- und Cloud-Sitzungen](#skills-in-cowork-and-cloud-sessions) aktivieren, einschließlich Routinen, laden Sie sie auf claude.ai hoch, sodass die gleichen Regeln gelten.

382 

383Wenn Sie ein Feld einbeziehen, das die Spezifikation nicht zulässt, schlägt die Verpackung oder der Upload mit einem schwerwiegenden Fehler fehl, anstatt das Feld zu ignorieren:

384 

385```

386Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, name

387```

388 

389Das Einschränken des Frontmatters auf die sechs Felder der Spezifikation vermeidet den obigen Fehler „unexpected-key". Die [Agent Skills-Spezifikation](https://agentskills.io) und die [Skills-API-Anforderungen](https://docs.claude.com/en/api/skills-guide) definieren alles andere, das diese Pfade validieren. Claude Code-spezifische Body-Funktionen, wie [dynamische Kontexteinspritzung](#inject-dynamic-context), funktionieren nicht in claude.ai-Chat oder über die API. Claude Code akzeptiert alle sechs Felder, sodass Frontmatter, das der Spezifikation folgt, ohne Änderungen in Claude Code geladen wird.

271 390 

272<h4 id="how-a-skill-gets-its-command-name">391<h4 id="how-a-skill-gets-its-command-name">

273 Wie ein Skill seinen Befehlsnamen erhält392 Wie eine Fähigkeit ihren Befehlsnamen erhält

274</h4>393</h4>

275 394 

276Der Befehl, den Sie eingeben, um einen Skill aufzurufen, kommt von dem Ort, an dem sich die Skill-Datei befindet. Das Frontmatter-Feld `name` setzt die Anzeigebeschriftung, die in Skill-Auflistungen angezeigt wird, und ändert außer bei einem Plugin-Root-`SKILL.md` nicht, was Sie nach `/` eingeben.395Der Befehl, den Sie eingeben, um eine Fähigkeit aufzurufen, kommt von dem Ort, an dem die Fähigkeitsdatei lebt, und für Plugin-Fähigkeiten auch vom Frontmatter-Feld `name`. In einer persönlichen oder Projektfähigkeit setzt `name` nur das Anzeigelabel, das in Fähigkeitsauflistungen angezeigt wird, und der Befehl kommt immer noch vom Verzeichnisnamen. In einer Plugin-Fähigkeit setzt `name` das letzte Segment des Befehls und das Plugin-Präfix bleibt bestehen.

277 396 

278Die folgende Tabelle zeigt, woher der Befehlsname für jedes Layout kommt:397Die folgende Tabelle zeigt, woher der Befehlsname für jedes Layout kommt:

279 398 

280| Skill-Speicherort | Befehlsnamen-Quelle | Beispiel |399| Fähigkeitsort | Befehlsnamenquelle | Beispiel |

281| :-------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------- |400| :------------------------------------------------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------ |

282| Skill-Verzeichnis unter `~/.claude/skills/` oder `.claude/skills/` | Verzeichnisname | `.claude/skills/deploy-staging/SKILL.md` → `/deploy-staging` |401| Fähigkeitsverzeichnis unter `~/.claude/skills/` oder `.claude/skills/` | Verzeichnisname | `.claude/skills/deploy-staging/SKILL.md` → `/deploy-staging` |

283| [Verschachteltes](#where-skills-live) `.claude/skills/`-Verzeichnis, wenn der Name mit einem anderen Skill kollidiert | Unterverzeichnispfad relativ zum Arbeitsverzeichnis, dann der Skill-Verzeichnisname | `apps/web/.claude/skills/deploy/SKILL.md` → `/apps/web:deploy` |402| [Verschachteltes](#where-skills-live) `.claude/skills/`-Verzeichnis, wenn der Name mit einer anderen Fähigkeit kollidiert | Unterverzzeichnisspfad relativ zum Arbeitsverzeichnis, dann der Fähigkeitsverzeichnisname | `apps/web/.claude/skills/deploy/SKILL.md` → `/apps/web:deploy` |

284| Datei unter `.claude/commands/` | Dateiname ohne Erweiterung | `.claude/commands/deploy.md` → `/deploy` |403| Datei unter `.claude/commands/` | Dateiname ohne Erweiterung | `.claude/commands/deploy.md` → `/deploy` |

285| Plugin-`skills/`-Unterverzeichnis | Verzeichnisname, mit Namespace durch Plugin | `my-plugin/skills/review/SKILL.md` → `/my-plugin:review` |404| Plugin-`skills/`-Unterverzeichnis | Frontmatter `name` oder der Verzeichnisname, mit Namespace durch Plugin | `my-plugin/skills/review/SKILL.md` → `/my-plugin:review`, oder `/my-plugin:fancy` mit `name: fancy` |

286| Plugin-Root-`SKILL.md` | Frontmatter `name`, mit dem Plugin-Verzeichnisnamen als Fallback | `my-plugin/SKILL.md` mit `name: review` → `/my-plugin:review`. Siehe [Pfad-Verhaltensregeln](/docs/de/plugins-reference#path-behavior-rules) |405| Plugin-Root `SKILL.md` | Frontmatter `name`, mit dem Plugin-Verzeichnisnamen als Fallback | `my-plugin/SKILL.md` mit `name: review` → `/my-plugin:review`. Siehe [Pfadverhaltenregeln](/docs/de/plugins-reference#path-behavior-rules) |

406 

407In einer Plugin-Fähigkeit ersetzt das Frontmatter-Feld `name` den Verzeichnisnamen im letzten Segment des Befehls, sodass `my-plugin/skills/review/SKILL.md` mit `name: fancy` zu `/my-plugin:fancy` wird. Der bloße `/fancy` ruft die Fähigkeit auch auf, es sei denn, ein anderer Befehl verwendet bereits diesen Namen. Wenn der `name`, den Sie schreiben, bereits mit dem eigenen Präfix des Plugins beginnt, fügt Claude Code das Präfix nicht erneut auf v2.1.246 oder später hinzu. Zum Beispiel wird `name: my-plugin:fancy` immer noch zu `/my-plugin:fancy`. Von v2.1.216 bis v2.1.245 verdoppelte Claude Code das Präfix, wenn der `name` es bereits trug.

408 

409In [nicht-interaktiven Sitzungen](/docs/de/headless) sind die Namen `help` und `feedback` nicht für ihre nur-Terminal-Befehle reserviert, sodass eine Plugin-Fähigkeit mit einem dieser Namen ihren bloßen Befehl dort behält. Jeder andere nur-Terminal-Befehl, wie `/login`, bleibt reserviert, obwohl der Befehl in diesen Sitzungen nicht ausgeführt werden kann. Eine synchronisierte Fähigkeit namens `help` oder `feedback` wird immer noch dort übersprungen, da Claude Code [eine synchronisierte Fähigkeit überspringt](#when-a-synced-skill-name-matches-another-command), deren Name mit einem beliebigen integrierten Befehl übereinstimmt, unabhängig davon, ob dieser Befehl ausgeführt werden kann.

287 410 

288Der Plugin-Root-Fall ist der einzige Ort, an dem `name` den Befehlsnamen setzt, da es kein Skill-Verzeichnis gibt, das ihn übernehmen könnte. Wenn `name` nicht im Frontmatter gesetzt ist, wird stattdessen der Plugin-Verzeichnisname verwendet.411Für eine Plugin-Root `SKILL.md` gibt es kein Fähigkeitsverzeichnis, aus dem der Name genommen werden kann, sodass `name` das ganze letzte Segment liefert. Ohne ein `name`-Feld fällt Claude Code auf den Plugin-Verzeichnisnamen zurück.

289 412 

290<h4 id="available-string-substitutions">413<h4 id="available-string-substitutions">

291 Verfügbare String-Substitutionen414 Verfügbare Zeichenkettensubstitutionen

292</h4>415</h4>

293 416 

294Skills unterstützen String-Substitution für dynamische Werte im Skill-Inhalt:417Fähigkeiten unterstützen Zeichenkettensubstitution für dynamische Werte im Fähigkeitsinhalt:

295 418 

296| Variable | Beschreibung |419| Variable | Beschreibung |

297| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |420| :---------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

298| `$ARGUMENTS` | Alle Argumente, die beim Aufrufen des Skills übergeben werden. Wenn `$ARGUMENTS` nicht im Inhalt vorhanden ist, werden Argumente als `ARGUMENTS: <value>` angehängt. |421| `$ARGUMENTS` | Alle Argumente, die beim Aufrufen der Fähigkeit übergeben werden. Wenn kein Platzhalter ein Argument empfängt, hängt Claude Code `ARGUMENTS: <value>` am Ende des Fähigkeitsinhalts an. Siehe [Argumente an Fähigkeiten übergeben](#pass-arguments-to-skills). |

299| `$ARGUMENTS[N]` | Greifen Sie auf ein bestimmtes Argument nach 0-basiertem Index zu, z. B. `$ARGUMENTS[0]` für das erste Argument. |422| `$ARGUMENTS[N]` | Greifen Sie auf ein bestimmtes Argument nach 0-basiertem Index zu, z. B. `$ARGUMENTS[0]` für das erste Argument. |

300| `$N` | Kurzform für `$ARGUMENTS[N]`, z. B. `$0` für das erste Argument oder `$1` für das zweite. |423| `$N` | Kurzform für `$ARGUMENTS[N]`, z. B. `$0` für das erste Argument oder `$1` für das zweite. |

301| `$name` | Benanntes Argument, das in der [`arguments`](#frontmatter-reference)-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. |424| `$name` | Benanntes Argument, das in der [`arguments`](#frontmatter-reference)-Frontmatter-Liste deklariert ist. Namen werden in Reihenfolge Positionen zugeordnet, sodass mit `arguments: [issue, branch]` der Platzhalter `$issue` zum ersten Argument und `$branch` zum zweiten expandiert. |

302| `${CLAUDE_SESSION_ID}` | Die aktuelle Sitzungs-ID. Nützlich zum Protokollieren, Erstellen sitzungsspezifischer Dateien oder Korrelieren der Skill-Ausgabe mit Sitzungen. |425| `${CLAUDE_SESSION_ID}` | Die aktuelle Sitzungs-ID. Nützlich für Protokollierung, Erstellen von sitzungsspezifischen Dateien oder Korrelation von Fähigkeitsausgabe mit Sitzungen. |

303| `${CLAUDE_EFFORT}` | Die aktuelle Anstrengungsstufe: `low`, `medium`, `high`, `xhigh` oder `max`. Ultracode ist keine separate Stufe und wird als `xhigh` gemeldet. Verwenden Sie dies, um Skill-Anweisungen an die aktive Anstrengungseinstellung anzupassen. |426| `${CLAUDE_EFFORT}` | Die aktuelle Aufwandsstufe: `low`, `medium`, `high`, `xhigh` oder `max`. Ultracode ist keine separate Stufe und wird als `xhigh` gemeldet. Verwenden Sie dies, um Fähigkeitsanweisungen an die aktive Aufwandseinstellung anzupassen. |

304| `${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. |427| `${CLAUDE_SKILL_DIR}` | Das Verzeichnis, das die `SKILL.md`-Datei der Fähigkeit enthält. Für Plugin-Fähigkeiten ist dies das Fähigkeitsunterverzeichnis innerhalb des Plugins, nicht die Plugin-Root. Verwenden Sie dies in Bash-Injektionsbefehlen, um auf Skripte oder Dateien zu verweisen, die mit der Fähigkeit gebündelt sind, unabhängig vom aktuellen Arbeitsverzeichnis. |

305| `${CLAUDE_PROJECT_DIR}` | Das Projekt-Root-Verzeichnis. Dies ist der gleiche Pfad, den [Hooks](/docs/de/hooks#reference-scripts-by-path) und MCP-Server als `CLAUDE_PROJECT_DIR` erhalten. Verwenden Sie dies, um auf projektlokale Scripts oder Dateien zu verweisen, wie `${CLAUDE_PROJECT_DIR}/.claude/hooks/helper.sh`, unabhängig davon, wo der Skill installiert ist. |428| `${CLAUDE_PROJECT_DIR}` | Das Projektroot-Verzeichnis. Dies ist der gleiche Pfad, den [Hooks](/docs/de/hooks#reference-scripts-by-path) und MCP-Server als `CLAUDE_PROJECT_DIR` erhalten. Verwenden Sie dies, um auf projektlokale Skripte oder Dateien zu verweisen, z. B. `${CLAUDE_PROJECT_DIR}/.claude/hooks/helper.sh`, unabhängig davon, wo die Fähigkeit installiert ist. |

429| `${CLAUDE_PLUGIN_ROOT}` | Das Installationsverzeichnis des Plugins. Wird nur in Plugin-Fähigkeiten ersetzt. Verwenden Sie dies, um auf Skripte oder Dateien zu verweisen, die überall im Plugin gebündelt sind, einschließlich Ressourcen, die zwischen den Plugin-Fähigkeiten geteilt werden. Siehe [Plugin-Umgebungsvariablen](/docs/de/plugins-reference#environment-variables). |

430| `${CLAUDE_PLUGIN_DATA}` | Das [persistente Datenverzeichnis](/docs/de/plugins-reference#persistent-data-directory) des Plugins, das Plugin-Updates überlebt. Wird nur in Plugin-Fähigkeiten ersetzt. Verwenden Sie dies, um auf installierte Abhängigkeiten, generierte Dateien oder Caches zu verweisen, die ein Update überleben müssen. |

306 431 

307Die `${CLAUDE_PROJECT_DIR}`-Substitution erfordert Claude Code v2.1.196 oder später. Sie gilt sowohl für den Skill-Text als auch für das [`allowed-tools`](#frontmatter-reference)-Frontmatter, sodass eine Berechtigungsregel wie `Bash(${CLAUDE_PROJECT_DIR}/scripts/lint.sh *)` zum gleichen Pfad aufgelöst wird, den der Skill-Text verwendet.432Claude Code ersetzt `${CLAUDE_SKILL_DIR}` und `${CLAUDE_PROJECT_DIR}` an zwei Stellen: im Markdown-Inhalt der Fähigkeit und in Bash-Regeln im [`allowed-tools`](#frontmatter-reference)-Frontmatter. In einer Plugin-Fähigkeit ersetzt Claude Code `${CLAUDE_PLUGIN_ROOT}` und `${CLAUDE_PLUGIN_DATA}` an den gleichen zwei Stellen. Die Verwendung der gleichen Variable an beiden Stellen ermöglicht es einer Fähigkeit, ein gebündeltes Skript ohne Genehmigungsaufforderung auszuführen. Die folgende Fähigkeit zeigt das Muster:

308 433 

309Indizierte 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.434```yaml theme={null}

435---

436name: render-chart

437description: Render a chart from a CSV file

438allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/render.sh *)

439---

440 

441Run `${CLAUDE_SKILL_DIR}/scripts/render.sh <csv-file>` to render the chart.

442```

443 

444Wenn diese Fähigkeit unter `~/.claude/skills/render-chart/` installiert ist, expandieren beide Vorkommen von `${CLAUDE_SKILL_DIR}` zu diesem Verzeichnis. Die `allowed-tools`-Regel stimmt dann mit dem genauen Befehl überein, den der Fähigkeitstext Claude ausführen sagt, sodass das Skript ohne Aufforderung ausgeführt wird.

445 

446Die `${CLAUDE_PROJECT_DIR}`-Substitution erfordert Claude Code v2.1.196 oder später.

447 

448Indizierte Argumente verwenden Shell-ähnliche Anführungszeichen, sodass mehrteilige Werte in Anführungszeichen einschließen, 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 expandiert immer zur vollständigen Argumentzeichenkette wie eingegeben.

310 449 

311Um ein Literal `$` vor einer Ziffer, `ARGUMENTS` oder einem deklarierten Argumentnamen einzufügen, z. B. `$1.00` in Prosa, maskieren Sie es mit einem Backslash: `\$1.00`. Ein Backslash vor jedem anderen `$` wird unverändert gelassen. Nur ein einzelner Backslash direkt vor dem Token maskiert ihn. Ein doppelter Backslash wie `\\$1` lässt beide Backslashes an Ort und Stelle, und `$1` wird immer noch zum Argumentwert erweitert.450Ein indizierter Platzhalter ohne entsprechendes Argument, z. B. `$2`, wenn nur ein Argument übergeben wurde, bleibt im Inhalt unverändert. Ein benannter Platzhalter aus dem [`arguments`](#frontmatter-reference)-Frontmatter ohne übereinstimmendes Argument expandiert zu einer leeren Zeichenkette.

451 

452Wenn Sie einen Argumentwert übergeben, der selbst Text wie `$1` oder `$ARGUMENTS` enthält, fügt Claude Code ihn als Literaltext ein und expandiert ihn nicht. Zum Beispiel, wenn der Fähigkeitstext `Summarize $0` enthält und Sie `/summarize "$ARGUMENTS from yesterday"` ausführen, empfängt Claude `Summarize $ARGUMENTS from yesterday`. Claude Code ersetzt immer noch `${CLAUDE_*}`-Variablen wie `${CLAUDE_SKILL_DIR}`, nachdem es die Argumente eingefügt hat.

453 

454Um ein Literal `$` vor einer Ziffer, `ARGUMENTS` oder einem deklarierten Argumentnamen einzubeziehen, z. B. `$1.00` in Prosa, maskieren Sie es mit einem Backslash: `\$1.00`. Ein Backslash vor jedem anderen `$` bleibt unverändert. Nur ein einzelner Backslash direkt vor dem Token maskiert ihn. Ein verdoppelter Backslash wie `\\$1` lässt beide Backslashes an Ort und Stelle, und `$1` expandiert immer noch zum Argumentwert. Die Backslash-Maskierung deckt nur diese Argumentplatzhalter ab. Ein Backslash verhindert nicht die Substitution einer `${CLAUDE_*}`-Variable, wo die Variable angewendet wird.

312 455 

313**Beispiel mit Substitutionen:**456**Beispiel mit Substitutionen:**

314 457 

327 Unterstützende Dateien hinzufügen470 Unterstützende Dateien hinzufügen

328</h3>471</h3>

329 472 

330Skills 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.473Fähigkeiten können mehrere Dateien in ihrem Verzeichnis enthalten. Dies hält `SKILL.md` auf das Wesentliche konzentriert, während Claude auf detailliertes Referenzmaterial nur bei Bedarf zugreifen kann. Große Referenzdokumente, API-Spezifikationen oder Beispielsammlungen müssen nicht jedes Mal geladen werden, wenn die Fähigkeit ausgeführt wird.

331 474 

332```text theme={null}475```text theme={null}

333my-skill/476my-skill/

338 └── helper.py (utility script - executed, not loaded)481 └── helper.py (utility script - executed, not loaded)

339```482```

340 483 

341Verweisen Sie auf unterstützende Dateien von `SKILL.md` aus, damit Claude weiß, was jede Datei enthält und wann sie geladen werden soll:484Verweisen Sie auf unterstützende Dateien aus `SKILL.md`, damit Claude weiß, was jede Datei enthält und wann sie geladen werden soll:

342 485 

343```markdown theme={null}486```markdown theme={null}

344## Additional resources487## Additional resources

350<Tip>Halten Sie `SKILL.md` unter 500 Zeilen. Verschieben Sie detailliertes Referenzmaterial in separate Dateien.</Tip>493<Tip>Halten Sie `SKILL.md` unter 500 Zeilen. Verschieben Sie detailliertes Referenzmaterial in separate Dateien.</Tip>

351 494 

352<h3 id="control-who-invokes-a-skill">495<h3 id="control-who-invokes-a-skill">

353 Steuern Sie, wer einen Skill aufruft496 Kontrollieren Sie, wer eine Fähigkeit aufruft

354</h3>497</h3>

355 498 

356Standardmäß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:499Standardmäßig können Sie und Claude jede Fähigkeit aufrufen. Sie können `/skill-name` eingeben, um sie direkt aufzurufen, und Claude kann sie automatisch laden, wenn sie für Ihr Gespräch relevant ist. Zwei Frontmatter-Felder ermöglichen es Ihnen, dies einzuschränken:

357 500 

358* **`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.501* **`disable-model-invocation: true`**: Nur Sie können die Fähigkeit aufrufen. Verwenden Sie dies für Workflows mit Nebenwirkungen oder die Sie zeitlich kontrollieren möchten, wie `/commit`, `/deploy` oder `/send-slack-message`. Sie möchten nicht, dass Claude bereitstellt, weil Ihr Code bereit aussieht.

359 502 

360* **`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.503* **`user-invocable: false`**: Nur Claude kann die Fähigkeit aufrufen. Verwenden Sie dies für Hintergrundwissen, das nicht als Befehl umsetzbar ist. Eine `legacy-system-context`-Fähigkeit erklärt, wie ein altes System funktioniert. Claude sollte dies kennen, wenn relevant, aber `/legacy-system-context` ist keine aussagekräftige Aktion für Benutzer.

361 504 

362Dieses 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:505Dieses Beispiel erstellt eine Deploy-Fähigkeit, die nur Sie auslösen können. Wenn Sie `disable-model-invocation: true` setzen, kann Claude die Fähigkeit nicht automatisch ausführen:

363 506 

364```yaml theme={null}507```yaml theme={null}

365---508---

3764. Verify the deployment succeeded5194. Verify the deployment succeeded

377```520```

378 521 

522Wenn Claude es trotzdem versucht, blockiert Claude Code den Aufruf und weist es an, die Deploy-Schritte nicht auf andere Weise zu reproduzieren, sodass Sie erwarten können, dass Claude vorschlägt, `/deploy` selbst auszuführen.

523 

379Hier ist, wie die beiden Felder Aufrufe und Kontextladung beeinflussen:524Hier ist, wie die beiden Felder Aufrufe und Kontextladung beeinflussen:

380 525 

381| Frontmatter | Sie können aufrufen | Claude kann aufrufen | Wann in Kontext geladen |526| Frontmatter | Sie können aufrufen | Claude kann aufrufen | Wann in Kontext geladen |

382| :------------------------------- | :------------------ | :------------------- | :--------------------------------------------------------------------------------- |527| :------------------------------- | :------------------ | :------------------- | :----------------------------------------------------------------------------------------- |

383| (Standard) | Ja | Ja | Beschreibung immer im Kontext, vollständiger Skill wird beim Aufrufen geladen |528| (Standard) | Ja | Ja | Beschreibung immer im Kontext, vollständige Fähigkeit wird beim Aufrufen geladen |

384| `disable-model-invocation: true` | Ja | Nein | Beschreibung nicht im Kontext, vollständiger Skill wird geladen, wenn Sie aufrufen |529| `disable-model-invocation: true` | Ja | Nein | Beschreibung nicht im Kontext, vollständige Fähigkeit wird beim Aufrufen durch Sie geladen |

385| `user-invocable: false` | Nein | Ja | Beschreibung immer im Kontext, vollständiger Skill wird beim Aufrufen geladen |530| `user-invocable: false` | Nein | Ja | Beschreibung immer im Kontext, vollständige Fähigkeit wird beim Aufrufen geladen |

386 531 

387<Note>532<Note>

388 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](/docs/de/sub-agents#preload-skills-into-subagents) funktionieren anders: Der vollständige Skill-Inhalt wird beim Start eingespritzt.533 In einer regulären Sitzung werden Fähigkeitsbeschreibungen in den Kontext geladen, damit Claude weiß, was verfügbar ist, aber vollständiger Fähigkeitsinhalt wird nur beim Aufrufen geladen. [Subagents mit vorgeladenen Fähigkeiten](/docs/de/sub-agents#preload-skills-into-subagents) funktionieren anders: Der vollständige Fähigkeitsinhalt wird beim Start eingespritzt.

389</Note>534</Note>

390 535 

391<h3 id="skill-content-lifecycle">536<h3 id="skill-content-lifecycle">

392 Skill-Inhalts-Lebenszyklus537 Fähigkeitsinhalts-Lebenszyklus

393</h3>538</h3>

394 539 

395Wenn 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.540Wenn Sie oder Claude eine Fähigkeit aufrufen, tritt der gerenderte `SKILL.md`-Inhalt als einzelne Nachricht in das Gespräch ein und bleibt über spätere Turns hinweg bestehen. Diese Persistenz gilt für die Anweisungen der Fähigkeit, nicht ihre Berechtigungen: Eine [`allowed-tools`](#pre-approve-tools-for-a-skill)-Genehmigung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. Claude Code liest die Fähigkeitsdatei bei späteren Turns nicht erneut, daher schreiben Sie Anleitung, die während einer Aufgabe gelten sollte, als stehende Anweisungen anstelle von einmaligen Schritten.

396 541 

397Wenn Claude einen Skill erneut aufruft, dessen gerenderter Inhalt identisch mit der bereits im Kontext vorhandenen Kopie ist, fügt Claude Code eine kurze Notiz hinzu, dass der Skill bereits geladen ist, anstatt eine zweite Kopie des Inhalts zu erstellen. Wenn sich der gerenderte Inhalt unterscheidet, weil sich die Argumente geändert haben oder ein [dynamischer Kontext](#inject-dynamic-context)-Befehl neue Ausgabe erzeugt hat, hängt Claude Code den vollständigen Inhalt erneut an. Vor v2.1.202 hängte jeder erneute Aufruf eine weitere vollständige Kopie der Skill-Anweisungen an.542Wenn Claude eine Fähigkeit erneut aufruft, deren gerenderter Inhalt identisch mit der bereits im Kontext vorhandenen Kopie ist, fügt Claude Code einen kurzen Hinweis hinzu, dass die Fähigkeit bereits geladen ist, anstatt eine zweite Kopie des Inhalts zu erstellen. Wenn sich der gerenderte Inhalt unterscheidet, weil sich die Argumente geändert haben oder ein [dynamischer Kontext](#inject-dynamic-context)-Befehl neue Ausgabe erzeugt hat, hängt Claude Code den vollständigen Inhalt erneut an.

398 543 

399[Auto-Komprimierung](/docs/de/how-claude-code-works#when-context-fills-up) 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.544[Auto-Komprimierung](/docs/de/how-claude-code-works#when-context-fills-up) trägt aufgerufene Fähigkeiten innerhalb eines Token-Budgets vorwärts. Wenn das Gespräch zusammengefasst wird, um Kontext freizugeben, hängt Claude Code die neueste Aufrufinvokation jeder Fähigkeit nach der Zusammenfassung erneut an, wobei die ersten 5.000 Token jeder beibehalten werden. Erneut angehängte Fähigkeiten teilen sich ein kombiniertes Budget von 25.000 Token. Claude Code füllt dieses Budget beginnend mit der zuletzt aufgerufenen Fähigkeit, sodass ältere Fähigkeiten vollständig gelöscht werden können, nachdem die Komprimierung erfolgt ist, wenn Sie viele in einer Sitzung aufgerufen haben.

400 545 

401Wenn 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](/docs/de/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.546Wenn eine Fähigkeit nach der ersten Antwort zu beeinflussen zu stoppen 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 der Fähigkeit, damit das Modell sie weiterhin bevorzugt, oder verwenden Sie [Hooks](/docs/de/hooks), um Verhalten deterministisch zu erzwingen. Wenn die Fähigkeit groß ist oder Sie mehrere andere danach aufgerufen haben, rufen Sie sie nach der Komprimierung erneut auf, um den vollständigen Inhalt wiederherzustellen.

402 547 

403<h3 id="pre-approve-tools-for-a-skill">548<h3 id="pre-approve-tools-for-a-skill">

404 Tools für einen Skill vorab genehmigen549 Tools für eine Fähigkeit vorab genehmigen

405</h3>550</h3>

406 551 

407Das `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](/docs/de/permissions) regeln weiterhin Tools, die nicht aufgelistet sind.552Das Feld `allowed-tools` gewährt Genehmigung für die aufgelisteten Tools während des Turns, der die Fähigkeit aufruft, sodass Claude sie ohne Genehmigungsaufforderung verwenden kann. Die Genehmigung wird gelöscht, wenn Sie Ihre nächste Nachricht senden, obwohl der Fähigkeitsinhalt [im Kontext bleibt](#skill-content-lifecycle); das erneute Aufrufen der Fähigkeit wendet es für diesen Turn erneut an. Es schränkt nicht ein, welche Tools verfügbar sind: Jedes Tool bleibt aufrufbar, und Ihre [Berechtigungseinstellungen](/docs/de/permissions) regieren immer noch Tools, die nicht aufgelistet sind. Um Tools für die ganze Sitzung vorab zu genehmigen, anstatt einen einzelnen Turn, fügen Sie stattdessen Zulassungsregeln zu diesen Berechtigungseinstellungen hinzu.

408 553 

409Fü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.554Workspace-Vertrauen gatet dieses Feld nicht. Claude Code wendet die `allowed-tools` einer Projektfähigkeit an, wann immer Sie oder Claude die Fähigkeit aufrufen, einschließlich in einem `-p`-Lauf in einem Ordner, dem Sie nie vertraut haben. Eine Fähigkeit kann sich selbst breiten Tool-Zugriff gewähren, daher überprüfen Sie die `allowed-tools` von Fähigkeiten, die in ein Repository eingecheckt sind, bevor Sie Claude Code dort ausführen.

410 555 

411Dieser Skill lässt Claude Git-Befehle ohne Genehmigung pro Verwendung ausführen, wenn Sie ihn aufrufen:556Diese Fähigkeit ermöglicht es Claude, Git-Befehle ohne Genehmigung pro Verwendung auszuführen, wann immer Sie sie aufrufen:

412 557 

413```yaml theme={null}558```yaml theme={null}

414---559---

419---564---

420```565```

421 566 

422Um Tools aus Claudes verfügbarem Pool zu entfernen, während ein Skill aktiv ist, listen Sie sie in `disallowed-tools` im Frontmatter des Skills auf. Die Einschränkung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. Um Tools über alle Skills und Eingaben hinweg zu blockieren, fügen Sie Ablehnungsregeln in Ihren [Berechtigungseinstellungen](/docs/de/permissions) hinzu.567Um Tools aus Claudes verfügbarem Pool zu entfernen, während eine Fähigkeit aktiv ist, listen Sie sie im `disallowed-tools` im Frontmatter der Fähigkeit auf. Die Einschränkung wird gelöscht, wenn Sie Ihre nächste Nachricht senden. Wie Ablehnungsregeln kann das Feld [`EndConversation`](/docs/de/tools-reference#endconversation-tool-behavior) nicht entfernen, während ein anderes Tool verfügbar bleibt. Um Tools über alle Fähigkeiten und Eingabeaufforderungen hinweg zu blockieren, fügen Sie Ablehnungsregeln in Ihren [Berechtigungseinstellungen](/docs/de/permissions) hinzu.

423 568 

424<h3 id="pass-arguments-to-skills">569<h3 id="pass-arguments-to-skills">

425 Argumente an Skills übergeben570 Argumente an Fähigkeiten übergeben

426</h3>571</h3>

427 572 

428Sowohl Sie als auch Claude können Argumente beim Aufrufen eines Skills übergeben. Argumente sind über den `$ARGUMENTS`-Platzhalter verfügbar.573Sowohl Sie als auch Claude können Argumente beim Aufrufen einer Fähigkeit übergeben. Argumente sind über den `$ARGUMENTS`-Platzhalter verfügbar.

429 574 

430Dieser Skill behebt ein GitHub-Problem nach Nummer. Der `$ARGUMENTS`-Platzhalter wird durch alles ersetzt, was dem Skill-Namen folgt:575Diese Fähigkeit behebt ein GitHub-Problem nach Nummer. Der `$ARGUMENTS`-Platzhalter wird durch alles ersetzt, das dem Fähigkeitsnamen folgt:

431 576 

432```yaml theme={null}577```yaml theme={null}

433---578---

4455. Create a commit5905. Create a commit

446```591```

447 592 

448Wenn Sie `/fix-issue 123` ausführen, erhält Claude „Fix GitHub issue 123 following our coding standards..."593Wenn Sie `/fix-issue 123` ausführen, empfängt Claude „Fix GitHub issue 123 following our coding standards..."

449 594 

450Wenn 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.595Wenn Sie eine Fähigkeit mit Argumenten aufrufen, aber kein Platzhalter im Fähigkeitsinhalt ein Argument empfängt, hängt Claude Code `ARGUMENTS: <your input>` am Ende des Fähigkeitsinhalts an, damit Claude immer noch sieht, was Sie eingegeben haben. Ein Platzhalter ist `$ARGUMENTS`, eine indizierte Form wie `$1` oder ein benanntes Argument. Ein indizierter Platzhalter ohne Argument an seiner Position bleibt als Literaltext und zählt nicht als empfangen. Ein benannter Platzhalter zählt auch, wenn seine Position kein Argument hat, weil er zu einer leeren Zeichenkette expandiert.

451 596 

452Sie können auch mehrere Skills am Anfang einer Nachricht stapeln. Ab v2.1.199 lädt das Eingeben von `/code-review /fix-issue 123` beide Skills und übergibt den nachfolgenden Text `123` als `$ARGUMENTS` an jeden von ihnen. In früheren Versionen wurde nur der erste Skill geladen und erhielt `/fix-issue 123` als wörtlichen Argumenttext.597Sie können auch mehrere Fähigkeiten am Anfang einer Nachricht stapeln. Das Eingeben von `/write-tests /fix-issue 123` lädt beide Fähigkeiten und übergibt den nachfolgenden Text `123` als `$ARGUMENTS` an jede von ihnen. Vor v2.1.199 wurde nur die erste Fähigkeit geladen und erhielt `/fix-issue 123` als Literalargumenttext.

453 598 

454Claude Code erweitert den ersten Skill plus bis zu fünf weitere, die danach gestapelt sind. Die Erweiterung stoppt beim ersten Token, das kein Inline-Benutzer-aufgerufener Skill ist, daher endet auch ein Skill, der als [verzweigter Subagent](#run-skills-in-a-subagent) ausgeführt wird, oder einer, dessen Argumente selbst mit einem Schrägstrich-Befehl beginnen können, wie `/loop`, auch dort; dieses Token und alles danach werden zum Argumenttext für jeden erweiterten Skill.599Claude Code expandiert die erste Fähigkeit plus bis zu fünf weitere, die danach gestapelt sind. Die Expansion stoppt beim ersten Token, das keine Inline-Benutzer-aufgerufene Fähigkeit ist, sodass eine Fähigkeit, die als [verzweigter Subagent](#run-skills-in-a-subagent) ausgeführt wird, wie [`/code-review`](/docs/de/code-review#review-a-diff-locally), oder eine, deren Argumente selbst mit einem Schrägstrich-Befehl beginnen können, wie `/loop`, auch dort endet. Dieser Token und alles danach werden der Argumenttext für jede expandierte Fähigkeit. `/code-review` wird ab v2.1.218 als verzweigter Subagent ausgeführt; in früheren Versionen wurde es inline ausgeführt und gestapelt.

455 600 

456Um auf einzelne Argumente nach Position zuzugreifen, verwenden Sie `$ARGUMENTS[N]` oder die kürzere Form `$N`:601Um auf einzelne Argumente nach Position zuzugreifen, verwenden Sie `$ARGUMENTS[N]` oder die kürzere `$N`:

457 602 

458```yaml theme={null}603```yaml theme={null}

459---604---

460name: migrate-component605name: migrate-component

461description: Migrate a component from one framework to another606description: Migrate a component from one language to another

462---607---

463 608 

464Migrate the $ARGUMENTS[0] component from $ARGUMENTS[1] to $ARGUMENTS[2].609Migrate the $ARGUMENTS[0] component from $ARGUMENTS[1] to $ARGUMENTS[2].

465Preserve all existing behavior and tests.610Preserve all existing behavior and tests.

466```611```

467 612 

468Wenn 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:613Das Ausführen von `/migrate-component SearchBar JavaScript TypeScript` ersetzt `$ARGUMENTS[0]` durch `SearchBar`, `$ARGUMENTS[1]` durch `JavaScript` und `$ARGUMENTS[2]` durch `TypeScript`. Die gleiche Fähigkeit mit der `$N`-Kurzform:

469 614 

470```yaml theme={null}615```yaml theme={null}

471---616---

472name: migrate-component617name: migrate-component

473description: Migrate a component from one framework to another618description: Migrate a component from one language to another

474---619---

475 620 

476Migrate the $0 component from $1 to $2.621Migrate the $0 component from $1 to $2.

478```623```

479 624 

480<h2 id="advanced-patterns">625<h2 id="advanced-patterns">

481 Fortgeschrittene Muster626 Erweiterte Muster

482</h2>627</h2>

483 628 

484<h3 id="inject-dynamic-context">629<h3 id="inject-dynamic-context">

485 Dynamischen Kontext einspritzen630 Dynamischen Kontext injizieren

486</h3>631</h3>

487 632 

488Die `` !`<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.633Die Syntax `` !`<command>` `` 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. Claude Code führt diese Befehle auf Ihrem Computer nicht aus, wenn der Skill [von Ihrem claude.ai-Konto synchronisiert wird](#how-claude-code-handles-the-body-of-a-synced-skill).

489 634 

490Dieser 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:635Dieser Skill fasst einen Pull Request zusammen, indem er Live-PR-Daten mit der GitHub CLI abruft. Die Befehle `` !`gh pr diff` `` und andere werden zuerst ausgeführt, und ihre Ausgabe wird in den Prompt eingefügt:

491 636 

492```yaml theme={null}637```yaml theme={null}

493---638---

507Summarize this pull request...652Summarize this pull request...