# Aider vs Claude Code: ehrlicher Vergleich

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

Aider vs Claude Code im Vergleich: Modelle und Anbieter, Kosten, Lizenz, Git-Auto-Commits, Repo-Map und Edit-Formate vs agentische Tools, Subagents, Hooks, MCP.

**Kurz gesagt:**

- Aider ist ein Open-Source-Pair-Programmer unter Apache-2.0, der mit den meisten LLMs und deinen eigenen Schlüsseln arbeitet; Claude Code ist Anthropics proprietärer Agent und nutzt nur Claude-Modelle.
- Aider arbeitet mit den Dateien, die du hinzufügst, plus einer Repo-Map und committet jede Änderung; Claude Code erkundet das Repo selbst, führt Befehle aus und committet auf Wunsch.
- Claude Code bringt Subagents, Hooks, MCP, Skills und Plan-Modus mit; Aider hat kein eingebautes MCP, bleibt dafür schlicht, günstig und ganz unter deiner Kontrolle.

Aider vs Claude Code läuft auf eine Frage hinaus: Wie viel soll der Agent selbst erledigen? Aider ist ein Open-Source-Pair-Programmer (Apache-2.0) fürs Terminal: Du fügst die Dateien hinzu, die sich ändern sollen, er bearbeitet sie mit dem Modell deiner Wahl und deinem eigenen Schlüssel und committet jede Änderung in Git. Claude Code ist Anthropics proprietärer Coding-Agent: Er erkundet das Repo selbst, führt Befehle aus, delegiert an Subagents und lässt sich mit Hooks und MCP erweitern, läuft aber nur mit Claude-Modellen und kommt mit einem Claude-Plan. Beide arbeiten im Terminal an deinem echten Repo, also geht es vor allem um Modelle, Kosten und Kontrolle.

Dieser Artikel vergleicht die beiden in den Punkten, auf die es ankommt, Stand Oktober 2026 und ohne erfundene Benchmarks. Danach geht es darum, welches du wählen solltest und wie du beide nutzt, ohne dass sie sich in die Quere kommen.

## Was die beiden sind

**Aider** beschreibt sich als „AI pair programming in your terminal“. Der Quellcode liegt auf GitHub (`Aider-AI/aider`) unter der Apache-2.0-Lizenz. Du startest `aider` in einem Git-Repo, wählst ein Modell, fügst die Dateien hinzu, die geändert werden müssen, und beschreibst die Änderung. Aider baut eine Karte deines ganzen Repos, bearbeitet Dateien in einem Format, das zum jeweiligen Modell passt, und committet das Ergebnis. Die Schritt-für-Schritt-Anleitung findest du unter [Aider nutzen](/de/blog/how-to-use-aider/ "Aider nutzen").

**Claude Code** ist Anthropics Agent. Starte `claude` in einem Projektordner und sprich mit ihm. Er liest und durchsucht Dateien selbst, bearbeitet sie, führt Befehle aus und prüft das Ergebnis. Er läuft auch in VS Code (und Cursor), JetBrains, einer Desktop-App, im Web und in der Claude-Mobile-App. Wenn du neu bist, fang mit [Claude Code nutzen](/de/blog/how-to-use-claude-code/ "Claude Code nutzen") an.

## Aider vs Claude Code auf einen Blick

| | Aider | Claude Code |
| --- | --- | --- |
| Hersteller | Das Aider-Projekt (`Aider-AI/aider`) | Anthropic |
| Lizenz | Apache-2.0, Open Source | Proprietär, unter Anthropics Commercial Terms |
| Befehl | `aider` | `claude` |
| Modelle | Die meisten LLMs: Anthropic, OpenAI, Gemini, DeepSeek, xAI, OpenRouter, Bedrock, Vertex AI, GitHub Copilot, lokale Modelle… | Nur Claude-Modelle |
| Bezahlung | API-Schlüssel deines Anbieters, ein Copilot-Abo oder nichts bei lokalen Modellen | Claude Pro, Max, Team oder Enterprise, Console-API-Guthaben oder ein Cloud-Anbieter |
| Kontext | Dateien, die du mit `/add` hinzufügst, plus Repo-Map | Der Agent liest und durchsucht Dateien selbst |
| Änderungen | Edit-Formate je nach Modell (whole, diff, udiff…) | Eigene Datei-Tools |
| Git | Committet standardmäßig jede Änderung; `/undo` macht sie rückgängig | Committet und öffnet PRs auf Wunsch; Checkpoints mit `/rewind` |
| Planung | `/ask` und Architect-Modus | Plan-Modus (`Shift+Tab`) |
| Subagents | Nein | Eingebaut und eigene, in `.claude/agents/` |
| Hooks | Nein; führt deine Lint- und Testbefehle aus | Ja, bei Events wie `PreToolUse` und `Stop` |
| MCP | Nicht eingebaut | Ja, `claude mcp add` oder `/mcp` |
| Projektanweisungen | Eine Konventionsdatei, die du mit `--read` lädst | `CLAUDE.md` (liest `AGENTS.md`, wenn es keine `CLAUDE.md` gibt) |
| Nicht interaktiv | `aider --message "..."` | `claude -p "..."` |

## Modelle und Anbieter

Das ist der größte Unterschied.

**Aider** kann sich mit den meisten LLMs verbinden. Die Doku hat Einrichtungsseiten für OpenAI, Anthropic, Gemini, Groq, xAI, Azure, Cohere, DeepSeek, OpenRouter, Amazon Bedrock, Vertex AI und GitHub Copilot, und lokale Modelle laufen über Ollama, LM Studio oder jede OpenAI-kompatible API. Modell und Schlüssel gibst du auf der Kommandozeile an oder legst sie in Umgebungsvariablen und `.aider.conf.yml` ab:

```bash
aider --model sonnet --api-key anthropic=<key>
aider --model deepseek --api-key deepseek=<key>
```

Für Commit-Messages und Chat-Zusammenfassungen nutzt Aider ein günstigeres „Weak Model“, und im Architect-Modus kombinierst du ein starkes Modell, das plant, mit einem günstigeren, das die Änderungen schreibt (`--editor-model`).

**Claude Code** läuft mit Claude-Modellen. `/model` wechselt zwischen ihnen. Du erreichst sie direkt über Anthropic oder über Amazon Bedrock, Google Cloud oder Microsoft Foundry, aber es ist in jedem Fall Claude, und das Tool ist genau auf diese Modelle abgestimmt.

Wenn du ein neues Modell am Tag seines Erscheinens ausprobieren oder alles auf deiner eigenen GPU laufen lassen willst, kann Aider das direkt. Wenn Claude das Modell ist, das du willst, holt Claude Code mehr aus ihm heraus.

## Kosten: eigener Schlüssel oder Claude-Plan

**Aider** selbst kostet nichts. Du bezahlst die Modelle:

- **Dein eigener API-Schlüssel**, vom Anbieter pro Token abgerechnet. `/tokens` zeigt, was der aktuelle Kontext kostet, und `--cache-prompts` (standardmäßig aus) schaltet Prompt-Caching für Modelle ein, die es unterstützen, etwa Claude und DeepSeek.
- **Ein GitHub-Copilot-Abo.** Aider kann Copilots Modelle nutzen, und die Aufrufe laufen über deinen Copilot-Plan.
- **Lokale Modelle**, ohne Rechnung außer deiner Hardware.

Weil du bestimmst, was in den Kontext kommt, bleibt eine disziplinierte Aider-Sitzung klein: Füge nur die Dateien hinzu, die geändert werden müssen, und überlass den Rest der Repo-Map.

**Claude Code** gehört zu den Claude-Plänen. Stand Oktober 2026 heißt das Pro (20 $ im Monat, oder 17 $ im Monat bei jährlicher Zahlung), Max (ab 100 $ im Monat) sowie Plätze in Team und Enterprise. Der Free-Plan enthält es nicht. Du kannst den Plan auch weglassen und mit einem Console-Konto pro Token zahlen.

Claude-Modelle in Aider bedeuten einen Anthropic-API-Schlüssel und Abrechnung pro Token; dein Claude-Pro- oder Max-Plan ist für Claude Code da. Wenn du also schon für Claude zahlst, ist Claude Code der günstigere Weg zu Claude-Modellen. Wenn du ein günstiges Modell willst oder schon für Copilot zahlst, nutzt du mit Aider, was du hast.

## Lizenz und Offenheit

Aider steht unter Apache-2.0. Du kannst den Code lesen, forken, patchen und überall laufen lassen. Das GitHub-Repository von Claude Code enthält Issues, Plugins und Beispiele, aber in der Lizenzdatei steht „© Anthropic PBC. All rights reserved“ mit Verweis auf Anthropics Commercial Terms. Die Installation ist kostenlos, genutzt wird es unter Anthropics Bedingungen.

Für die meisten Entwickler zählt das weniger als Modelle und Preis. Für Teams, die das Tool prüfen oder verändern müssen, kann es die Frage entscheiden.

## Wie sie arbeiten: Pair-Programmer vs Agent

Hier fühlen sie sich im Alltag am unterschiedlichsten an.

### Aider: Du wählst die Dateien

Aider arbeitet mit dem, was du ihm gibst. `/add` holt Dateien zum Bearbeiten in den Chat, `/read-only` fügt Referenzdateien hinzu, und `/drop` entfernt sie wieder. Dazu schickt Aider eine **Repo-Map**: eine kompakte Liste der Dateien in deinem Repo mit ihren wichtigsten Klassen, Funktionen und Signaturen, gewichtet danach, wie die Dateien voneinander abhängen. Die Map ist standardmäßig etwa 1k Token groß (`--map-tokens`) und wächst, wenn du keine Dateien hinzugefügt hast. So weiß das Modell, wo was liegt, ohne dass du das halbe Repo hinzufügst.

Aider lässt das Modell in einem **Edit-Format** antworten, das zu ihm passt: `whole` (die ganze Datei), `diff` (Suchen-und-Ersetzen-Blöcke), `diff-fenced`, `udiff` und Editor-Varianten. Daran drehst du selten, aber es ist der Grund, warum Aider mit so vielen Modellen gut funktioniert.

Es gibt vier Chat-Modi:

```text
/code      die Änderung umsetzen (Standard)
/ask       über den Code reden, nie bearbeiten
/architect ein Modell plant, ein Editor-Modell schreibt die Änderungen
/help      Fragen zu Aider selbst
```

Der Architect-Modus schickt pro Änderung zwei Anfragen, ist also langsamer und teurer, hilft aber bei schwierigeren Problemen.

### Claude Code: Der Agent findet seinen Weg selbst

Claude Code arbeitet agentisch. Du beschreibst die Aufgabe, und er entscheidet, welche Dateien er liest, durchsucht die Codebasis, bearbeitet Dateien, führt deine Tests und Befehle aus und macht weiter, bis er fertig ist oder dich braucht. Vor Änderungen und Befehlen fragt er, solange du keinen lockereren Rechte-Modus wählst.

Für größere Arbeit gibt es mehr Bausteine. Der **Plan-Modus** (`Shift+Tab`) recherchiert und schreibt einen Plan, ohne Quellcode anzufassen, bis du ihn freigibst. **Subagents** übernehmen eine Nebenaufgabe in ihrem eigenen Kontext und melden das Ergebnis zurück, damit das Hauptgespräch fokussiert bleibt. Skills und Plugins verpacken wiederkehrende Abläufe.

Kurz gesagt: Aider ist präzise und günstig, wenn du weißt, welche Dateien zählen. Claude Code ist besser, wenn du es nicht weißt oder die Aufgabe verlangt, quer durchs Repo Dinge auszuführen und zu reparieren.

## Git: Auto-Commits vs Commits auf Wunsch

**Aider** committet jede Änderung, die es macht, mit einer Message, die das Weak Model im Conventional-Commits-Stil schreibt. Hast du in einer Datei noch nicht committete Änderungen, bevor Aider sie bearbeitet, committet es diese zuerst, damit deine Arbeit und seine getrennt bleiben. An Autor- und Committer-Namen wird „(aider)“ angehängt. `/diff` zeigt die letzte Änderung, `/undo` macht sie rückgängig. Standardmäßig committet Aider mit `--no-verify`; mit `--git-commit-verify` laufen deine Pre-Commit-Hooks. `--no-auto-commits` lässt Änderungen uncommittet.

**Claude Code** committet nur, wenn du darum bittest. Dann staged es Änderungen, schreibt Commit-Messages und öffnet Pull Requests. Sein eigenes Sicherheitsnetz sind Checkpoints: `/rewind` setzt seine Dateiänderungen auf einen früheren Stand zurück.

Wenn du eine saubere, rückgängig machbare Historie für jeden Schritt magst, ist Aiders Standard schwer zu schlagen. Wenn du lieber selbst prüfst und committest, passt der Standard von Claude Code besser.

## Erweitern: Hooks, MCP und Konventionen

**Claude Code** hat hier viel zu bieten:

- **Hooks** führen deine Skripte bei Events wie `PreToolUse`, `PostToolUse` und `Stop` aus, konfiguriert in `.claude/settings.json`. Die [Claude Code Hooks Anleitung](/de/blog/claude-code-hooks-guide/ "Claude Code Hooks Anleitung") zeigt echte Beispiele.
- **MCP** verbindet lokale und entfernte Server mit `claude mcp add` oder `/mcp`.
- **CLAUDE.md** enthält die Projektregeln, und Claude Code liest `AGENTS.md`, wenn es keine `CLAUDE.md` gibt.

**Aider** bleibt schlanker. Eingebautes MCP gibt es nicht; Stand Oktober 2026 erwähnen weder die Doku noch die Release Notes es. Was Aider hat:

- **Lint und Tests** nach jeder Änderung: `--lint-cmd`, `--test-cmd` und `--auto-test`, und es versucht zu beheben, was fehlschlägt.
- **Konventionen** in einer Markdown-Datei, die du schreibgeschützt lädst: `aider --read CONVENTIONS.md` oder per `.aider.conf.yml`.
- **Watch-Modus** (`--watch-files`): Schreib in deinem Editor einen Kommentar, der auf `AI!` endet, und Aider setzt die Änderung um; endet er auf `AI?`, beantwortet es die Frage.
- Spracheingabe sowie Bilder und Webseiten als Kontext.

Für Skripte und CI haben beide einen Einmal-Modus:

```bash
aider --message "Typ-Hinweise zu utils.py hinzufügen" utils.py
claude -p "Typ-Hinweise zu utils.py hinzufügen"
```

## Plattformen

| | Aider | Claude Code |
| --- | --- | --- |
| macOS, Linux | Installationsskript, `aider-install`, uv, pipx | Nativer Installer, Homebrew, apt/dnf/apk |
| Windows | PowerShell-Installationsskript, `aider-install`, uv, pipx | Nativer Installer (PowerShell, CMD), WinGet, WSL |
| Editor | Jeder Editor über `--watch-files` | Erweiterung für VS Code (und Cursor), JetBrains-Plugin |
| Weitere Oberflächen | Terminal | Desktop-App, Web, Mobile, Slack, GitHub Actions |

## Welches solltest du wählen?

- **Du willst Modellauswahl, lokale Modelle oder eine offene Codebasis unter Apache-2.0:** Nimm Aider. Es passt auch, wenn du schon für Copilot zahlst.
- **Du zahlst schon für Claude oder willst Subagents, Hooks, MCP und Plan-Modus:** Nimm Claude Code. Nur so nutzt du deinen Claude-Plan, und es ist um diese Modelle herum gebaut.
- **Du weißt, welche Dateien eine Änderung betrifft, und willst enge Kontrolle mit einem Commit pro Schritt:** Aider ist schlank und berechenbar.
- **Die Aufgabe zieht sich durchs ganze Repo, Befehle müssen laufen und Fehler in einer Schleife behoben werden:** Das erledigt Claude Code selbst.
- **Dir sind die Kosten am wichtigsten:** Aider mit einem günstigen oder lokalen Modell kann deutlich weniger kosten. Claude Code mit Pro ist berechenbar, wenn du Claude willst.

Der ehrliche Test ist wie immer derselbe: Gib beiden dieselbe echte Aufgabe in deinem eigenen Repo, etwa einen Bug mit fehlschlagendem Test, und vergleiche die Diffs. Wenn du auch andere Open-Source-Agents abwägst, lies [opencode vs Claude Code](/de/blog/opencode-vs-claude-code/ "opencode vs Claude Code").

## Aider und Claude Code nebeneinander in AgentVera

Viele behalten beide: Claude Code mit dem Claude-Plan, Aider für andere Modelle oder schnelle Änderungen an einzelnen Dateien. Die Reibung kennt man: zwei Terminals, zwei Commit-Ströme und zwei Agents, die dieselbe Datei bearbeiten könnten.

AgentVera ist eine Desktop-App für macOS, Windows und Linux, die Aider und Claude Code (und 16 weitere CLI-Agents) in echten Terminals öffnet, mit deinen eigenen Installationen, Schlüsseln und Logins:

- **Ein Raster.** Beide Agents sitzen in einem [Workspace](/de/features/workspace/ "Workspace")-Raster, jeder in seinem eigenen Git-Worktree, sodass Aiders Auto-Commits nie im Checkout von Claude Code landen.
- **Deine Schlüssel.** Aider liest Anbieter-Schlüssel wie gewohnt aus Umgebungsvariablen oder `.aider.conf.yml`. Ein Modell, das du in AgentVera wählst, wird mit `--model` übergeben, der Aufwand mit `--reasoning-effort`. Dein Claude-Login funktioniert, wie er ist.
- **Miteinander reden.** Aider nimmt kein MCP, daher werden in AgentVera eingerichtete MCP-Server nicht an Aider übergeben, aber über den Shell-Befehl `agentvera-agents` bekommt es trotzdem [Agenten-Nachrichten](/de/features/agent-messaging/ "Agenten-Nachrichten").
- **Review.** Das [automatische Code-Review](/de/features/code-review/ "Automatisches Code-Review") prüft den Code, wenn ein Zug endet, und mit Flows (Pro und Team) geht die Antwort eines Agents automatisch an den anderen.

Raster, Worktrees und Code-Review sind im kostenlosen Plan enthalten. [Lade AgentVera herunter](/de/download/ "AgentVera herunterladen") und öffne einen Aider-Agent neben einem Claude-Code-Agent, um beide an deinem eigenen Code zu vergleichen.

## Häufige Fragen

**Ist Aider besser als Claude Code?** Keiner gewinnt überall. Aider gibt dir jedes Modell, eine offene Codebasis unter Apache-2.0 und einen Git-Commit pro Änderung. Claude Code gibt dir einen Agent, der selbst erkundet und Befehle ausführt, dazu Subagents, Hooks, MCP und einen Claude-Plan. Gib beiden dieselbe echte Aufgabe und vergleiche die Diffs.

**Kann Aider Claude-Modelle nutzen?** Ja. Aider arbeitet mit Anthropic-Modellen über einen API-Schlüssel (aider --model sonnet), abgerechnet pro Token, und auch über Amazon Bedrock, Vertex AI oder OpenRouter. Ein Claude-Pro- oder Max-Plan ist für Claude Code gedacht; Aider nutzt stattdessen die API-Abrechnung.

**Ist Aider kostenlos?** Das Tool ist kostenlos und steht unter Apache-2.0. Du zahlst deinen Modellanbieter pro Token, nutzt ein GitHub-Copilot-Abo oder lässt lokale Modelle über Ollama oder einen OpenAI-kompatiblen Server laufen, ohne Kosten außer deiner Hardware.

**Unterstützt Aider MCP?** Nicht eingebaut. Stand Oktober 2026 erwähnen weder Aiders Doku noch die Release Notes MCP-Unterstützung. Claude Code unterstützt lokale und entfernte MCP-Server über claude mcp add und /mcp.

**Kann ich Aider und Claude Code im selben Projekt nutzen?** Ja. Gib jedem einen eigenen Git-Worktree, damit sie nicht dieselben Dateien bearbeiten, und denk daran, dass Aider standardmäßig jede Änderung committet. AgentVera öffnet beide CLIs nebeneinander in einem Raster, jedes in seinem eigenen Worktree, mit deinen eigenen Schlüsseln und Logins.

---

**Ü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/