---
type: "BlogPosting"
title: "Claude Code Plugins: Der komplette Guide zum Erweiterungssystem 2025"
description: "Claude Code Plugins revolutionieren die KI-gestützte Entwicklung. Verstehe die Unterschiede zwischen Skills, Plugins, MCP Servern und Agents – und erweitere Claude Code mit eigenen Funktionen."
resource: "https://www.contextstudios.ai/de/blog/claude-code-plugins-der-komplette-guide-zum-erweiterungssystem-2025"
language: "de"
tags: ["Claude Code", "Plugins", "MCP", "AI Development", "Anthropic", "Developer Tools", "Automation"]
generated:
  by: "process:contextstudios-md/1"
  at: "2026-10-08T20:59:10.043Z"
status: "stable"
---

# Claude Code Plugins: Der komplette Guide zum Erweiterungssystem 2025

Published: 2026-01-04
Tags: Claude Code, Plugins, MCP, AI Development, Anthropic, Developer Tools, Automation

![Claude Code Plugins: Der komplette Guide zum Erweiterungssystem 2025](https://wary-platypus-754.convex.cloud/api/storage/a6e2f14d-e250-41f9-aeaf-a67a5ee19ae1)

# Claude Code Plugins: Der komplette Guide zum Erweiterungssystem 2025

Claude Code Plugins steht im Mittelpunkt dieses Guides. Claude Code hat sich als das führende KI-Entwicklungstool für das Terminal etabliert. Doch die wahre Stärke liegt im **modularen Erweiterungssystem**, das Entwicklern ermöglicht, Claude Code an ihre spezifischen Workflows anzupassen. In diesem Guide erfährst du alles über Plugins, Skills, MCP Server, Agents und wie sie zusammenarbeiten.

---

## Das Claude Code Erweiterungssystem im Überblick

Claude Code bietet **fünf verschiedene Erweiterungsmechanismen**, die jeweils unterschiedliche Anwendungsfälle abdecken:

| Komponente | Zweck | Aufruf | Scope |
|------------|-------|--------|-------|
| **Plugins** | Wiederverwendbare Pakete mit Commands, Agents, Skills & Hooks | `/plugin-name:command` | Team/Community |
| **Skills** | Kontextuelle Fähigkeiten für Claude | Automatisch durch Claude | Projekt/User |
| **MCP Server** | Externe Tool-Integration | Via Tool-Aufrufe | Universal |
| **Agents/Subagents** | Spezialisierte KI-Assistenten | Via Task-Delegation | Session |
| **CLAUDE.md** | Projekt-Kontext & Regeln | Automatisch geladen | Projekt |

### Die Hierarchie verstehen

```
┌─────────────────────────────────────────────────────────────┐
│                      Claude Code CLI                         │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │   Plugins   │  │   Skills    │  │    MCP Server       │  │
│  │  (Pakete)   │  │ (Fähigkeit) │  │ (Externe Tools)     │  │
│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘  │
│         │                │                     │             │
│         ▼                ▼                     ▼             │
│  ┌─────────────────────────────────────────────────────────┐│
│  │                    Agents/Subagents                      ││
│  │              (Spezialisierte Assistenten)                ││
│  └─────────────────────────────────────────────────────────┘│
│                            ▲                                 │
│                            │                                 │
│  ┌─────────────────────────────────────────────────────────┐│
│  │    CLAUDE.md / AGENTS.md (Projekt-Kontext & Regeln)     ││
│  └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
```

---

## 1. Claude Code Plugins – Die Komplettlösung

**Plugins** sind das mächtigste Erweiterungsformat. Sie bündeln mehrere Komponenten in einem verteilbaren Paket:

### Was Plugins enthalten können

- **Slash Commands** – Benutzerdefinierte Befehle (`/plugin:command`)
- **Agents** – Spezialisierte Subagenten
- **Skills** – Kontext-sensitive Fähigkeiten
- **Hooks** – Event-Handler für Automatisierung
- **MCP Server** – Externe Tool-Konfigurationen
- **LSP Server** – Code-Intelligenz für Sprachen

### Plugin-Struktur

```
my-plugin/
├── .claude-plugin/
│   └── plugin.json          # Plugin-Metadaten (erforderlich)
├── commands/                # Slash Commands
│   └── hello.md
├── agents/                  # Subagent-Definitionen
│   └── reviewer.md
├── skills/                  # Agent Skills
│   └── code-review/
│       └── SKILL.md
├── hooks/                   # Event-Handler
│   └── hooks.json
├── .mcp.json                # MCP Server Konfiguration
├── .lsp.json                # LSP Server Konfiguration
└── README.md                # Dokumentation
```

### Plugin-Manifest (plugin.json)

```json
{
  "name": "my-plugin",
  "description": "Beschreibung des Plugins",
  "version": "1.0.0",
  "author": {
    "name": "Dein Name",
    "email": "email@example.com"
  },
  "repository": "https://github.com/user/my-plugin",
  "license": "MIT"
}
```

---

## 2. Skills – Kontextuelle Fähigkeiten

**Skills** sind Model-invoked: Claude entscheidet automatisch, wann ein Skill relevant ist, basierend auf dem Task-Kontext.

### Unterschied zu Plugins

| Aspekt | Skills | Plugins |
|--------|--------|---------|
| Aufruf | Automatisch durch Claude | Explizit via `/command` |
| Namespace | Kein Namespace | `plugin-name:command` |
| Verteilung | Lokal oder via Plugin | Via Marketplaces |
| Komplexität | Einzelne SKILL.md | Multi-Komponenten-Paket |

### Skill-Struktur (SKILL.md)

```yaml
---
name: code-review
description: Reviews code for best practices. Use when reviewing PRs or code changes.
---

When reviewing code, analyze:
1. Code structure and readability
2. Security vulnerabilities
3. Performance implications
4. Test coverage

Provide feedback organized by priority:
- Critical (must fix)
- Warnings (should fix)
- Suggestions (consider)
```

### Skill-Speicherorte

| Typ | Pfad | Priorität |
|-----|------|-----------|
| Projekt | `.claude/skills/` | Höchste |
| User | `~/.claude/skills/` | Mittel |
| Plugin | `plugin/skills/` | Niedrigste |

---

## 3. MCP Server – Externe Tool-Integration

**Model Context Protocol (MCP)** ermöglicht Claude den Zugriff auf externe Datenquellen und Tools. MCP Server sind unabhängig von Claude Code und können von verschiedenen Clients verwendet werden.

### MCP vs. Plugin

| Aspekt | MCP Server | Plugins |
|--------|------------|---------|
| Protokoll | Standardisiert (JSON-RPC) | Claude Code spezifisch |
| Client | Beliebiger MCP Client | Nur Claude Code |
| Transport | stdio, HTTP, WebSocket | Integriert |
| Fokus | Tool-Integration | Workflow-Erweiterung |

### MCP in Plugins einbinden

Plugins können MCP Server über `.mcp.json` konfigurieren:

```json
{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "@my-org/db-mcp-server"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}
```

### Wann MCP vs. Plugin?

**Verwende MCP wenn:**
- Du externe APIs/Datenbanken integrierst
- Die Funktionalität Client-agnostisch sein soll
- Du bestehende MCP Server nutzen willst

**Verwende Plugins wenn:**
- Du Claude Code Workflows anpassen willst
- Du Slash Commands oder Hooks brauchst
- Du spezialisierte Agents definieren willst

---

## 4. Agents & Subagents – Spezialisierte Assistenten

**Agents** (auch Subagents genannt) sind vorkonfigurierte KI-Persönlichkeiten, die Claude Code an spezialisierte Tasks delegieren kann.

### Unterschied zu Skills

| Aspekt | Agents | Skills |
|--------|--------|--------|
| Ausführung | Eigener Kontext-Window | Im Haupt-Kontext |
| Tools | Einschränkbar | Erbt alle Tools |
| Modell | Konfigurierbar | Haupt-Modell |
| Zweck | Task-Delegation | Fähigkeits-Erweiterung |

### Agent-Definition

```yaml
---
name: code-reviewer
description: Expert code review. Use proactively after code changes.
tools: Read, Grep, Glob, Bash
model: sonnet
permissionMode: default
---

You are a senior code reviewer. Focus on:
- Code quality and readability
- Security best practices
- Performance considerations
- Test coverage

Provide actionable feedback with examples.
```

### Built-in Agents

Claude Code enthält diese eingebauten Agents:

| Agent | Zweck | Modell |
|-------|-------|--------|
| **general-purpose** | Komplexe Multi-Step-Tasks | Sonnet |
| **Explore** | Codebase-Suche (read-only) | Haiku |
| **Plan** | Recherche im Plan-Modus | Sonnet |

---

## 5. CLAUDE.md & AGENTS.md – Projekt-Kontext

Diese Markdown-Dateien liefern Claude persistenten Kontext über dein Projekt.

### CLAUDE.md

Wird automatisch geladen und enthält:
- Projekt-Beschreibung & Architektur
- Code-Konventionen & Stil-Guides
- Build- & Test-Befehle
- Wichtige Dateien & Strukturen

```markdown
# Project: My Web App

## Architecture
- Frontend: Next.js 14 with App Router
- Backend: Python FastAPI
- Database: PostgreSQL with Prisma

## Commands
- `npm run dev` - Start development
- `npm test` - Run tests
- `npm run build` - Production build

## Conventions
- Use TypeScript strict mode
- Follow ESLint rules
- Write tests for all new features
```

### AGENTS.md

Spezifische Anweisungen für KI-Agenten:

```markdown
# Agent Instructions

## Code Review Rules
- Always check for security vulnerabilities
- Require test coverage for new features
- Flag deprecated API usage

## Commit Guidelines
- Use conventional commits
- Include ticket numbers
- Sign commits with GPG
```

### Speicherorte

| Datei | Pfade |
|-------|-------|
| CLAUDE.md | `./CLAUDE.md`, `./.claude/CLAUDE.md` |
| AGENTS.md | `./AGENTS.md`, `./.claude/AGENTS.md` |

---

## Offizielle Claude Code Plugins

Anthropic stellt **12 offizielle Plugins** bereit, die Best Practices demonstrieren:

### 1. agent-sdk-dev
**Entwicklungskit für das Claude Agent SDK**

| Komponente | Beschreibung |
|------------|--------------|
| Command | `/new-sdk-app` – Interaktives Setup für Agent SDK Projekte |
| Agents | `agent-sdk-verifier-py`, `agent-sdk-verifier-ts` – Validierung gegen Best Practices |

### 2. claude-opus-4-5-migration
**Migration zu Claude Opus 4.5**

Automatisierte Migration von Sonnet 4.x und Opus 4.1:
- Model-String Updates
- Beta-Header Anpassungen
- Prompt-Optimierungen

### 3. code-review ⭐
**Automatisiertes PR-Review mit Multi-Agent-System**

| Komponente | Beschreibung |
|------------|--------------|
| Command | `/code-review` – Startet Review-Workflow |
| Agents | 5 parallele Sonnet-Agents für: CLAUDE.md Compliance, Bug Detection, Historical Context, PR History, Code Comments |

Verwendet Confidence-Scoring zur Filterung von False Positives.

### 4. commit-commands
**Git-Workflow-Automatisierung**

| Command | Funktion |
|---------|----------|
| `/commit` | Änderungen committen |
| `/commit-push-pr` | Commit, Push & PR erstellen |
| `/clean_gone` | Gelöschte Remote-Branches aufräumen |

### 5. explanatory-output-style
**Lernorientierte Ausgaben**

Hook bei Session-Start, der Claude anweist, Implementierungsentscheidungen und Codebase-Patterns zu erklären.

### 6. feature-dev ⭐
**Strukturierter 7-Phasen Feature-Entwicklungsworkflow**

| Komponente | Beschreibung |
|------------|--------------|
| Command | `/feature-dev` – Geführter Entwicklungsworkflow |
| Agents | `code-explorer` – Codebase-Analyse |
| | `code-architect` – Architektur-Design |
| | `code-reviewer` – Qualitätsprüfung |

### 7. frontend-design
**Professionelles Frontend-Design**

Skill zur Erstellung distinctiver, produktionsreifer Interfaces. Vermeidet generische "AI-Ästhetik" durch Fokus auf:
- Typografie & Spacing
- Animationen & Micro-Interactions
- Visuelle Details

### 8. hookify
**Custom Hook Generator**

| Command | Funktion |
|---------|----------|
| `/hookify` | Erstellt Custom Hooks |
| `/hookify:list` | Listet bestehende Hooks |
| `/hookify:configure` | Konfiguriert Hooks |
| `/hookify:help` | Hilfe anzeigen |

Analysiert Konversationen, um problematische Verhaltensmuster zu identifizieren.

### 9. learning-output-style
**Interaktiver Lernmodus**

Hook, der Benutzer ermutigt, an Entscheidungspunkten selbst 5-10 Zeilen Code zu schreiben.

### 10. plugin-dev ⭐
**Plugin-Entwicklungs-Toolkit**

| Komponente | Beschreibung |
|------------|--------------|
| Command | `/plugin-dev:create-plugin` – 8-Phasen geführter Plugin-Erstellungsprozess |
| Agents | `agent-creator`, `plugin-validator`, `skill-reviewer` |
| Skills | Hook-Entwicklung, MCP-Integration, Plugin-Struktur, Settings, Commands, Agents, Skill-Entwicklung |

### 11. pr-review-toolkit
**Umfassendes PR-Review-System**

```bash
/pr-review-toolkit:review-pr [aspects]
```

Verfügbare Aspekte: `comments`, `tests`, `errors`, `types`, `code`, `simplify`, `all`

| Agent | Fokus |
|-------|-------|
| `comment-analyzer` | Kommentar-Qualität |
| `pr-test-analyzer` | Test-Abdeckung |
| `silent-failure-hunter` | Stille Fehler |
| `type-design-analyzer` | Type-System Design |
| `code-reviewer` | Code-Qualität |
| `code-simplifier` | Vereinfachungen |

### 12. ralph-wiggum
**Selbstreferentielle Iterationsschleifen**

| Command | Funktion |
|---------|----------|
| `/ralph-loop` | Startet autonome Iteration |
| `/cancel-ralph` | Stoppt Iteration |

Claude arbeitet wiederholt am gleichen Task bis zur Fertigstellung.

### 13. security-guidance
**Sicherheits-Reminder Hook**

Überwacht 9 Sicherheitsmuster bei Datei-Bearbeitungen:
- Command Injection
- XSS Vulnerabilities
- eval() Nutzung
- Gefährliches HTML
- Pickle Deserialization
- os.system Aufrufe
- Und mehr...

---

## Plugin-Installation

### Methode 1: Via Marketplace

```bash
# In Claude Code
/plugin install marketplace-name/plugin-name
```

### Methode 2: Lokale Entwicklung

```bash
# Plugin-Verzeichnis laden
claude --plugin-dir ./my-plugin
```

### Methode 3: Projekt-Konfiguration

In `.claude/settings.json`:

```json
{
  "plugins": [
    {
      "name": "my-plugin",
      "source": "./plugins/my-plugin"
    }
  ]
}
```

---

## Eigene Plugins erstellen

### Schritt 1: Plugin-Struktur erstellen

```bash
mkdir -p my-plugin/.claude-plugin
mkdir -p my-plugin/commands
mkdir -p my-plugin/agents
```

### Schritt 2: Manifest erstellen

```json
// my-plugin/.claude-plugin/plugin.json
{
  "name": "my-plugin",
  "description": "Mein erstes Claude Code Plugin",
  "version": "1.0.0"
}
```

### Schritt 3: Command hinzufügen

```markdown
<!-- my-plugin/commands/hello.md -->
---
description: Begrüßt den Benutzer freundlich
---

# Hello Command

Begrüße den Benutzer mit "$ARGUMENTS" warmherzig und frage, wie du helfen kannst.
```

### Schritt 4: Testen

```bash
claude --plugin-dir ./my-plugin
# Dann in Claude Code:
/my-plugin:hello Max
```

### Schritt 5: Agent hinzufügen

```yaml
# my-plugin/agents/reviewer.md
---
name: code-reviewer
description: Führt Code-Reviews durch. Proaktiv nach Code-Änderungen verwenden.
tools: Read, Grep, Glob
model: sonnet
---

Du bist ein erfahrener Code-Reviewer. Prüfe:
1. Code-Qualität und Lesbarkeit
2. Sicherheitslücken
3. Performance-Probleme
4. Test-Abdeckung
```

### Schritt 6: Hooks hinzufügen

```json
// my-plugin/hooks/hooks.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint:fix $FILE"
          }
        ]
      }
    ]
  }
}
```

---

## Best Practices

### 1. Naming Conventions

```
plugin-name/           # kebab-case für Plugin-Namen
├── commands/
│   └── my-command.md  # kebab-case für Command-Namen
├── agents/
│   └── my-agent.md    # kebab-case für Agent-Namen
└── skills/
    └── my-skill/      # kebab-case für Skill-Ordner
        └── SKILL.md   # UPPERCASE für SKILL.md
```

### 2. Fokussierte Komponenten

Jede Komponente sollte **eine Aufgabe** gut erledigen:

```yaml
# ❌ Schlecht: Ein Agent für alles
---
name: super-agent
description: Does everything
---

# ✅ Gut: Spezialisierte Agents
---
name: security-reviewer
description: Reviews code for security vulnerabilities only
tools: Read, Grep
---
```

### 3. Klare Beschreibungen

Beschreibungen helfen Claude zu entscheiden, wann ein Agent/Skill verwendet werden soll:

```yaml
# ❌ Vage
description: Helps with code

# ✅ Spezifisch
description: Reviews TypeScript code for type safety issues. Use proactively when editing .ts or .tsx files.
```

### 4. Tool-Einschränkung

Gib Agents nur die Tools, die sie brauchen:

```yaml
# Security-Reviewer braucht nur Lese-Zugriff
tools: Read, Grep, Glob

# Build-Agent braucht auch Bash
tools: Read, Write, Bash
```

---

## Zusammenfassung: Wann was verwenden?

| Anwendungsfall | Empfehlung |
|----------------|------------|
| Persönliche Workflow-Anpassung | Skills in `.claude/skills/` |
| Team-weite Standards | Plugin via Marketplace |
| Externe API-Integration | MCP Server |
| Spezialisierte Task-Delegation | Custom Agents |
| Projekt-Kontext für Claude | CLAUDE.md |
| KI-spezifische Regeln | AGENTS.md |
| Event-basierte Automatisierung | Hooks |
| Code-Intelligenz für neue Sprachen | LSP via Plugin |

---

## Fazit

Das Claude Code Erweiterungssystem bietet maximale Flexibilität:

- **Plugins** für komplette, verteilbare Pakete
- **Skills** für kontextuelle Fähigkeiten
- **MCP Server** für externe Tool-Integration
- **Agents** für spezialisierte Task-Delegation
- **CLAUDE.md** für Projekt-Kontext

Mit den 12 offiziellen Plugins als Inspiration und diesem Guide als Referenz kannst du Claude Code perfekt an deine Entwicklungs-Workflows anpassen.

**Nächste Schritte:**
1. Installiere ein offizielles Plugin wie `code-review` oder `feature-dev`
2. Erstelle dein erstes eigenes Plugin mit einem einfachen Command
3. Experimentiere mit Agents und Skills
4. Teile deine Plugins über Team-Marketplaces

---

## Häufige Fragen (FAQ)

### Was ist der Unterschied zwischen einem Plugin und einem MCP Server?

Plugins sind Claude Code-spezifische Erweiterungspakete, die Commands, Agents, Skills und Hooks bündeln. MCP Server hingegen sind protokollbasierte Tool-Server, die von jedem MCP-kompatiblen Client verwendet werden können. Plugins können MCP Server konfigurieren, aber MCP Server sind unabhängig von Plugins nutzbar.

### Kann ich bestehende `.claude/` Konfigurationen in Plugins umwandeln?

Ja! Du kannst deine bestehenden Commands aus `.claude/commands/`, Agents aus `.claude/agents/` und Skills aus `.claude/skills/` direkt in ein Plugin-Verzeichnis kopieren. Füge nur ein `.claude-plugin/plugin.json` Manifest hinzu und deine Konfiguration wird zum teilbaren Plugin.

### Wann sollte ich einen Custom Agent statt eines Skills verwenden?

Verwende **Agents** wenn du: eigenen Kontext-Window brauchst, Tool-Zugriff einschränken willst, ein anderes Modell (z.B. Haiku für schnelle Suchen) nutzen willst, oder komplexe Multi-Step-Tasks delegieren möchtest. Verwende **Skills** für einfachere Fähigkeits-Erweiterungen, die im Haupt-Kontext laufen sollen.

### Wie kann ich Plugins mit meinem Team teilen?

Es gibt mehrere Optionen: 1) Erstelle einen Team-Marketplace (Git-Repository mit Plugin-Index), 2) Teile das Plugin-Verzeichnis über euer Monorepo, 3) Veröffentliche auf einem öffentlichen Marketplace. Für Team-Nutzung empfiehlt sich ein privater Git-basierter Marketplace.

### Welche Hooks sind am nützlichsten für Entwickler-Workflows?

Die beliebtesten Hooks sind: `PostToolUse` für automatisches Linting nach Datei-Änderungen, `PreToolUse` für Sicherheits-Checks vor gefährlichen Operationen, und `SessionStart` für Kontext-Injektion. Der `security-guidance` Plugin demonstriert effektive PreToolUse-Hooks für Security-Monitoring.

## Related

- [KI-Agent-Entwicklung](https://www.contextstudios.ai/de/ki-agent-entwicklung.md)
- [KI-Entwicklung](https://www.contextstudios.ai/de/ki-entwicklung.md)
- [KI-API-Entwicklung](https://www.contextstudios.ai/de/ki-api-entwicklung.md)
- [KI-Automatisierung](https://www.contextstudios.ai/de/ai-automatisierung.md)