Cursor Skills, Commands und Rules: Was ist der Unterschied?

Cursor hat drei überlappende, aber unterschiedliche Funktionen, die viele Nutzer verwirren: Skills, Commands und Rules. Der Forum-Thread mit 11 Antworten stellte im Grunde die gleiche Frage auf verschiedene Weise -- "Welchen verwende ich wofür?" Dieser Guide zieht klare Grenzen zwischen ihnen und zeigt Ihnen, wann Sie welche verwenden.

Definitionen

Beginnen wir damit, was jede Funktion tatsächlich ist.

Was sind Rules?

Rules sagen Cursors KI, wie sie sich verhalten soll, wenn sie Code generiert oder modifiziert. Sie definieren Coding-Standards, Konventionen, Einschränkungen und Präferenzen.

Rules sind deklarativ -- Sie sagen, was wahr sein sollte, und die KI folgt ihm.

Beispiel-Rule
Immer TypeScript Strict Mode verwenden.
Benannte Exports gegenüber Default-Exports bevorzugen.
Funktionale Komponenten mit Hooks verwenden, keine Klassenkomponenten.

Rules werden automatisch auf jede KI-Interaktion im Projekt angewendet, in dem sie konfiguriert sind. Sie rufen sie nicht manuell auf.

Wo Rules leben:

Globale Rules: Einstellungen > Allgemein > Rules for AI
Projekt-Rules: .cursorrules-Datei im Projekt-Root
Scoped Rules: .mdc-Dateien im .cursor/rules/-Verzeichnis

Was sind Commands?

Commands sind vordefinierte Prompts, die Sie manuell aufrufen, um spezifische Aktionen auszuführen. Sie sind Shortcuts für häufige Aufgaben.

Commands sind imperativ -- Sie lösen sie aus, um jetzt etwas Spezifisches zu tun.

Beispiel-Command-Aufruf
Sie tippen: "/explain"
Ergebnis: KI erklärt den ausgewählten Code

Sie tippen:
"/fix"
Ergebnis: KI behebt Fehler im ausgewählten Code

Commands sind explizite Nutzeraktionen. Die KI verwendet sie nicht, es sei denn, Sie sagen es ihr.

Wo Commands leben:

Eingebaute Commands: /explain, /fix, /doc, /test, etc.
Benutzerdefinierte Commands: Nutzerdefiniert in den Einstellungen

Was sind Skills?

Skills sind kontextuelle Fähigkeiten, auf die Cursors KI bei Bedarf zurückgreifen kann. Sie repräsentieren Domänenwissen oder spezialisierte Fähigkeiten, die die KI auf Ihre Anfragen anwenden kann.

Skills sind adaptiv -- die KI entscheidet, wann sie sie basierend auf Ihrem Prompt verwendet.

Beispiel-Skill in Aktion
Nutzer: "Richte ein Next.js-Projekt mit TypeScript, Tailwind und Prisma ein"

Die KI verwendet ihren "Next.js-Projekt-Scaffolding"-Skill, um:
- Die korrekten Initialisierungsbefehle auszuführen
- Tailwind ordnungsgemäß zu konfigurieren
- Prisma mit dem richtigen Schema-Standort einzurichten
- TypeScript-Pfade zu konfigurieren

Sie rufen Skills nicht explizit auf. Die KI erkennt, wann ein Skill zutrifft, und verwendet ihn automatisch.

Wo Skills herkommen:

In Cursors KI-Training eingebaut
Über Zeit aus Ihrer Codebase gelernt
Über MCP (Model Context Protocol)-Server hinzugefügt

Direktvergleich

Aspekt	Rules	Commands	Skills
Zweck	Verhaltensstandards definieren	Spezifische Aktionen ausführen	Domänenwissen anwenden
Wann angewendet	Automatisch, immer	Wenn manuell aufgerufen	Wenn KI Relevanz erkennt
Nutzerkontrolle	Einmal setzen, immer anwenden	Bei Bedarf auslösen	Implizit, KI entscheidet
Format	Text / JSON / .mdc	Slash-Commands (`/fix`)	Interne KI-Fähigkeit
Scope	Global oder projektspezifisch	Universell	Kontextabhängig
Beispiel	"Semikolons verwenden"	`/explain selection`	"Weiß, wie man React-Apps scaffoldet"

Wann welche verwenden

Rules verwenden, wenn

Sie wollen, wie die KI Code konsistent über Ihr Projekt hinweg schreibt.

Gute Rule-Anwendungsfälle:

Einen Coding-Stil durchsetzen (Tabs vs. Leerzeichen, Namenskonventionen)
Tech-Stack-Präferenzen angeben (React vs. Vue, Prisma vs. Drizzle)
Architektureinschränkungen definieren (keine zirkulären Imports, spezifische Ordnerstruktur)
Antwortstil festlegen ("sei prägnant", "immer Kommentare hinzufügen")

.cursorrules-Beispiel
{
  "techStack": ["Next.js 14", "TypeScript", "Tailwind CSS"],
  "rules": [
    "Server-Komponenten als Standard verwenden",
    "'use client' nur hinzufügen, wenn Interaktivität benötigt wird",
    "Alle API-Routen kommen in app/api/",
    "Prisma für alle Datenbankoperationen verwenden"
  ]
}

tipp

Rules sind die "Verfassung" Ihres Projekts. Schreiben Sie sie einmal und sie leiten jede KI-Interaktion.

Commands verwenden, wenn

Sie wollen, jetzt eine spezifische Aktion auf ausgewähltem Code oder dem aktuellen Kontext ausführen.

Gute Command-Anwendungsfälle:

Unbekannten Code erklären (/explain)
Einen spezifischen Fehler beheben (/fix)
Dokumentation generieren (/doc)
Tests für eine Funktion schreiben (/test)
Einen ausgewählten Block refactoren (/refactor)

Command-Workflow
Wählen Sie die Funktion aus, die Sie dokumentieren möchten
Tippen Sie /doc in den Chat
Die KI generiert JSDoc-Kommentare für diese Funktion

Eingebaute Commands-Referenz:

Command	Was es tut	Wann zu verwenden
`/explain`	Erklärt ausgewählten Code	Unbekannten Code lesen
`/fix`	Behebt Fehler im ausgewählten Code	Wenn es einen Bug oder Fehler gibt
`/doc`	Generiert Dokumentation	JSDoc/Docstrings hinzufügen
`/test`	Generiert Unit-Tests	Testabdeckung schreiben
`/refactor`	Schlägt Refactoring vor	Code-Struktur verbessern
`/commit`	Generiert Commit-Nachricht	Vor dem Committen von Änderungen

info

Commands können kombiniert werden. Sie können Code auswählen, /doc tippen und dann mit /test folgen, um sowohl Dokumentation als auch Tests für dieselbe Funktion zu generieren.

Skills verwenden, wenn

Skills sind nicht etwas, das Sie direkt "verwenden" -- sie sind etwas, das die KI nutzt. Aber Sie können Skills aktivieren oder konfigurieren über MCP-Server und Projektkontext.

Gute Skill-Konfigurationen:

Einen MCP-Server für Datenbankschema-Awareness hinzufügen
Websuche-Fähigkeit aktivieren
Dokumentations-APIs verbinden
Repository-spezifisches Wissen einrichten

MCP-Server-Konfiguration (Skill-Erweiterung)
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

Wenn diese MCP-Server verbunden sind, erhält die KI den "Skill", Ihre Datenbank oder GitHub-Issues direkt abzufragen.

Kombinieren: Ein praktisches Beispiel

Die wahre Kraft kommt aus der Verwendung aller drei zusammen. So sieht ein realer Workflow aus:

Szenario: Neuen API-Endpoint hinzufügen

Setup (Rules):

Ihre .cursorrules-Datei enthält:

Tech-Stack: Next.js 14 App Router, TypeScript, Prisma, Zod
API-Konventionen:
- Alle Routen in app/api/[resource]/route.ts
- Zod für Eingabevalidierung verwenden
- Konsistentes Fehlerformat zurückgeben: { error: string, code: string }
- Prisma-Transaktionen für Multi-Table-Operationen verwenden

Ausführung (Commands):

Sie wählen eine bestehende Route-Datei aus und tippen:

/test

Die KI generiert Tests für die bestehende Route basierend auf Ihren Rules.

Dann tippen Sie:

Erstelle einen neuen POST-Endpoint für /api/orders, der
{ items: Array<{ productId: string, quantity: number }>, 
  customerEmail: string } akzeptiert und eine Bestellung mit
Bestellpositionen in einer Transaktion erstellt.

KI-Unterstützung (Skills):

Die KI automatisch:

Wendet Ihre Rules an -- platziert die Datei in app/api/orders/route.ts, verwendet Zod-Validierung, wrappt in Prisma-Transaktion
Verwendet ihren Skill für Next.js App Router-Routing-Konventionen
Verwendet ihren Skill für Prisma-Transaktionssyntax
Generiert den Code unter Einhaltung aller Einschränkungen

Generierter Code unter Beachtung von Rules und Skills
import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';
import { prisma } from '@/lib/db';

const orderSchema = z.object({
  items: z.array(z.object({
    productId: z.string().uuid(),
    quantity: z.number().int().positive()
  })).min(1),
  customerEmail: z.string().email()
});

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validated = orderSchema.parse(body);
    
    const order = await prisma.$transaction(async (tx) => {
      const newOrder = await tx.order.create({
        data: {
          customerEmail: validated.customerEmail,
          status: 'PENDING'
        }
      });
      
      await tx.orderItem.createMany({
        data: validated.items.map(item => ({
          orderId: newOrder.id,
          productId: item.productId,
          quantity: item.quantity
        }))
      });
      
      return newOrder;
    });
    
    return NextResponse.json(order, { status: 201 });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Ungültige Eingabe', code: 'VALIDATION_ERROR' },
        { status: 400 }
      );
    }
    
    return NextResponse.json(
      { error: 'Interner Serverfehler', code: 'INTERNAL_ERROR' },
      { status: 500 }
    );
  }
}

Beachten Sie, wie der Code jede Ihrer definierten Rules befolgt, ohne dass Sie sie im Prompt wiederholen müssen. Das ist die Kraft der Kombination aller drei Mechanismen.

Häufige Verwirrungen und Klärungen

"Kann ich Rules in Commands umwandeln?"

Nicht direkt. Rules sind passive Einschränkungen; Commands sind aktive Aktionen. Sie können jedoch benutzerdefinierte Commands schreiben, die auf Ihre Rules verweisen:

Benutzerdefinierter Command-Idee

"/lint" -- ein benutzerdefinierter Command, der die KI bittet zu prüfen,
ob ausgewählter Code allen Projekt-Rules folgt

"Überschreiben Skills Rules?"

Nein. Rules haben immer Vorrang. Wenn ein Skill einen Ansatz vorschlägt, der eine Rule verletzt, sollte die KI der Rule folgen. Wenn Sie sehen, dass die KI Rules ignoriert, sind Ihre Rules möglicherweise zu vage oder widersprüchlich.

"Welches sollte ich zuerst einrichten?"

Rules zuerst -- definieren Sie Ihre Projekt-Konventionen
Commands zweitens -- lernen Sie die eingebauten, fügen Sie bei Bedarf benutzerdefinierte hinzu
Skills zuletzt -- fügen Sie MCP-Server oder Kontext hinzu, sobald Sie wissen, welche Lücken bestehen

"Kann ich mehrere gleichzeitig verwenden?"

Absolut. Tatsächlich sollten Sie. Rules setzen die Basislinie, Commands lösen Aktionen aus und Skills füllen Wissenslücken. Sie sind dafür gemacht, zusammenzuarbeiten.

Benutzerdefinierte Commands: Weiter gehen

Sie können benutzerdefinierte Commands in den Cursor-Einstellungen für Workflows definieren, die spezifisch für Ihr Projekt sind.

Benutzerdefinierte Commands in Einstellungen
{
  "cursor.customCommands": [
    {
      "name": "api-check",
      "description": "Prüft, ob API-Route Projekt-Konventionen folgt",
      "prompt": "Überprüfe diese API-Route-Datei und prüfe: 1) Ist sie am richtigen Ort? 2) Verwendet sie Zod-Validierung? 3) Verwendet sie Prisma-Transaktionen für Multi-Table-Ops? 4) Gibt sie das Standard-Fehlerformat zurück? Liste Verstöße auf."
    },
    {
      "name": "add-logging",
      "description": "Strukturiertes Logging zu einer Funktion hinzufügen",
      "prompt": "Füge dieser Funktion strukturiertes Logging mit dem Projekt-Logger aus @/lib/logger hinzu. Logge Eingabeparameter, Ausgabeergebnisse und alle aufgefangenen Fehler."
    }
  ]
}

Verwenden Sie sie, indem Sie /api-check oder /add-logging in den Chat tippen.

Zusammenfassung

Feature	Denken Sie daran als	Ihre Aktion	KI-Aktion
Rules	Projekt-Verfassung	Einmal schreiben	Automatisch folgen
Commands	Power-Tools	Bei Bedarf aufrufen	Spezifische Aufgabe ausführen
Skills	Domänen-Expertise	Konfigurieren/erweitern	Anwenden wenn relevant

Das einfachste mentale Modell:

Rules = "Mach es immer so"
Commands = "Mach jetzt dieses spezifische Ding"
Skills = "Ich weiß, wie man diese Art von Dingen macht"

Richten Sie zuerst Ihre Rules ein, damit die KI Ihre Standards kennt. Lernen Sie die eingebauten Commands, um häufige Aufgaben zu beschleunigen. Fügen Sie Skills über MCP-Server hinzu, wenn Sie die KI externe Systeme verstehen lassen müssen. Zusammen verwendet, machen sie Cursor deutlich leistungsfähiger als jede einzelne Funktion allein.

Definitionen​

Was sind Rules?​

Was sind Commands?​

Was sind Skills?​

Direktvergleich​

Wann welche verwenden​

Rules verwenden, wenn​

Commands verwenden, wenn​

Skills verwenden, wenn​

Kombinieren: Ein praktisches Beispiel​

Szenario: Neuen API-Endpoint hinzufügen​

Häufige Verwirrungen und Klärungen​

"Kann ich Rules in Commands umwandeln?"​

"Überschreiben Skills Rules?"​

"Welches sollte ich zuerst einrichten?"​

"Kann ich mehrere gleichzeitig verwenden?"​

Benutzerdefinierte Commands: Weiter gehen​

Zusammenfassung​