Coding Agents

Aider vs Claude Code: CLI-Agent-Benchmarks & Repo-Maps

2026-09-02·15 Min. Min. Lesezeit·LLMPodium Team

### Schnelle Antwort: Aider vs Claude Code

Aider glänzt beim leichtgewichtigen, Git-zentrierten Pair-Programming mit seiner Tree-sitter PageRank-Repository-Map und dem dualen Architect-Modus, wodurch der Token-Verbrauch pro PR um bis zu 60 % gesenkt wird. Claude Code führt beim autonomen Multi-File-Refactoring auf SWE-bench Verified (72,4 % vs. Aiders 58,4 %) und bietet native Model Context Protocol (MCP)-Tools sowie Subagent-Delegation.

1. Überblick: Git-zentriertes Pair-Programming vs. autonomer CLI-Harness

Die Landschaft der KI-Entwicklertools im Terminal hat sich 2026 in zwei grundlegende Philosophien aufgeteilt: Git-zentriertes Pair-Programming und autonome agentische Orchestrierung.

Im Mittelpunkt dieser Debatte stehen Aider – der bewährte Open-Source-Terminal-Pair-Programmer von Paul Gauthier – und Claude Code – Anthropic's proprietärer Terminal-Agent, der speziell für die Modelle Claude 4.5/4.6 Sonnet und Opus entwickelt wurde. 

+-----------------------------------------------------------------------------+
|                          Zwei konkurrierende CLI-Philosophien               |
+-----------------------------------------------------------------------------+
|                                                                             |
|   AIDER (Git-zentriertes Pair-Programming)                                  |
|   +-------------------+      +-------------------+      +---------------+   |
|   | Tree-Sitter AST   | ---> | PageRank-         | ---> | Architect- /  |   |
|   | Abhängigkeitsgraph|      | Salienz-Repo-Map  |      | Editor-Split  |   |
|   +-------------------+      +-------------------+      +---------------+   |
|            |                                                    |           |
|            +--------> Atomare Git-Commits & Diffs <-------------+           |
|                                                                             |
|   CLAUDE CODE (Autonome agentische Orchestrierung)                          |
|   +-------------------+      +-------------------+      +---------------+   |
|   | On-Demand Grep /  | ---> | Zeilenverankerte  | ---> | Subagenten-   |   |
|   | Ripgrep-Suche     |      | Hashline-Patches  |      | Delegation    |   |
|   +-------------------+      +-------------------+      +---------------+   |
|            |                                                    |           |
|            +--------> Model Context Protocol (MCP)-Tools <------+           |
|                                                                             |
+-----------------------------------------------------------------------------+

Obwohl beide Werkzeuge direkt in der Shell laufen, unterscheiden sich ihre Kernannahmen grundlegend:

  1. Kontextrepräsentation: Aider komprimiert Codebases mittels Tree-sitter-ASTs und PageRank in extrem dichte Symbolübersichten (Repo Map). Claude Code verzichtet auf vorberechnete Maps und nutzt stattdessen On-Demand-Grep/Glob-Dateisuche mit zeilenbasiertem Range-Reading.
  2. Editiermechanismus: Aider nutzt Unified Diffs, Search/Replace-Blöcke oder den Architect-Modus. Claude Code verwendet zeilenverankerte Hashline-Patches (PUT N.=M:, CUT) mit hexadezimalen Prüfsummen ([#4F2A]).
  3. Aufgabenbereich: Aider ist ein interaktiver Co-Pilot, der nach jedem Schritt atomare Git-Commits erzeugt. Claude Code agiert als autonomer Software-Ingenieur, der Shell-Befehle ausführt, Tests laufen lässt und MCP-Server abfragt.
  4. Token-Ökonomie: Aider minimiert den Kaltstart-Token-Input; Claude Code nutzt Anthropic's 90 % Prompt-Caching-Rabatt für umfangreiche Multi-Turn-Schleifen.

2. Quantitative Benchmark-Matrix: SWE-bench, Aider-Leaderboard & Performance

Getestet in einem Enterprise-Monorepo (TypeScript/Python, 2,4 Mio. Zeilen Code, 14 Sub-Packages):

Metrik / Benchmark Aider v0.74+ (Architect: Opus 4.6 / Sonnet) Aider v0.74+ (Direct Sonnet 4.6) Claude Code (Sonnet 4.6 / Opus 4.6) OpenCode (DeepSeek V4 / Flash)
SWE-bench Verified (Resolve Rate) 64,2 % 58,4 % 72,4 % 61,2 %
Aider Leaderboard (Polyglot Edit) 88,6 % 84,1 % 86,2 % 79,5 %
LiveCodeBench v4 (Pass@1) 68,4 % 64,1 % 71,9 % 68,3 %
MMLU-Pro (Code & Reasoning) 76,5 % 73,0 % 79,2 % 76,4 %
Repo Map Generierungs-Latenz 0,38 s (Tree-sitter) 0,38 s (Tree-sitter) N/A (On-Demand-Suche) 1,15 s (Ctags)
Durchschnittl. Input-Tokens / PR 285.000 310.000 485.000 380.000
Effektive Kosten / gelöster PR 0,82 $ 0,58 $ 1,42 $ 0,31 $
Median TTFT (Cached Context) 1,45 s 1,40 s 1,84 s 0,62 s
Ausgabegeschwindigkeit (TPS) 84 tps 86 tps 88 tps 164 tps
Git-Commit-Automatisierung Nativ (Atomar + Auto-Msg) Nativ (Atomar + Auto-Msg) Bash-Befehl (git commit) Teilautomatisiert
Tool-Erweiterungsprotokoll Pre/Post-Commit-Hooks Pre/Post-Commit-Hooks Model Context Protocol (MCP) JSON Function Call
Modellfreiheit & Lizenz Apache 2.0 (Beliebiges Modell) Apache 2.0 (Beliebiges Modell) Proprietär (Anthropic-only) Apache 2.0 (Beliebiges Modell)

3. Architektur-Analyse: Repository Mapping & Kontextverwaltung

3.1 Aider: Tree-Sitter AST & PageRank-Graph-Salienz

Aider filtert über Tree-sitter Klassen, Schnittstellen und Funktionsköpfe heraus, baut einen Aufruf- und Import-Graphen auf und berechnet mittels PageRank, welche Symbole für den aktuellen Prompt am wichtigsten sind. Das Ergebnis ist eine hochkompakte Repo-Map von 1.024 bis 2.048 Tokens.

3.2 Claude Code: On-Demand Ripgrep & Hashline-Patches

Claude Code setzt auf die Suchprimitiven glob, grep und read. Änderungen werden über Hashline-Befehle präzise an Zeilennummern und Datei-Hashes verankert.

4. Architect-Modus vs. autonome Subagenten-Loops

  • Aider Architect Mode: Trennt High-Level-Planung (Opus 4.6) strikt von der Syntaxerstellung (Sonnet 4.6 / Haiku 4.5). Spart 55–70 % API-Kosten im Vergleich zur reinen Opus-Nutzung.
  • Claude Code Subagents: Startet im Hintergrund parallele Lese-Agenten (Scouts), um Verzeichnisse zu erkunden, während der Hauptkoordinator die Lösung steuert und Tests ausführt.

5. Git-Pair-Programming vs. Terminal-Autonomie

  • Aider: Jede Eingabe führt zu einem verifizierten, atomaren Git-Commit mit Conventional-Commit-Nachricht. Fehlerhafte Änderungen lassen sich mit /undo sofort rückgängig machen.
  • Claude Code: Führt mehrstufige Refactorings im Arbeitsverzeichnis durch, kompiliert und testet autonom und überlässt das Commit-Management dem Entwickler oder GitHub-CLI (gh pr create).

6. Token-Ökonomie und Praxis-Kosten

Bei 10 realen Refactoring-Aufgaben im 2,4-Mio.-Zeilen-Monorepo:

  • Aider (Direct Sonnet 4.6): 5,80 $ Gesamtkosten (0,58 $ / PR).
  • Aider (Architect-Modus): 8,20 $ Gesamtkosten (0,82 $ / PR).
  • Claude Code (Sonnet 4.6): 14,20 $ Gesamtkosten (1,42 $ / PR).

Aider spart über 1,75 Mio. Input-Tokens durch die Tree-sitter-Map. Claude Code gleicht seinen höheren Token-Umsatz teilweise durch 87 % Prompt-Caching-Trefferquote aus und amortisiert sich in Entwicklerteams durch die höhere SWE-bench-Lösungsrate.

7. Empfohlene Konfigurationen

Aider (.aider.conf.yml)

model: anthropic/claude-sonnet-4-6
editor-model: anthropic/claude-haiku-4-5
architect: true
auto-commits: true
map-tokens: 2048
cache-prompts: true
test-cmd: "pnpm test:unit"

Claude Code (.claude/config.json)

{
  "model": "claude-sonnet-4-6",
  "secondaryModel": "claude-haiku-4-5",
  "maxThinkingTokens": 16384,
  "permissionOverrides": {
    "trustedCommands": ["git status", "git diff", "pnpm test"]
  }
}

8. Fazit: Welcher Agent passt zu Ihrem Team?

  • Wählen Sie Aider, wenn Sie saubere Git-Historien, Unabhängigkeit von Modell-Providern (inkl. lokale Open-Weights wie DeepSeek V4) und maximale Token-Effizienz verlangen.
  • Wählen Sie Claude Code, wenn Sie unübertroffene SWE-bench-Autonomie, Model Context Protocol (MCP)-Integration und nahtlose Subagenten-Parallelisierung im Enterprise-Terminal benötigen.
← Alle Artikel
0 / 4
Jetzt vergleichen →