1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Erstelle einen Mod

6 

7> Lasse Claude einen Claude Code Mod aus einer Beschreibung schreiben, oder schreibe selbst einen, der Werkzeugaufrufe zählt und einen Befehl hinzufügt. Lerne die Reload- und Validierungsschleife.

8 

9Ein Mod ist ein Claude Code [Plugin](/docs/de/plugins/overview) mit einer Eingabedatei, genannt das Hooks-Modul: eine JavaScript- oder TypeScript-Datei, deren Funktionen Claude Code aufruft, wenn Ereignisse auftreten. Es gibt zwei Möglichkeiten, einen zu erstellen:

10 

11* **Claude bitten, ihn zu schreiben**: [beschreibe, was du möchtest](#ask-claude-for-a-mod) in einer Claude Code Sitzung

12* **Schreibe ihn selbst**: [folge dem Tutorial](#write-a-mod-yourself), um zu lernen, wie der Code eines Mods funktioniert. Du brauchst Node.js, einen Bundler oder einen Build-Schritt nicht, da Claude Code `.js` und `.ts` Dateien direkt lädt.

13 

14Wenn du dich noch nicht entschieden hast, ob ein Mod das richtige Werkzeug ist, lies zuerst den [Vergleich in der Übersicht](/docs/de/plugins/mods/overview#compare-mods-settings-hooks-skills-and-mcp-servers).

15 

16<Note>

17 Mods erfordern Claude Code v2.1.287 oder später. Führe in deiner Shell `claude --version` aus, um dies zu überprüfen. Um zu sehen, ob Mods für dich geladen werden können, siehe [Überprüfe, ob Mods geladen werden können](/docs/de/plugins/mods/troubleshoot#check-whether-mods-can-load).

18</Note>

19 

20<h2 id="ask-claude-for-a-mod">

21 Claude um einen Mod bitten

22</h2>

23 

24Beschreibe den Mod, den du möchtest, in einer interaktiven Claude Code Sitzung, und Claude schreibt ihn. Claude arbeitet von einer integrierten [Skill](/docs/de/skills) namens `plugin-authoring`, die ihm sagt, wo der Mod geschrieben werden soll, welche Ereignisse und Methoden deine Version hat, und wie der Mod geladen wird. Claude kann die Skill laden, wenn du um einen Mod bittest, oder du kannst sie selbst laden, indem du `/plugin-authoring` an der Claude Code Eingabeaufforderung ausführst.

25 

26Der Mod wird ausgeführt, sobald du ihn genehmigst, außer in [Sitzungen, in denen ein von Claude geschriebener Mod nicht geladen werden kann](#sessions-that-skip-the-approval).

27 

28<Steps>

29 <Step title="Beschreibe den Mod">

30 Bitte um den Mod in deinen eigenen Worten, zum Beispiel `make a mod that shows the current git branch above the prompt`. Claude schreibt den Mod in einem eigenen Verzeichnis im Mods-Ordner der Sitzung, das `~/.claude/dev-mods/` gefolgt von der Sitzungs-ID ist. Der vollständige Pfad eines Mods sieht wie `~/.claude/dev-mods/3f2a9c1e-5b7d-4e8a-9c21-6d0f4b8a7e13/git-branch/` aus.

31 

32 <Note>

33 In den [Berechtigungsmodi](/docs/de/permission-modes#protected-paths) `default` und `acceptEdits` fragt Claude Code, bevor Claude jede der Dateien des Mods erstellt, da `~/.claude` ein geschützter Pfad ist. Genehmige jede Datei, wenn sie auftaucht.

34 </Note>

35 </Step>

36 

37 <Step title="Genehmige den Mod">

38 Wenn Claude die erste Datei speichert, fragt Claude Code, ob Hot Reloading für die Sitzung aktiviert werden soll. Hot Reloading führt die Mods aus, die Claude in dieser Sitzung schreibt, und nimmt jede spätere Änderung auf.

39 

40 Wähle eine dieser Antworten:

41 

42 * **Für diese Sitzung aktivieren**: Die Mods im Mods-Ordner der Sitzung werden geladen, wenn die Runde endet, und werden am Ende jeder Runde neu geladen, die sie ändert. Deine Antwort gilt für die Sitzung, auch nachdem du sie fortgesetzt hast.

43 * **Nicht jetzt**: Nichts wird jetzt geladen. Die Dateien bleiben dort, wo Claude sie geschrieben hat, und die Mods werden beim nächsten Start dieser Sitzung geladen. Um zu verhindern, dass ein Mod jemals geladen wird, lösche sein Verzeichnis.

44 </Step>

45 

46 <Step title="Überprüfe, dass der Mod geladen wurde">

47 Führe `/plugin` an der Claude Code Eingabeaufforderung aus und drücke Tab, bis die Registerkarte **Installed** ausgewählt ist. Sie listet den Mod auf, und du kannst ihn dort ausschalten.

48 </Step>

49 

50 <Step title="Probiere den Mod aus">

51 Nutze das, worum du gebeten hast. Für die Beispiel-Eingabeaufforderung erscheint der aktuelle Branchname über dem Eingabefeld. Wenn der Mod nicht das tut, was du wolltest, sag Claude, was geändert werden soll. Der Mod wird am Ende jeder Runde neu geladen, die seine Dateien ändert, sodass du die Änderung ausprobieren kannst, sobald Claude fertig ist.

52 </Step>

53</Steps>

54 

55<h3 id="use-the-mod-in-other-sessions">

56 Verwende den Mod in anderen Sitzungen

57</h3>

58 

59Ein Mod, den Claude geschrieben hat, wird nur in der Sitzung geladen, die ihn erstellt hat, und Claude Code löscht den Mods-Ordner dieser Sitzung, sobald er älter als [`cleanupPeriodDays`](/docs/de/settings-reference#cleanupperioddays) ist. Um den Mod zu behalten, kopiere sein Verzeichnis aus dem Mods-Ordner an einen Ort deiner Wahl, z. B. `~/mods/git-branch`. Wähle dann, wie du ihn laden möchtest:

60 

61* **In einer Sitzung, die du startest**: Führe in deiner Shell `claude --plugin-dir ~/mods/git-branch` aus

62* **Für andere Personen**: [Füge ihn zu einem Marketplace hinzu](#share-your-mod), damit sie ihn installieren können

63 

64<h3 id="sessions-that-skip-the-approval">

65 Sitzungen, in denen ein von Claude geschriebener Mod nicht geladen werden kann

66</h3>

67 

68Ein Mod, den Claude schreibt, wird nur geladen, nachdem du ihn genehmigt hast, in einem vertrauenswürdigen Arbeitsbereich, in dem Mods ausgeführt werden dürfen. In diesen Sitzungen wird er nicht geladen:

69 

70* **Niemand ist da, um zu genehmigen**: Die Sitzung kann dir keine Eingabeaufforderung anzeigen, wie in einem `claude -p` Lauf oder im [`dontAsk` Modus](/docs/de/permission-modes)

71* **Der Arbeitsbereich ist nicht vertrauenswürdig**: Du hast die Vertrauensaufforderung für das Verzeichnis nicht akzeptiert

72* **Mods sind gestoppt**: Du hast mit `--safe-mode` oder `--bare` gestartet, du hast `disableAllHooks` gesetzt, oder die [verwalteten Einstellungen](/docs/de/plugins/mods/admin#choose-how-much-to-allow) deiner Organisation blockieren es

73 

74<h2 id="write-a-mod-yourself">

75 Schreibe einen Mod selbst

76</h2>

77 

78In diesem Tutorial erstellst du einen Mod namens `first-mod`, der die Werkzeugaufrufe zählt, die Claude macht, die Anzahl neben dem Spinner anzeigt, während Claude arbeitet, und einen `/tally` Befehl hinzufügt, der sie ausdruckt. Dann liest du die Typdeklarationen, die Claude Code neben deinem Mod schreibt, und führst `claude plugin validate` aus. Zusammen zeigen sie dir die Ereignisse und Methoden, die deine Version bietet, und was Claude Code aus deinem Code liest.

79 

80Diese Aufzeichnung zeigt den fertigen Mod. Der Spinner zählt Werkzeugaufrufe, `/tally` druckt die Anzahl, und eine Bearbeitung des Codes wird wirksam, während die Sitzung läuft:

81 

82<Frame>

83 <video autoPlay muted loop playsInline controls className="w-full dark:hidden" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-light.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=eb561134afa90375777408453ba51c77" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-light.mp4" />

84 

85 <video autoPlay muted loop playsInline controls className="w-full hidden dark:block" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-dark.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=09779dadc7ef66c2b1e2da0c2e31ac72" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-dark.mp4" />

86</Frame>

87 

88Du schreibst drei Dateien:

89 

90```text theme={null}

91first-mod/

92├── .claude-plugin/

93│ └── plugin.json

94└── hooks/

95 ├── hooks.json

96 └── register.js

97```

98 

99* **`plugin.json`**: das [Manifest](/docs/de/plugins/manifest-reference) des Plugins

100* **`hooks.json`**: [verweist auf deine Codedatei](/docs/de/plugins/mods/reference#files)

101* **`register.js`**: dein Code, genannt das Hooks-Modul

102 

103<Steps>

104 <Step title="Erstelle das Plugin-Verzeichnis">

105 Erstelle die zwei Verzeichnisse, die die Dateien enthalten:

106 

107 <Tabs>

108 <Tab title="Bash oder Zsh">

109 ```bash theme={null}

110 mkdir -p first-mod/.claude-plugin first-mod/hooks

111 ```

112 </Tab>

113 

114 <Tab title="PowerShell">

115 ```powershell theme={null}

116 New-Item -ItemType Directory -Force first-mod\.claude-plugin, first-mod\hooks

117 ```

118 </Tab>

119 </Tabs>

120 </Step>

121 

122 <Step title="Schreibe das Manifest">

123 Ein Mod ist ein Plugin, und ein Mod braucht ein [Manifest](/docs/de/plugins/manifest-reference). Das Manifest dieses Mods hat keine speziellen Felder. Speichere dies als `first-mod/.claude-plugin/plugin.json`:

124 

125 ```json first-mod/.claude-plugin/plugin.json theme={null}

126 {

127 "name": "first-mod",

128 "version": "0.1.0",

129 "description": "Counts Claude's tool calls, shows the count beside the spinner, and adds a /tally command",

130 "author": { "name": "Your Name" }

131 }

132 ```

133 </Step>

134 

135 <Step title="Sag Claude Code, wo dein Code ist">

136 Wenn Claude Code ein Plugin lädt, liest es die `hooks/hooks.json` des Plugins. Der `modules` Schlüssel in dieser Datei gibt den Pfad zu deinem Code an, und ihn zu haben ist das, was das Plugin zu einem Mod macht. Liste einen Pfad auf, relativ zu `hooks.json`. Hier verweist es auf `register.js`, das du im nächsten Schritt schreibst.

137 

138 Speichere dies als `first-mod/hooks/hooks.json`:

139 

140 ```json first-mod/hooks/hooks.json theme={null}

141 {

142 "description": "The first-mod hooks module",

143 "modules": ["./register.js"]

144 }

145 ```

146 </Step>

147 

148 <Step title="Schreibe den Code">

149 Diese Datei ist der Code des Mods, genannt das Hooks-Modul. Wenn der Mod geladen wird, ruft Claude Code die `register` Funktion auf, die die Datei exportiert, und übergibt ihr eine Funktion namens [`on`](/docs/de/plugins/mods/reference#the-hook-function). Jeder Aufruf zu `on` registriert einen Ereignishandler, genannt ein Hook, für das Ereignis, das er benennt.

150 

151 Speichere dies als `first-mod/hooks/register.js`:

152 

153 ```javascript first-mod/hooks/register.js theme={null}

154 // The count, shared by the hooks below

155 let calls = 0

156 

157 // Claude Code calls this once when the mod loads

158 export function register(on) {

159 // Runs when the session starts, before your first prompt

160 on('session.start', async ($, e, next) => {

161 // Add the /tally command

162 await $.command.register({

163 name: 'tally',

164 description: 'Show how many tool calls Claude has made',

165 })

166 // Let the session start as usual

167 return next(e)

168 })

169 

170 // Runs each time Claude is about to use a tool

171 on('tool.call', async ($, e, next) => {

172 calls += 1

173 // Ask Claude Code to draw the interface again, so the new count shows

174 $.ui.invalidate('ui.render')

175 // Let the tool run as usual

176 return next(e)

177 })

178 

179 // Runs when you type /tally, and only then, because of the matcher

180 on('command.run', { command: 'tally' }, async () => {

181 // The text to print in the transcript

182 return { text: 'Claude has made ' + calls + ' tool calls since this mod loaded' }

183 })

184 

185 // Runs each time Claude Code draws the spinner

186 on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

187 // Keep Claude Code's spinner, with the count added after its word

188 return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })

189 })

190 }

191 ```

192 

193 Die Datei behält eine Anzahl in `calls` und registriert vier Hooks:

194 

195 * **[`session.start`](/docs/de/plugins/mods/reference#session)** wird ausgeführt, wenn die Sitzung startet, vor deiner ersten Eingabeaufforderung, und jedes Mal, wenn der Mod neu geladen wird. Es fügt den `/tally` Befehl zu Claude Code hinzu.

196 * **[`tool.call`](/docs/de/plugins/mods/reference#tools)** wird jedes Mal ausgeführt, wenn Claude ein Werkzeug verwenden wird. Es addiert eins zu `calls` und bittet Claude Code, die Schnittstelle erneut zu zeichnen.

197 * **[`command.run`](/docs/de/plugins/mods/reference#commands-and-configuration)** wird ausgeführt, wenn du `/tally` eingibst. Es gibt den Text zurück, der gedruckt werden soll.

198 * **[`ui.render`](/docs/de/plugins/mods/reference#interface)** wird jedes Mal ausgeführt, wenn Claude Code den Spinner zeichnet. Es fügt die Anzahl nach dem Wort des Spinners hinzu.

199 

200 [Wie der Beispiel-Mod funktioniert](#how-the-example-mod-works) erklärt die drei Argumente, die jeder Hook nimmt, und was jeder zurückgibt.

201 </Step>

202 

203 <Step title="Lade den Mod">

204 Starte Claude Code mit dem `--plugin-dir` Flag, das ein Plugin-Verzeichnis für eine Sitzung lädt, ohne es zu installieren:

205 

206 ```bash theme={null}

207 claude --plugin-dir ./first-mod

208 ```

209 </Step>

210 

211 <Step title="Probiere den Mod aus">

212 Bitte Claude, etwas zu tun, das ein paar Werkzeugaufrufe dauert, wie `list the files here and read the README`. Während Claude arbeitet, wird das Wort des Spinners gefolgt von einer Anzahl, die steigt, wie in `Thinking · tool calls: 2…`. Wenn Claude fertig ist, gib `/tally` ein und drücke Enter. Das Transkript zeigt `first-mod: Claude has made 2 tool calls since this mod loaded`, mit deiner eigenen Anzahl. Claude Code stellt den Namen des Plugins vor den Text des Befehls.

213 

214 Um den Befehl ohne eine interaktive Sitzung zu überprüfen, führe ihn im nicht-interaktiven Modus aus:

215 

216 ```bash theme={null}

217 claude -p "/tally" --plugin-dir ./first-mod

218 ```

219 

220 ```text theme={null}

221 first-mod: Claude has made 0 tool calls since this mod loaded

222 ```

223 

224 Wenn `/tally` nicht in der Befehlsliste ist, wurde das Modul nicht geladen. Siehe [Finde heraus, warum ein Mod nichts tut](/docs/de/plugins/mods/troubleshoot#find-out-why-a-mod-does-nothing).

225 </Step>

226 

227 <Step title="Ändere den Code, während die Sitzung läuft">

228 Lasse die Sitzung offen. In `register.js`, ändere `' · tool calls: '` zu `' · tools used: '` im `ui.render` Hook und speichere. Die hervorgehobene Zeile ist die, die sich ändert:

229 

230 ```javascript first-mod/hooks/register.js {4} theme={null}

231 // Runs each time Claude Code draws the spinner

232 on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

233 // Keep Claude Code's spinner, with the count added after its word

234 return next({ ...e, props: { ...e.props, suffix: ' · tools used: ' + calls + '…' } })

235 })

236 ```

237 

238 Eine Zeile im Transkript sagt, dass `first-mod` neu geladen wurde und listet seine Hooks auf, und der nächste Spinner verwendet den neuen Text, wie in `Thinking · tools used: 1…`.

239 </Step>

240</Steps>

241 

242<h3 id="how-the-example-mod-works">

243 Wie der Beispiel-Mod funktioniert

244</h3>

245 

246Jede Funktion, die du an `on` übergibst, ist ein Hook, der ein Ereignishandler ist. Claude Code übergibt jedem Hook die gleichen drei Argumente:

247 

248* **Die Mods API**, genannt `$`: jede Methode, die ein Mod aufrufen kann, um sich selbst zu erreichen, in [Namespaces](/docs/de/plugins/mods/reference#mods-api-methods) wie `$.ui` und `$.command`

249* **Das Ereignis**, genannt `e`: die [Eingabe des Ereignisses](/docs/de/plugins/mods/reference#events) als einfache Daten, wie der Name und die Argumente eines Werkzeugaufrufs

250* **Der nächste Handler**, genannt [`next`](/docs/de/plugins/mods/events#how-a-hook-handles-an-event): eine Funktion, die das Ereignis an die anderen Mods und dann an Claude Codes eigenes Verhalten weiterleitet und das Ergebnis zurückgibt

251 

252Die Hooks in `first-mod` handhaben ihre Ereignisse auf die drei Arten, auf die ein Hook kann:

253 

254* **Beobachten**: Der `session.start` Hook registriert den Befehl, und der `tool.call` Hook zählt den Aufruf und bittet um eine Neuzeichnung. Beide geben `next(e)` zurück, sodass die Sitzung startet und das Werkzeug wie gewohnt läuft.

255* **Antworten**: Der `command.run` Hook gibt sein eigenes Ergebnis zurück und ruft niemals `next` auf. Das zweite Argument zu `on`, `{ command: 'tally' }`, ist ein Filter, genannt ein [Matcher](/docs/de/plugins/mods/events#filter-which-events-a-hook-handles), sodass der Hook nur für `/tally` läuft.

256* **Umschreiben**: Der `ui.render` Hook ruft `next` mit einer Kopie von `e` auf, deren `suffix` die Anzahl hält, sodass Claude Code seinen üblichen Spinner mit deinem Text nach dem Wort zeichnet

257 

258Claude Code beobachtet ein Verzeichnis, das mit `--plugin-dir` geladen wird, und lädt das Hooks-Modul neu, wenn sich eine Datei darin ändert. Jedes Neuladen führt `register` erneut aus, sodass `calls` auf `0` zurückgeht und `/tally` wieder zu zählen beginnt. Um einen Wert über Neuladen hinweg zu behalten, siehe [Behalte den Status](/docs/de/plugins/mods/interface#keep-state).

259 

260<h2 id="keep-working-on-a-mod">

261 Arbeite weiter an einem Mod

262</h2>

263 

264Sobald ein Mod geladen ist, kannst du Claude ihn ändern lassen, deinen Code gegen die Typdefinitionen für deine Version überprüfen, die Ereignisse und Aufrufe auflisten, die Claude Code darin findet, und ihn testen.

265 

266<h3 id="change-a-mod-with-claude">

267 Ändere einen Mod mit Claude

268</h3>

269 

270Um einen Mod zu ändern, den du bereits hast, starte die Sitzung mit `--plugin-dir` auf das Verzeichnis des Mods gerichtet, sodass das, was Claude schreibt, in der gleichen Sitzung geladen wird:

271 

272```bash theme={null}

273claude --plugin-dir ./first-mod

274```

275 

276Dann bitte um die Änderung, zum Beispiel `add a /tally-reset command to this mod that sets the tally back to zero`. Claude bearbeitet das Hooks-Modul, führt `claude plugin validate` aus und behebt, was es meldet. Ein Verzeichnis, das du mit `--plugin-dir` lädst, ist ein [geschützter Pfad](/docs/de/permission-modes#protected-paths), sodass du in den Modi `default` und `acceptEdits` aufgefordert wirst, jede von Claudes Bearbeitungen des Mods zu genehmigen. Die Tabelle der geschützten Pfade gibt das Ergebnis für die anderen Berechtigungsmodi.

277 

278Dateien, die Claude während seiner Runde speichert, werden neu geladen, wenn die Runde endet, sodass du `/tally-reset` ausprobieren kannst, sobald Claude fertig ist.

279 

280<h3 id="get-the-types-for-your-build">

281 Erhalte Typdeklarationen für deine Version

282</h3>

283 

284Jedes Mal, wenn Claude Code einen Mod aus einem Verzeichnis lädt oder neu lädt, das du an `--plugin-dir` übergibst, oder einen Mod [Claude für dich geschrieben hat](#ask-claude-for-a-mod), schreibt es TypeScript-Deklarationsdateien, die auf `.d.ts` enden, in `.claude-plugin/types/` im Verzeichnis des Mods. Sie beschreiben die genauen Ereignisse, Mods API Methoden und Elemente in der Claude Code Version, die du ausführst, sodass dein Editor Autovervollständigung und Typprüfung für deine Hooks durchführen kann. Um die Deklarationen online zu durchsuchen, lies [`mods/types/claude-code.d.ts`](https://github.com/anthropics/claude-code/blob/main/mods/types/claude-code.d.ts) im Claude Code Repository, dessen erste Zeile die Version benennt, die es geschrieben hat. Das Verzeichnis enthält diese Dateien:

285 

286| Pfad | Was es deklariert |

287| :- | :- |

288| `claude-code/index.d.ts` | Jedes Ereignis und seine Eingabe und sein Ergebnis, jeder Mods API Namespace und Methode, und die Elemente, die jede Oberfläche zeichnen kann |

289| `claude-code-tools/index.d.ts` | Die Eingaben der integrierten Werkzeuge, sodass die Überprüfung von `e.tool === 'Bash'` `e` einengt |

290| `claude-code-mcp/index.d.ts` | Die Eingaben der MCP Werkzeuge, die das letzte Mal verbunden waren, als du eine Datei im Mod gespeichert hast |

291| `index.d.ts` in einem Verzeichnis, das nach einem Plugin benannt ist | Was dieses Plugin zur Mods API hinzufügt. Es gibt ein Verzeichnis für jedes Plugin, das deine `plugin.json` unter `dependencies` auflistet. |

292| `tsconfig.json` | Compiler-Optionen, die zu einem Hooks-Modul passen |

293 

294Wenn dein Mod keine eigene `tsconfig.json` hat, fügt Claude Code eine an der Wurzel des Mods hinzu, die die generierte erweitert, sodass dein Editor und `tsc -p ./first-mod` den Mod ohne weitere Einrichtung typprüfen.

295 

296Die Ereignisse und Methoden können sich zwischen Versionen ändern, daher vertraue diesen Dateien über jede Seite, einschließlich dieser, wenn sie nicht übereinstimmen.

297 

298`claude-code/index.d.ts` ist die vollständigste Referenz für deinen Build, mit einem Kommentar und einem Beispiel für jede Mods API Methode. Um etwas nachzuschlagen, durchsuche die Datei nach seinem Namen, wie `'tool.call'`.

299 

300<h3 id="check-what-claude-code-reads-from-your-mod">

301 Überprüfe, was Claude Code aus deinem Mod liest

302</h3>

303 

304Um deinen Mod so zu sehen, wie Claude Code ihn sieht, ohne deinen Code auszuführen oder eine Sitzung zu starten, verwende `claude plugin validate`. Es überprüft das Manifest und führt die gleiche statische Analyse auf der Quelle des Hooks-Moduls durch, die Claude Code durchführt, wenn es einen Mod lädt. Führe es in deiner Shell auf dem Verzeichnis des Mods aus:

305 

306```bash theme={null}

307claude plugin validate ./first-mod

308```

309 

310Für `first-mod` enthält die Ausgabe diese Zeilen.

311 

312```text theme={null}

313 ❯ ./register.js hooks: session.start, tool.call, command.run{command=tally}, ui.render{component=Spinner}

314 ❯ ./register.js calls: $.command.register, $.ui.invalidate

315 

316✔ Validation passed

317```

318 

319Die `hooks:` Zeile listet die Ereignisse auf, die dein Modul hookt, jeweils mit seinem Filter in Klammern. Die `calls:` Zeile listet jede Mods API Methode auf, die es aufruft. Ein Modul, das Umgebungsvariablen liest oder setzt, erhält auch `env reads:` und `env writes:` Zeilen, und eines, das [`$.state`](/docs/de/plugins/mods/interface#keep-state) verwendet, erhält `state reads:` und `state writes:`.

320 

321Wenn ein Ereignis, das du hooken wolltest, in der ersten Zeile fehlt, wird Claude Code diesen Hook auch nicht aufrufen. Die übliche Ursache ist ein falsch geschriebener Ereignisname, den der Befehl als Fehler meldet, wie `"tool.calls" is not an event`.

322 

323Befolge diese Regeln, damit statische Analyse jeden Hook und Aufruf finden kann:

324 

325* Schreibe jeden Mods API Aufruf vollständig: `$`, den Namespace, dann die Methode, wie in `$.store.get('notes')`. Du kannst `$` an eine Funktion übergeben, die auf der obersten Ebene der gleichen Datei deklariert ist, und für eine Funktion von dir namens `loadNotes`, liest die `calls:` Zeile dann `$.store.get (via loadNotes)`. Das Übergeben von `$` an eine Methode, eine Funktion, die im Hook definiert ist, oder eine Funktion, die du aus einer anderen deiner Dateien importierst, schlägt die Validierung fehl. Die `read` und `update` Funktionen, die [`$.state`](/docs/de/plugins/mods/interface#keep-state) verwendet, sind die Importe, die es nehmen können. Weise `$` oder einen seiner Namespaces nicht einer Variablen zu, destrukturiere ihn nicht, und indexiere ihn nicht mit einem berechneten Namen. `const ui = $.ui` schlägt mit `$.ui is used as a value` fehl.

326* Schreibe den Ereignisnamen in jedem `on` Aufruf als String-Literal, wie `'tool.call'`. Eine Variable oder eine Schleife über eine Liste von Namen schlägt mit `the event name passed to on() is not a string literal` fehl.

327* Deklariere innerhalb von `register` keine zweite Variable oder keinen Parameter namens `on`. Die Validierung schlägt mit `"on" is declared again (shadowed)` fehl.

328* Importiere nur aus Dateien im Plugin-Verzeichnis, nach relativem Pfad. Der einzige erlaubte bloße Import ist `claude-code`, für Typen und ein paar Helfer.

329* Verwende `import` Deklarationen am Anfang der Datei, wie in `import { name } from './file.js'`. Ein dynamischer `import()` schlägt mit `a dynamic import(); a hooks module imports its own files with an import declaration` fehl.

330* Schreibe jede Datei als ES-Modul, mit `import` und nicht `require`. Die [Referenz](/docs/de/plugins/mods/reference#files) listet die Dateierweiterungen auf, die Claude Code lädt.

331 

332<h3 id="test-the-mod">

333 Teste den Mod

334</h3>

335 

336Du kannst automatisierte Tests für einen Mod schreiben und sie von deiner Shell mit `claude plugin test` ausführen, ohne Sitzung, Anmeldung oder Netzwerk. Ein Test löst die Ereignisse aus, die deine Hooks handhaben, und überprüft, was die Hooks taten.

337 

338Dieser Test löst zwei Werkzeugaufrufe aus, führt `/tally` aus und überprüft, dass die Antwort beide zählt. Speichere ihn als `first-mod/tests/first-mod.test.ts`:

339 

340```typescript first-mod/tests/first-mod.test.ts theme={null}

341import { expect, test } from 'claude-code/testing'

342 

343test('/tally reports the tool calls the mod has seen', async ($, on) => {

344 // Answer each tool call in Claude Code's place, so no tool runs

345 on('tool.call', () => ({ result: 'ok' }))

346 

347 // Raise two tool calls, which the mod's tool.call hook counts

348 await $.tool.call({ tool: 'Bash', command: 'ls' })

349 await $.tool.call({ tool: 'Read', file_path: 'README.md' })

350 

351 // Run /tally and check the text its hook returns

352 const answer = await $.command.run({ command: 'tally', args: '' })

353 expect(answer.text).toBe('Claude has made 2 tool calls since this mod loaded')

354})

355```

356 

357Führe die Tests von deiner Shell aus dem `first-mod` Verzeichnis aus:

358 

359```bash theme={null}

360claude plugin test

361```

362 

363Die Ausgabe benennt jeden Test und ob er bestanden hat, mit Timings, die von Lauf zu Lauf variieren:

364 

365```text theme={null}

366tests/first-mod.test.ts:

367(pass) /tally reports the tool calls the mod has seen [22.87ms]

368 

369 1 pass

370 0 fail

371Ran 1 test across 1 file. [0.19s]

372```

373 

374[Teste einen Mod](/docs/de/plugins/mods/test) behandelt das Stubben eines Modellaufrufs oder des Speichers, und das Testen von Timern und Zeichnungen.

375 

376<h2 id="share-your-mod">

377 Teile deinen Mod

378</h2>

379 

380Ein Mod ist ein Plugin, daher versionierst du ihn im Manifest und Personen installieren und aktualisieren ihn mit den `/plugin` Befehlen. Um ihn anderen Personen zu geben, [füge ihn zu einem Marketplace hinzu](/docs/de/plugins/publish).

381 

382Bevor du das tust, überprüfe den Namen des Plugins: `claude plugin validate` schlägt einen Namen fehl, der [wie einer von Anthropics eigenen aussieht](/docs/de/plugins/manifest-reference#name), wie einer, der mit `claude-` beginnt. Die Ereignisse und Methoden können sich zwischen Versionen ändern, daher ist deine README der Ort, um zu sagen, welche Claude Code Version du getestet hast.

383 

384Entwickle weiter gegen das Verzeichnis mit `--plugin-dir`, nicht gegen eine installierte Kopie. Claude Code speichert ein installiertes Plugin nach Version, sodass deine Bearbeitungen die installierte Kopie nicht erreichen, bis du die Version erhöhst und erneut installierst.

385 

386<h2 id="next-steps">

387 Nächste Schritte

388</h2>

389 

390* [Zeichne in der Schnittstelle](/docs/de/plugins/mods/interface): öffne einen Bereich, zeichne über der Eingabeaufforderung, und füge Schaltflächen und Textfelder hinzu

391* [Reagiere auf Ereignisse](/docs/de/plugins/mods/events): hook Werkzeugaufrufe, Eingabeaufforderungen und Runden

392* [Verwende die Mods API](/docs/de/plugins/mods/api): füge Befehle und Werkzeuge hinzu, rufe ein Modell auf, und führe Arbeit auf einem Timer aus

393* [Teste einen Mod](/docs/de/plugins/mods/test): stub, was Claude Code antworten würde, und teste Timer und Zeichnungen

394* [Behebe einen Mod](/docs/de/plugins/mods/troubleshoot): die Gründe, warum ein Mod nichts tut, und das Debug-Protokoll

395* [Lese die Quelle von integrierten Mods](/docs/de/plugins/mods/overview#read-the-source-of-built-in-mods): vollständige Plugins, jeweils mit seinem Hooks-Modul und Tests