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:

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)

{
  "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

Skill-Struktur (SKILL.md)

---
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

---

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

MCP in Plugins einbinden

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

{
  "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

Agent-Definition

---
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:

---

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

# 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:

# 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

---

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

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

Verwendet Confidence-Scoring zur Filterung von False Positives.

4. commit-commands

Git-Workflow-Automatisierung

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

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

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

11. pr-review-toolkit

Umfassendes PR-Review-System

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

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

12. ralph-wiggum

Selbstreferentielle Iterationsschleifen

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

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

Methode 2: Lokale Entwicklung

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

Methode 3: Projekt-Konfiguration

In .claude/settings.json:

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

---

Eigene Plugins erstellen

Schritt 1: Plugin-Struktur erstellen

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

Schritt 2: Manifest erstellen

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

Schritt 3: Command hinzufügen

<!-- 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

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

Schritt 5: Agent hinzufügen

# 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

// 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:

# ❌ 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:

# ❌ 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:

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

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

---

Zusammenfassung: Wann was verwenden?

---

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.