Claude Code erweitern

Verstehen Sie, wann Sie CLAUDE.md, Skills, Subagents, Hooks, MCP und Plugins verwenden.

Claude Code kombiniert ein Modell, das über Ihren Code nachdenkt, mit integrierten Tools für Dateivorgänge, Suche, Ausführung und Webzugriff. Die integrierten Tools decken die meisten Codierungsaufgaben ab. Dieses Handbuch behandelt die Erweiterungsebene: Funktionen, die Sie hinzufügen, um anzupassen, was Claude weiß, es mit externen Diensten zu verbinden und Workflows zu automatisieren.

Neu bei Claude Code? Beginnen Sie mit CLAUDE.md für Projektkonventionen. Fügen Sie dann andere Erweiterungen hinzu, wenn spezifische Trigger auftreten.

Übersicht

Erweiterungen verbinden sich mit verschiedenen Teilen der Agentenschleife:

CLAUDE.md fügt persistenten Kontext hinzu, den Claude in jeder Sitzung sieht
Ausgabestile legen Claudes Rolle, Ton und Antwortformat für jede Antwort in einer Sitzung fest
Skills fügen wiederverwendbares Wissen und aufrufbare Workflows hinzu
Code-Intelligenz verbindet Claude mit einem Language Server für Symbol-Navigation und Live-Typfehler
MCP verbindet Claude mit externen Diensten und Tools
Subagents führen ihre eigenen Schleifen in isoliertem Kontext aus und geben Zusammenfassungen zurück
Dynamische Workflows führen viele Subagents aus einem Skript aus, das Claude schreibt, und geben ein Ergebnis zurück
Sitzungsübergreifendes Messaging ermöglicht es Claude, eine Nachricht von einer Ihrer Sitzungen an eine andere zu übergeben
Hooks führen Ihr Skript, eine HTTP-Anfrage, einen MCP-Tool-Aufruf, einen Prompt oder einen Subagent aus, wenn Claude Code ein Lebenszyklusereignis erreicht
Plugins und Marketplaces verpacken und verteilen diese Funktionen

Skills sind die flexibelste Erweiterung. Ein Skill ist eine Markdown-Datei, die Wissen, Workflows oder Anweisungen enthält. Sie können Skills mit einem Befehl wie /deploy aufrufen, oder Claude kann sie automatisch laden, wenn sie relevant sind. Skills können in Ihrer aktuellen Konversation oder in einem isolierten Kontext über Subagents ausgeführt werden.

Funktionen an Ihr Ziel anpassen

Funktionen reichen von immer aktivem Kontext, den Claude in jeder Sitzung sieht, über On-Demand-Funktionen, die Sie oder Claude aufrufen können, bis hin zu Hintergrundautomatisierung, die bei bestimmten Ereignissen ausgeführt wird. Die folgende Tabelle zeigt, was verfügbar ist und wann jede Funktion sinnvoll ist.

Funktion	Was sie tut	Wann man sie nutzt	Beispiel
CLAUDE.md	Persistenter Kontext, der in jedem Gespräch geladen wird	Projektkonventionen, „immer X tun"-Regeln	„Verwenden Sie pnpm, nicht npm. Führen Sie Tests vor dem Commit aus."
Ausgabestil	Anweisungen, die Claudes Rolle, Ton und Antwortformat für eine ganze Sitzung festlegen	Eine Stimme, Länge oder Format, das Sie in jeder Antwort möchten, oder Claude arbeitet als etwas anderes als ein Softwareingenieur	Der integrierte Concise-Stil für kürzere Antworten; ein benutzerdefinierter Stil, der jede Frage zuerst mit einem Diagramm beantwortet
Skill	Anweisungen, Wissen und Workflows, die Claude nutzen kann	Wiederverwendbarer Inhalt, Referenzdokumente, wiederholbare Aufgaben	`/deploy` führt Ihre Bereitstellungs-Checkliste aus; API-Docs-Skill mit Endpunkt-Mustern
Subagent	Isolierter Ausführungskontext, der zusammengefasste Ergebnisse zurückgibt	Kontextisolation, parallele Aufgaben, spezialisierte Worker	Recherche-Aufgabe, die viele Dateien liest, aber nur wichtige Erkenntnisse zurückgibt
Dynamischer Workflow	Skript, das Claude schreibt und das viele Subagents im Hintergrund ausführt	Arbeit, die über eine Handvoll Subagents hinauswächst, oder Erkenntnisse, die Sie überprüft haben möchten	Audit eines ganzen Codebase, wobei ein zweiter Satz von Agenten jede Erkenntnis überprüft
Sitzungsübergreifendes Messaging	Claude liefert eine Nachricht von einer Ihrer Sitzungen zu einer anderen	Sitzungen, die Sie selbst ausführen und die gegenseitig ihre Erkenntnisse während der Aufgabe benötigen	Eine Sitzung warnt eine andere, dass eine Änderung, die sie vorgenommen hat, das bricht, worauf die andere aufbaut
Code-Intelligenz	Language-Server-Navigation und Diagnose	Typisierte Sprachen, große Codebases, bei denen grep langsam oder ungenau ist	Springen Sie zur Definition eines Symbols, anstatt die ganze Datei zu lesen
MCP	Verbindung zu externen Diensten	Externe Daten oder Aktionen	Abfrage Ihrer Datenbank, Posten auf Slack, Steuerung eines Browsers
Hook	Skript, HTTP-Anfrage, MCP-Tool-Aufruf, Prompt oder Subagent, ausgelöst durch Ereignisse	Automatisierung, die bei jedem übereinstimmenden Ereignis ausgeführt werden muss	ESLint nach jeder Dateibearbeitung ausführen
Artefakt	Veröffentlichen Sie die Sitzungsausgabe als private, interaktive Webseite	Ausgabe, die Sie visuell sehen oder teilen möchten, anstatt als Terminaltext	Eine Incident-Timeline, die sich aktualisiert, während Claude untersucht

Plugins sind die Verpackungsebene. Ein Plugin bündelt Skills, Hooks, Subagents und MCP-Server in eine einzelne installierbare Einheit. Plugin-Skills sind namespaced (wie /my-plugin:review), sodass mehrere Plugins nebeneinander existieren können. Verwenden Sie Plugins, wenn Sie dieselbe Einrichtung über mehrere Repositories hinweg wiederverwenden möchten oder über einen Marketplace an andere verteilen möchten.

Bauen Sie Ihre Einrichtung im Laufe der Zeit auf

Sie müssen nicht alles im Voraus konfigurieren. Jede Funktion hat einen erkennbaren Auslöser, und die meisten Teams fügen sie ungefähr in dieser Reihenfolge hinzu:

Auslöser	Hinzufügen
Claude bekommt eine Konvention oder einen Befehl zweimal falsch	Fügen Sie es zu CLAUDE.md hinzu
Sie bitten Claude ständig, kürzer zu sein, mehr zu erklären oder im gleichen Format zu antworten	Legen Sie einen Ausgabestil fest
Sie tippen ständig denselben Prompt, um eine Aufgabe zu starten	Speichern Sie ihn als benutzer-aufrufbaren Skill
Sie fügen zum dritten Mal dasselbe Playbook oder mehrstufige Verfahren in den Chat ein	Erfassen Sie es als Skill
Sie kopieren ständig Daten aus einer Browser-Registerkarte, die Claude nicht sehen kann	Verbinden Sie dieses System als MCP-Server
Claude liest viele Dateien, um zu finden, wo ein Symbol definiert oder verwendet wird	Installieren Sie ein Code-Intelligence-Plugin für Ihre Sprache
Eine Nebenaufgabe überschwemmt Ihr Gespräch mit Ausgabe, auf die Sie nicht mehr verweisen werden	Leiten Sie es durch einen Subagent
Sie möchten, dass etwas jedes Mal passiert, ohne zu fragen	Schreiben Sie einen Hook
Ein zweites Repository benötigt dieselbe Einrichtung	Verpacken Sie es als Plugin

Die gleichen Auslöser sagen Ihnen, wann Sie das aktualisieren sollten, was Sie bereits haben. Ein wiederholter Fehler oder ein wiederkehrender Review-Kommentar ist eine CLAUDE.md-Bearbeitung, keine einmalige Korrektur im Chat. Ein Workflow, den Sie ständig von Hand anpassen, ist ein Skill, der eine weitere Überarbeitung benötigt.

Vergleichen Sie ähnliche Funktionen

Einige Funktionen können ähnlich wirken. Für eine tiefere Anleitung zur Auswahl zwischen ihnen siehe Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents auf dem Blog. So unterscheiden Sie sie.

Skills und Subagents lösen unterschiedliche Probleme:

Skills sind wiederverwendbarer Inhalt, den Sie in jeden Kontext laden können
Subagents sind isolierte Worker, die separat von Ihrem Hauptgespräch ausgeführt werden

Aspekt	Skill	Subagent
Was es ist	Wiederverwendbare Anweisungen, Wissen oder Workflows	Isolierter Worker mit eigenem Kontext
Hauptvorteil	Inhalte über Kontexte hinweg teilen	Kontextisolation. Die Arbeit läuft separat, nur die Zusammenfassung wird zurückgegeben
Kontextfenster-Auswirkung	Fügt zu Ihrem Hauptfenster hinzu	Verwendet ein separates Fenster mit eigenen Input- und Output-Tokens
Am besten für	Referenzmaterial, aufrufbare Workflows	Aufgaben, die viele Dateien lesen, parallele Arbeit, spezialisierte Worker

Skills können Referenz oder Aktion sein. Referenz-Skills bieten Wissen, das Claude während Ihrer Sitzung nutzt (wie Ihr API-Stilhandbuch). Action-Skills sagen Claude, etwas Bestimmtes zu tun (wie /deploy, das Ihren Bereitstellungs-Workflow ausführt).

Verwenden Sie einen Subagent, wenn Sie Kontextisolation benötigen oder wenn Ihr Kontextfenster voll wird. Der Subagent könnte Dutzende von Dateien lesen oder umfangreiche Suchen durchführen, aber Ihr Hauptgespräch erhält nur eine Zusammenfassung. Da die Subagent-Arbeit Ihren Hauptkontext nicht verbraucht, ist dies auch nützlich, wenn Sie nicht möchten, dass die Zwischenarbeit sichtbar bleibt. Benutzerdefinierte Subagents können ihre eigenen Anweisungen haben und Skills vorladen.

Sie können sich kombinieren. Ein Subagent kann spezifische Skills vorladen (skills:-Feld). Ein Skill kann in isoliertem Kontext mit context: fork ausgeführt werden. Siehe Skills für Details.

Beide speichern Anweisungen, aber sie laden unterschiedlich und dienen unterschiedlichen Zwecken.

Aspekt	CLAUDE.md	Skill
Lädt	Jede Sitzung, automatisch	On Demand
Kann Dateien einschließen	Ja, mit `@path`-Importen	Ja, mit `@path`-Importen
Kann Workflows auslösen	Nein	Ja, mit `/<name>`
Am besten für	„Immer X tun"-Regeln	Referenzmaterial, aufrufbare Workflows

Legen Sie es in CLAUDE.md ab, wenn Claude es immer wissen sollte: Codierungskonventionen, Build-Befehle, Projektstruktur, „niemals X tun"-Regeln.

Legen Sie es in einen Skill, wenn es Referenzmaterial ist, das Claude manchmal benötigt (API-Docs, Stilhandbücher) oder ein Workflow, den Sie mit /<name> auslösen (bereitstellen, überprüfen, freigeben).

Faustregel: Halten Sie CLAUDE.md unter 200 Zeilen. Wenn es wächst, verschieben Sie Referenzinhalte zu Skills oder teilen Sie sie in .claude/rules/-Dateien auf.

Beide geben Claude stehende Anweisungen. CLAUDE.md trägt das, was Claude wissen sollte, und ein Ausgabestil legt fest, wie Claude antwortet.

Aspekt	CLAUDE.md	Ausgabestil
Hält	Fakten und Regeln über Ihr Projekt	Eine Rolle, einen Ton und ein Antwortformat
Wechsel	Immer geladen	Einer aktiv auf einmal; Wechseln Sie Stile wann immer Sie möchten
Am besten für	Build-Befehle, Konventionen, „niemals X tun"-Regeln	Kürzere Antworten, Erklärungen neben Code, eine nicht-technische Rolle

Legen Sie es in CLAUDE.md ab, wenn es unabhängig vom Stil wahr ist: Codierungskonventionen, Build-Befehle, Projektstruktur.

Verwenden Sie einen Ausgabestil, wenn es um die Antwort selbst geht und Sie ihn möglicherweise wieder ausschalten möchten: Länge, Format, wie viel Claude erklärt, oder eine andere Rolle wie ein Schreibassistent. Claude Code enthält integrierte Stile, und Sie können Ihre eigenen schreiben.

Sie kombinieren sich. CLAUDE.md bleibt geladen, welchen Stil Sie auch wählen. Claude folgt beiden als Anweisungen, also wird keiner erzwungen. Für alles, das jedes Mal passieren muss, verwenden Sie einen Hook.

Alle drei speichern Anweisungen, aber sie laden unterschiedlich:

Aspekt	CLAUDE.md	`.claude/rules/`	Skill
Lädt	Jede Sitzung	Jede Sitzung, oder wenn übereinstimmende Dateien geöffnet werden	On Demand, wenn aufgerufen oder relevant
Umfang	Ganzes Projekt	Kann auf Dateipfade begrenzt werden	Aufgabenspezifisch
Am besten für	Kernkonventionen und Build-Befehle	Sprachspezifische oder verzeichnisspezifische Richtlinien	Referenzmaterial, wiederholbare Workflows

Verwenden Sie CLAUDE.md für Anweisungen, die jede Sitzung benötigt: Build-Befehle, Test-Konventionen, Projektarchitektur.

Verwenden Sie Regeln, um CLAUDE.md fokussiert zu halten. Regeln mit paths-Frontmatter laden nur, wenn Claude mit übereinstimmenden Dateien arbeitet, was Kontext spart.

Verwenden Sie Skills für Inhalte, die Claude nur manchmal benötigt, wie API-Dokumentation oder eine Bereitstellungs-Checkliste, die Sie mit /<name> auslösen.

MCP verbindet Claude mit externen Diensten. Skills erweitern das, was Claude weiß, einschließlich wie man diese Dienste effektiv nutzt.

Aspekt	MCP	Skill
Was es ist	Protokoll zur Verbindung mit externen Diensten	Wissen, Workflows und Referenzmaterial
Bietet	Tools und Datenzugriff	Wissen, Workflows, Referenzmaterial
Beispiele	Slack-Integration, Datenbankabfragen, Browser-Steuerung	Code-Review-Checkliste, Bereitstellungs-Workflow, API-Stilhandbuch

Diese lösen unterschiedliche Probleme und funktionieren gut zusammen:

MCP gibt Claude speziell entwickelte Tools für ein externes System, wobei die Verbindung und Authentifizierung vom Server behandelt werden.

Skills geben Claude Wissen darüber, wie man diese Tools effektiv nutzt, plus Workflows, die Sie mit /<name> auslösen können. Ein Skill könnte Ihr Team-Datenbankschema und Abfragemuster enthalten, oder einen /post-to-slack-Workflow mit Ihren Team-Nachrichtenformatierungsregeln.

Claude Code führt einen Hook bei einem Lebenszyklusereignis aus; es lädt einen Skill in den Kontext, damit Claude ihn anwendet.

Aspekt	Hook	Skill
Führt aus	Ein Shell-Befehl, HTTP-Anfrage, MCP-Tool-Aufruf, LLM-Prompt oder Subagent	Anweisungen, die Claude liest und befolgt
Ausgelöst durch	Lebenszyklusereignisse wie `PostToolUse` oder `SessionStart`	Sie tippen `/<name>`, oder Claude passt die Beschreibung zu Ihrer Aufgabe an
Determinismus	Wird immer bei seinem Ereignis ausgelöst; der Auslöser ist garantiert	Claude interpretiert die Anweisungen; das Ergebnis kann variieren
Kontextkosten	Null, es sei denn, der Hook gibt Ausgabe zurück	Beschreibung lädt jede Sitzung; vollständiger Inhalt lädt bei Verwendung
Am besten für	Linting nach Bearbeitungen, Blockieren unsicherer Befehle, Protokollierung, Benachrichtigungen	Workflows, die Überlegung benötigen, Referenzmaterial, mehrstufige Aufgaben

Verwenden Sie einen Hook, wenn die Aktion jedes Mal auf die gleiche Weise passieren muss und Claude nicht denken muss. Zum Beispiel: Formatierung beim Speichern, Ablehnung von rm -rf /, Posten einer Slack-Nachricht, wenn eine Sitzung endet.

Verwenden Sie einen Skill, wenn Claude entscheiden sollte, wie die Schritte angewendet werden, oder wenn der Inhalt Wissen statt ein Skript ist. Zum Beispiel: eine /release-Checkliste, Ihr API-Stilhandbuch, ein Debugging-Playbook.

Legen Sie Schutzmaßnahmen in Hooks. Eine Anweisung wie „niemals .env bearbeiten" in CLAUDE.md oder einem Skill ist eine Anfrage, keine Garantie. Ein PreToolUse-Hook, der die Bearbeitung blockiert, ist Durchsetzung. Wenn eine Regel jedes Mal gelten muss, machen Sie sie zu einem Hook statt zu einer Prompt-Anweisung.

Hook-Ausgabe landet im Kontext. Ein PostToolUse-Hook, der Ihren Linter ausführt, gibt Ergebnisse als Text zurück, den Claude liest; ein /fix-lint-Skill sagt Claude, wie man sie löst.

Verstehen Sie, wie Funktionen sich schichten

Funktionen können auf mehreren Ebenen definiert werden: benutzerübergreifend, pro Projekt, über Plugins oder durch verwaltete Richtlinien. Sie können auch CLAUDE.md-Dateien in Unterverzeichnissen verschachteln oder Skills in bestimmten Paketen eines Monorepo platzieren. Wenn die gleiche Funktion auf mehreren Ebenen existiert, so schichten sie sich:

CLAUDE.md-Dateien sind additiv: alle Ebenen tragen Inhalte gleichzeitig zu Claudes Kontext bei. Dateien aus Ihrem Arbeitsverzeichnis und darüber laden beim Start; Unterverzeichnisse laden, während Sie in ihnen arbeiten. Wenn Anweisungen in Konflikt geraten, nutzt Claude Urteilsvermögen, um sie zu versöhnen. Siehe wie CLAUDE.md-Dateien laden.
Skills und Subagents überschreiben nach Name: wenn der gleiche Name auf mehreren Ebenen existiert, gewinnt eine Definition basierend auf Priorität (verwaltet > Benutzer > Projekt für Skills; verwaltet > CLI-Flag > Projekt > Benutzer > Plugin für Subagents). Plugin-Skills sind namespaced, um Konflikte zu vermeiden. Siehe Skill-Erkennung und Subagent-Umfang.
MCP-Server überschreiben nach Name: lokal > Projekt > Benutzer. Siehe MCP-Umfang.
Hooks zusammenführen: alle registrierten Hooks werden für ihre übereinstimmenden Ereignisse unabhängig von der Quelle ausgelöst. Siehe Hooks.

Kombinieren Sie Funktionen

Jede Erweiterung löst ein anderes Problem: CLAUDE.md behandelt immer-aktiven Kontext, Skills behandeln On-Demand-Wissen und Workflows, MCP behandelt externe Verbindungen, Subagents behandeln Isolation, und Hooks behandeln Automatisierung. Echte Setups kombinieren sie basierend auf Ihrem Workflow.

Zum Beispiel könnten Sie CLAUDE.md für Projektkonventionen verwenden, einen Skill für Ihren Bereitstellungs-Workflow, MCP zur Verbindung mit Ihrer Datenbank und einen Hook zum Ausführen von Linting nach jeder Bearbeitung. Jede Funktion behandelt das, wofür sie am besten geeignet ist.

Muster	Wie es funktioniert	Beispiel
Skill + MCP	MCP bietet die Verbindung; ein Skill lehrt Claude, sie gut zu nutzen	MCP verbindet sich mit Ihrer Datenbank, ein Skill dokumentiert Ihr Schema und Abfragemuster
Skill + Subagent	Ein Skill spawnt Subagents für parallele Arbeit	`/audit`-Skill startet Sicherheits-, Leistungs- und Style-Subagents, die in isoliertem Kontext arbeiten
CLAUDE.md + Skills	CLAUDE.md hält immer-aktive Regeln; Skills halten Referenzmaterial, das On Demand geladen wird	CLAUDE.md sagt „folgen Sie unseren API-Konventionen", ein Skill enthält das vollständige API-Stilhandbuch
Hook + MCP	Ein Hook löst externe Aktionen durch MCP aus	Post-Edit-Hook sendet eine Slack-Benachrichtigung, wenn Claude kritische Dateien ändert

Verstehen Sie Kontextkosten

Jede Funktion, die Sie hinzufügen, verbraucht etwas von Claudes Kontext. Zu viel kann Ihr Kontextfenster füllen, aber es kann auch Rauschen hinzufügen, das Claude weniger effektiv macht; Skills werden möglicherweise nicht korrekt ausgelöst, oder Claude kann Ihre Konventionen aus den Augen verlieren. Das Verständnis dieser Kompromisse hilft Ihnen, ein effektives Setup zu erstellen. Für eine interaktive Ansicht, wie diese Funktionen in einer laufenden Sitzung kombiniert werden, siehe Erkunden Sie das Kontextfenster.

Kontextkosten nach Funktion

Jede Funktion hat eine andere Ladestrategie und Kontextkosten:

Funktion	Wann sie lädt	Was lädt	Kontextkosten
CLAUDE.md	Sitzungsstart	Vollständiger Inhalt	Jede Anfrage
Output-Stile	Sitzungsstart und erneut, wenn Sie Stile wechseln	Die vollständigen Anweisungen des aktiven Stils; nichts für den Standardstil	Jede Anfrage
Skills	Sitzungsstart + wenn verwendet	Beschreibungen beim Start, vollständiger Inhalt bei Verwendung	Niedrig (Beschreibungen jede Anfrage)*
MCP-Server	Sitzungsstart	Tool-Namen; vollständige Schemas bei Bedarf	Niedrig bis ein Tool verwendet wird
Code-Intelligenz	Nach Dateibearbeitungen und bei Bedarf	Diagnosen nach Bearbeitungen; Symbol-Positionen bei Suche	Niedrig; reduziert Dateileser anderswo
Subagents	Wenn gespawnt	Frischer Kontext mit angegebenen Skills oder die übergeordnete Konversation für einen Fork	Isoliert von Hauptsitzung
Hooks	Bei Auslösung	Nichts (läuft extern)	Null, es sei denn, Hook gibt zusätzlichen Kontext zurück

*Standardmäßig werden Skill-Beschreibungen beim Sitzungsstart geladen, damit Claude entscheiden kann, wann sie verwendet werden. Setzen Sie disable-model-invocation: true in das Frontmatter eines Skills, um es vollständig vor Claude zu verbergen, bis Sie es manuell aufrufen. Für einen Skill, den Sie nicht geschrieben haben, setzen Sie skillOverrides in den Einstellungen, um dasselbe zu tun, ohne die Datei zu bearbeiten.

Verstehen Sie, wie Funktionen geladen werden

Jede Funktion wird an verschiedenen Punkten in Ihrer Sitzung geladen. Die Registerkarten unten erklären, wann jede geladen wird und was in den Kontext geht.

Wann: Sitzungsstart

Was lädt: Vollständiger Inhalt aller CLAUDE.md-Dateien (verwaltet, Benutzer und Projektebenen).

Vererbung: Claude liest CLAUDE.md-Dateien aus Ihrem Arbeitsverzeichnis bis zur Wurzel und entdeckt verschachtelte in Unterverzeichnissen, wenn es auf diese Dateien zugreift. Weitere Informationen finden Sie unter Wie CLAUDE.md-Dateien geladen werden.

Skills sind zusätzliche Funktionen in Claudes Toolkit. Sie können Referenzmaterial sein (wie ein API-Stilhandbuch) oder aufrufbare Workflows, die Sie mit /<name> auslösen (wie /deploy). Claude Code wird mit gebündelten Skills wie /code-review, /batch und /debug ausgeliefert, die sofort funktionieren. Sie können auch Ihre eigenen erstellen.

Wann: Hängt von der Konfiguration des Skills ab. Standardmäßig werden Beschreibungen beim Sitzungsstart geladen und vollständiger Inhalt bei Verwendung. Für nur-Benutzer-Skills (disable-model-invocation: true) wird nichts geladen, bis Sie sie aufrufen.

Was lädt: Für modell-aufrufbare Skills sieht Claude Namen und Beschreibungen in jeder Anfrage. Wenn Sie einen Skill mit /<name> aufrufen oder Claude ihn automatisch lädt, wird der vollständige Inhalt in Ihre Konversation geladen.

Wie Claude Skills wählt: Claude gleicht Ihre Aufgabe gegen Skill-Beschreibungen ab, um zu entscheiden, welche relevant sind. Wenn Beschreibungen vage oder überlappend sind, kann Claude den falschen Skill laden oder einen verpassen, der helfen würde. Um Claude zu sagen, einen bestimmten Skill zu verwenden, rufen Sie ihn mit /<name> auf. Skills mit disable-model-invocation: true sind für Claude unsichtbar, bis Sie sie aufrufen.

Kontextkosten: Niedrig bis verwendet. Nur-Benutzer-Skills haben Null-Kosten bis aufgerufen.

In Subagents: Skills funktionieren in Subagents anders. Anstelle von On-Demand-Laden werden Skills, die im skills:-Feld des Subagenten aufgelistet sind, vollständig in seinen Kontext beim Start vorgeladen. Subagents können immer noch unlisted Project-, Benutzer- und Plugin-Skills durch das Skill-Tool entdecken und aufrufen.

Wann: Sitzungsstart.

Was lädt: Tool-Namen und Server-Anweisungen von verbundenen Servern. Vollständige JSON-Schemas bleiben aufgeschoben, bis Claude ein bestimmtes Tool benötigt.

Kontextkosten: Tool-Suche ist standardmäßig aktiviert, sodass untätige MCP-Tools minimalen Kontext verbrauchen.

Wann: Bei Bedarf, wenn Sie oder Claude einen für eine Aufgabe spawnt.

Was lädt: Frischer, isolierter Kontext, der Folgendes enthält:

Der Agent's eigener System-Prompt, nicht der Claude Code System-Prompt
Vollständiger Inhalt von Skills, die im skills:-Feld des Agenten aufgelistet sind
CLAUDE.md und Git-Status, außer die integrierten Explore- und Plan-Agenten lassen beide weg, und ein Agent, dessen Definition omitClaudeMd setzt, überspringt die Benutzer-, Projekt- und lokalen CLAUDE.md-Dateien
Welcher Kontext auch immer der Lead-Agent im Prompt übergibt

Für einen Fork lädt Claude Code die bisherige Konversation des übergeordneten Elements, den System-Prompt und die Tools statt dessen.

Kontextkosten: Isoliert von Hauptsitzung.

Weitere Informationen

Jede Funktion hat ihr eigenes Handbuch mit Setup-Anweisungen, Beispielen und Konfigurationsoptionen.

file-lines CLAUDE.md

Speichern Sie Projektkontext, Konventionen und Anweisungen

brain Skills

Geben Sie Claude Fachkompetenz und wiederverwendbare Workflows

users Subagents

Lagern Sie Arbeit in isoliertem Kontext aus

network Dynamic workflows

Führen Sie viele Subagents aus einem Skript aus

terminal Cross-session messaging

Lassen Sie Claude Ihre anderen Sitzungen benachrichtigen

plug MCP

Verbinden Sie Claude mit externen Diensten

bolt Hooks

Automatisieren Sie Aktionen mit Hooks

puzzle-piece Plugins

Bündeln und teilen Sie Feature-Sets

store Marketplaces

Hosten und verteilen Sie Plugin-Sammlungen

features-overview.md +84 −64

21Erweiterungen verbinden sich mit verschiedenen Teilen der Agentenschleife:21Erweiterungen verbinden sich mit verschiedenen Teilen der Agentenschleife:

22 22

23* **[CLAUDE.md](/docs/de/memory)** fügt persistenten Kontext hinzu, den Claude in jeder Sitzung sieht23* **[CLAUDE.md](/docs/de/memory)** fügt persistenten Kontext hinzu, den Claude in jeder Sitzung sieht

24* **[Ausgabestile](/docs/de/output-styles)** legen Claudes Rolle, Ton und Antwortformat für jede Antwort in einer Sitzung fest

24* **[Skills](/docs/de/skills)** fügen wiederverwendbares Wissen und aufrufbare Workflows hinzu25* **[Skills](/docs/de/skills)** fügen wiederverwendbares Wissen und aufrufbare Workflows hinzu

25* **[Code-Intelligenz](/docs/de/tools-reference#lsp-tool-behavior)** verbindet Claude mit einem Language Server für Symbol-Navigation und Live-Typfehler26* **[Code-Intelligenz](/docs/de/tools-reference#lsp-tool-behavior)** verbindet Claude mit einem Language Server für Symbol-Navigation und Live-Typfehler

26* **[MCP](/docs/de/mcp)** verbindet Claude mit externen Diensten und Tools27* **[MCP](/docs/de/mcp)** verbindet Claude mit externen Diensten und Tools

36 Funktionen an Ihr Ziel anpassen37 Funktionen an Ihr Ziel anpassen

37</h2>38</h2>

38 39

39Funktionen reichen von immer aktivem Kontext, den Claude in jeder Sitzung sieht, bis zu On-Demand-Funktionen, die Sie oder Claude aufrufen können, bis zu Hintergrundautomatisierung, die bei bestimmten Ereignissen ausgeführt wird. Die folgende Tabelle zeigt, was verfügbar ist und wann jede Funktion sinnvoll ist.40Funktionen reichen von immer aktivem Kontext, den Claude in jeder Sitzung sieht, über On-Demand-Funktionen, die Sie oder Claude aufrufen können, bis hin zu Hintergrundautomatisierung, die bei bestimmten Ereignissen ausgeführt wird. Die folgende Tabelle zeigt, was verfügbar ist und wann jede Funktion sinnvoll ist.

40 41

42| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |43| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |

44| **Skill** | Anweisungen, Wissen und Workflows, die Claude verwenden kann | Wiederverwendbarer Inhalt, Referenzdokumente, wiederholbare Aufgaben | `/deploy` führt Ihre Bereitstellungs-Checkliste aus; API-Docs-Skill mit Endpunkt-Mustern |45| **[Ausgabestil](/docs/de/output-styles)** | Anweisungen, die Claudes Rolle, Ton und Antwortformat für eine ganze Sitzung festlegen | Eine Stimme, Länge oder Format, das Sie in jeder Antwort möchten, oder Claude arbeitet als etwas anderes als ein Softwareingenieur | Der integrierte Concise-Stil für kürzere Antworten; ein benutzerdefinierter Stil, der jede Frage zuerst mit einem Diagramm beantwortet |

46| **Skill** | Anweisungen, Wissen und Workflows, die Claude nutzen kann | Wiederverwendbarer Inhalt, Referenzdokumente, wiederholbare Aufgaben | `/deploy` führt Ihre Bereitstellungs-Checkliste aus; API-Docs-Skill mit Endpunkt-Mustern |

45| **Subagent** | Isolierter Ausführungskontext, der zusammengefasste Ergebnisse zurückgibt | Kontextisolation, parallele Aufgaben, spezialisierte Worker | Recherche-Aufgabe, die viele Dateien liest, aber nur wichtige Erkenntnisse zurückgibt |47| **Subagent** | Isolierter Ausführungskontext, der zusammengefasste Ergebnisse zurückgibt | Kontextisolation, parallele Aufgaben, spezialisierte Worker | Recherche-Aufgabe, die viele Dateien liest, aber nur wichtige Erkenntnisse zurückgibt |

46| **[Dynamischer Workflow](/docs/de/workflows)** | Skript, das Claude schreibt und das viele Subagents im Hintergrund ausführt | Arbeit, die über eine Handvoll Subagents hinauswächst, oder Erkenntnisse, die Sie überprüft haben möchten | Audit einer ganzen Codebasis, wobei ein zweiter Satz von Agenten jeden Fund überprüft |48| **[Dynamischer Workflow](/docs/de/workflows)** | Skript, das Claude schreibt und das viele Subagents im Hintergrund ausführt | Arbeit, die über eine Handvoll Subagents hinauswächst, oder Erkenntnisse, die Sie überprüft haben möchten | Audit eines ganzen Codebase, wobei ein zweiter Satz von Agenten jede Erkenntnis überprüft |

47| **[Sitzungsübergreifendes Messaging](/docs/de/cross-session-messaging)** | Claude liefert eine Nachricht von einer Ihrer Sitzungen zu einer anderen | Sitzungen, die Sie selbst ausführen und die gegenseitig Erkenntnisse benötigen | Eine Sitzung warnt eine andere, dass eine Änderung, die sie vorgenommen hat, das bricht, worauf die andere aufbaut |49| **[Sitzungsübergreifendes Messaging](/docs/de/cross-session-messaging)** | Claude liefert eine Nachricht von einer Ihrer Sitzungen zu einer anderen | Sitzungen, die Sie selbst ausführen und die gegenseitig ihre Erkenntnisse während der Aufgabe benötigen | Eine Sitzung warnt eine andere, dass eine Änderung, die sie vorgenommen hat, das bricht, worauf die andere aufbaut |

48| **[Code intelligence](/docs/de/tools-reference#lsp-tool-behavior)** | Language-Server-Navigation und Diagnostik | Typisierte Sprachen, große Codebases, bei denen grep langsam oder ungenau ist | Springen Sie zur Definition eines Symbols, anstatt die ganze Datei zu lesen |50| **[Code-Intelligenz](/docs/de/tools-reference#lsp-tool-behavior)** | Language-Server-Navigation und Diagnose | Typisierte Sprachen, große Codebases, bei denen grep langsam oder ungenau ist | Springen Sie zur Definition eines Symbols, anstatt die ganze Datei zu lesen |

49| **MCP** | Verbindung zu externen Diensten | Externe Daten oder Aktionen | Abfrage Ihrer Datenbank, Posten auf Slack, Steuerung eines Browsers |51| **MCP** | Verbindung zu externen Diensten | Externe Daten oder Aktionen | Abfrage Ihrer Datenbank, Posten auf Slack, Steuerung eines Browsers |

50| **Hook** | Skript, HTTP-Anfrage, MCP-Tool-Aufruf, Prompt oder Subagent, ausgelöst durch Ereignisse | Automatisierung, die bei jedem übereinstimmenden Ereignis ausgeführt werden muss | Führen Sie ESLint nach jeder Dateibearbeitung aus |52| **Hook** | Skript, HTTP-Anfrage, MCP-Tool-Aufruf, Prompt oder Subagent, ausgelöst durch Ereignisse | Automatisierung, die bei jedem übereinstimmenden Ereignis ausgeführt werden muss | ESLint nach jeder Dateibearbeitung ausführen |

51| **[Artifact](/docs/de/artifacts)** | Veröffentlichen Sie die Sitzungsausgabe als private, interaktive Webseite | Ausgabe, die Sie visuell sehen oder teilen möchten, anstatt als Terminaltext | Eine Incident-Timeline, die sich aktualisiert, während Claude untersucht |53| **[Artefakt](/docs/de/artifacts)** | Veröffentlichen Sie die Sitzungsausgabe als private, interaktive Webseite | Ausgabe, die Sie visuell sehen oder teilen möchten, anstatt als Terminaltext | Eine Incident-Timeline, die sich aktualisiert, während Claude untersucht |

52 54

53**[Plugins](/docs/de/plugins)** sind die Verpackungsebene. Ein Plugin bündelt Skills, Hooks, Subagents und MCP-Server in eine einzelne installierbare Einheit. Plugin-Skills sind namensgebunden (wie `/my-plugin:review`), sodass mehrere Plugins nebeneinander existieren können. Verwenden Sie Plugins, wenn Sie dasselbe Setup über mehrere Repositories hinweg wiederverwenden möchten oder es über einen **[Marketplace](/docs/de/plugin-marketplaces)** an andere verteilen möchten.55**[Plugins](/docs/de/plugins)** sind die Verpackungsebene. Ein Plugin bündelt Skills, Hooks, Subagents und MCP-Server in eine einzelne installierbare Einheit. Plugin-Skills sind namespaced (wie `/my-plugin:review`), sodass mehrere Plugins nebeneinander existieren können. Verwenden Sie Plugins, wenn Sie dieselbe Einrichtung über mehrere Repositories hinweg wiederverwenden möchten oder über einen **[Marketplace](/docs/de/plugin-marketplaces)** an andere verteilen möchten.

54 56

55<h3 id="build-your-setup-over-time">57<h3 id="build-your-setup-over-time">

~~56 Bauen Sie Ihr Setup im Laufe der Zeit auf~~58 Bauen Sie Ihre Einrichtung im Laufe der Zeit auf

57</h3>59</h3>

58 60

~~59Sie müssen nicht alles im Voraus konfigurieren. Jede Funktion hat einen erkennbaren Trigger, und die meisten Teams fügen sie ungefähr in dieser Reihenfolge hinzu:~~61Sie müssen nicht alles im Voraus konfigurieren. Jede Funktion hat einen erkennbaren Auslöser, und die meisten Teams fügen sie ungefähr in dieser Reihenfolge hinzu:

60 62

61| Trigger | Hinzufügen |63| Auslöser | Hinzufügen |

62| :---------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- |64| :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- |

63| Claude bekommt eine Konvention oder einen Befehl zweimal falsch | Fügen Sie es zu [CLAUDE.md](/docs/de/memory) hinzu |65| Claude bekommt eine Konvention oder einen Befehl zweimal falsch | Fügen Sie es zu [CLAUDE.md](/docs/de/memory) hinzu |

64| Sie tippen immer wieder denselben Prompt, um eine Aufgabe zu starten | Speichern Sie es als benutzer-aufrufen [Skill](/docs/de/skills) |66| Sie bitten Claude ständig, kürzer zu sein, mehr zu erklären oder im gleichen Format zu antworten | Legen Sie einen [Ausgabestil](/docs/de/output-styles) fest |

67| Sie tippen ständig denselben Prompt, um eine Aufgabe zu starten | Speichern Sie ihn als benutzer-aufrufbaren [Skill](/docs/de/skills) |

65| Sie fügen zum dritten Mal dasselbe Playbook oder mehrstufige Verfahren in den Chat ein | Erfassen Sie es als [Skill](/docs/de/skills) |68| Sie fügen zum dritten Mal dasselbe Playbook oder mehrstufige Verfahren in den Chat ein | Erfassen Sie es als [Skill](/docs/de/skills) |

66| Sie kopieren immer wieder Daten aus einer Browser-Registerkarte, die Claude nicht sehen kann | Verbinden Sie dieses System als [MCP-Server](/docs/de/mcp) |69| Sie kopieren ständig Daten aus einer Browser-Registerkarte, die Claude nicht sehen kann | Verbinden Sie dieses System als [MCP-Server](/docs/de/mcp) |

67| Claude liest viele Dateien, um zu finden, wo ein Symbol definiert oder verwendet wird | Installieren Sie ein [Code-Intelligence-Plugin](/docs/de/discover-plugins#code-intelligence) für Ihre Sprache |70| Claude liest viele Dateien, um zu finden, wo ein Symbol definiert oder verwendet wird | Installieren Sie ein [Code-Intelligence-Plugin](/docs/de/discover-plugins#code-intelligence) für Ihre Sprache |

68| Eine Nebenaufgabe überschwemmt Ihre Konversation mit Ausgabe, auf die Sie nicht mehr verweisen werden | Leiten Sie sie durch einen [Subagent](/docs/de/sub-agents) |71| Eine Nebenaufgabe überschwemmt Ihr Gespräch mit Ausgabe, auf die Sie nicht mehr verweisen werden | Leiten Sie es durch einen [Subagent](/docs/de/sub-agents) |

69| Sie möchten, dass etwas jedes Mal passiert, ohne zu fragen | Schreiben Sie einen [Hook](/docs/de/hooks-guide) |72| Sie möchten, dass etwas jedes Mal passiert, ohne zu fragen | Schreiben Sie einen [Hook](/docs/de/hooks-guide) |

70| Ein zweites Repository benötigt dasselbe Setup | Verpacken Sie es als [Plugin](/docs/de/plugins) |73| Ein zweites Repository benötigt dieselbe Einrichtung | Verpacken Sie es als [Plugin](/docs/de/plugins) |

71 74

72Die gleichen Trigger sagen Ihnen, wann Sie das aktualisieren, was Sie bereits haben. Ein wiederholter Fehler oder ein wiederkehrender Review-Kommentar ist eine CLAUDE.md-Bearbeitung, keine einmalige Korrektur im Chat. Ein Workflow, den Sie immer wieder von Hand anpassen, ist ein Skill, der eine weitere Überarbeitung benötigt.75Die gleichen Auslöser sagen Ihnen, wann Sie das aktualisieren sollten, was Sie bereits haben. Ein wiederholter Fehler oder ein wiederkehrender Review-Kommentar ist eine CLAUDE.md-Bearbeitung, keine einmalige Korrektur im Chat. Ein Workflow, den Sie ständig von Hand anpassen, ist ein Skill, der eine weitere Überarbeitung benötigt.

73 76

74<h3 id="compare-similar-features">77<h3 id="compare-similar-features">

75 Vergleichen Sie ähnliche Funktionen78 Vergleichen Sie ähnliche Funktionen

76</h3>79</h3>

77 80

78Einige Funktionen können ähnlich wirken. Für eine tiefere Anleitung zur Auswahl zwischen ihnen siehe [Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents](https://claude.com/blog/steering-claude-code-skills-hooks-rules-subagents-and-more) im Blog. Hier erfahren Sie, wie Sie sie unterscheiden.81Einige Funktionen können ähnlich wirken. Für eine tiefere Anleitung zur Auswahl zwischen ihnen siehe [Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents](https://claude.com/blog/steering-claude-code-skills-hooks-rules-subagents-and-more) auf dem Blog. So unterscheiden Sie sie.

79 82

80<Tabs>83<Tabs>

81 <Tab title="Skill vs Subagent">84 <Tab title="Skill vs Subagent">

82 Skills und Subagents lösen unterschiedliche Probleme:85 Skills und Subagents lösen unterschiedliche Probleme:

83 86

~~84 * **Skills** sind wiederverwendbare Inhalte, die Sie in jeden Kontext laden können~~87 * **Skills** sind wiederverwendbarer Inhalt, den Sie in jeden Kontext laden können

~~85 * **Subagents** sind isolierte Worker, die separat von Ihrer Hauptkonversation ausgeführt werden~~88 * **Subagents** sind isolierte Worker, die separat von Ihrem Hauptgespräch ausgeführt werden

86 89

88 | --------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------- |91 | --------------------------------------------------- | ---------------------------------------------------- | -------------------------------------------------------------------------------------- |

93 96

94 **Skills können Referenz oder Aktion sein.** Referenz-Skills bieten Wissen, das Claude während Ihrer Sitzung nutzt (wie Ihr API-Stilhandbuch). Action-Skills sagen Claude, etwas Bestimmtes zu tun (wie `/deploy`, das Ihren Bereitstellungs-Workflow ausführt).97 **Skills können Referenz oder Aktion sein.** Referenz-Skills bieten Wissen, das Claude während Ihrer Sitzung nutzt (wie Ihr API-Stilhandbuch). Action-Skills sagen Claude, etwas Bestimmtes zu tun (wie `/deploy`, das Ihren Bereitstellungs-Workflow ausführt).

95 98

96 **Verwenden Sie einen Subagent**, wenn Sie Kontextisolation benötigen oder wenn Ihr Kontextfenster voll wird. Der Subagent könnte Dutzende von Dateien lesen oder umfangreiche Suchen durchführen, aber Ihre Hauptkonversation erhält nur eine Zusammenfassung. Da die Arbeit des Subagent Ihren Hauptkontext nicht verbraucht, ist dies auch nützlich, wenn Sie nicht möchten, dass die Zwischenarbeit sichtbar bleibt. Benutzerdefinierte Subagents können ihre eigenen Anweisungen haben und können Skills vorladen.99 **Verwenden Sie einen Subagent**, wenn Sie Kontextisolation benötigen oder wenn Ihr Kontextfenster voll wird. Der Subagent könnte Dutzende von Dateien lesen oder umfangreiche Suchen durchführen, aber Ihr Hauptgespräch erhält nur eine Zusammenfassung. Da die Subagent-Arbeit Ihren Hauptkontext nicht verbraucht, ist dies auch nützlich, wenn Sie nicht möchten, dass die Zwischenarbeit sichtbar bleibt. Benutzerdefinierte Subagents können ihre eigenen Anweisungen haben und Skills vorladen.

97 100

98 **Sie können sich kombinieren.** Ein Subagent kann spezifische Skills vorladen (`skills:`-Feld). Ein Skill kann in isoliertem Kontext mit `context: fork` ausgeführt werden. Weitere Informationen finden Sie unter [Skills](/docs/de/skills).101 **Sie können sich kombinieren.** Ein Subagent kann spezifische Skills vorladen (`skills:`-Feld). Ein Skill kann in isoliertem Kontext mit `context: fork` ausgeführt werden. Siehe [Skills](/docs/de/skills) für Details.

99 </Tab>102 </Tab>

100 103

101 <Tab title="CLAUDE.md vs Skill">104 <Tab title="CLAUDE.md vs Skill">

102 Beide speichern Anweisungen, aber sie werden unterschiedlich geladen und dienen unterschiedlichen Zwecken.105 Beide speichern Anweisungen, aber sie laden unterschiedlich und dienen unterschiedlichen Zwecken.

103 106

105 | --------------------------- | ------------------------- | -------------------------------------- |108 | ----------------------------- | ------------------------- | -------------------------------------- |

110 113

111 **Fügen Sie es in CLAUDE.md ein**, wenn Claude es immer wissen sollte: Codierungskonventionen, Build-Befehle, Projektstruktur, „niemals X tun"-Regeln.114 **Legen Sie es in CLAUDE.md** ab, wenn Claude es immer wissen sollte: Codierungskonventionen, Build-Befehle, Projektstruktur, „niemals X tun"-Regeln.

112 115

113 **Fügen Sie es in einen Skill ein**, wenn es Referenzmaterial ist, das Claude manchmal benötigt (API-Docs, Stilhandbücher) oder ein Workflow, den Sie mit `/<name>` auslösen (bereitstellen, überprüfen, freigeben).116 **Legen Sie es in einen Skill**, wenn es Referenzmaterial ist, das Claude manchmal benötigt (API-Docs, Stilhandbücher) oder ein Workflow, den Sie mit `/<name>` auslösen (bereitstellen, überprüfen, freigeben).

114 117

115 **Faustregel:** Halten Sie CLAUDE.md unter 200 Zeilen. Wenn es wächst, verschieben Sie Referenzinhalte zu Skills oder teilen Sie sie in [`.claude/rules/`](/docs/de/memory#organize-rules-with-claude%2Frules%2F)-Dateien auf.118 **Faustregel:** Halten Sie CLAUDE.md unter 200 Zeilen. Wenn es wächst, verschieben Sie Referenzinhalte zu Skills oder teilen Sie sie in [`.claude/rules/`](/docs/de/memory#organize-rules-with-claude/rules/)-Dateien auf.

116 </Tab>119 </Tab>

117 120

118 <Tab title="CLAUDE.md vs Rules vs Skills">121 <Tab title="CLAUDE.md vs Ausgabestil">

119 Alle drei speichern Anweisungen, aber sie werden unterschiedlich geladen:122 Beide geben Claude stehende Anweisungen. CLAUDE.md trägt das, was Claude wissen sollte, und ein Ausgabestil legt fest, wie Claude antwortet.

123

124 | Aspekt | CLAUDE.md | Ausgabestil |

125 | ----------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |

126 | **Hält** | Fakten und Regeln über Ihr Projekt | Eine Rolle, einen Ton und ein Antwortformat |

127 | **Wechsel** | Immer geladen | Einer aktiv auf einmal; [Wechseln Sie Stile](/docs/de/output-styles#change-your-output-style) wann immer Sie möchten |

128 | **Am besten für** | Build-Befehle, Konventionen, „niemals X tun"-Regeln | Kürzere Antworten, Erklärungen neben Code, eine nicht-technische Rolle |

129

130 **Legen Sie es in CLAUDE.md** ab, wenn es unabhängig vom Stil wahr ist: Codierungskonventionen, Build-Befehle, Projektstruktur.

131

132 **Verwenden Sie einen Ausgabestil**, wenn es um die Antwort selbst geht und Sie ihn möglicherweise wieder ausschalten möchten: Länge, Format, wie viel Claude erklärt, oder eine andere Rolle wie ein Schreibassistent. Claude Code enthält [integrierte Stile](/docs/de/output-styles#built-in-output-styles), und Sie können Ihre eigenen schreiben.

133

134 **Sie kombinieren sich.** CLAUDE.md bleibt geladen, welchen Stil Sie auch wählen. Claude folgt beiden als Anweisungen, also wird keiner erzwungen. Für alles, das jedes Mal passieren muss, verwenden Sie einen [Hook](/docs/de/hooks-guide).

135 </Tab>

136

137 <Tab title="CLAUDE.md vs Regeln vs Skills">

138 Alle drei speichern Anweisungen, aber sie laden unterschiedlich:

120 139

122 | ----------------- | ---------------------------------- | --------------------------------------------------------------- | ----------------------------------------- |141 | ----------------- | ---------------------------------- | ---------------------------------------------------------------- | ----------------------------------------- |

126 145

127 **Verwenden Sie CLAUDE.md** für Anweisungen, die jede Sitzung benötigt: Build-Befehle, Test-Konventionen, Projektarchitektur.146 **Verwenden Sie CLAUDE.md** für Anweisungen, die jede Sitzung benötigt: Build-Befehle, Test-Konventionen, Projektarchitektur.

128 147

129 **Verwenden Sie Regeln**, um CLAUDE.md fokussiert zu halten. Regeln mit [`paths`-Frontmatter](/docs/de/memory#path-specific-rules) werden nur geladen, wenn Claude mit übereinstimmenden Dateien arbeitet, was Kontext spart.148 **Verwenden Sie Regeln**, um CLAUDE.md fokussiert zu halten. Regeln mit [`paths`-Frontmatter](/docs/de/memory#path-specific-rules) laden nur, wenn Claude mit übereinstimmenden Dateien arbeitet, was Kontext spart.

130 149

131 **Verwenden Sie Skills** für Inhalte, die Claude nur manchmal benötigt, wie API-Dokumentation oder eine Bereitstellungs-Checkliste, die Sie mit `/<name>` auslösen.150 **Verwenden Sie Skills** für Inhalte, die Claude nur manchmal benötigt, wie API-Dokumentation oder eine Bereitstellungs-Checkliste, die Sie mit `/<name>` auslösen.

132 </Tab>151 </Tab>

133 152

134 <Tab title="Subagent vs Dynamischer Workflow">153 <Tab title="Subagent vs Dynamischer Workflow">

135 Beide führen Arbeit außerhalb Ihrer Hauptkonversation aus. Bei Subagents entscheidet Claude Zug um Zug, was als nächstes ausgeführt wird. In einem Workflow entscheidet das Skript:154 Beide führen Arbeit außerhalb Ihres Hauptgesprächs aus. Bei Subagents entscheidet Claude Zug um Zug, was als nächstes ausgeführt wird. In einem Workflow entscheidet das Skript:

136 155

137 * **Subagents** sind Worker, die Claude spawnt, jeder gibt eine Zusammenfassung an die Konversation zurück, die ihn spawnt156 * **Subagents** sind Worker, die Claude spawnt, jeder gibt eine Zusammenfassung an das Gespräch zurück, das ihn spawnt

138 * **[Dynamische Workflows](/docs/de/workflows)** sind Skripte, die Claude schreibt und die viele Subagents im Hintergrund ausführen und ein Ergebnis zurückgeben157 * **[Dynamische Workflows](/docs/de/workflows)** sind Skripte, die Claude schreibt und die viele Subagents im Hintergrund ausführen und ein Ergebnis zurückgeben

139 158

140 **Verwenden Sie einen Subagent**, wenn Sie einen schnellen, fokussierten Worker benötigen: eine Frage recherchieren, eine Behauptung überprüfen, eine Datei überprüfen. Der Subagent erledigt die Arbeit und gibt eine Zusammenfassung zurück, sodass Ihre Hauptkonversation sauber bleibt. Subagents, die Claude beim Spawnen benannt hat, können sich auch [gegenseitig Nachrichten senden](/docs/de/sub-agents#what-loads-at-startup).159 **Verwenden Sie einen Subagent**, wenn Sie einen schnellen, fokussierten Worker benötigen: eine Frage recherchieren, einen Anspruch überprüfen, eine Datei überprüfen. Der Subagent führt die Arbeit aus und gibt eine Zusammenfassung zurück, sodass Ihr Hauptgespräch sauber bleibt. Subagents, die Claude benannt hat, als es sie spawnte, können auch [sich gegenseitig Nachrichten senden](/docs/de/sub-agents#what-loads-at-startup).

141 160

142 **Verwenden Sie einen dynamischen Workflow**, wenn ein Job [über eine Handvoll Subagents hinauswächst](/docs/de/workflows#when-to-use-a-workflow), oder wenn Sie möchten, dass die Erkenntnisse überprüft werden, bevor Sie sie sehen, wie z. B. ein codebase-weites Audit, eine große Migration oder ein Plan, der aus mehreren Blickwinkeln entworfen wurde. Um einen zu starten, [fragen Sie in Ihrem Prompt nach einem Workflow](/docs/de/workflows#ask-for-a-workflow-in-your-prompt).161 **Verwenden Sie einen dynamischen Workflow**, wenn ein Job [über eine Handvoll Subagents hinauswächst](/docs/de/workflows#when-to-use-a-workflow), oder wenn Sie möchten, dass die Erkenntnisse überprüft werden, bevor Sie sie sehen, wie ein codebase-weites Audit, eine große Migration oder ein Plan, der aus mehreren Blickwinkeln entworfen wurde. Um einen zu starten, [fragen Sie in Ihrem Prompt nach einem Workflow](/docs/de/workflows#ask-for-a-workflow-in-your-prompt).

143 162

144 **Um einen Fund von einer Ihrer Sitzungen zu einer anderen zu übergeben**, bitten Sie Claudes erste Sitzung, ihn zu senden. Claude liefert ihn mit [sitzungsübergreifendem Messaging](/docs/de/cross-session-messaging). [Agenten parallel ausführen](/docs/de/agents) vergleicht die anderen Möglichkeiten, mehr als einen Claude gleichzeitig auszuführen, einschließlich Sitzungen, die Sie übergeben und später überprüfen.163 **Um eine Erkenntnis von einer Ihrer Sitzungen zu einer anderen zu übergeben**, bitten Sie Claudes erste Sitzung, sie zu senden. Claude liefert sie mit [sitzungsübergreifendem Messaging](/docs/de/cross-session-messaging). [Führen Sie Agenten parallel aus](/docs/de/agents) vergleicht die anderen Möglichkeiten, mehr als einen Claude auf einmal auszuführen, einschließlich Sitzungen, die Sie übergeben und später überprüfen.

145 </Tab>164 </Tab>

146 165

147 <Tab title="MCP vs Skill">166 <Tab title="MCP vs Skill">

148 MCP verbindet Claude mit externen Diensten. Skills erweitern das Wissen von Claude, einschließlich der effektiven Verwendung dieser Dienste.167 MCP verbindet Claude mit externen Diensten. Skills erweitern das, was Claude weiß, einschließlich wie man diese Dienste effektiv nutzt.

149 168

150 | Aspekt | MCP | Skill |169 | Aspekt | MCP | Skill |

151 | -------------- | ------------------------------------------------------- | ------------------------------------------------------------------ |170 | -------------- | ------------------------------------------------------- | ------------------------------------------------------------------ |

155 174

156 Diese lösen unterschiedliche Probleme und funktionieren gut zusammen:175 Diese lösen unterschiedliche Probleme und funktionieren gut zusammen:

157 176

158 **MCP** gibt Claude zweckgebundene Tools für ein externes System, wobei die Verbindung und Authentifizierung vom Server verwaltet werden.177 **MCP** gibt Claude speziell entwickelte Tools für ein externes System, wobei die Verbindung und Authentifizierung vom Server behandelt werden.

159 178

160 **Skills** geben Claude Wissen darüber, wie diese Tools effektiv verwendet werden, plus Workflows, die Sie mit `/<name>` auslösen können. Ein Skill könnte Ihr Team-Datenbankschema und Abfragemuster enthalten, oder einen `/post-to-slack`-Workflow mit Ihren Team-Nachrichtenformatierungsregeln.179 **Skills** geben Claude Wissen darüber, wie man diese Tools effektiv nutzt, plus Workflows, die Sie mit `/<name>` auslösen können. Ein Skill könnte Ihr Team-Datenbankschema und Abfragemuster enthalten, oder einen `/post-to-slack`-Workflow mit Ihren Team-Nachrichtenformatierungsregeln.

161 </Tab>180 </Tab>

162 181

163 <Tab title="Hook vs Skill">182 <Tab title="Hook vs Skill">

164 Claude Code führt einen Hook bei einem Lebenszyklusereignis aus; es lädt einen Skill in den Kontext, damit Claude ihn anwendet.183 Claude Code führt einen Hook bei einem Lebenszyklusereignis aus; es lädt einen Skill in den Kontext, damit Claude ihn anwendet.

165 184

167 | ------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------- |186 | ------------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |

169 | **Ausgelöst durch** | [Lebenszyklusereignisse](/docs/de/hooks#hook-events) wie `PostToolUse` oder `SessionStart` | Sie tippen `/<name>`, oder Claude passt die Beschreibung zu Ihrer Aufgabe an |188 | **Ausgelöst durch** | [Lebenszyklusereignisse](/docs/de/hooks#hook-events) wie `PostToolUse` oder `SessionStart` | Sie tippen `/<name>`, oder Claude passt die Beschreibung zu Ihrer Aufgabe an |

172 | **Am besten für** | Linting nach Bearbeitungen, Blockierung unsicherer Befehle, Logging, Benachrichtigungen | Workflows, die Überlegung benötigen, Referenzmaterial, mehrstufige Aufgaben |191 | **Am besten für** | Linting nach Bearbeitungen, Blockieren unsicherer Befehle, Protokollierung, Benachrichtigungen | Workflows, die Überlegung benötigen, Referenzmaterial, mehrstufige Aufgaben |

173 192

174 **Verwenden Sie einen Hook**, wenn die Aktion jedes Mal auf die gleiche Weise erfolgen muss und Claude nicht denken muss. Beispiel: Formatierung beim Speichern, Ablehnung von `rm -rf /`, Posten einer Slack-Nachricht, wenn eine Sitzung endet.193 **Verwenden Sie einen Hook**, wenn die Aktion jedes Mal auf die gleiche Weise passieren muss und Claude nicht denken muss. Zum Beispiel: Formatierung beim Speichern, Ablehnung von `rm -rf /`, Posten einer Slack-Nachricht, wenn eine Sitzung endet.

175 194

176 **Verwenden Sie einen Skill**, wenn Claude entscheiden sollte, wie die Schritte angewendet werden, oder wenn der Inhalt eher Wissen als ein Skript ist. Beispiel: eine `/release`-Checkliste, Ihr API-Stilhandbuch, ein Debugging-Playbook.195 **Verwenden Sie einen Skill**, wenn Claude entscheiden sollte, wie die Schritte angewendet werden, oder wenn der Inhalt Wissen statt ein Skript ist. Zum Beispiel: eine `/release`-Checkliste, Ihr API-Stilhandbuch, ein Debugging-Playbook.

177 196

178 **Setzen Sie Schutzmaßnahmen in Hooks.** Eine Anweisung wie „niemals `.env` bearbeiten" in CLAUDE.md oder einem Skill ist eine Anfrage, keine Garantie. Ein `PreToolUse`-Hook, der die Bearbeitung blockiert, ist Durchsetzung. Wenn eine Regel jedes Mal gelten muss, machen Sie sie zu einem Hook statt zu einer Prompt-Anweisung.197 **Legen Sie Schutzmaßnahmen in Hooks.** Eine Anweisung wie „niemals `.env` bearbeiten" in CLAUDE.md oder einem Skill ist eine Anfrage, keine Garantie. Ein `PreToolUse`-Hook, der die Bearbeitung blockiert, ist Durchsetzung. Wenn eine Regel jedes Mal gelten muss, machen Sie sie zu einem Hook statt zu einer Prompt-Anweisung.

179 198

180 **Hook-Ausgabe landet im Kontext.** Ein `PostToolUse`-Hook, der Ihren Linter ausführt, gibt Ergebnisse als Text zurück, den Claude liest; ein `/fix-lint`-Skill sagt Claude, wie sie zu beheben sind.199 **Hook-Ausgabe landet im Kontext.** Ein `PostToolUse`-Hook, der Ihren Linter ausführt, gibt Ergebnisse als Text zurück, den Claude liest; ein `/fix-lint`-Skill sagt Claude, wie man sie löst.

181 </Tab>200 </Tab>

182</Tabs>201</Tabs>

183 202

185 Verstehen Sie, wie Funktionen sich schichten204 Verstehen Sie, wie Funktionen sich schichten

186</h3>205</h3>

187 206

188Funktionen können auf mehreren Ebenen definiert werden: benutzerübergreifend, pro Projekt, über Plugins oder durch verwaltete Richtlinien. Sie können auch CLAUDE.md-Dateien in Unterverzeichnissen verschachteln oder Skills in bestimmten Paketen eines Monorepos platzieren. Wenn dieselbe Funktion auf mehreren Ebenen vorhanden ist, so schichten sie sich:207Funktionen können auf mehreren Ebenen definiert werden: benutzerübergreifend, pro Projekt, über Plugins oder durch verwaltete Richtlinien. Sie können auch CLAUDE.md-Dateien in Unterverzeichnissen verschachteln oder Skills in bestimmten Paketen eines Monorepo platzieren. Wenn die gleiche Funktion auf mehreren Ebenen existiert, so schichten sie sich:

189 208

190* **CLAUDE.md-Dateien** sind additiv: alle Ebenen tragen gleichzeitig Inhalte zu Claudes Kontext bei. Dateien aus Ihrem Arbeitsverzeichnis und darüber werden beim Start geladen; Unterverzeichnisse werden geladen, wenn Sie darin arbeiten. Wenn Anweisungen in Konflikt geraten, nutzt Claude sein Urteilsvermögen, um sie zu reconciliieren, wobei spezifischere Anweisungen typischerweise Vorrang haben. Siehe [wie CLAUDE.md-Dateien geladen werden](/docs/de/memory#how-claude-md-files-load).209* **CLAUDE.md-Dateien** sind additiv: alle Ebenen tragen Inhalte gleichzeitig zu Claudes Kontext bei. Dateien aus Ihrem Arbeitsverzeichnis und darüber laden beim Start; Unterverzeichnisse laden, während Sie in ihnen arbeiten. Wenn Anweisungen in Konflikt geraten, nutzt Claude Urteilsvermögen, um sie zu versöhnen. Siehe [wie CLAUDE.md-Dateien laden](/docs/de/memory#how-claude-md-files-load).

191* **Skills und Subagents** überschreiben nach Name: wenn derselbe Name auf mehreren Ebenen vorhanden ist, gewinnt eine Definition basierend auf Priorität (verwaltet > Benutzer > Projekt für Skills; verwaltet > CLI-Flag > Projekt > Benutzer > Plugin für Subagents). Plugin-Skills sind [namensgebunden](/docs/de/plugins#add-skills-to-your-plugin), um Konflikte zu vermeiden. Siehe [Skill-Erkennung](/docs/de/skills#resolve-skills-that-share-a-name) und [Subagent-Umfang](/docs/de/sub-agents#choose-the-subagent-scope).210* **Skills und Subagents** überschreiben nach Name: wenn der gleiche Name auf mehreren Ebenen existiert, gewinnt eine Definition basierend auf Priorität (verwaltet > Benutzer > Projekt für Skills; verwaltet > CLI-Flag > Projekt > Benutzer > Plugin für Subagents). Plugin-Skills sind [namespaced](/docs/de/plugins#add-skills-to-your-plugin), um Konflikte zu vermeiden. Siehe [Skill-Erkennung](/docs/de/skills#resolve-skills-that-share-a-name) und [Subagent-Umfang](/docs/de/sub-agents#choose-the-subagent-scope).

192* **MCP-Server** überschreiben nach Name: lokal > Projekt > Benutzer. Siehe [MCP-Umfang](/docs/de/mcp#scope-hierarchy-and-precedence).211* **MCP-Server** überschreiben nach Name: lokal > Projekt > Benutzer. Siehe [MCP-Umfang](/docs/de/mcp#scope-hierarchy-and-precedence).

193* **Hooks** zusammenführen: alle registrierten Hooks werden für ihre übereinstimmenden Ereignisse unabhängig von der Quelle ausgelöst. Siehe [Hooks](/docs/de/hooks).212* **Hooks** zusammenführen: alle registrierten Hooks werden für ihre übereinstimmenden Ereignisse unabhängig von der Quelle ausgelöst. Siehe [Hooks](/docs/de/hooks).

194 213

196 Kombinieren Sie Funktionen215 Kombinieren Sie Funktionen

197</h3>216</h3>

198 217

199Jede Erweiterung löst ein anderes Problem: CLAUDE.md behandelt immer aktivem Kontext, Skills behandeln On-Demand-Wissen und Workflows, MCP behandelt externe Verbindungen, Subagents behandeln Isolation und Hooks behandeln Automatisierung. Echte Setups kombinieren sie basierend auf Ihrem Workflow.218Jede Erweiterung löst ein anderes Problem: CLAUDE.md behandelt immer-aktiven Kontext, Skills behandeln On-Demand-Wissen und Workflows, MCP behandelt externe Verbindungen, Subagents behandeln Isolation, und Hooks behandeln Automatisierung. Echte Setups kombinieren sie basierend auf Ihrem Workflow.

200 219

201Beispielsweise könnten Sie CLAUDE.md für Projektkonventionen, einen Skill für Ihren Bereitstellungs-Workflow, MCP zur Verbindung mit Ihrer Datenbank und einen Hook zum Ausführen von Linting nach jeder Bearbeitung verwenden. Jede Funktion behandelt das, wofür sie am besten geeignet ist.220Zum Beispiel könnten Sie CLAUDE.md für Projektkonventionen verwenden, einen Skill für Ihren Bereitstellungs-Workflow, MCP zur Verbindung mit Ihrer Datenbank und einen Hook zum Ausführen von Linting nach jeder Bearbeitung. Jede Funktion behandelt das, wofür sie am besten geeignet ist.

202 221

204| ---------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |223| ---------------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |

206| **Skill + Subagent** | Ein Skill spawnt Subagents für parallele Arbeit | `/audit`-Skill startet Sicherheits-, Leistungs- und Style-Subagents, die in isoliertem Kontext arbeiten |225| **Skill + Subagent** | Ein Skill spawnt Subagents für parallele Arbeit | `/audit`-Skill startet Sicherheits-, Leistungs- und Style-Subagents, die in isoliertem Kontext arbeiten |

207| **CLAUDE.md + Skills** | CLAUDE.md hält immer aktivem Regeln; Skills halten Referenzmaterial, das On Demand geladen wird | CLAUDE.md sagt „folgen Sie unseren API-Konventionen", ein Skill enthält das vollständige API-Stilhandbuch |226| **CLAUDE.md + Skills** | CLAUDE.md hält immer-aktive Regeln; Skills halten Referenzmaterial, das On Demand geladen wird | CLAUDE.md sagt „folgen Sie unseren API-Konventionen", ein Skill enthält das vollständige API-Stilhandbuch |

209 228

210<h2 id="understand-context-costs">229<h2 id="understand-context-costs">

211 Verstehen Sie Kontextkosten230 Verstehen Sie Kontextkosten

220Jede Funktion hat eine andere Ladestrategie und Kontextkosten:239Jede Funktion hat eine andere Ladestrategie und Kontextkosten:

221 240

223| -------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- |242| -------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- |

features-overview.md 2026-09-21 22:59 UTC to 2026-09-22 23:59 UTC

Claude Code erweitern

Übersicht

Funktionen an Ihr Ziel anpassen

Bauen Sie Ihre Einrichtung im Laufe der Zeit auf

Vergleichen Sie ähnliche Funktionen

Verstehen Sie, wie Funktionen sich schichten

Kombinieren Sie Funktionen

Verstehen Sie Kontextkosten

Kontextkosten nach Funktion

Verstehen Sie, wie Funktionen geladen werden

Weitere Informationen