Plugins System

Was sind Claude Code Plugins?

Plugins sind benutzerdefinierte Sammlungen von Entwicklungstools, die die Funktionen von Claude Code erweitern. Stellen Sie sie sich als Power-Ups für Ihren Entwicklungs-Workflow vor - Sie können alles, was Sie benötigen, mit einem einzigen Befehl installieren.

Ein Plugin kann vier Kernkomponenten enthalten:

Slash Commands: Schnelle Shortcuts für häufige Operationen
Subagents: Spezialisierte KI-Agenten für bestimmte Aufgaben
MCP Servers: Verbindungen zu externen Tools und Datenquellen
Hooks: Benutzerdefinierte Verhaltensweisen zu bestimmten Workflow-Zeitpunkten

Die Schlüsselinnovation: Alle diese Komponenten sind gebündelt, sodass die Einrichtung komplexer Entwicklungsumgebungen einfach und schnell wird.

Warum Plugins verwenden?

Traditionelle Probleme bei der Tool-Verwaltung

Ohne Plugins stehen Entwicklungsteams vor folgenden Herausforderungen:

🔄 Verstreute Tools: Jedes Teammitglied konfiguriert seine Tools unterschiedlich
📚 Steile Lernkurve: Neue Mitglieder verbringen Tage mit der Einrichtung ihrer Umgebung
🔧 Konfigurationshölle: Jeder pflegt seine eigenen Skripte und Konfigurationen
🐛 Inkonsistente Standards: Keine einheitliche Methode zur Durchsetzung von Best Practices

Plugins-Lösung

Plugins lösen diese Probleme durch:

✅ Ein-Befehl-Installation: Die gesamte Toolchain wird sofort installiert
🎯 Standardisierung: Alle verwenden die gleichen Tools und Workflows
🚀 Schnelles Onboarding: Neue Mitglieder sind ab dem ersten Tag produktiv
🔄 Einfache Verwaltung: Plugins nach Bedarf aktivieren/deaktivieren

Die vier Komponenten verstehen

1. Slash Commands

Slash Commands sind Einstiegspunkte für schnelle Operationen. Sie kapseln komplexe Aufgaben in einfache Befehle.

Häufige Muster:

/test          # Testsuite ausführen
/deploy        # In Produktion deployen
/review        # Code-Review-Prozess starten
/docs          # Dokumentation generieren
/build         # Optimierten Build ausführen

Wie sie funktionieren:

Wenn Sie /test eingeben, macht Claude Code Folgendes:

Liest die Befehlsdefinition aus .claude/commands/test.md
Führt den definierten Workflow aus
Gibt Ihnen die Ergebnisse zurück

Ihren ersten Slash Command erstellen:

<!-- .claude/commands/hello.md -->
Say hello to the user and show the current project structure.

Wenn Sie jetzt /hello eingeben, wird dieser Befehl ausgeführt.

2. Subagents

Subagents sind spezialisierte KI-Agenten mit tiefgreifender Domänenexpertise. Sie sind wie Fachberater in Ihrem Team.

Praxisbeispiele:

DevOps Agent:

Automatisiert Deployment-Prozesse
Überwacht die Systemgesundheit
Verwaltet Infrastruktur-Aufgaben

> Use DevOps agent to set up CI/CD pipeline for this project

Testing Agent:

Generiert intelligente Testfälle
Identifiziert Randfälle
Optimiert Testabdeckung

> Use Testing agent to create comprehensive tests for the authentication module

Security Agent:

Scannt Code auf Schwachstellen
Schlägt Sicherheitsverbesserungen vor
Validiert Sicherheitsmuster

> Use Security agent to audit this API endpoint

3. MCP Servers

MCP (Model Context Protocol) Servers bieten Konnektivität zu externen Tools und Datenquellen.

Verbindungsmöglichkeiten:

Entwicklungstools:

- Git: Versionskontroll-Operationen
- Docker: Container-Management
- Kubernetes: Orchestrierung und Deployment

Datenbanken:

- PostgreSQL: Relationale Daten
- MongoDB: Dokumentenspeicherung
- Redis: Caching und Sessions

Cloud-Dienste:

- AWS: Cloud-Infrastruktur
- Azure: Microsoft-Cloud
- GCP: Google Cloud Platform

API-Dienste:

- Interne Microservices
- Drittanbieter-APIs
- Webhook-Integrationen

Beispiel für eine MCP Server-Konfiguration:

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION": "postgresql://localhost/mydb"
      }
    }
  }
}

4. Hooks

Hooks passen das Verhalten von Claude Code zu bestimmten Workflow-Zeitpunkten an.

Verfügbare Hook-Typen:

Pre-commit Hook:

// .claude/hooks/pre-commit.js
// Wird vor Code-Commits ausgeführt
module.exports = async (context) => {
  // Linters ausführen
  // Formatierung prüfen
  // Tests validieren
  return { allow: true };
};

Post-analysis Hook:

// .claude/hooks/post-analysis.js
// Wird nach der Code-Analyse ausgeführt
module.exports = async (context) => {
  // Berichte generieren
  // Dokumentation aktualisieren
  // Team benachrichtigen
};

Error Hook:

// .claude/hooks/error.js
// Wird bei Fehlern ausgeführt
module.exports = async (error, context) => {
  // Fehlerdetails protokollieren
  // Wiederherstellung versuchen
  // Überwachungssysteme benachrichtigen
};

Plugins installieren und verwenden

Grundlegende Installation

Der einfachste Weg, ein Plugin zu installieren:

/plugin install organization/plugin-name

Beispiel:

/plugin install danavila/devops-toolkit

Claude wird:

Das Plugin aus dem Repository herunterladen
Alle Abhängigkeiten installieren
Alle Komponenten konfigurieren
Es sofort verfügbar machen

Plugins verwalten

Plugins sind so konzipiert, dass sie leichtgewichtig und umschaltbar sind:

# Plugin aktivieren
/plugin enable plugin-name

# Plugin deaktivieren
/plugin disable plugin-name

# Alle installierten Plugins auflisten
/plugin list

# Plugin-Details anzeigen
/plugin info plugin-name

# Plugin deinstallieren
/plugin uninstall plugin-name

Plugin-Lebenszyklus

Install → Configure → Enable → Use → Disable/Uninstall

Installation: Lädt das Plugin herunter und richtet es ein Configuration: Plugin-Einstellungen für Ihr Projekt anpassen Enable: Plugin-Funktionen aktivieren Use: Auf Slash Commands, Subagents und Hooks zugreifen Disable: Temporär ausschalten ohne zu deinstallieren Uninstall: Plugin vollständig entfernen

Plugin-Marketplaces

Was sind Marketplaces?

Marketplaces sind Repositories, in denen Entwickler Plugins teilen. Jeder kann seinen eigenen Marketplace erstellen und hosten.

Einen Marketplace erstellen

Schritt 1: Konfigurationsdatei erstellen

// .claude-plugin/marketplace.json
{
  "name": "My Marketplace",
  "description": "Custom plugins for our team",
  "plugins": [
    {
      "name": "team-standards",
      "description": "Enforce team coding standards",
      "version": "1.0.0",
      "repository": "github.com/myteam/team-standards"
    }
  ]
}

Schritt 2: Auf GitHub hosten

git init
git add .claude-plugin/
git commit -m "Initialize plugin marketplace"
git push origin main

Schritt 3: Mit dem Team teilen

/plugin marketplace add myteam/plugin-marketplace

Community-Marketplaces

Dan Ávilas Marketplace:

/plugin marketplace add danavila/plugins

Enthält:

DevOps-Automatisierungstools
Dokumentationsgeneratoren
Projektmanagement-Integrationen

Seth Hobsons Repository:

/plugin marketplace add sethhobson/agents

Bietet über 80 spezialisierte Subagents:

Frontend-Entwicklung (React, Vue, Angular)
Backend-Entwicklung (Node.js, Python, Java)
Data Science und Machine Learning
Mobile-Entwicklung (iOS, Android)

Praxisnahe Plugin-Workflows

Szenario 1: Frontend-Team-Standardisierung

Problem: Teammitglieder verwenden unterschiedliche Linting-Regeln und Formatierungsstandards

Lösung: Team Standards Plugin erstellen

# Team-Standards-Plugin installieren
/plugin install company/frontend-standards

Plugin beinhaltet:

/lint - Führt ESLint mit Team-Konfiguration aus
/format - Wendet Team-Prettier-Regeln an
/test - Führt Jest mit Coverage-Anforderungen aus
React Agent - Erzwingt Komponenten-Muster
Accessibility Agent - Stellt WCAG-Konformität sicher

Ergebnis:

Konsistenter Code-Stil im gesamten Team
Automatisierte Qualitätsprüfungen
Reduzierte Code-Review-Zeit

Szenario 2: Full-Stack-Produktivitäts-Boost

Problem: Sich wiederholender Boilerplate-Code verlangsamt die Entwicklung

Lösung: Produktivitäts-Plugin installieren

/plugin install awesome-dev/fullstack-boost

Plugin bietet:

/api - Generiert REST API mit Best Practices
/component - Erstellt UI-Komponenten mit Tests
/db-migrate - Datenbank-Migrations-Helfer
Backend Agent - API-Optimierungsvorschläge
Database Agent - Query-Performance-Tipps

Ergebnis:

3x schnellere Feature-Entwicklung
Konsistente Architekturmuster
Integrierte Optimierungsanleitung

Szenario 3: Enterprise-Sicherheits-Compliance

Problem: Muss Sicherheitsstandards vor dem Deployment erfüllen

Lösung: Security Compliance Plugin

/plugin install enterprise/security-compliance

Plugin erzwingt:

/security-scan - Automatisierte Sicherheitsprüfungen
/compliance-check - Validierung der regulatorischen Compliance
/audit-log - Audit-Trail generieren
Security Agent - Schwachstellenerkennung und Fixes
Compliance Hook - Pre-Commit-Sicherheitsvalidierung

Ergebnis:

Automatisierte Sicherheitsdurchsetzung
Compliance-Dokumentation wird automatisch generiert
Reduzierte Sicherheitsvorfälle

Ihr erstes Plugin erstellen

Plugin-Struktur

my-plugin/
├── .claude-plugin/
│   ├── manifest.json          # Plugin-Metadaten
│   ├── commands/               # Slash commands
│   │   ├── test.md
│   │   └── deploy.md
│   ├── agents/                 # Subagents
│   │   ├── testing-agent.md
│   │   └── deploy-agent.md
│   ├── mcp-servers/            # MCP Server-Konfigurationen
│   │   └── custom-tools.json
│   └── hooks/                  # Hooks-Konfiguration
│       ├── pre-commit.js
│       └── post-analysis.js
└── README.md

Schritt 1: Manifest erstellen

{
  "name": "my-first-plugin",
  "version": "1.0.0",
  "description": "My custom development tools",
  "author": "Your Name",
  "components": {
    "commands": ["test", "deploy"],
    "agents": ["testing-agent"],
    "hooks": ["pre-commit"]
  }
}

Schritt 2: Slash Command hinzufügen

<!-- .claude-plugin/commands/test.md -->
# Test Command

Run the project test suite with coverage reporting.

## Steps:
1. Check for test files
2. Run Jest with coverage
3. Generate HTML report
4. Open report in browser

Schritt 3: Subagent erstellen

<!-- .claude-plugin/agents/testing-agent.md -->
# Testing Agent

You are a testing expert specializing in comprehensive test coverage.

## Capabilities:
- Generate unit tests for functions and classes
- Create integration tests for APIs
- Design end-to-end test scenarios
- Identify edge cases and test coverage gaps
- Suggest test data and mocking strategies

## Guidelines:
- Follow AAA pattern (Arrange, Act, Assert)
- Aim for 80%+ code coverage
- Include positive and negative test cases
- Mock external dependencies appropriately

Schritt 4: Hook hinzufügen

// .claude-plugin/hooks/pre-commit.js
module.exports = async (context) => {
  console.log('Running pre-commit checks...');

  // Run linter
  const lintResult = await context.exec('npm run lint');
  if (lintResult.exitCode !== 0) {
    return {
      allow: false,
      message: 'Linting failed. Please fix errors before committing.'
    };
  }

  // Run tests
  const testResult = await context.exec('npm test');
  if (testResult.exitCode !== 0) {
    return {
      allow: false,
      message: 'Tests failed. Please fix failing tests before committing.'
    };
  }

  return { allow: true };
};

Schritt 5: Plugin testen

# Plugin lokal laden
/plugin install ./my-plugin

# Slash Command testen
/test

# Subagent verwenden
> Use Testing agent to create tests for UserService

# Hook verifizieren (versuchen zu committen)
git add .
git commit -m "test commit"

Best Practices

1. Single Responsibility

Jedes Plugin sollte sich auf eine Domäne konzentrieren:

✅ Gut:

- authentication-plugin (behandelt nur Auth)
- testing-plugin (behandelt nur Testing)
- deployment-plugin (behandelt nur Deployment)

❌ Schlecht:

- everything-plugin (versucht alles zu machen)

2. Kompositionsfähigkeit

Entwerfen Sie Plugins so, dass sie gut zusammenarbeiten:

# Plugins sollten sich ergänzen
/plugin enable testing-plugin
/plugin enable quality-plugin
/plugin enable deployment-plugin

# Sie sollten nicht in Konflikt geraten

3. Klare Dokumentation

Jedes Plugin benötigt:

# Plugin Name

## Description
Klare Erklärung, was es tut

## Installation
Schritt-für-Schritt-Installationsanleitung

## Usage
Beispiele für alle Befehle und Features

## Configuration
Verfügbare Optionen und Einstellungen

## Troubleshooting
Häufige Probleme und Lösungen

4. Versionsverwaltung

Verwenden Sie semantische Versionierung:

{
  "version": "1.2.3"
  // 1 = Major (Breaking Changes)
  // 2 = Minor (neue Features)
  // 3 = Patch (Bugfixes)
}

5. Performance-Optimierung

Lazy Loading:

// Nur laden, wenn benötigt
if (command === '/heavy-operation') {
  const module = await import('./heavy-module');
  module.execute();
}

Caching:

// Teure Operationen cachen
const cache = new Map();
if (cache.has(key)) {
  return cache.get(key);
}
const result = await expensiveOperation();
cache.set(key, result);

Fehlerbehebung

Plugin lässt sich nicht installieren

Problem: Plugin-Installation schlägt fehl

Lösungen:

# Netzwerkverbindung prüfen
ping github.com

# Überprüfen, ob Plugin-Repository existiert
git ls-remote https://github.com/org/plugin-name

# Mit ausführlichem Logging versuchen
/plugin install org/plugin-name --verbose

# Nach Konflikt-Plugins suchen
/plugin list

Slash Command nicht gefunden

Problem: /mycommand sagt "command not found"

Lösungen:

# Überprüfen, ob Plugin aktiviert ist
/plugin list

# Aktivieren, falls deaktiviert
/plugin enable plugin-name

# Plugins neu laden
/plugin reload

# Prüfen, ob Befehlsdefinition existiert
ls .claude-plugin/commands/

Hook wird nicht ausgelöst

Problem: Pre-Commit-Hook wird nicht ausgeführt

Lösungen:

// Prüfen, ob Hook registriert ist
/plugin info plugin-name

// Überprüfen, ob Hook-Datei existiert und den korrekten Namen hat
ls .claude-plugin/hooks/

// Hook-Syntax prüfen
node .claude-plugin/hooks/pre-commit.js

// Hook-Debugging aktivieren
/plugin config plugin-name --debug-hooks

Fortgeschrittene Themen

Bedingtes Laden von Plugins

// Nur in bestimmten Umgebungen laden
if (process.env.NODE_ENV === 'production') {
  await loadPlugin('production-monitoring');
}

Plugin-Abhängigkeiten

{
  "name": "advanced-plugin",
  "dependencies": {
    "base-plugin": "^1.0.0",
    "utils-plugin": "^2.1.0"
  }
}

Benutzerdefinierte Plugin-Konfiguration

{
  "plugins": {
    "my-plugin": {
      "enabled": true,
      "config": {
        "apiKey": "your-key",
        "timeout": 5000,
        "retries": 3
      }
    }
  }
}

Plugin-Sicherheit

Best Practices

1. Code-Review: Überprüfen Sie Plugin-Code immer vor der Installation 2. Vertrauenswürdige Quellen: Installieren Sie nur von verifizierten Marketplaces 3. Berechtigungen: Verstehen Sie, welche Zugriffe Plugins anfordern 4. Regelmäßige Updates: Halten Sie Plugins für Sicherheitspatches aktuell

Warnsignale

⚠️ Warnzeichen:

Fordert übermäßige Berechtigungen an
Enthält verschleierten Code
Kein Quellcode verfügbar
Unbekannter Entwickler
Keine Dokumentation

Nächste Schritte

Nachdem Sie Plugins verstehen, können Sie:

Marketplaces erkunden: Verfügbare Plugins durchsuchen

/plugin marketplace add danavila/plugins
/plugin browse

Nützliche Plugins installieren: Mit Community-Favoriten beginnen
```
/plugin install danavila/devops-toolkit
```
Ihr eigenes Plugin erstellen: Tools für Ihren Workflow bauen
```
mkdir my-plugin
cd my-plugin
# Folgen Sie der obigen Struktur
```
Mit der Community teilen: Ihr Plugin veröffentlichen
```
git push origin main
# Repository-URL teilen
```

Weiterlesen: Dynamic Memory um zu erfahren, wie Claude Code den Kontext über Sessions hinweg beibehält.

Was sind Claude Code Plugins?​

Warum Plugins verwenden?​

Traditionelle Probleme bei der Tool-Verwaltung​

Plugins-Lösung​

Die vier Komponenten verstehen​

1. Slash Commands​

2. Subagents​

3. MCP Servers​

4. Hooks​

Plugins installieren und verwenden​

Grundlegende Installation​

Plugins verwalten​

Plugin-Lebenszyklus​

Plugin-Marketplaces​

Was sind Marketplaces?​

Einen Marketplace erstellen​

Community-Marketplaces​

Praxisnahe Plugin-Workflows​

Szenario 1: Frontend-Team-Standardisierung​

Szenario 2: Full-Stack-Produktivitäts-Boost​

Szenario 3: Enterprise-Sicherheits-Compliance​

Ihr erstes Plugin erstellen​

Plugin-Struktur​

Schritt 1: Manifest erstellen​

Schritt 2: Slash Command hinzufügen​

Schritt 3: Subagent erstellen​

Schritt 4: Hook hinzufügen​

Schritt 5: Plugin testen​

Best Practices​

1. Single Responsibility​

2. Kompositionsfähigkeit​

3. Klare Dokumentation​

4. Versionsverwaltung​

5. Performance-Optimierung​

Fehlerbehebung​

Plugin lässt sich nicht installieren​

Slash Command nicht gefunden​

Hook wird nicht ausgelöst​

Fortgeschrittene Themen​

Bedingtes Laden von Plugins​

Plugin-Abhängigkeiten​

Benutzerdefinierte Plugin-Konfiguration​

Plugin-Sicherheit​

Best Practices​

Warnsignale​

Nächste Schritte​

Was sind Claude Code Plugins?

Warum Plugins verwenden?

Traditionelle Probleme bei der Tool-Verwaltung

Plugins-Lösung

Die vier Komponenten verstehen

1. Slash Commands

2. Subagents

3. MCP Servers

4. Hooks

Plugins installieren und verwenden

Grundlegende Installation

Plugins verwalten

Plugin-Lebenszyklus

Plugin-Marketplaces

Was sind Marketplaces?

Einen Marketplace erstellen

Community-Marketplaces

Praxisnahe Plugin-Workflows

Szenario 1: Frontend-Team-Standardisierung

Szenario 2: Full-Stack-Produktivitäts-Boost

Szenario 3: Enterprise-Sicherheits-Compliance

Ihr erstes Plugin erstellen

Plugin-Struktur

Schritt 1: Manifest erstellen

Schritt 2: Slash Command hinzufügen

Schritt 3: Subagent erstellen

Schritt 4: Hook hinzufügen

Schritt 5: Plugin testen

Best Practices

1. Single Responsibility

2. Kompositionsfähigkeit

3. Klare Dokumentation

4. Versionsverwaltung

5. Performance-Optimierung

Fehlerbehebung

Plugin lässt sich nicht installieren

Slash Command nicht gefunden

Hook wird nicht ausgelöst

Fortgeschrittene Themen

Bedingtes Laden von Plugins

Plugin-Abhängigkeiten

Benutzerdefinierte Plugin-Konfiguration

Plugin-Sicherheit

Best Practices

Warnsignale

Nächste Schritte