# Claude Code vs Cursor: Terminal-Agent oder KI-IDE?

URL: https://agentvera.dev/de/blog/claude-code-vs-cursor/ · Veröffentlicht: 2026-10-23

Claude Code vs Cursor im ehrlichen Vergleich: Modelle, Preismodell, Agent-Modus, Cloud-Agenten, Cursor CLI, Regeldateien und wann welches Tool gewinnt.

**Kurz gesagt:**

- Claude Code ist der Terminal-Agent von Anthropic mit Claude-Modellen, Cursor ist ein VS-Code-Fork, der Modelle mehrerer Anbieter anbietet.
- Cursor CLI bringt den Agenten von Cursor ins Terminal mit den Modi Agent, Plan und Ask, und Cursor Cloud Agents arbeiten auf einem Branch in Cloud-VMs und öffnen einen Pull Request.
- Claude Code liest CLAUDE.md, Cursor nutzt .cursor/rules/*.mdc plus AGENTS.md, gemeinsame Regeln gehören deshalb am besten in AGENTS.md.

**Bei Claude Code vs Cursor geht es darum, wo der Agent leben soll.** Claude Code ist der Coding-Agent von Anthropic: Er läuft in deinem Terminal (und in IDE-Extensions, einer Desktop-App und im Web), liest dein Repo, bearbeitet Dateien und führt Befehle mit Claude-Modellen aus. Cursor ist ein KI-Code-Editor, ein Fork von VS Code, mit einem in den Editor eingebauten Agenten, einer Auswahl an Modellen mehrerer Anbieter, Cloud-Agenten und einer eigenen CLI. Wähle Claude Code, wenn du im Terminal zu Hause bist und die tiefste Claude-Integration willst. Wähle Cursor, wenn du zuerst einen Editor willst und gern Modelle wechselst. Viele nutzen beide.

Dieser Beitrag behandelt, was sich wirklich unterscheidet: Modelle, Preismodell, Agent-Modus, Cloud-Agenten, Cursor CLI und Regeldateien. Benchmarks gibt es hier nicht. Ergebnisse hängen von deinem Repo, deinen Prompts und dem Modell der Woche ab, und wer einen einzelnen Score nennt, verkauft etwas. Wenn du auch das Tool von OpenAI in Betracht ziehst, lies [Claude Code vs Codex](/de/blog/claude-code-vs-codex/ "Claude Code vs Codex").

## Was sie sind

**Claude Code** ist ein agentisches Coding-Tool von Anthropic. Du startest es mit `claude` in einem Projektordner, beschreibst eine Aufgabe, und es plant, bearbeitet Dateien, führt Tests aus und fragt vor riskanten Schritten nach. Derselbe Agent gibt es auch in Extensions für VS Code und JetBrains, als Desktop-App und unter claude.ai/code.

```bash
# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex
```

**Cursor** ist ein vollständiger Code-Editor. Du öffnest einen Ordner, chattest in einem Seitenpanel mit dem Agenten, nimmst Diffs inline an oder lehnst sie ab und nutzt weiter die Editor-Funktionen, die du von VS Code kennst: Extensions, Debugger, Git-Ansicht. Tab-Vervollständigung und Inline-Edits stehen neben dem Agenten. **Cursor CLI** bringt denselben Agenten ins Terminal.

```bash
# macOS, Linux, WSL
curl https://cursor.com/install -fsS | bash

# Windows PowerShell
irm 'https://cursor.com/install?win32=true' | iex
```

## Auf einen Blick

| | Claude Code | Cursor |
| --- | --- | --- |
| Hauptoberfläche | Terminal, dazu IDE-Extensions, Desktop-App, Web | Editor (VS-Code-Fork), dazu CLI, Web und Mobile für Cloud-Agenten |
| Modelle | Claude-Modelle von Anthropic | Modelle von OpenAI, Anthropic, Google und Cursors eigene, plus eine Auto-Option |
| Abrechnung | Claude-Abo oder Anthropic-API-Nutzung | Cursor-Tarife mit enthaltener Modellnutzung |
| Regeldatei | `CLAUDE.md` | `.cursor/rules/*.mdc`, `AGENTS.md` |
| Cloud-Läufe | Cloud-Sessions auf claude.ai/code | Cloud Agents (früher Background Agents) |
| Terminal-Befehl | `claude` | `agent` (älter: `cursor-agent`) |
| Erweiterbarkeit | MCP, Hooks, Skills, Subagenten, Plugins | MCP, Regeln, Team-Regeln in Business-Tarifen |

## Modelle

Claude Code nutzt Claude-Modelle. Du wechselst mit `/model` innerhalb einer Session, die Auswahl besteht aus den aktuellen Stufen von Anthropic. Du kannst es auch über Amazon Bedrock oder Google Vertex AI auf Claude-Modelle richten, wenn deine Firma über einen Cloud-Anbieter einkauft. Was du nicht bekommst, sind GPT oder Gemini in Claude Code.

Cursor ist modellunabhängig. Seine Modellliste umfasst Modelle von OpenAI, Anthropic und Google sowie Cursors eigene Modelle (Composer), und eine Einstellung **Auto** lässt Cursor wählen. Dazu gehören Claude-Modelle, du kannst Claude also im Agenten von Cursor laufen lassen. Der Kompromiss: Das Harness um das Modell stammt von Cursor, nicht von Anthropic. Claude Code wird von derselben Firma gebaut, die das Modell trainiert, und seine Tools, Prompts und sein Berechtigungsablauf sind darauf abgestimmt.

Die ehrliche Fragestellung lautet also nicht „welches Modell ist besser“, sondern „willst du das Modell eines Anbieters in dessen Harness oder ein Harness, das Modellwechsel erlaubt“.

## Preismodell

Preise ändern sich zu oft, um sie hier abzudrucken, deshalb behandelt dieser Abschnitt nur, wie jedes abrechnet. Die aktuellen Zahlen findest du unter [Claude-Preise](https://claude.com/pricing "Claude pricing") und [Cursor-Preise](https://cursor.com/pricing "Cursor pricing").

- **Claude Code** ist in den kostenpflichtigen Abos von Claude enthalten, oder du zahlst pro Token über einen Anthropic-API-Schlüssel. Die Abo-Nutzung läuft in gleitenden Nutzungsfenstern; erreichst du eines, wartest du oder wechselst zur API-Abrechnung. Details stehen in [Claude Code Nutzungslimits](/de/blog/claude-code-usage-limits/ "Claude Code Nutzungslimits").
- **Cursor** hat einen kostenlosen Tarif sowie kostenpflichtige Tarife für Einzelpersonen und Unternehmen. Agent- und Modellnutzung zehren von dem, was dein Tarif enthält, zu einem Satz, der vom gewählten Modell abhängt. Cloud Agents zehren von derselben Nutzung.

Praktisch heißt das: Wenn du schon für Claude zahlst, kostet dich das Ausprobieren von Claude Code nichts extra. Wenn du schon für Cursor zahlst, sind sein Agent und seine CLI bereits in deinem Tarif. Für beide zu zahlen ist unter Vielnutzern üblich, vor allem, um einen zweiten Nutzungstopf zu haben, wenn einer leer ist.

## Agent-Modus

Beide Tools durchlaufen dieselbe Kernschleife: Dateien lesen, planen, bearbeiten, Befehle ausführen, die Ausgabe ansehen, wiederholen. Der Unterschied liegt darin, wie du zusiehst und steuerst.

**Claude Code** zeigt alles im Terminal. Berechtigungsmodi bestimmen, wie viel es allein tun darf: Standardmäßig fragt es vor Bearbeitungen und Befehlen, du kannst es Bearbeitungen annehmen lassen oder in den Plan-Modus wechseln, in dem es nur liest und Vorschläge macht. `Shift+Tab` schaltet zwischen ihnen um. Änderungen prüfst du mit `git diff` oder in deinem Editor.

**Der Agent von Cursor** arbeitet im Editor. Diffs erscheinen inline in den Dateien, du nimmst sie Hunk für Hunk an oder lehnst sie ab und kannst direkt in den Debugger springen. Für viele ist das der Hauptgrund für Cursor: Die Arbeit eines Agenten zu prüfen ist einfacher, wenn der Diff schon in dem Editor liegt, den du ohnehin nutzt.

Cursor CLI hat drei Modi:

| Modus | Was er tut | Wie du wechselst |
| --- | --- | --- |
| Agent | Standard; bearbeitet Dateien und führt Befehle aus | Standard |
| Plan | Entwirft den Ansatz und stellt Fragen, bevor Code geschrieben wird | `Shift+Tab`, `/plan`, `--plan` oder `--mode=plan` |
| Ask | Nur lesende Fragen zum Code | `/ask` oder `--mode=ask` |

Cursor CLI bittet um Freigabe, bevor es Terminalbefehle ausführt. Das Gegenstück bei Claude Code ist der Standard-Berechtigungsmodus.

## Hintergrund- und Cloud-Agenten

Beide lassen Agenten inzwischen auch abseits deines Laptops laufen.

**Cursor Cloud Agents** (das Feature hieß früher Background Agents) laufen in isolierten Cloud-VMs. Sie klonen dein Repo, arbeiten auf einem Branch und öffnen einen Pull Request. Du kannst einen aus dem Cursor-Editor, von cursor.com/agents, mobil, aus Slack, GitHub, Linear oder über die API starten, und in Cursor CLI schickst du einem Cloud-Agenten eine Nachricht, indem du ihr ein `&` voranstellst. Sie zehren von deiner Tarifnutzung zum Satz des gewählten Modells.

**Claude Code** hat Cloud-Sessions auf claude.ai/code, die in von Anthropic verwalteten VMs laufen. Aus dem Terminal startet `claude --cloud "task"` eine, und `claude --teleport` holt eine Cloud-Session zurück in dein lokales Terminal. Cloud-Sessions gibt es in den kostenpflichtigen Tarifen von Claude.

Auch die lokale Hintergrundarbeit unterscheidet sich. Claude Code kann Subagenten und Hintergrundaufgaben innerhalb einer Session ausführen. Der lokale Agent von Cursor läuft im gerade geöffneten Editorfenster. Willst du in einem der beiden Tools mehrere lokale Agenten gleichzeitig, brauchst du getrennte Terminals oder Fenster und eine Möglichkeit, sie aus den Dateien der anderen herauszuhalten, genau darum geht es bei [Coding-Agenten parallel ausführen](/de/blog/parallel-coding-agents/ "Parallele Coding-Agenten").

## Cursor CLI vs Claude Code im Terminal

Cursor CLI macht diesen Vergleich eng. Ohne sie lautete die Wahl „Terminal oder Editor“. Mit ihr ist Cursor auch ein Terminal-Agent.

```bash
# interactive
agent

# non-interactive, for scripts and CI
agent -p "find unused exports in src/" --output-format text

# pick up where you left off
agent ls
agent resume
```

Die Entsprechungen bei Claude Code:

```bash
claude
claude -p "find unused exports in src/"
claude --continue
claude --resume
```

Wo sie sich unterscheiden: Claude Code hat mehr terminalnative Erweiterungspunkte (Hooks, die bei Ereignissen deine Skripte ausführen, Skills, eigene Subagenten, Plugins). Die Stärke von Cursor CLI ist, dass sie Modelle, Regeln und MCP-Einstellungen mit dem Cursor-Editor teilt, der Agent sich also an beiden Orten gleich verhält.

## Regeldateien: .cursor/rules vs CLAUDE.md und AGENTS.md

Jeder Agent muss deinen Build-Befehl, deinen Testbefehl und die Dinge kennen, die er nicht anfassen darf. Die beiden Tools lesen unterschiedliche Dateien.

**Claude Code** liest `CLAUDE.md` im Projekt (und `~/.claude/CLAUDE.md` für persönliche Regeln). Es kann mit `@path` andere Dateien importieren.

**Cursor** nutzt Projektregeln in `.cursor/rules/`. Jede Regel ist eine `.mdc`-Datei mit Frontmatter, das bestimmt, wann sie gilt:

```markdown
---
description: API conventions for the server package
globs: server/**/*.ts
alwaysApply: false
---

- Validate every request body with zod.
- Return errors as { error: string }.
```

Regeln können immer gelten, gelten, wenn der Agent sie für relevant hält, gelten für passende Dateien oder gelten nur, wenn du sie erwähnst. Einfache `.md`-Dateien in diesem Ordner werden ignoriert. Cursor liest außerdem `AGENTS.md` im Root und in Unterordnern, Benutzerregeln aus seinen Einstellungen und Team-Regeln in Business-Tarifen. Cursor CLI liest auch `CLAUDE.md` im Projekt-Root.

Das portable Setup hält gemeinsame Regeln in `AGENTS.md` und macht `CLAUDE.md` zu einem einzeiligen Import:

```markdown
@AGENTS.md
```

Ergänze dann `.cursor/rules` nur für Dinge, die Globs brauchen. [CLAUDE.md und AGENTS.md schreiben](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md schreiben") behandelt, was in die Datei gehört.

## Wann welches gewinnt

**Claude Code gewinnt, wenn:**

- du im Terminal arbeitest, per SSH oder in tmux, und keinen Editor im Ablauf willst.
- du den Agenten automatisieren willst: Hooks, `claude -p` in Skripten und CI, eigene Subagenten und Skills.
- du schon für Claude zahlst und das Harness willst, das Anthropic für seine eigenen Modelle abstimmt.
- du viele Agenten gleichzeitig laufen lassen und jeden als Prozess behandeln willst.

**Cursor gewinnt, wenn:**

- du Diffs inline in einem Editor sehen und annehmen willst, mit dem Debugger einen Klick entfernt.
- du gern pro Aufgabe das Modell wechselst oder Cursors Auto wählen lassen willst.
- du Tab-Vervollständigung und schnelle Inline-Edits neben einem vollwertigen Agenten willst.
- dein Team Cloud-Agenten aus Slack, GitHub oder Linear starten und PRs zurückbekommen will.

**Bei der reinen Qualität gewinnt keines durchgehend.** Mit demselben Claude-Modell hängt das Ergebnis stärker von deiner Aufgabenbeschreibung und deiner Regeldatei ab als vom Tool.

## Beide nutzen

Beide zu nutzen ist häufiger, als sich für eines zu entscheiden:

- **Claude Code im Terminal von Cursor.** Schreibe und prüfe in Cursor und gib größere Aufgaben an `claude` im integrierten Terminal oder über die Claude Code Extension, die die Doku von Anthropic für Cursor anbietet.
- **Zweite Meinung.** Ein Agent schreibt die Änderung, der andere prüft sie. Verschiedene Harnesses übersehen verschiedene Dinge.
- **Zwei Nutzungstöpfe.** Wenn das Fenster von Claude aufgebraucht ist, macht der Agent von Cursor weiter, und umgekehrt.

Der Haken ist die Koordination. Zwei Agenten im selben Ordner bearbeiten dieselben Dateien. Gib jedem mit [Git Worktrees](/de/blog/git-worktree-parallel-agents/ "Git Worktrees für parallele Agenten") einen eigenen Branch und Ordner und halte eine `AGENTS.md`, damit beide dieselben Regeln befolgen.

## Claude Code und Cursor CLI nebeneinander in AgentVera

AgentVera ist eine Desktop-App für macOS, Windows und Linux, die Terminal-Coding-Agenten in echten Terminals ausführt, in einem Raster, mit deinen vorhandenen Logins. Den Cursor-Editor führt es nicht aus; es führt [Cursor CLI](/de/agents/cursor-agent/ "Cursor Agent in AgentVera") (`cursor-agent` oder `agent`) neben [Claude Code](/de/agents/claude-code/ "Claude Code in AgentVera") aus.

| Bedarf | In AgentVera |
| --- | --- |
| Beide Agenten gleichzeitig sehen | Ein Raster pro Projekt, von 1×1 bis 5×4 Panels |
| Sie aus den Dateien des anderen heraushalten | Wähle einen Worktree im Feld Workspace des Dialogs „New agent“ |
| Getrennte Cursor-Gespräche | Jeder Cursor-Agent bekommt einen eigenen Chat, angelegt mit `cursor-agent create-chat` und wieder geöffnet mit `--resume` |
| Berechtigungen steuern | Ask, Auto oder Full access pro Agent; bei Cursor übergibt Full access `--force` |
| Einer prüft den anderen | [Automatisches Code-Review](/de/features/code-review/ "Automatisches Code-Review"), wenn ein Turn endet, für beide Agenten |
| Arbeit von einem an den anderen übergeben | [Flows](/de/features/flows/ "Flows") reichen die Antwort eines Agenten an einen anderen weiter (Pro und Team) |

Eine ehrliche Grenze. Cursor CLI hat kein Rollen-Flag, das Feld „Role and instructions“ wird also nicht an sie übergeben; lege die Anweisungen stattdessen in `AGENTS.md` oder `.cursor/rules`. Die MCP-Server und der Browser von AgentVera erreichen Cursor dagegen: Sie werden als lokales Plugin hinzugefügt und für diesen Lauf freigegeben, neben deinen eigenen MCP-Einstellungen. Lässt du das Modell leer, nutzt Cursor das Modell aus seinen eigenen Einstellungen.

Das Raster, Worktrees und Code-Review sind im kostenlosen Tarif enthalten. [Lade AgentVera herunter](/de/download/ "AgentVera herunterladen"), öffne einen Claude-Code-Agenten und einen Cursor-Agenten in zwei Worktrees und sieh, zu welchem du greifst.

## Was solltest du wählen?

- Terminal-Mensch, zahlt schon für Claude, will Automatisierung: **beginne mit Claude Code**.
- Editor-Mensch, will Inline-Diffs und Modellauswahl: **beginne mit Cursor**.
- Stößt an Limits oder will bei wichtigen Änderungen eine zweite Meinung: **nutze beide**, jedes in einem eigenen Worktree, mit einer `AGENTS.md`.

Womit auch immer du beginnst, halte deine Regeln in `AGENTS.md`. Ein späterer Wechsel kostet dich dann nichts.

## Häufige Fragen

**Was ist der Hauptunterschied zwischen Claude Code und Cursor?** Claude Code ist der Coding-Agent von Anthropic, der in deinem Terminal lebt (mit IDE-Extensions, Desktop-App und Web-Version) und Claude-Modelle nutzt. Cursor ist ein KI-Code-Editor, ein Fork von VS Code, der einen Agenten in den Editor setzt und dich Modelle mehrerer Anbieter wählen lässt.

**Kann ich Claude Code in Cursor nutzen?** Ja. Cursor basiert auf VS Code, und die Doku von Anthropic bietet die Claude Code Extension für Cursor an. Du kannst auch einfach `claude` im integrierten Terminal von Cursor ausführen. Der eigene Agent von Cursor und Claude Code arbeiten dann an denselben Dateien, gib ihnen also getrennte Aufgaben oder getrennte Worktrees.

**Hat Cursor eine CLI wie Claude Code?** Ja. Cursor CLI wird mit `curl https://cursor.com/install -fsS | bash` installiert und läuft als `agent` (ältere Installationen nutzen `cursor-agent`). Sie hat die Modi Agent, Plan und Ask, einen Print-Modus mit `-p` für Skripte und liest AGENTS.md, CLAUDE.md und `.cursor/rules`.

**Was ist günstiger, Claude Code oder Cursor?** Das hängt davon ab, wie du arbeitest, und beide Anbieter ändern ihre Tarife oft. Claude Code ist in Claude-Abos enthalten oder wird über die API abgerechnet; Cursor hat eigene Tarife mit enthaltener Modellnutzung. Vergleiche die aktuellen Zahlen auf claude.com/pricing und cursor.com/pricing, statt einer Zahl in einem Blogbeitrag zu trauen.

**Teilen sich Claude Code und Cursor Regeldateien?** Teilweise. Claude Code liest CLAUDE.md; Cursor liest `.cursor/rules`, AGENTS.md und in Cursor CLI auch CLAUDE.md. Wenn du gemeinsame Regeln in AGENTS.md hältst und sie aus CLAUDE.md mit `@AGENTS.md` importierst, bekommen beide Tools dieselben Anweisungen.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/
