Agentic Coding
6 Minuten

Claude Code erweitern: MCP, Skills und Plugins einfach erklärt

Dieser Text wurde mit Hilfe von KI erstellt.

Claude Code kann deutlich mehr als nur Code schreiben. Du kannst den Coding Agent mit eigenen Tools, Wissen und Arbeitsabläufen erweitern.

Dafür gibt es vor allem drei wichtige Möglichkeiten: MCP, Skills und Plugins.

Das klingt zunächst technisch. Die Grundidee ist aber einfach.

I. MCP: Claude bekommt Zugriff auf andere Systeme

MCP steht für Model Context Protocol. Es verbindet Claude Code mit anderen Programmen und Diensten.

Zum Beispiel mit:

  • GitHub

  • Jira

  • Datenbanken

  • APIs

  • Slack

  • Notion

  • eigenen Anwendungen

Stell dir Claude Code als Entwickler vor, der an deinem Schreibtisch sitzt. Ohne MCP kann er vor allem mit deinem Code arbeiten. Mit MCP bekommt er zusätzliche Werkzeuge.

Ein MCP-Server kann Claude zum Beispiel ermöglichen:

„Lies das Jira-Ticket und prüfe, welche Anforderungen darin stehen.“

Oder:

„Erstelle nach dem erfolgreichen Test einen Pull Request auf GitHub.“

MCP erweitert also vor allem die Fähigkeiten von Claude Code.

A. Einen MCP-Server hinzufügen

Claude Code bietet dafür die claude mcp add-Befehle.

Zum Beispiel:

claude mcp add github -- npx -y @modelcontextprotocol/server-github

Damit wird ein MCP-Server namens github hinzugefügt.

Anschließend kannst du dir die konfigurierten MCP-Server anzeigen lassen:

claude mcp list

Du kannst einen Server auch wieder entfernen:

claude mcp remove github

B. Ein MCP-Server für eine eigene API

MCP ist nicht nur für fertige Integrationen gedacht. Du kannst auch eigene MCP-Server entwickeln.

Eine vereinfachte Struktur könnte so aussehen:

my-mcp-server/
├── package.json
└── src/
    └── index.ts

Der Server könnte beispielsweise ein Tool get_customer bereitstellen:

server.tool(
  "get_customer",
  "Liefert Kundendaten",
  {
    customerId: z.string()
  },
  async ({ customerId }) => {
    const customer = await getCustomer(customerId);

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(customer)
        }
      ]
    };
  }
);

Claude kann dieses Tool anschließend verwenden.

Das ist interessant, wenn du interne Systeme oder eigene APIs in deinen Coding Agent integrieren möchtest.

II. Skills: Claude lernt, wie etwas gemacht wird

Skills funktionieren anders als MCP.

Ein Skill ist im Grunde kein eigenes Programm und keine spezielle Erweiterung. Es handelt sich zunächst einfach um Dateien in einer bestimmten Ordnerstruktur. Claude Code erkennt diese Dateien anhand ihrer Position und ihres Aufbaus als Skill.

Ein einfacher Skill kann zum Beispiel so aussehen:

.claude/
└── skills/
    └── code-review/
        └── SKILL.md

Die wichtigste Datei ist SKILL.md. Sie enthält die Anweisungen, die Claude bei dieser Aufgabe beachten soll.

Zum Beispiel:

---
name: code-review
description: Führt einen strukturierten Code Review durch
---

# Code Review

Prüfe den Code in dieser Reihenfolge:

1. Architektur
2. Sicherheit
3. Performance
4. Fehlerbehandlung
5. Tests
6. Lesbarkeit

Bewerte jedes Problem nach:

- kritisch
- wichtig
- optional

Zeige anschließend konkrete Verbesserungsvorschläge.

Das Prinzip ist damit sehr einfach:

Ordnerstruktur + SKILL.md + Anweisungen = Skill

Du musst also keine eigene Software programmieren, um einen Skill zu erstellen. Du legst im Projekt lediglich einen passenden Ordner an und beschreibst darin, wie Claude eine bestimmte Aufgabe erledigen soll.

A. Warum das praktisch ist

Dadurch lassen sich Skills sehr einfach selbst erstellen und versionieren.

Du kannst sie beispielsweise direkt in Git einchecken:

.claude/
└── skills/
    ├── code-review/
    │   └── SKILL.md
    ├── testing/
    │   └── SKILL.md
    └── documentation/
        └── SKILL.md

Damit liegen die Anweisungen für dein Team direkt im Repository.

Ein neuer Entwickler, der das Repository klont, erhält damit automatisch auch die definierten Skills.

Skills sind deshalb besonders interessant für Coding-Standards, Best Practices und wiederkehrende Arbeitsabläufe.

Zum Beispiel:

  • „Wie führen wir Code Reviews durch?“

  • „Wie schreiben wir Tests?“

  • „Wie strukturieren wir React-Komponenten?“

  • „Wie erstellen wir API-Dokumentation?“

  • „Welche Regeln gelten für unsere Datenbankmigrationen?“

Der große Unterschied zu MCP bleibt:

MCP erweitert, was Claude tun kann.

Skills beschreiben, wie Claude etwas tun soll.

Und weil Skills im Kern nur strukturierte Dateien mit Anweisungen sind, kannst du sie relativ einfach selbst erstellen, anpassen und gemeinsam mit deinem Code verwalten.

B. Skills und Kontext

Der große Vorteil von Skills im Hinblick auf den Kontext ist: Sie müssen nicht alle Anweisungen dauerhaft in den Kontext von Claude laden.

1. Skills können bei Bedarf geladen werden

Claude Code kann anhand der Beschreibung eines Skills erkennen, wann er relevant ist. Der eigentliche Inhalt des Skills muss dann nicht von Anfang an vollständig im Kontext stehen.

Beispiel:

.claude/

└── skills/

├── code-review/

│ └── SKILL.md

├── testing/

│ └── SKILL.md

└── database-migration/

└── SKILL.md

Du hast vielleicht 20 Skills im Projekt. Claude muss deshalb nicht automatisch die kompletten 20 Anleitungen in jedem Gespräch mitschleppen.

Das spart Context Window.

2. Skills können große Anleitungen auslagern

Ein Skill kann außerdem auf weitere Dateien verweisen:

.claude/

└── skills/

└── frontend/

├── SKILL.md

├── coding-standards.md

├── accessibility.md

└── examples.md

In SKILL.md steht dann beispielsweise:

Für detaillierte Accessibility-Regeln:

Lies accessibility.md.

Für unsere Coding Standards:

Lies coding-standards.md.

Damit kannst du umfangreiches Wissen außerhalb des normalen Gesprächskontexts organisieren und bei Bedarf nachladen.

3. Skills reduzieren unnötigen Kontext

Das ist besonders bei großen Projekten interessant.

Ohne Skills könnte man versucht sein, eine riesige CLAUDE.md zu schreiben:

CLAUDE.md

├── Coding Standards

├── Testing

├── React

├── Accessibility

├── API

├── Datenbank

├── Deployment

├── Security

└── ...

Diese Informationen sind dann schnell sehr umfangreich.

Mit Skills kannst du sie aufteilen:

CLAUDE.md

│

└── grundlegende Projektregeln

Skills

├── Testing

├── React

├── Security

├── API

└── Deployment

Claude bekommt dadurch gezielter die Informationen, die für die aktuelle Aufgabe relevant sind.

4. Wichtig: Skills sind kein „unbegrenzter Speicher“

Man sollte allerdings nicht sagen:

„Skills lösen das Context-Window-Problem.“

Das wäre zu stark formuliert.

Wenn Claude einen Skill tatsächlich verwendet und dessen Inhalte lädt, verbrauchen diese Inhalte natürlich weiterhin Kontext.

Der Vorteil liegt vielmehr in der selektiven Aktivierung und Organisation:

Nicht alles muss immer im Kontext sein. Nur das, was für die aktuelle Aufgabe relevant ist.

Das macht Skills gerade bei großen Projekten interessant.

Kurz gesagt

CLAUDE.md: Grundregeln, die Claude grundsätzlich kennen sollte.

Skills: Spezifisches Wissen und Arbeitsanweisungen, die bei bestimmten Aufgaben relevant sind.

MCP: Externe Tools und Datenquellen.

Die Kombination ermöglicht damit eine Art Just-in-Time Context: Claude bekommt nicht möglichst viel Kontext, sondern möglichst passenden Kontext zum richtigen Zeitpunkt.

III. Plugins: Mehrere Erweiterungen als Paket

Plugins gehen noch einen Schritt weiter.

Ein Plugin kann mehrere Erweiterungen zusammenfassen. Dazu können beispielsweise Skills, Commands, Agents, Hooks und MCP-Konfigurationen gehören.

Eine mögliche Plugin-Struktur:

my-plugin/
├── .claude-plugin/
│   └── plugin.json
├── skills/
│   └── code-review/
│       └── SKILL.md
├── commands/
│   └── review.md
├── agents/
│   └── security-reviewer.md
└── .mcp.json

Die plugin.json könnte beispielsweise Metadaten für das Plugin enthalten:

{
  "name": "my-development-tools",
  "description": "Interne Entwicklungswerkzeuge",
  "version": "1.0.0"
}

Das Plugin kann anschließend verschiedene Erweiterungen gemeinsam bereitstellen.

A. Beispiel: Ein Jira-Plugin

Stell dir ein Plugin für dein Entwicklungsteam vor.

Es könnte folgende Bestandteile enthalten:

jira-plugin/
│
├── Skills
│   ├── analyze-ticket
│   └── sprint-report
│
├── Commands
│   └── jira
│
├── Agents
│   └── jira-agent
│
└── MCP
    └── Jira API

Damit erhält Claude Code eine komplette Jira-Integration.

Du könntest beispielsweise einen Workflow aufbauen, bei dem Claude:

Jira-Ticket lesen
       ↓
Anforderungen analysieren
       ↓
Code ändern
       ↓
Tests ausführen
       ↓
Code Review
       ↓
Pull Request erstellen

MCP stellt dabei den Zugriff auf Jira und GitHub bereit.

Skills beschreiben, wie Claude die einzelnen Aufgaben erledigen soll.

Ein Plugin kann diese Bestandteile zusammenfassen.

IV. Ein praktisches Beispiel: Code Review automatisieren

Nehmen wir an, du möchtest mit Claude Code regelmäßig Code Reviews durchführen.

Dafür kannst du einen Skill erstellen.

A. Verzeichnis anlegen

mkdir -p .claude/skills/code-review

Danach legst du SKILL.md an:

touch .claude/skills/code-review/SKILL.md

B. Skill definieren

---
name: code-review
description: Prüft Änderungen auf Qualität, Sicherheit und Performance
---

# Code Review

Analysiere zuerst die Änderungen im Git-Diff.

Prüfe anschließend:

1. Funktionalität
2. Fehlerbehandlung
3. Sicherheit
4. Performance
5. Tests
6. Wartbarkeit

Melde nur konkrete Probleme.

Für jedes Problem verwende dieses Format:

## Problem

Beschreibung des Problems.

## Warum?

Warum ist das Problem relevant?

## Lösung

Konkreter Verbesserungsvorschlag.

Bewerte die Priorität als:

- Critical
- High
- Medium
- Low

Jetzt besitzt dein Projekt eine eigene Anleitung für Code Reviews.

Du kannst Claude beispielsweise auffordern:

Führe einen Code Review der aktuellen Änderungen durch.

Claude kann dafür den passenden Skill verwenden.

V. MCP und Skills gemeinsam verwenden

Besonders interessant wird es, wenn du beide Technologien kombinierst.

Angenommen, dein Team verwendet Jira und GitHub.

MCP stellt die Verbindung bereit:

Claude Code
    │
    ├── MCP → Jira
    │
    └── MCP → GitHub

Ein Skill beschreibt dagegen den Ablauf:

1. Jira-Ticket lesen
2. Anforderungen analysieren
3. Code ändern
4. Tests ausführen
5. Code Review durchführen
6. Pull Request erstellen

Claude kann damit nicht nur auf die Systeme zugreifen. Er bekommt gleichzeitig einen definierten Arbeitsablauf.

Das ist ein wichtiger Schritt in Richtung Agentic Coding.

VI. Ein eigenes MCP-Tool programmieren

Noch interessanter wird es, wenn du eigene Tools bereitstellst.

Angenommen, dein Unternehmen besitzt eine interne API:

https://api.example.com/customers

Du könntest einen MCP-Server bauen, der daraus ein Claude-Tool macht.

Vereinfacht könnte das Tool so aussehen:

server.tool(
  "search_customers",
  "Sucht Kunden im internen System",
  {
    query: z.string()
  },
  async ({ query }) => {
    const response = await fetch(
      `https://api.example.com/customers?q=${query}`
    );

    const customers = await response.json();

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(customers)
        }
      ]
    };
  }
);

Claude kann anschließend beispielsweise gefragt werden:

Suche den Kunden "Müller" in unserem Kundensystem.

Claude entscheidet, dass dafür das MCP-Tool search_customers verwendet werden kann.

Das ist der große Vorteil von MCP: Du kannst Claude mit deinen eigenen Systemen verbinden.

VII. MCP, Skills und Plugins im Vergleich

Erweiterung

Einfach erklärt

Beispiel

MCP

Gibt Claude Werkzeuge

GitHub, Jira, Datenbank

Skill

Zeigt Claude, wie eine Aufgabe erledigt wird

Code Review

Plugin

Bündelt mehrere Erweiterungen

Entwickler-Toolkit

Command

Startet einen definierten Befehl

/review

Agent

Übernimmt eine spezialisierte Aufgabe

Security-Analyse

Hook

Reagiert automatisch auf Ereignisse

Tests nach Änderungen

Eine einfache Eselsbrücke hilft:

MCP gibt Claude Werkzeuge.

Skills geben Claude Anleitungen.

Plugins bündeln Erweiterungen.

Agents übernehmen spezialisierte Aufgaben.

Hooks automatisieren Abläufe.

VIII. Warum diese Erweiterbarkeit wichtig ist

Die Stärke von Claude Code liegt deshalb nicht nur im verwendeten KI-Modell.

Entscheidend ist auch, was der Agent tun kann.

Ein einfacher KI-Assistent erzeugt Code.

Ein Coding Agent kann dagegen:

Aufgabe verstehen
      ↓
Repository analysieren
      ↓
Dateien ändern
      ↓
Tests ausführen
      ↓
Externe Systeme verwenden
      ↓
Ergebnis überprüfen
      ↓
Pull Request vorbereiten

MCP, Skills und Plugins machen solche Abläufe möglich.

Für die Auswahl eines Coding Agents sollte deshalb nicht nur die Frage zählen:

„Welches KI-Modell ist am besten?“

Ebenso wichtig ist:

„Wie gut kann ich den Agenten an meine Entwicklungsumgebung und meine Arbeitsweise anpassen?“

Genau hier unterscheiden sich Claude Code, Cursor, Codex, GitHub Copilot, Windsurf und andere Coding Agents deutlich.