Cursor erweitern: MCP, Skills und Plugins einfach erklärt

Cursor ist längst mehr als ein KI-Editor. Der Coding Agent lässt sich mit MCP, Skills und Plugins an die eigene Entwicklungsumgebung anpassen.

Damit kann Cursor auf externe Systeme zugreifen, bestimmte Arbeitsweisen lernen und komplette Erweiterungen nutzen.

Die Grundidee ist einfach:

MCP gibt Cursor Werkzeuge. Skills geben ihm Anleitungen. Plugins bündeln Erweiterungen.

I. MCP: Cursor bekommt Zugriff auf andere Systeme

MCP steht für Model Context Protocol. Es ermöglicht Cursor, mit externen Systemen zu kommunizieren.

Dazu gehören zum Beispiel:

• GitHub

• Jira

• Slack

• Notion

• Datenbanken

• APIs

• Figma

• Cloud-Dienste

Ein MCP-Server stellt dafür bestimmte Werkzeuge bereit. Cursor kann diese Werkzeuge während einer Agent-Aufgabe verwenden.

Stell dir vor, du bittest Cursor:

„Lies das Jira-Ticket und implementiere die beschriebene Funktion.“

Mit einem passenden MCP-Server kann Cursor das Jira-Ticket selbst abrufen.

Danach kann der Agent den Code ändern und über einen GitHub-MCP-Server beispielsweise einen Pull Request erstellen.

A. MCP in Cursor konfigurieren

Cursor kann MCP-Server über die Einstellungen und die Customize-Oberfläche verwalten. Du kannst aber auch selbst eine MCP-Konfiguration anlegen.

Eine einfache Konfiguration sieht beispielsweise so aus:

{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["-y", "my-mcp-server"],
      "env": {
        "API_KEY": "..."
      }
    }
  }
}

Damit weiß Cursor, welchen MCP-Server es starten soll und welche Umgebungsvariablen dieser benötigt.

Du kannst damit nicht nur fertige MCP-Server verwenden. Du kannst auch eigene MCP-Server entwickeln.

Das ist besonders interessant für Unternehmen mit internen APIs oder eigenen Anwendungen.

II. Skills: Cursor bekommt spezialisiertes Wissen

Skills haben eine andere Aufgabe.

Ein Skill beschreibt, wie Cursor eine bestimmte Aufgabe erledigen soll.

Das können zum Beispiel Regeln für Code Reviews, Tests oder die Entwicklung von React-Komponenten sein.

Ein wichtiger Punkt: Ein Skill ist keine komplizierte Software.

Im Kern besteht er aus Dateien, die einer bestimmten Ordnerstruktur folgen.

Ein einfacher Skill könnte so aussehen:

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

Die Datei SKILL.md enthält die eigentlichen Anweisungen:

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

# Code Review

Prüfe:

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

Melde konkrete Probleme und
schlage jeweils eine Lösung vor.

Das Prinzip ist damit sehr einfach:

Ordnerstruktur + SKILL.md + Anweisungen = Skill

Du musst also keine eigene Anwendung programmieren, um einen Skill zu erstellen.

A. Skills für Entwicklungsstandards

Skills eignen sich besonders für wiederkehrende Aufgaben und Teamstandards.

Zum Beispiel:

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

Damit kannst du festlegen:

• Wie führt das Team Code Reviews durch?

• Wie werden Tests geschrieben?

• Welche Sicherheitsregeln gelten?

• Wie wird Dokumentation erstellt?

• Wie sollen React-Komponenten aufgebaut sein?

Die Skills können außerdem weitere Dateien enthalten. So lässt sich umfangreicheres Wissen auslagern.

III. Skills und Kontext

Skills sind auch im Hinblick auf den Context Window interessant.

Du könntest theoretisch sämtliche Entwicklungsregeln in eine große zentrale Anweisungsdatei schreiben.

Das wird bei größeren Projekten schnell unübersichtlich.

Stattdessen kannst du dein Wissen auf verschiedene Skills verteilen:

Skills
│
├── React
├── Testing
├── Security
├── Database
└── Deployment

Cursor kann passende Skills für eine Aufgabe verwenden. Dadurch muss nicht sämtliches Wissen zu jeder Zeit Teil des relevanten Kontexts sein.

Das Prinzip lautet:

Nicht möglichst viel Kontext laden, sondern möglichst passenden Kontext verwenden.

Natürlich verbrauchen die Inhalte eines Skills weiterhin Kontext, wenn Cursor sie tatsächlich lädt. Skills vergrößern also nicht das Context Window. Sie helfen vielmehr dabei, Wissen gezielt zu organisieren und bei Bedarf zu verwenden.

IV. Plugins: Erweiterungen als Paket

Plugins gehen noch einen Schritt weiter.

Ein Plugin kann verschiedene Bestandteile zusammenfassen:

Plugin
│
├── Skills
├── MCP
├── Rules
├── Agents
├── Commands
└── Hooks

Dadurch entsteht aus mehreren einzelnen Erweiterungen ein fertiges Paket.

Stell dir beispielsweise ein Plugin für Jira vor.

Es könnte enthalten:

• einen MCP-Server für Jira

• einen Skill zum Analysieren von Tickets

• einen Command zum Erstellen von Tickets

• einen spezialisierten Agenten für Sprint-Analysen

Der Entwickler muss diese Bestandteile nicht einzeln zusammensuchen.

Er installiert das Plugin und erhält die komplette Erweiterung.

V. Ein eigenes Plugin

Ein einfaches Plugin könnte beispielsweise so aufgebaut sein:

my-development-tools/
├── plugin.json
├── skills/
│   └── code-review/
│       └── SKILL.md
└── mcp.json

Die Plugin-Beschreibung könnte beispielsweise so aussehen:

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

Das Plugin kann anschließend einen Code-Review-Skill und einen MCP-Server gemeinsam bereitstellen.

Damit lässt sich beispielsweise ein unternehmensinterner Coding-Workflow als Paket verteilen.

VI. Ein praktisches Beispiel

Nehmen wir an, dein Team entwickelt eine React-Anwendung.

Ihr verwendet Jira für Tickets und GitHub für den Code.

Ihr möchtet, dass Cursor möglichst viel vom Entwicklungsprozess übernehmen kann.

Dann könnte die Umgebung so aussehen:

                    Cursor Agent
                         │
          ┌──────────────┼──────────────┐
          │              │              │
         MCP           Skills         Plugin
          │              │              │
     Jira/GitHub    React/TDD       Dev Toolkit

Ein typischer Ablauf könnte so aussehen:

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

Dabei hat jeder Baustein eine klare Aufgabe.

MCP verbindet Cursor mit Jira und GitHub.

Skills beschreiben die Regeln und Arbeitsweisen.

Das Plugin kann diese Bestandteile gemeinsam bereitstellen.

VII. Cursor Marketplace

Du musst solche Erweiterungen nicht immer selbst erstellen.

Cursor bietet einen Marketplace, über den sich fertige Plugins und Skills beziehen lassen.

Dort können beispielsweise Erweiterungen für verschiedene Technologien, Plattformen und Dienste angeboten werden.

Das macht den Einstieg einfacher:

Marketplace
     ↓
Plugin installieren
     ↓
Skills + MCP + weitere Komponenten
     ↓
Cursor Agent

Damit entsteht ein Ökosystem ähnlich einem App Store. Entwickler können vorhandene Erweiterungen verwenden, statt alles selbst zu bauen.

VIII. Cursor für Teams

Die Erweiterbarkeit ist nicht nur für einzelne Entwickler interessant.

Teams können gemeinsame Regeln und Werkzeuge definieren und zentral bereitstellen.

Ein Unternehmen könnte beispielsweise ein internes Plugin entwickeln:

Company Development Plugin
│
├── Coding Standards
├── Security Skill
├── Testing Skill
├── Jira MCP
├── GitHub MCP
└── Deployment Commands

Damit erhält jeder Entwickler dieselben Grundlagen.

Das hat einen wichtigen Vorteil:

Das Wissen über den Entwicklungsprozess steckt nicht nur in den Köpfen einzelner Entwickler. Es wird direkt in der Entwicklungsumgebung verfügbar.

IX. MCP, Skills und Plugins im Vergleich

Eine einfache Eselsbrücke:

MCP gibt Cursor Werkzeuge.

Skills geben Cursor Anleitungen.

Plugins bündeln Erweiterungen.

X. Warum die Erweiterbarkeit immer wichtiger wird

Die Qualität eines Coding Agents hängt nicht nur vom verwendeten KI-Modell ab.

Ebenso wichtig ist die Frage:

Was kann der Agent in meiner Entwicklungsumgebung tatsächlich tun?

Ein einfacher KI-Assistent erzeugt Code.

Ein moderner Coding Agent kann dagegen:

Aufgabe verstehen
      ↓
Repository analysieren
      ↓
externe Informationen abrufen
      ↓
Code ändern
      ↓
Tests ausführen
      ↓
Änderungen überprüfen
      ↓
Pull Request erstellen

MCP, Skills und Plugins sind wichtige Bausteine dafür.

Das macht Cursor zu einer erweiterbaren Agent-Plattform und nicht mehr nur zu einem Editor mit KI-Unterstützung.

Für den Vergleich mit Claude Code, Codex, GitHub Copilot oder Windsurf ist deshalb eine Frage besonders wichtig:

Wie einfach kann ich den Coding Agent an meine eigenen Tools, Regeln und Arbeitsabläufe anpassen?

Genau hier werden MCP, Skills und Plugins zu einem wichtigen Auswahlkriterium.