plugins.md +0 −527 deleted
File Deleted View Diff
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# Plugins erstellen
6
7> Erstellen Sie benutzerdefinierte Plugins, um Claude Code mit Skills, Agents, Hooks und MCP-Servern zu erweitern.
8
9Plugins ermöglichen es Ihnen, Claude Code mit benutzerdefinierten Funktionen zu erweitern, die projektübergreifend und teamübergreifend freigegeben werden können. Diese Anleitung behandelt die Erstellung eigener Plugins mit Skills, Agents, Hooks und MCP-Servern.
10
11Möchten Sie vorhandene Plugins installieren? Siehe [Plugins entdecken und installieren](/docs/de/discover-plugins). Für vollständige technische Spezifikationen siehe [Plugins-Referenz](/docs/de/plugins-reference).
12
13<h2 id="when-to-use-plugins-vs-standalone-configuration">
14 Wann Plugins vs. eigenständige Konfiguration verwenden
15</h2>
16
17Claude Code unterstützt zwei Möglichkeiten, um benutzerdefinierte Skills, Agents und Hooks hinzuzufügen:
18
19| Ansatz | Skill-Namen | Am besten für |
20| :------------------------------------------------------------------------------------------------------------------- | :------------------- | :------------------------------------------------------------------------------------------------------------------- |
21| **Eigenständig** (`.claude/`-Verzeichnis) | `/hello` | Persönliche Workflows, projektspezifische Anpassungen, schnelle Experimente |
22| **Plugins** (eigenständige Verzeichnisse mit Skills, Agents, Hooks oder einem `.claude-plugin/plugin.json`-Manifest) | `/plugin-name:hello` | Freigabe für Teamkollegen, Verteilung an die Community, versionierte Releases, wiederverwendbar über Projekte hinweg |
23
24<Tip>
25 Beginnen Sie mit eigenständiger Konfiguration in `.claude/` für schnelle Iteration, dann [konvertieren Sie zu einem Plugin](#convert-existing-configurations-to-plugins), wenn Sie bereit sind zu teilen.
26</Tip>
27
28<h2 id="quickstart">
29 Schnellstart
30</h2>
31
32Dieser Schnellstart führt Sie durch die Erstellung eines Plugins mit einem benutzerdefinierten Skill. Sie erstellen ein Manifest (die Konfigurationsdatei, die Ihr Plugin definiert), fügen einen Skill hinzu und testen ihn lokal mit dem Flag `--plugin-dir`.
33
34<h3 id="prerequisites">
35 Voraussetzungen
36</h3>
37
38* Claude Code [installiert und authentifiziert](/docs/de/quickstart#step-1-install-claude-code)
39
40<h3 id="create-your-first-plugin">
41 Erstellen Sie Ihr erstes Plugin
42</h3>
43
44<Steps>
45 <Step title="Erstellen Sie das Plugin-Verzeichnis">
46 Jedes Plugin befindet sich in seinem eigenen Verzeichnis, das Ihre Skills, Agents oder Hooks enthält, optional zusammen mit einem `.claude-plugin/plugin.json`-Manifest. Der Speicherort spielt für diesen Schnellstart keine Rolle, da Sie Claude Code im Testschritt mit `--plugin-dir` auf das Verzeichnis verweisen. Erstellen Sie es überall, wo es praktisch ist, z. B. in einem Scratch-Ordner oder einem Projektverzeichnis:
47
48 ```bash theme={null}
49 mkdir my-first-plugin
50 ```
51
52 Die verbleibenden Schritte werden vom übergeordneten Verzeichnis aus ausgeführt und referenzieren Pfade wie `my-first-plugin/...` relativ dazu.
53 </Step>
54
55 <Step title="Erstellen Sie das Plugin-Manifest">
56 Die Manifestdatei unter `.claude-plugin/plugin.json` definiert die Identität Ihres Plugins: seinen Namen, die Beschreibung und die Version. Claude Code verwendet diese Metadaten, um Ihr Plugin im Plugin-Manager anzuzeigen.
57
58 Erstellen Sie das `.claude-plugin`-Verzeichnis in Ihrem Plugin-Ordner:
59
60 ```bash theme={null}
61 mkdir my-first-plugin/.claude-plugin
62 ```
63
64 Erstellen Sie dann `my-first-plugin/.claude-plugin/plugin.json` mit diesem Inhalt:
65
66 ```json my-first-plugin/.claude-plugin/plugin.json theme={null}
67 {
68 "name": "my-first-plugin",
69 "description": "A greeting plugin to learn the basics",
70 "version": "1.0.0",
71 "author": {
72 "name": "Your Name"
73 }
74 }
75 ```
76
77 | Feld | Zweck |
78 | :------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
79 | `name` | Eindeutige Kennung und Skill-Namespace. Skills werden mit diesem Präfix versehen (z. B. `/my-first-plugin:hello`). |
80 | `description` | Wird im Plugin-Manager angezeigt, wenn Sie Plugins durchsuchen oder installieren. |
81 | `version` | Optional. Falls gesetzt, erhalten Benutzer nur Updates, wenn Sie dieses Feld erhöhen, außer für eine [`command`-Quelle](/docs/de/plugin-marketplaces#command-sources) oder ein Plugin [lokal geladen](/docs/de/plugins-reference#plugin-caching-and-file-resolution); siehe [Versionsverwaltung](/docs/de/plugins-reference#version-management). Falls weggelassen, stammt die Version aus der nächsten Quelle in der [Versionsverwaltung](/docs/de/plugins-reference#version-management). |
82 | `author` | Optional. Hilfreich für die Zuordnung. |
83
84 Für zusätzliche Felder wie `homepage`, `repository` und `license` siehe das [vollständige Manifest-Schema](/docs/de/plugins-reference#plugin-manifest-schema).
85 </Step>
86
87 <Step title="Fügen Sie einen Skill hinzu">
88 Skills befinden sich im Verzeichnis `skills/`. Jeder Skill ist ein Ordner, der eine Datei `SKILL.md` enthält. Der Ordnername wird zum Skill-Namen, mit dem Präfix des Plugin-Namespace (`hello/` in einem Plugin namens `my-first-plugin` erstellt `/my-first-plugin:hello`).
89
90 Erstellen Sie ein Skill-Verzeichnis in Ihrem Plugin-Ordner:
91
92 ```bash theme={null}
93 mkdir -p my-first-plugin/skills/hello
94 ```
95
96 Erstellen Sie dann `my-first-plugin/skills/hello/SKILL.md` mit diesem Inhalt:
97
98 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
99 ---
100 description: Greet the user with a friendly message
101 disable-model-invocation: true
102 ---
103
104 Greet the user warmly and ask how you can help them today.
105 ```
106 </Step>
107
108 <Step title="Testen Sie Ihr Plugin">
109 Führen Sie Claude Code mit dem Flag `--plugin-dir` aus, um Ihr Plugin zu laden:
110
111 ```bash theme={null}
112 claude --plugin-dir ./my-first-plugin
113 ```
114
115 Sobald Claude Code startet, versuchen Sie Ihren neuen Skill:
116
117 ```shell theme={null}
118 /my-first-plugin:hello
119 ```
120
121 Sie sehen Claude mit einer Begrüßung antworten. Führen Sie `/help` aus und öffnen Sie die Registerkarte **Benutzerdefinierte Befehle**, um Ihren Skill unter dem Plugin-Namespace aufgelistet zu sehen.
122
123 <Note>
124 **Warum Namespacing?** Plugin-Skills sind immer mit Namespace versehen (wie `/my-first-plugin:hello`), um Konflikte zu vermeiden, wenn mehrere Plugins Skills mit demselben Namen haben.
125
126 Um das Namespace-Präfix zu ändern, aktualisieren Sie das Feld `name` in `plugin.json`.
127 </Note>
128 </Step>
129
130 <Step title="Fügen Sie Skill-Argumente hinzu">
131 Machen Sie Ihren Skill dynamisch, indem Sie Benutzereingaben akzeptieren. Der Platzhalter `$ARGUMENTS` erfasst jeden Text, den der Benutzer nach dem Skill-Namen bereitstellt.
132
133 Aktualisieren Sie Ihre Datei `SKILL.md`:
134
135 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
136 ---
137 description: Greet the user with a personalized message
138 ---
139
140 # Hello Skill
141
142 Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
143 ```
144
145 Führen Sie `/reload-plugins` aus, um die Änderungen zu übernehmen. Versuchen Sie dann den Skill mit Ihrem Namen:
146
147 ```shell theme={null}
148 /my-first-plugin:hello Alex
149 ```
150
151 Claude wird Sie beim Namen begrüßen. Weitere Informationen zum Übergeben von Argumenten an Skills finden Sie unter [Skills](/docs/de/skills#pass-arguments-to-skills).
152 </Step>
153</Steps>
154
155<Tip>
156 Das Flag `--plugin-dir` ist nützlich für Entwicklung und Tests. Wenn Sie bereit sind, Ihr Plugin mit anderen zu teilen, siehe [Erstellen und verteilen Sie einen Plugin-Marketplace](/docs/de/plugin-marketplaces).
157</Tip>
158
159<h2 id="develop-a-plugin-in-your-skills-directory">
160 Entwickeln Sie ein Plugin in Ihrem Skills-Verzeichnis
161</h2>
162
163Anstatt `--plugin-dir` bei jedem Start zu übergeben, können Sie ein Plugin in Ihrem Skills-Verzeichnis behalten und Claude Code es automatisch laden lassen. `claude plugin init` erstellt ein Gerüst dafür:
164
165```bash theme={null}
166claude plugin init my-tool
167```
168
169Dies erstellt `~/.claude/skills/my-tool/` mit einem `.claude-plugin/plugin.json`-Manifest und einer Starter-`SKILL.md`. In der nächsten Sitzung wird es als `my-tool@skills-dir` geladen, ohne dass ein Marketplace oder Installationsschritt erforderlich ist.
170
171Für die Auto-Load-Regeln, persönlicher vs. Projekt-Umfang, die Workspace-Trust-Anforderung und wie man eine aktualisiert oder entfernt, siehe [Skills-Verzeichnis-Plugins](/docs/de/plugins-reference#skills-directory-plugins).
172
173<h2 id="plugin-structure-overview">
174 Übersicht über die Plugin-Struktur
175</h2>
176
177Sie haben ein Plugin mit einem Skill erstellt, aber Plugins können viel mehr enthalten: benutzerdefinierte Agents, Hooks, MCP-Server, LSP-Server und Hintergrund-Monitore.
178
179<Warning>
180 **Häufiger Fehler**: Platzieren Sie `commands/`, `agents/`, `skills/` oder `hooks/` nicht im Verzeichnis `.claude-plugin/`. Nur `plugin.json` gehört in `.claude-plugin/`. Alle anderen Verzeichnisse müssen auf der Plugin-Root-Ebene sein.
181
182 Das Plugin-Root ist das eigene Verzeichnis des einzelnen Plugins, z. B. `my-first-plugin/` aus dem [Schnellstart](#quickstart). Es ist niemals `~/.claude/`. Zum Beispiel liest Claude Code eine `.mcp.json`, die unter `~/.claude/.mcp.json` platziert ist, nicht.
183</Warning>
184
185| Verzeichnis | Speicherort | Zweck |
186| :---------------- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
187| `.claude-plugin/` | Plugin-Root | Enthält `plugin.json`-Manifest (optional, wenn Komponenten Standardspeicherorte verwenden) |
188| `skills/` | Plugin-Root | Skills als `<name>/SKILL.md`-Verzeichnisse |
189| `commands/` | Plugin-Root | Skills als flache Markdown-Dateien. Verwenden Sie `skills/` für neue Plugins |
190| `agents/` | Plugin-Root | Benutzerdefinierte Agent-Definitionen |
191| `hooks/` | Plugin-Root | Event-Handler in `hooks.json` |
192| `.mcp.json` | Plugin-Root | MCP-Server-Konfigurationen |
193| `.lsp.json` | Plugin-Root | LSP-Server-Konfigurationen für Code-Intelligenz |
194| `monitors/` | Plugin-Root | Hintergrund-Monitor-Konfigurationen in `monitors.json` |
195| `bin/` | Plugin-Root | Ausführbare Dateien, die zum `PATH` des Bash-Tools hinzugefügt werden, während das Plugin aktiviert ist. Sie können dieses Verzeichnis nicht in ein Plugin einbeziehen, das Sie [über die Organisationseinstellungen von claude.ai verteilen](/docs/de/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
196| `settings.json` | Plugin-Root | Standard-[Einstellungen](/docs/de/settings), die angewendet werden, wenn das Plugin aktiviert ist |
197
198Ein Plugin, das genau einen Skill enthält, kann `SKILL.md` direkt im Plugin-Root platzieren, anstatt ein `skills/`-Verzeichnis zu erstellen. Claude Code lädt es als einen einzelnen Skill und verwendet das Frontmatter-Feld `name` für den Aufrufen-Namen. Verwenden Sie das `skills/`-Layout für Plugins, die möglicherweise auf mehr als einen Skill anwachsen.
199
200<h2 id="develop-more-complex-plugins">
201 Entwickeln Sie komplexere Plugins
202</h2>
203
204Sobald Sie sich mit grundlegenden Plugins vertraut gemacht haben, können Sie anspruchsvollere Erweiterungen erstellen.
205
206<h3 id="add-skills-to-your-plugin">
207 Fügen Sie Skills zu Ihrem Plugin hinzu
208</h3>
209
210Plugins können [Agent-Skills](/docs/de/skills) enthalten, um die Fähigkeiten von Claude zu erweitern. Skills werden vom Modell aufgerufen: Claude verwendet sie automatisch basierend auf dem Task-Kontext.
211
212Fügen Sie ein Verzeichnis `skills/` auf Ihrer Plugin-Root mit Skill-Ordnern hinzu, die `SKILL.md`-Dateien enthalten:
213
214```text theme={null}
215my-plugin/
216├── .claude-plugin/
217│ └── plugin.json
218└── skills/
219 └── code-review/
220 └── SKILL.md
221```
222
223Jede `SKILL.md` enthält YAML-Frontmatter und Anweisungen. Fügen Sie eine `description` ein, damit Claude weiß, wann der Skill verwendet werden soll:
224
225```yaml theme={null}
226description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
227
228When reviewing code, check for:
2291. Code organization and structure
2302. Error handling
2313. Security concerns
2324. Test coverage
233```
234
235Nach der Installation des Plugins überprüfen Sie die Installationszusammenfassung: Wenn sie `Run /reload-plugins to activate.` meldet, siehe [Wenden Sie Plugin-Änderungen an, ohne neu zu starten](/docs/de/discover-plugins#apply-plugin-changes-without-restarting), um die Skills in Ihrer aktuellen Sitzung zu laden. Für vollständige Anleitung zur Skill-Erstellung, einschließlich progressiver Offenlegung und Tool-Einschränkungen, siehe [Agent-Skills](/docs/de/skills).
236
237<h3 id="add-lsp-servers-to-your-plugin">
238 Fügen Sie LSP-Server zu Ihrem Plugin hinzu
239</h3>
240
241<Tip>
242 Für gängige Sprachen wie TypeScript, Python und Rust installieren Sie die vorgefertigten LSP-Plugins aus dem offiziellen Marketplace. Erstellen Sie benutzerdefinierte LSP-Plugins nur, wenn Sie Unterstützung für Sprachen benötigen, die noch nicht abgedeckt sind.
243</Tip>
244
245LSP-Plugins (Language Server Protocol) geben Claude Echtzeit-Code-Intelligenz. Wenn Sie eine Sprache unterstützen müssen, die kein offizielles LSP-Plugin hat, können Sie ein eigenes erstellen, indem Sie eine `.lsp.json`-Datei zu Ihrem Plugin hinzufügen:
246
247```json .lsp.json theme={null}
248{
249 "go": {
250 "command": "gopls",
251 "args": ["serve"],
252 "extensionToLanguage": {
253 ".go": "go"
254 }
255 }
256}
257```
258
259Benutzer, die Ihr Plugin installieren, müssen die Language-Server-Binärdatei auf ihrem Computer installiert haben.
260
261Um zu bestätigen, dass der Server startet, starten Sie Claude Code mit aktiviertem Plugin und überprüfen Sie die Registerkarte `/plugin` Fehler: Ein Language-Server, der nicht startet, wird dort angezeigt, zum Beispiel mit `Executable not found in $PATH`, wenn die Binärdatei nicht installiert ist. Ein Eintrag mit ungültiger Konfiguration wird stattdessen übersprungen; führen Sie `claude --debug` aus, um zu sehen, warum.
262
263Für vollständige LSP-Konfigurationsoptionen siehe [LSP-Server](/docs/de/plugins-reference#lsp-servers).
264
265<h3 id="add-background-monitors-to-your-plugin">
266 Fügen Sie Hintergrund-Monitore zu Ihrem Plugin hinzu
267</h3>
268
269Hintergrund-Monitore ermöglichen es Ihrem Plugin, Protokolle, Dateien oder externen Status im Hintergrund zu überwachen und Claude zu benachrichtigen, wenn Ereignisse eintreffen. Claude Code startet jeden Monitor automatisch, wenn das Plugin aktiv ist, sodass Sie Claude nicht anweisen müssen, die Überwachung zu starten.
270
271Fügen Sie eine Datei `monitors/monitors.json` auf der Plugin-Root mit einem Array von Monitor-Einträgen hinzu:
272
273```json monitors/monitors.json theme={null}
274[
275 {
276 "name": "error-log",
277 "command": "tail -F ./logs/error.log",
278 "description": "Application error log"
279 }
280]
281```
282
283Jede stdout-Zeile aus `command` wird Claude während der Sitzung als Benachrichtigung zugestellt. Für das vollständige Schema, einschließlich des `when`-Triggers und der Variablenersetzung, siehe [Monitore](/docs/de/plugins-reference#monitors).
284
285<h3 id="ship-default-settings-with-your-plugin">
286 Versenden Sie Standard-Einstellungen mit Ihrem Plugin
287</h3>
288
289Plugins können eine Datei `settings.json` auf der Plugin-Root enthalten, um Standard-Konfiguration anzuwenden, wenn das Plugin aktiviert ist. Derzeit werden nur die Schlüssel `agent` und `subagentStatusLine` unterstützt.
290
291Das Setzen von `agent` aktiviert einen der [benutzerdefinierten Agents](/docs/de/sub-agents) des Plugins als Haupt-Thread und wendet seinen System-Prompt, Tool-Einschränkungen und Modell an. Dies ermöglicht es einem Plugin, das Standardverhalten von Claude Code zu ändern, wenn es aktiviert ist.
292
293```json settings.json theme={null}
294{
295 "agent": "security-reviewer"
296}
297```
298
299Dieses Beispiel aktiviert den Agent `security-reviewer`, der im Verzeichnis `agents/` des Plugins definiert ist. Einstellungen aus `settings.json` haben Vorrang vor `settings`, die in `plugin.json` deklariert sind. Unbekannte Schlüssel werden stillschweigend ignoriert.
300
301<h3 id="organize-complex-plugins">
302 Organisieren Sie komplexe Plugins
303</h3>
304
305Für Plugins mit vielen Komponenten organisieren Sie Ihre Verzeichnisstruktur nach Funktionalität. Für vollständige Verzeichnislayouts und Organisationsmuster siehe [Plugin-Verzeichnisstruktur](/docs/de/plugins-reference#plugin-directory-structure).
306
307<h3 id="test-your-plugins-locally">
308 Testen Sie Ihre Plugins lokal
309</h3>
310
311Verwenden Sie das Flag `--plugin-dir`, um Plugins während der Entwicklung zu testen. Dies lädt Ihr Plugin direkt, ohne dass eine Installation erforderlich ist.
312
313```bash theme={null}
314claude --plugin-dir ./my-plugin
315```
316
317Das Flag akzeptiert auch ein `.zip`-Archiv des Plugin-Verzeichnisses.
318
319```bash theme={null}
320claude --plugin-dir ./my-plugin.zip
321```
322
323Wenn ein `--plugin-dir`-Plugin denselben Namen wie ein installiertes Marketplace-Plugin hat, hat die lokale Kopie in dieser Sitzung Vorrang. Dies ermöglicht es Ihnen, Änderungen an einem Plugin zu testen, das Sie bereits installiert haben, ohne es zuerst zu deinstallieren. Die Ausnahme sind Plugins, die durch verwaltete Einstellungen erzwungen aktiviert oder deaktiviert werden: `--plugin-dir` kann diese nicht überschreiben.
324
325Wenn Sie Änderungen an Ihrem Plugin vornehmen, führen Sie `/reload-plugins` aus, um die Updates zu übernehmen, ohne neu zu starten. Dies lädt Plugins, Skills, Agents, Hooks, Plugin-MCP-Server und Plugin-LSP-Server neu; in einer Sitzung ohne interaktives Terminal warten Plugin-MCP-Server-Änderungen [auf Ihre nächste Sitzung](/docs/de/discover-plugins#apply-plugin-changes-without-restarting). Testen Sie Ihre Plugin-Komponenten:
326
327* Versuchen Sie Ihre Skills mit `/plugin-name:skill-name`
328* Überprüfen Sie, dass Agents in `/context` unter Custom Agents angezeigt werden, oder erwähnen Sie einen mit seinem scoped Namen mit @
329* Lösen Sie das Ereignis aus, das jeder Hook erfasst, z. B. indem Sie Claude auffordern, eine Datei für einen `PostToolUse`-Hook zu bearbeiten, und bestätigen Sie seine Auswirkung. Claude Code zeichnet auf, welche Hooks erfasst wurden, ihre Exit-Codes und ihre Ausgabe im [Debug-Protokoll](/docs/de/hooks#debug-hooks)
330
331<Tip>
332 Sie können mehrere Plugins gleichzeitig laden, indem Sie das Flag mehrmals angeben:
333
334 ```bash theme={null}
335 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
336 ```
337
338 Um ein Plugin zusammen mit einem Plugin zu testen, von dem es abhängt, siehe [Testen Sie ein Plugin und seine Abhängigkeit lokal](/docs/de/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
339</Tip>
340
341Um Plugins in einer Sitzung zu laden, in der Sie das Flag nicht hinzufügen können, listen Sie ihre absoluten Pfade stattdessen in der Umgebungsvariablen [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/de/env-vars#variables) auf. Claude Code lädt jeden Pfad wie einen `--plugin-dir`-Pfad. Diese Plugins werden zusätzlich zu allen geladen, die Sie mit `--plugin-dir` übergeben. [Projekt- und lokale Einstellungen können diese Variable nicht setzen](/docs/de/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` erfordert Claude Code v2.1.280 oder später.
342
343Das Testen des Plugins mit `--plugin-dir` zeigt Ihnen, dass es funktionieren kann. Um herauszufinden, wie oft Claude tatsächlich danach greift und das richtige Ergebnis erhält, führen Sie es gegen eine Reihe von Test-Prompts mit [`claude plugin eval`](/docs/de/plugin-evals) aus. Jeder Prompt wird mehrmals mit und ohne das geladene Plugin ausgeführt, sodass Sie sehen können, was das Plugin beiträgt, und Regressionsfehler erkennen können, wenn Sie es ändern oder ein neues Modell ausgeliefert wird.
344
345Um mehrere Plugins von einem Ort aus zu laden, übergeben Sie einen Ordner, der sie enthält, z. B. `--plugin-dir ./plugins`. Das Laden eines Ordners mit Plugins erfordert Claude Code v2.1.265 oder später. Claude Code liest die oberste Ebene des Ordners, um zu entscheiden, welche Plugins geladen werden, und in einer interaktiven Sitzung überwacht es auch den Ordner auf spätere Änderungen:
346
347* **Was wird geladen**: Wenn der Ordner keine Manifest- oder Plugin-Komponenten auf seiner obersten Ebene hat, behandelt Claude Code ihn als einen Ordner mit Plugins. Jeder unmittelbare Unterordner, der ein `.claude-plugin/plugin.json`-Manifest hat, wird als separates Plugin geladen. Claude Code überspringt alles andere im Ordner ohne Fehlermeldung, einschließlich Plugins, die kein Manifest haben.
348* **Änderungen während einer interaktiven Sitzung**: Ein Unterordner, den Sie hinzufügen, wird als neues Plugin geladen, sobald sein Manifest vorhanden ist, und wenn Sie einen Unterordner entfernen, wird sein Plugin entladen. Claude Code druckt eine Zeile in der Sitzung für jede Änderung. Wenn das Anwenden einer Änderung mitten in der Konversation den [Prompt-Cache ungültig machen würde](/docs/de/prompt-caching#enabling-or-disabling-a-plugin), hält Claude Code sie an, und die Zeile sagt, dass Sie `/reload-plugins` ausführen sollen, um sie anzuwenden.
349
350Um ein Plugin zu testen, das bereits als `.zip`-Archiv verpackt und unter einer URL gehostet wird, z. B. ein CI-Build-Artefakt, verwenden Sie stattdessen `--plugin-url`. Claude Code ruft das Archiv beim Start ab und lädt es nur für diese Sitzung. Wenn Claude Code das Archiv nicht abrufen kann oder das Archiv ungültig ist, startet es ohne das Plugin und zeichnet einen Plugin-Ladefehler auf, den Sie in der Registerkarte **Fehler** des `/plugin`-Managers überprüfen können. Die gleichen [Vertrauensüberlegungen](/docs/de/discover-plugins#security) gelten wie für jede andere Plugin-Quelle: Verweisen Sie dieses Flag nur auf Archive, die Sie kontrollieren oder denen Sie vertrauen.
351
352Um mehrere Plugins zu laden, wiederholen Sie das Flag für jede URL:
353
354```bash theme={null}
355claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
356```
357
358Oder übergeben Sie durch Leerzeichen getrennte URLs als ein Argument in Anführungszeichen:
359
360```bash theme={null}
361claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
362```
363
364<h3 id="debug-plugin-issues">
365 Debuggen Sie Plugin-Probleme
366</h3>
367
368Wenn Ihr Plugin nicht wie erwartet funktioniert:
369
3701. **Überprüfen Sie die Struktur**: Stellen Sie sicher, dass Ihre Verzeichnisse auf der Plugin-Root sind, nicht in `.claude-plugin/`
3712. **Testen Sie Komponenten einzeln**: Überprüfen Sie jeden Skill, Agent und Hook separat
3723. **Verwenden Sie Validierungs- und Debugging-Tools**: Siehe [Debugging- und Entwicklungstools](/docs/de/plugins-reference#debugging-and-development-tools) für CLI-Befehle und Troubleshooting-Techniken
373
374<h3 id="share-your-plugins">
375 Teilen Sie Ihre Plugins
376</h3>
377
378Wenn Ihr Plugin bereit zum Teilen ist:
379
3801. **Fügen Sie Dokumentation hinzu**: Fügen Sie eine `README.md` mit Installations- und Verwendungsanweisungen ein
3812. **Wählen Sie eine Versionierungsstrategie**: Entscheiden Sie, ob Sie eine explizite `version` setzen oder sich auf die im [Versionsverwaltung](/docs/de/plugins-reference#version-management) beschriebene Fallback-Lösung verlassen.
3823. **Erstellen oder verwenden Sie einen Marketplace**: Verteilen Sie über [Plugin-Marketplaces](/docs/de/plugin-marketplaces) zur Installation
3834. **Testen Sie mit anderen**: Lassen Sie Teamkollegen das Plugin vor einer breiteren Verteilung testen
384
385Sobald Ihr Plugin in einem Marketplace ist, können andere es mit den Anweisungen in [Plugins entdecken und installieren](/docs/de/discover-plugins) installieren. Um ein Plugin intern für Ihr Team zu halten, hosten Sie den Marketplace in einem [privaten Repository](/docs/de/plugin-marketplaces#private-repositories).
386
387<h3 id="submit-your-plugin-to-the-community-marketplace">
388 Reichen Sie Ihr Plugin beim Community-Marketplace ein
389</h3>
390
391Anthropic verwaltet zwei öffentliche Marketplaces für Claude Code Plugins:
392
393* **`claude-plugins-official`**: ein kuratierter Satz von Plugins, die von Anthropic verwaltet werden. Claude Code registriert ihn automatisch beim ersten Mal, wenn Sie Claude Code interaktiv starten. Wenn Sie Claude Code nicht-interaktiv ausführen, bevor dieser erste interaktive Start erfolgt, oder wenn eine [Marketplace-Richtlinie](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) einen früheren Versuch blockiert hat, registrieren Sie ihn selbst mit `claude plugin marketplace add anthropics/claude-plugins-official`.
394* **`claude-community`**: der öffentliche Community-Marketplace, auf dem Drittanbieter-Einreichungen nach Überprüfung landen. Benutzer fügen ihn mit `/plugin marketplace add anthropics/claude-plugins-community` hinzu und installieren ihn als `@claude-community`.
395
396Um Ihr Plugin zur Überprüfung im Community-Marketplace einzureichen, verwenden Sie eines der In-App-Formulare:
397
398* **claude.ai**: [claude.ai/admin-settings/directory/submissions/plugins/new](https://claude.ai/admin-settings/directory/submissions/plugins/new)
399* **Console**: [platform.claude.com/plugins/submit](https://platform.claude.com/plugins/submit)
400
401Das claude.ai-Formular erfordert eine Team- oder Enterprise-Organisation und Verzeichnisverwaltungszugriff; Organisationsinhaber haben diesen Zugriff standardmäßig. Einzelne Autoren, die nicht Teil einer Team- oder Enterprise-Organisation sind, können stattdessen das Console-Formular verwenden.
402
403Führen Sie `claude plugin validate ./your-plugin` lokal aus, bevor Sie einreichen, und ersetzen Sie `./your-plugin` durch den Pfad zu Ihrem Plugin-Verzeichnis. Die Überprüfungs-Pipeline führt die gleiche Überprüfung bei jeder Einreichung durch, zusammen mit automatisierter Sicherheitsüberprüfung. Wenn die Validierung erfolgreich ist, druckt Claude Code `✔ Validation passed` oder `✔ Validation passed with warnings`, wenn es Warnungen gibt. Warnungen führen nicht zu einem Validierungsfehler; fügen Sie `--strict` hinzu, um sie als Fehler zu behandeln.
404
405Genehmigte Plugins werden auf einen bestimmten Commit-SHA im Katalog [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community) angeheftet, und CI erhöht die Anheftung automatisch, wenn Sie neue Commits in Ihr Repository pushen. Der öffentliche Katalog wird jede Nacht aus der Überprüfungs-Pipeline synchronisiert, daher kann es eine Verzögerung zwischen Genehmigung und dem Erscheinen Ihres Plugins in `marketplace.json` geben. Um zu überprüfen, ob Ihr Plugin bereits installierbar ist, suchen Sie nach seinem Namen im [Community-Katalog](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
406
407Der offizielle Marketplace, `claude-plugins-official`, wird separat kuratiert. Anthropic entscheidet nach eigenem Ermessen, welche Plugins einbezogen werden. Es gibt keinen Bewerbungsprozess, und das Einreichungsformular fügt Plugins nicht zum offiziellen Marketplace hinzu.
408
409Wenn Anthropic Ihr Plugin im offiziellen Marketplace auflistet, kann Ihre CLI Claude Code-Benutzer auffordern, es zu installieren. Siehe [Empfehlen Sie Ihr Plugin von Ihrer CLI](/docs/de/plugin-hints).
410
411<h2 id="convert-existing-configurations-to-plugins">
412 Konvertieren Sie vorhandene Konfigurationen in Plugins
413</h2>
414
415Wenn Sie bereits Skills oder Hooks in Ihrem Verzeichnis `.claude/` haben, können Sie diese in ein Plugin konvertieren, um die Freigabe und Verteilung zu vereinfachen.
416
417<h3 id="migration-steps">
418 Migrationschritte
419</h3>
420
421<Steps>
422 <Step title="Erstellen Sie die Plugin-Struktur">
423 Erstellen Sie ein neues Plugin-Verzeichnis in Ihrem Projektstammverzeichnis neben dem vorhandenen Ordner `.claude/`, damit die relativen `cp`-Pfade im nächsten Schritt aufgelöst werden:
424
425 ```bash theme={null}
426 mkdir -p my-plugin/.claude-plugin
427 ```
428
429 Erstellen Sie die Manifestdatei unter `my-plugin/.claude-plugin/plugin.json`:
430
431 ```json my-plugin/.claude-plugin/plugin.json theme={null}
432 {
433 "name": "my-plugin",
434 "description": "Migrated from standalone configuration",
435 "version": "1.0.0"
436 }
437 ```
438 </Step>
439
440 <Step title="Kopieren Sie Ihre vorhandenen Dateien">
441 Kopieren Sie jedes Konfigurationsverzeichnis, das Sie haben, in das Plugin-Stammverzeichnis. Möglicherweise haben Sie nicht alle drei: Wenn ein Verzeichnis nicht vorhanden ist, gibt `cp` die Meldung `No such file or directory` aus und kopiert nichts, daher können Sie diesen Befehl überspringen oder den Fehler ignorieren.
442
443 ```bash theme={null}
444 cp -r .claude/commands my-plugin/
445
446 cp -r .claude/agents my-plugin/
447
448 cp -r .claude/skills my-plugin/
449 ```
450
451 Ihr Plugin enthält nun Kopien der Verzeichnisse, die Sie unter `.claude/` hatten. Führen Sie `ls my-plugin` aus, um dies zu bestätigen: Sie sollten jedes Verzeichnis sehen, das Sie kopiert haben.
452 </Step>
453
454 <Step title="Migrieren Sie Hooks">
455 Wenn Sie Hooks in Ihren Einstellungen haben, erstellen Sie ein Hooks-Verzeichnis:
456
457 ```bash theme={null}
458 mkdir my-plugin/hooks
459 ```
460
461 Erstellen Sie `my-plugin/hooks/hooks.json` mit Ihrer Hooks-Konfiguration. Kopieren Sie das Objekt `hooks` aus Ihrer `.claude/settings.json` oder `settings.local.json`, da das Format gleich ist. Der Befehl empfängt Hook-Eingaben als JSON auf stdin, verwenden Sie also `jq`, um den Dateipfad zu extrahieren:
462
463 ```json my-plugin/hooks/hooks.json theme={null}
464 {
465 "hooks": {
466 "PostToolUse": [
467 {
468 "matcher": "Write|Edit",
469 "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
470 }
471 ]
472 }
473 }
474 ```
475 </Step>
476
477 <Step title="Testen Sie Ihr migriertes Plugin">
478 Laden Sie Ihr Plugin, um zu überprüfen, ob alles funktioniert:
479
480 ```bash theme={null}
481 claude --plugin-dir ./my-plugin
482 ```
483
484 Testen Sie jede Komponente: Führen Sie Ihre Befehle aus, überprüfen Sie, dass Agents in `/context` angezeigt werden, und lösen Sie das Ereignis aus, das jeder Hook abgleicht, um seine Auswirkung zu bestätigen. Claude Code zeichnet auf, welche Hooks abgeglichen wurden und wie sie beendet wurden, im [Debug-Protokoll](/docs/de/hooks#debug-hooks).
485 </Step>
486</Steps>
487
488<h3 id="what-changes-when-migrating">
489 Was sich bei der Migration ändert
490</h3>
491
492| Eigenständig (`.claude/`) | Plugin |
493| :---------------------------------------- | :---------------------------------------- |
494| Nur in einem Projekt verfügbar | Kann über Marketplaces freigegeben werden |
495| Dateien in `.claude/commands/` | Dateien in `plugin-name/commands/` |
496| Hooks in `settings.json` | Hooks in `hooks/hooks.json` |
497| Muss manuell kopiert werden, um zu teilen | Mit `/plugin install` installieren |
498
499<Note>
500 Nach der Migration entfernen Sie die ursprünglichen Dateien aus `.claude/`, um Duplikate zu vermeiden. Projekt- und Benutzer-`.claude/agents/`-Definitionen überschreiben gleichnamige Plugin-Agents, daher wird die Plugin-Version erst wirksam, wenn die ursprünglichen Dateien entfernt werden. Plugin-Skills werden als `/plugin-name:skill-name` namensgebunden, daher bleiben sowohl das Original `/skill-name` als auch die Plugin-Kopie verfügbar, anstatt dass eines das andere überschreibt.
501</Note>
502
503<h2 id="next-steps">
504 Nächste Schritte
505</h2>
506
507Jetzt, da Sie das Plugin-System von Claude Code verstehen, finden Sie hier vorgeschlagene Pfade für verschiedene Ziele:
508
509<h3 id="for-plugin-users">
510 Für Plugin-Benutzer
511</h3>
512
513* [Plugins entdecken und installieren](/docs/de/discover-plugins): Durchsuchen Sie Marketplaces und installieren Sie Plugins
514* [Konfigurieren Sie Team-Marketplaces](/docs/de/discover-plugins#configure-team-marketplaces): Richten Sie Repository-Level-Plugins für Ihr Team ein
515
516<h3 id="for-plugin-developers">
517 Für Plugin-Entwickler
518</h3>
519
520* [Testen Sie Plugins mit Evals](/docs/de/plugin-evals): Messen Sie, was Ihr Plugin ändert, und gaten Sie CI darauf
521* [Erstellen und verteilen Sie einen Marketplace](/docs/de/plugin-marketplaces): Verpacken und teilen Sie Ihre Plugins
522* [Plugins-Referenz](/docs/de/plugins-reference): Vollständige technische Spezifikationen
523* Tauchen Sie tiefer in spezifische Plugin-Komponenten ein:
524 * [Skills](/docs/de/skills): Details zur Skill-Entwicklung
525 * [Subagents](/docs/de/sub-agents): Agent-Konfiguration und Fähigkeiten
526 * [Hooks](/docs/de/hooks): Event-Handling und Automatisierung
527 * [MCP](/docs/de/mcp): Integration externer Tools