Coding-Agents verändern, wie Software entwickelt wird.

Modelle können jetzt stundenlang laufen, anspruchsvolle Refactorings über viele Dateien hinweg durchführen und so lange iterieren, bis alle Tests bestehen. Aber um das Maximum aus Agents herauszuholen, muss man verstehen, wie sie arbeiten, und neue Arbeitsmuster entwickeln.

Dieser Leitfaden stellt Techniken für die Arbeit mit dem Cursor Agent vor. Egal, ob Sie neu im Programmieren mit Agents sind oder erfahren möchten, wie unser Team Cursor einsetzt – wir zeigen bewährte Methoden für das Programmieren mit Agents.

#Agent-Harnesses verstehen

Ein Agent-Harness baut auf drei Komponenten auf:

1. Instructions: Der Systemprompt und die Regeln, die das Verhalten des Agents steuern
2. Tools: Dateibearbeitung, Codesuche im Repository, Terminalausführung und mehr
3. User messages: Deine Prompts und Rückfragen, mit denen du die Arbeit steuerst

Das Agent-Harness von Cursor orchestriert diese Komponenten für jedes Modell, das wir unterstützen. Wir optimieren Instructions und Tools speziell für jedes Frontier-Modell auf Basis interner Auswertungen und externer Benchmarks.

Dieses Harness ist wichtig, weil unterschiedliche Modelle unterschiedlich auf dieselben Prompts reagieren. Ein Modell, das stark auf Shell-orientierte Workflows trainiert wurde, bevorzugt möglicherweise grep gegenüber einem speziellen Suchtool. Ein anderes benötigt eventuell explizite Anweisungen, um nach Änderungen Linter-Tools aufzurufen. Der Agent von Cursor übernimmt das für dich, sodass du dich beim Erscheinen neuer Modelle darauf konzentrieren kannst, Software zu bauen.

#Starte mit einem Plan

Die wirkungsvollste Änderung, die du vornehmen kannst, ist, vor dem Programmieren zu planen.

Eine Studie der University of Chicago hat ergeben, dass erfahrene Entwickler häufiger dazu neigen, zu planen, bevor sie Code schreiben. Planung zwingt dich, klar darüber nachzudenken, was du baust, und gibt dem Agent konkrete Ziele, auf die er hinarbeiten kann.

#Planmodus verwenden

Drücke Shift+Tab im Agent-Eingabefeld, um den Planmodus umzuschalten. Anstatt sofort Code zu schreiben, wird der Agent:

1. Deine Codebasis durchsuchen, um relevante Dateien zu finden
2. Klärende Fragen zu deinen Anforderungen stellen
3. Einen detaillierten Implementierungsplan mit Dateipfaden und Codeverweisen erstellen
4. Auf deine Freigabe warten, bevor er mit der Umsetzung beginnt

Pläne werden als Markdown-Dateien geöffnet, die du direkt bearbeiten kannst, um unnötige Schritte zu entfernen, den Ansatz anzupassen oder Kontext hinzuzufügen, den der Agent verpasst hat.

Tipp: Klicke auf „Save to workspace“, um Pläne in .cursor/plans/ zu speichern. Das erzeugt Dokumentation für dein Team, macht es einfach, unterbrochene Arbeit wieder aufzunehmen, und stellt Kontext für zukünftige Agents bereit, die an derselben Funktion arbeiten.

Nicht jede Aufgabe benötigt einen detaillierten Plan. Für schnelle Änderungen oder Aufgaben, die du schon viele Male erledigt hast, kannst du direkt mit dem Agent arbeiten.

#Neu starten anhand eines Plans

Manchmal erstellt der Agent etwas, das nicht dem entspricht, was du wolltest. Anstatt zu versuchen, es über weitere Prompts zu korrigieren, gehe zurück zum Plan.

Mache die Änderungen rückgängig, verfeinere den Plan, damit er genauer beschreibt, was du brauchst, und führe ihn erneut aus. Das ist oft schneller, als einen laufenden Agenten zu reparieren, und führt zu saubereren Ergebnissen.

#Kontext verwalten

Wenn du dich daran gewöhnst, dass Agents Code für dich schreiben, besteht deine Aufgabe darin, jedem Agent den Kontext zu geben, der für die Erledigung seiner Aufgabe nötig ist.

#Lass den Agenten den Kontext finden

Du musst nicht jede Datei in deinem Prompt manuell taggen.

Der Agent von Cursor verfügt über leistungsstarke Suchtools und holt bei Bedarf Kontext. Wenn du nach „dem Authentifizierungsablauf“ fragst, findet der Agent relevante Dateien über grep und semantische Suche – selbst wenn dein Prompt diese exakten Wörter nicht enthält.

Halte es einfach: Wenn du die exakte Datei kennst, tagge sie. Wenn nicht, findet der Agent sie. Wenn du irrelevante Dateien einbeziehst, kann das den Agenten darin verwirren, was wirklich wichtig ist.

Der Agent von Cursor verfügt außerdem über hilfreiche Tools wie @Branch, mit denen du dem Agenten Kontext zu deiner aktuellen Arbeit geben kannst. „Überprüfe die Änderungen auf diesem Branch“ oder „Woran arbeite ich gerade?“ werden so zu natürlichen Möglichkeiten, den Agenten auf deine aktuelle Aufgabe auszurichten.

#Wann Sie ein neues Gespräch beginnen sollten

Eine der häufigsten Fragen: Soll ich dieses Gespräch fortsetzen oder ein neues beginnen?

Starten Sie ein neues Gespräch, wenn:

• Sie zu einer anderen Aufgabe oder einem anderen Feature wechseln
• der Agent verwirrt wirkt oder immer wieder dieselben Fehler macht
• Sie eine logische Arbeitseinheit abgeschlossen haben

Führen Sie das Gespräch fort, wenn:

• Sie am selben Feature weiterarbeiten
• der Agent Kontext aus früheren Teilen des Gesprächs benötigt
• Sie etwas debuggen, das er gerade erstellt hat

Lange Gespräche können dazu führen, dass der Agent den Fokus verliert. Nach vielen Dialogrunden und Zusammenfassungen sammelt sich Rauschen im Kontext an, und der Agent kann abgelenkt werden oder zu unzusammenhängenden Aufgaben wechseln. Wenn Sie bemerken, dass die Effektivität des Agents abnimmt, ist es Zeit, ein neues Gespräch zu beginnen.

#Frühere Arbeiten referenzieren

Wenn du eine neue Unterhaltung beginnst, verwende @Past Chats, um auf frühere Arbeiten zu verweisen, statt die gesamte Unterhaltung zu kopieren und einzufügen. Der Agent kann selektiv aus dem Chatverlauf lesen und nur den Kontext hinzuziehen, den er benötigt.

Das ist effizienter als ganze Unterhaltungen zu duplizieren.

#Agent erweitern

Cursor bietet zwei Hauptmöglichkeiten, das Verhalten des Agents anzupassen: Rules für statischen Kontext, der für jede Unterhaltung gilt, und Skills für dynamische Fähigkeiten, die der Agent bei Bedarf einsetzen kann.

#Regeln: Statischer Kontext für dein Projekt

Regeln definieren dauerhafte Vorgaben, die bestimmen, wie der Agent mit deinem Code arbeitet. Du kannst sie dir als stets aktiven Kontext vorstellen, den der Agent zu Beginn jedes Gesprächs sieht.

Erstelle Regeln als Markdown-Dateien in .cursor/rules/:

# Commands

- `npm run build`: Build the project
- `npm run typecheck`: Run the typechecker
- `npm run test`: Run tests (prefer single test files for speed)

# Code style

- Use ES modules (import/export), not CommonJS (require)
- Destructure imports when possible: `import { foo } from 'bar'`
- See `components/Button.tsx` for canonical component structure

# Workflow

- Always typecheck after making a series of code changes
- API routes go in `app/api/` following existing patterns

Beschränke Regeln auf das Wesentliche: die auszuführenden Befehle, die zu befolgenden Muster und Verweise auf kanonische Beispiele in deiner Codebasis. Verweise auf Dateien, anstatt deren Inhalte zu kopieren; so bleiben Regeln kurz und veralten nicht, wenn sich der Code ändert.

Das solltest du in Regeln vermeiden:

• Ganze Styleguides kopieren (verwende stattdessen einen Linter)
• Jeden möglichen Befehl dokumentieren (der Agent kennt gängige Tools)
• Anweisungen für Randfälle hinzufügen, die selten zutreffen

Tipp: Fang einfach an. Füge nur dann Regeln hinzu, wenn du bemerkst, dass der Agent denselben Fehler wiederholt macht. Optimiere nicht übermäßig, bevor du deine Muster wirklich verstehst.

Checke deine Regeln in Git ein, damit dein gesamtes Team davon profitiert. Wenn du bemerkst, dass der Agent einen Fehler macht, aktualisiere die Regel. Du kannst sogar @cursor in einem GitHub-Issue oder einer PR taggen, damit der Agent die Regel für dich aktualisiert.

#Skills: Dynamische Fähigkeiten und Workflows

Agent Skills erweitern die Möglichkeiten von Agents. Skills bündeln domänenspezifisches Wissen, Workflows und Skripte, die Agents bei Bedarf aufrufen können.

Skills werden in SKILL.md-Dateien definiert und können Folgendes enthalten:

• Custom-Befehle: Wiederverwendbare Workflows, die mit / in der Agent-Eingabe ausgelöst werden
• Hooks: Skripte, die vor oder nach Agent-Aktionen ausgeführt werden
• Domänenwissen: Anweisungen für spezifische Aufgaben, die der Agent bei Bedarf hinzuziehen kann

Im Gegensatz zu Rules, die immer einbezogen werden, werden Skills dynamisch geladen, wenn der Agent entscheidet, dass sie relevant sind. So bleibt dein Kontextfenster übersichtlich, während der Agent Zugriff auf spezialisierte Fähigkeiten erhält.

#Beispiel: Langlaufende Agent-Schleife

Ein leistungsstarkes Muster ist der Einsatz von Skills, um Agents zu erstellen, die über längere Zeiträume hinweg laufen und iterieren, bis sie ein Ziel erreichen. So könntest du beispielsweise einen Hook erstellen, der einen Agent so lange arbeiten lässt, bis alle Tests erfolgreich sind.

Konfiguriere zunächst den Hook in .cursor/hooks.json:

{
  "version": 1,
  "hooks": {
    "stop": [{ "command": "bun run .cursor/hooks/grind.ts" }]
  }
}

Das Hook-Skript (.cursor/hooks/grind.ts) erhält Kontext von stdin und gibt eine followup_message zurück, um die Schleife fortzusetzen:

import { readFileSync, existsSync } from "fs";

interface StopHookInput {
  conversation_id: string;
  status: "completed" | "aborted" | "error";
  loop_count: number;
}

const input: StopHookInput = await Bun.stdin.json();
const MAX_ITERATIONS = 5;

if (input.status !== "completed" || input.loop_count >= MAX_ITERATIONS) {
  console.log(JSON.stringify({}));
  process.exit(0);
}

const scratchpad = existsSync(".cursor/scratchpad.md")
  ? readFileSync(".cursor/scratchpad.md", "utf-8")
  : "";

if (scratchpad.includes("DONE")) {
  console.log(JSON.stringify({}));
} else {
  console.log(JSON.stringify({
    followup_message: `[Iteration ${input.loop_count + 1}/${MAX_ITERATIONS}] Continue working. Update .cursor/scratchpad.md with DONE when complete.`
  }));
}

Dieses Muster ist nützlich für:

• Ausführen (und Beheben von Fehlern), bis alle Tests erfolgreich sind
• Iteratives Überarbeiten der UI, bis sie einem Design-Mockup entspricht
• Alle zielorientierten Aufgaben, bei denen sich der Erfolg überprüfen lässt

Tipp: Skills mit Hooks können mit Sicherheitstools, Secrets-Managern und Observability-Plattformen integriert werden. Siehe die Hooks-Dokumentation für Partnerintegrationen.

Agent Skills sind derzeit nur im Nightly-Release-Kanal verfügbar. Öffne die Cursor-Einstellungen, wähle Beta und stelle dann deinen Update-Kanal auf Nightly und starte anschließend neu.

Über das reine Programmieren hinaus kannst du den Agent mit anderen Tools verbinden, die du täglich verwendest. MCP (Model Context Protocol) ermöglicht es dem Agent, Slack-Nachrichten zu lesen, Datadog-Logs zu untersuchen, Fehler aus Sentry zu debuggen, Datenbanken abzufragen und mehr.

#Bilder einbinden

Der Agent kann Bilder direkt aus deinen Prompts verarbeiten. Füge Screenshots ein, zieh Designdateien hinein oder gib Bildpfade an.

#Vom Design zum Code

Füge ein Design-Mockup ein und bitte den Agent, es umzusetzen. Der Agent sieht das Bild und kann Layout, Farben und Abstände nachbilden. Du kannst auch den Figma-MCP-Server verwenden.

#Visuelles Debugging

Erstelle einen Screenshot eines Fehlerzustands oder einer unerwarteten Benutzeroberfläche und bitte den Agent, das Problem zu untersuchen. Das ist oft schneller, als das Problem in Worten zu beschreiben.

Der Agent kann außerdem einen Browser steuern, um eigene Screenshots zu erstellen, Anwendungen zu testen und visuelle Änderungen zu überprüfen. Weitere Details findest du in der Browser-Dokumentation.

#Häufige Workflows

Hier sind Agent-Muster, die sich für verschiedene Aufgabentypen gut eignen.

#Testgetriebene Entwicklung

Der Agent kann Code schreiben, Tests ausführen und automatisch iterieren:

1. Bitte den Agenten, Tests zu schreiben, basierend auf erwarteten Input/Output-Paaren. Stelle ausdrücklich klar, dass du TDD verwendest, damit er keine Mock-Implementierungen für Funktionalität erstellt, die noch nicht existiert.
2. Weise den Agenten an, die Tests auszuführen und zu bestätigen, dass sie fehlschlagen. Sage ausdrücklich, dass er in diesem Schritt keinen Implementierungscode schreiben soll.
3. Committe die Tests, wenn du damit zufrieden bist.
4. Bitte den Agenten, Code zu schreiben, der die Tests besteht, und weise ihn an, die Tests nicht zu ändern. Sage ihm, er soll weiter iterieren, bis alle Tests bestehen.
5. Committe die Implementierung, sobald du mit den Änderungen zufrieden bist.

Agenten arbeiten am besten, wenn sie ein klares Ziel haben, gegen das sie iterieren können. Tests ermöglichen es dem Agenten, Änderungen vorzunehmen, Ergebnisse zu bewerten und sich schrittweise zu verbessern, bis er erfolgreich ist.

#Verständnis der Codebasis

Wenn du in eine neue Codebasis einsteigst, nutze den Agenten zum Lernen und Erkunden. Stelle dieselben Fragen, die du auch einem Teammitglied stellen würdest:

• „Wie funktioniert Logging in diesem Projekt?“
• „Wie füge ich einen neuen API-Endpunkt hinzu?“
• „Welche Randfälle behandelt CustomerOnboardingFlow?“
• „Warum rufen wir in Zeile 1738 setUser() statt createUser() auf?“

Der Agent verwendet sowohl grep als auch semantische Suche, um die Codebasis zu durchsuchen und Antworten zu finden. Das ist eine der schnellsten Methoden, um sich in unbekannten Code einzuarbeiten.

#Git-Workflows

Agents können die Git-Historie durchsuchen, Merge-Konflikte lösen und Git-Workflows automatisieren.

Zum Beispiel ein /pr-Befehl, der Änderungen committet, pusht und eine PR eröffnet:

Create a pull request for the current changes.

1. Look at the staged and unstaged changes with `git diff`
2. Write a clear commit message based on what changed
3. Commit and push to the current branch
4. Use `gh pr create` to open a pull request with title/description
5. Return the PR URL when done

Befehle eignen sich ideal für Workflows, die du mehrmals täglich ausführst. Speichere sie als Markdown-Dateien in .cursor/commands/ und checke sie in git ein, damit dein gesamtes Team sie nutzen kann.

Weitere Beispiele für Befehle, die wir verwenden:

• /fix-issue [number]: Ruft mit gh issue view die Details eines Issues ab, findet relevanten Code, implementiert einen Fix und öffnet eine PR
• /review: Führt Linter aus, prüft auf häufige Probleme und fasst zusammen, was Aufmerksamkeit benötigen könnte
• /update-deps: Prüft auf veraltete Abhängigkeiten und aktualisiert sie nacheinander, wobei nach jedem Schritt Tests ausgeführt werden

Der Agent kann diese Befehle eigenständig ausführen, sodass du mehrschrittige Workflows mit einem einzigen /-Aufruf delegieren kannst.

#Code-Review

KI-generierter Code sollte überprüft werden, und Cursor bietet dafür mehrere Möglichkeiten.

#Während der Generierung

Beobachte, wie der Agent arbeitet. In der Diff-Ansicht siehst du die Änderungen in Echtzeit. Wenn du merkst, dass der Agent in die falsche Richtung geht, drücke Escape, um ihn zu unterbrechen und neu auszurichten.

#Agent Review

Sobald der Agent fertig ist, klicke auf Review → Find Issues, um einen eigenen Review-Durchlauf zu starten. Der Agent analysiert die vorgeschlagenen Änderungen Zeile für Zeile und markiert potenzielle Probleme.

Für alle lokalen Änderungen öffne den Tab „Source Control“ und führe Agent Review aus, um sie mit deinem Main-Branch zu vergleichen.

#Bugbot für Pull Requests

Pushen Sie Ihren Code in Ihr Versionskontrollsystem, um automatisierte Reviews Ihrer Pull Requests zu erhalten. Bugbot führt eine erweiterte Analyse durch, um Probleme frühzeitig zu erkennen und bei jedem PR Verbesserungen vorzuschlagen.

#Architekturdiagramme

Bei größeren Änderungen kannst du den Agent bitten, Architekturdiagramme zu erstellen. Versuche zum Beispiel: „Erstelle ein Mermaid-Diagramm, das den Datenfluss für unser Authentifizierungssystem zeigt, einschließlich OAuth-Providern, Sitzungsverwaltung und Token-Refresh.“ Diese Diagramme sind nützlich für die Dokumentation und können Architekturprobleme schon vor dem Code-Review aufdecken.

#Agents parallel ausführen

Cursor macht es einfach, viele Agents parallel auszuführen, ohne dass sie einander in die Quere kommen. Wir haben festgestellt, dass es die Ergebnisqualität deutlich verbessert, wenn mehrere Modelle dasselbe Problem angehen und wir anschließend das beste Ergebnis auswählen – insbesondere bei schwierigeren Aufgaben.

#Native Worktree-Unterstützung

Cursor erstellt und verwaltet automatisch git worktrees für parallele Agents. Jeder Agent läuft in seinem eigenen Worktree mit isolierten Dateien und Änderungen, sodass Agents Code bearbeiten, bauen und testen können, ohne sich gegenseitig in die Quere zu kommen.

Um einen Agenten in einem Worktree auszuführen, wähle die Worktree-Option im Agent-Dropdown aus. Wenn der Agent fertig ist, klicke auf Apply, um seine Änderungen wieder in deinen Arbeits-Branch zu übernehmen.

#Mehrere Modelle gleichzeitig ausführen

Ein leistungsfähiges Vorgehen ist, denselben Prompt gleichzeitig über mehrere Modelle laufen zu lassen. Wähle mehrere Modelle aus dem Dropdown-Menü, sende deinen Prompt ab und vergleiche die Ergebnisse nebeneinander. Cursor schlägt außerdem vor, welche Lösung es für die beste hält.

Das ist besonders nützlich für:

• Schwierige Probleme, bei denen verschiedene Modelle unterschiedliche Ansätze wählen könnten
• Den Vergleich der Codequalität zwischen verschiedenen Modellfamilien
• Das Finden von Randfällen (Edge Cases), die ein Modell übersehen könnte

Wenn du viele Agents parallel laufen lässt, konfiguriere Benachrichtigungen und Sounds so, dass du weißt, wenn sie fertig sind.

#Delegieren an Cloud-Agents

Cloud-Agents eignen sich gut für Aufgaben, die du sonst auf eine To-do-Liste setzen würdest:

• Bugfixes, die beim Arbeiten an etwas anderem aufgefallen sind
• Refactorings kürzlich vorgenommener Codeänderungen
• Schreiben von Tests für bestehenden Code
• Aktualisieren von Dokumentation

Du kannst je nach Aufgabe zwischen lokalen und Cloud-Agents wechseln. Starte Cloud-Agents über cursor.com/agents, den Cursor Editor oder von deinem Handy. Verfolge Sitzungen im Web oder auf deinem Mobilgerät, wenn du nicht am Schreibtisch bist. Cloud-Agents laufen in entfernten Sandbox-Umgebungen, sodass du deinen Laptop schließen und die Ergebnisse später prüfen kannst.

So funktionieren Cloud-Agents unter der Haube:

1. Beschreibe die Aufgabe und den relevanten Kontext
2. Der Agent klont dein Repo und erstellt einen Branch
3. Er arbeitet autonom und eröffnet am Ende einen Pull Request
4. Du wirst benachrichtigt, wenn er fertig ist (über Slack, E-Mail oder die Weboberfläche)
5. Prüfe die Änderungen und merge sie, wenn du bereit bist

Tipp: Du kannst Agents in Slack mit „@Cursor“ starten. Mehr erfahren.

#Debug-Modus für knifflige Bugs

Wenn Standard-Agent-Interaktionen bei einem Bug an ihre Grenzen stoßen, bietet der Debug-Modus einen anderen Ansatz.

Anstatt auf Verdacht zu fixen, macht der Debug-Modus Folgendes:

1. Erzeugt mehrere Hypothesen darüber, was falsch sein könnte
2. Instrumentiert deinen Code mit Logging-Ausgaben
3. Bittet dich, den Bug zu reproduzieren, während Laufzeitdaten gesammelt werden
4. Analysiert das tatsächliche Verhalten, um die eigentliche Ursache zu finden
5. Nimmt gezielte Korrekturen auf Basis dieser Erkenntnisse vor

Dies funktioniert am besten für:

• Bugs, die du reproduzieren kannst, aber nicht verstehst
• Race Conditions und Timing-Probleme
• Performance-Probleme und Memory Leaks
• Regressionen, bei denen etwas früher funktioniert hat

Entscheidend ist, ausführlichen Kontext dazu zu liefern, wie sich das Problem reproduzieren lässt. Je konkreter du bist, desto nützlichere Instrumentierung fügt der Agent hinzu.

#Deinen Workflow entwickeln

Die Entwickler:innen, die am meisten von Agents profitieren, haben ein paar Dinge gemeinsam:

Sie schreiben spezifische Prompts. Die Erfolgsrate des Agenten verbessert sich deutlich mit klaren, spezifischen Anweisungen. Vergleiche „add tests for auth.ts“ mit „Write a test case for auth.ts covering the logout edge case, using the patterns in __tests__/ and avoiding mocks.“

Sie verfeinern ihr Setup iterativ. Starte einfach. Füge Regeln nur hinzu, wenn du bemerkst, dass der Agent denselben Fehler wiederholt macht. Füge Befehle erst hinzu, nachdem du einen Workflow gefunden hast, den du wiederholen möchtest. Optimiere nicht zu früh, bevor du deine Muster wirklich verstanden hast.

Sie prüfen sorgfältig. KI-generierter Code kann korrekt aussehen und trotzdem subtil falsch sein. Lies die Diffs und prüfe sie genau. Je schneller der Agent arbeitet, desto wichtiger wird dein Review-Prozess.

Sie geben überprüfbare Ziele vor. Agents können nichts beheben, von dem sie nichts wissen. Nutze typisierte Sprachen, konfiguriere Linter und schreibe Tests. Gib dem Agenten klare Signale dafür, ob Änderungen korrekt sind.

Sie behandeln Agents als fähige Partner. Bitte sie um Pläne. Fordere Erklärungen an. Widersprich Ansätzen, die dir nicht gefallen.

Agents verbessern sich rasant. Auch wenn sich die Muster mit neueren Modellen weiterentwickeln werden, hoffen wir, dass dir dies heute hilft, produktiver mit Coding-Agents zu arbeiten.

Starte mit dem Cursor Agent, um diese Techniken auszuprobieren.