Viele denken, Claude Code sei „im Cloud-Modell“ und brauche keine starke Hardware — das stimmt nur halb. Die Inferenz braucht keine lokale GPU, aber bei jedem Tool Call startet der Agent lokal npm test, xcodebuild, docker compose, Language Server … Wir haben auf drei M4-Macs mit gleichem Chip (16 / 24 / 64 GB) acht identische Aufgaben gefahren und Peak-Speicher, Swap-Häufigkeit und End-to-End-Zeit gemessen. Kurz vorweg: Für reines Terminal und leichte Nutzung reichen 16 GB; IDE + Agent im Alltag ist 24 GB der Sweet Spot; Xcode + mehrere Simulatoren + parallele Subagents → direkt 64 GB.
1. Irrtum: Claude Code braucht keine lokale Leistung?
Die Modell-Inferenz von Claude Code läuft in der Anthropic-Cloud — Ihr Mac braucht keine NVIDIA-GPU und stürzt nicht wegen „zu großem Modell“ mit OOM ab. Das heißt aber nicht, dass ein alter 8-GB-Rechner reicht: Im Agent-Modus lässt die KI Ihre lokale Umgebung arbeiten:
- Dateien lesen → ripgrep, git, Dateisystem-Cache
- Tests ausführen → Node, Jest, pytest, cargo test und weitere Prozessbäume
- CI reparieren → ggf.
xcodebuild, Gradle, Docker-Container - Parallele Subagents → mehrere Terminal-Sessions lesen und kompilieren gleichzeitig
In unserem 30-Tage-Claude-Code-Rechnungsaudit steht: Am teuersten sind oft lange Sessions plus volles Repo-Lesen. Beim Speicher gilt dasselbe — Swap verlangsamt lokal ausgelöste Agent-Befehle um das 2–5-Fache; Sie warten nicht nur auf das Modell, sondern auch auf lokale Builds und Tests.
2. Testumgebung und Methodik
| Punkt | Spezifikation |
|---|---|
| Hardware | Mac mini M4 (drei Geräte, 16 / 24 / 64 GB RAM, je 512 GB SSD) |
| System | macOS 15.5, iCloud-Desktop-Sync aus, Energiesparmodus einheitlich aus |
| Claude Code | Version 2026.7, Standard Sonnet; komplexe Refactorings zusätzlich mit Opus |
| Test-Repos | ① TypeScript-Monorepo (pnpm, ca. 180 Pakete) ② Swift-iOS-Projekt (SPM + CocoaPods) ③ mittleres Go-Backend (mit Docker Compose) |
| Messung | Je Szenario 3 Läufe, Median; memory_pressure + Aktivitätsanzeige für Peak und Swap |
| Zeit | Wall-Clock von Prompt bis Agent meldet „Aufgabe erledigt“ (inkl. lokaler Befehle) |
Hinweis: Vergleich gleicher Chip, nur RAM unterschiedlich — keine CPU-Generation als Störfaktor. Absolute Zahlen schwanken mit Repo-Größe und Dependencies; die relativen Abstände zwischen den drei Stufen blieben bei Wiederholungen stabil.
3. Wie viel Speicher braucht Claude Code allein?
Extrem leicht: nur Terminal, leeres Repo, eine kurze Q&A-Runde:
| Zustand | Resident | Peak |
|---|---|---|
| Claude Code idle (eingeloggt) | ~180 MB | ~220 MB |
| Eine Runde ohne Tool Call | ~200 MB | ~350 MB |
| 5 Tool Calls (20 Dateien lesen) | ~280 MB | ~520 MB |
| 40 Agent-Runden (Kontext nicht geleert) | ~400 MB | ~780 MB |
Folgerung: Wer Claude Code nur als „besseres ChatGPT-Terminal“ nutzt, kommt mit 16 GB locker aus. Den Unterschied machen die lokalen Nebenwirkungen, die der Agent auslöst.
4. 8 Szenarien im Vergleich
Tabelle: Peak-Speicher (Claude Code + parallele lokale Prozesse), deutlicher Swap (>500 MB/min Paging) und Median der Wall-Clock-Zeit.
| Szenario | 16 GB Peak | 16 GB Zeit | 24 GB Peak | 24 GB Zeit | 64 GB Peak | 64 GB Zeit |
|---|---|---|---|---|---|---|
| S1 Nur Terminal + kleiner TS-Fix (3 Dateien, lint) | 6.8 GB OK | 42s | 6.8 GB | 41s | 6.8 GB | 40s |
| S2 Claude Code + Cursor + TS LSP | 14.6 GB Gelegentlicher Swap | — | 14.6 GB OK | — | 14.6 GB | — |
S3 Agent führt pnpm test aus (volle Suite) |
15.9 GB Starkes Swap | 8m 12s | 16.4 GB Leichter Swap | 3m 05s | 16.4 GB | 2m 58s |
| S4 API-Refactor über 12 Dateien + Tests | 16.1 GB Starkes Swap | 14m 30s | 17.8 GB OK | 6m 20s | 17.8 GB | 6m 08s |
| S5 Claude Code + Xcode + iPhone-16-Simulator | — Nicht nutzbar | 25m+ | 22.3 GB Grenzwertig | 11m 40s | 22.3 GB OK | 10m 55s |
| S6 Zwei parallele Subagents (je Tests) | — OOM-Risiko | Fehlgeschlagen | 21.7 GB Swap | 9m 50s | 21.7 GB OK | 4m 22s |
| S7 Docker Compose mit 4 Services + Agent-API | — Nicht nutzbar | — | 23.1 GB Swap | 7m 15s | 23.1 GB OK | 5m 40s |
| S8 Nächtliches Monorepo-CI (build + test + lint) | — Dauer-Swap | 45m+ | 24.6 GB Hohe Last | 18m 20s | 24.6 GB OK | 16m 05s |
Lesen der Tabelle: Ab S3 bricht 16 GB ein — nicht weil Claude Code langsam ist, sondern weil Tests im Swap hängen. 24 GB deckt S1–S4 und leichtes S5; parallele Agents und Docker bleiben knapp. 64 GB: nirgends „nicht nutzbar“; S6 mit zwei Subagents ist über doppelt so schnell wie 24 GB.
5. 16 GB: Was geht, wann muss man durchhalten
Für wen
- Claude Code vor allem im Terminal, IDE selten oder Vim/Neovim
- Kleines Repo (<50k Zeilen), Tests in unter 30 Sekunden
- Kein iOS-Simulator, kein Docker-Matrix
- Bereits MacBook Air / Einstiegs-MacBook Pro, Budget für mehr RAM fehlt vorerst
Überlebensregeln mit 16 GB
- Nur eine „schwere“ App gleichzeitig: Beim Agent-Test Cursor-Fenster mit TS-LSP schließen
.claudeignoresetzen, weniger sinnloses Indexieren (wie in der Rechnungsanalyse — spart auch RAM)- Nach Subtasks sofort
/clear, damit der Kontext-Snowball keinen Extra-Puffer frisst xcodebuild, Docker, lange CI-Läufe an Cloud-Mac; lokal nur Editieren und leichte Checks
# Echtzeit-Überblick memory_pressure # Swap-Nutzung sysctl vm.swapusage # Speicherhungrigste Prozesse top -l 1 -s 0 -o mem | head -20
Subjektiv: S1–S2 laufen flüssig; sobald der Agent volle Tests startet (S3), dreht der Lüfter, der Cursor hängt, der Agent denkt „Test-Timeout“ und versucht es erneut — langsam und teuer in Tokens.
6. 24 GB: Die beste Wahl für die meisten
Für „Claude Code + moderne IDE“ ist 24 GB 2026 der Sweet Spot — beim M4 MacBook Pro 14″ ist 24 GB ein häufiges Upgrade, meist deutlich günstiger als der Sprung auf 48 GB.
24 GB deckt bequem ab
- Claude Code + Cursor (oder VS Code) + TypeScript-/Python-LSP parallel
- Einmal volle Tests in mittelgroßem Monorepo
- Refactor über bis zu 12 Dateien + automatische Test-Schleife
- Ein Docker-Service (DB / Redis) + lokale API-Entwicklung
24 GB wird trotzdem eng
- Xcode + iOS-Simulator + Claude Code gleichzeitig (S5 Peak 22,3 GB, kaum Reserve)
- Zwei parallele Subagents (S6) oder vier Docker-Services (S7)
- Chrome mit 50+ Tabs plus obiger Stack (kommt häufiger vor als man denkt)
7. 64 GB: Wer es wirklich braucht
64 GB klingt nach Overkill, löst für Claude Code-Power-User aber das Parallelitäts-Problem — nicht mehr eine Build-Queue, sondern mehrere Subagents lesen, testen und starten Container gleichzeitig.
Signale für 64 GB
| Signal | Warum 64 GB |
|---|---|
| Oft 2+ iOS-Simulatoren für UI-Tests | Ein Simulator ~3–5 GB, Xcode selbst ~4–6 GB |
| Parallele Subagents mit Claude Code | Jede Session kann eigene Test-Prozessbäume starten |
| Lokale Docker-Matrix (DB + Cache + Queue + Mock) | Container-RAM summiert sich schnell |
| Großes Monorepo (turbo / nx Cache resident) | Build-Cache + LSP + Index füllen 24 GB |
| Tech Lead mit 3 Projekt-Fenstern gleichzeitig | Kein Luxus, sondern Alltag |
S6 zwei Subagents: 64 GB 4m 22s vs. 24 GB 9m 50s — nicht das Modell, sondern zwei parallele npm test ohne Swap-Kampf. Bei 2 parallelen Jobs/Tag, je 5 Minuten gespart: rund 60 Stunden Wartezeit pro Jahr.
Budget bei 36 GB (einige M4 Pro): guter Kompromiss für iOS; S5 stabiler als 24 GB, bei doppelten Subagents trotzdem einen abschalten oder in die Cloud auslagern.
8. Was neben dem RAM noch zählt
| Komponente | Einfluss auf Claude Code | Empfehlung |
|---|---|---|
| SSD | Agent liest viele Dateien; bei Swap entscheidet Disk-Geschwindigkeit über Ruckeln | Ab 512 GB, 1 TB entspannter; langsames externes Laufwerk für Repos vermeiden |
| Chip | Lokale Builds, nicht Modell-Inferenz | M4 reicht; M4 Pro schneller bei Multi-Core-Builds, siehe MacBook-Pro-Kaufberatung |
| Netzwerk | Streaming, großer Kontext-Upload; Offline bricht Agent ab | Stabiles Kabel oder 5-GHz-WLAN; Hotspot bei langen Jobs meiden |
| Kühlung | Lange Builds + Sommerhitze → Dauerleistung | Ständer fürs Notebook; 7×24 eher Mac mini / Cloud |
| Display | Kein direkter RAM-Effekt, aber Dual-Screen = mehr IDE-Fenster resident | Externes Display → mehr RAM-Reserve einplanen |
9. Hybrid: Lokaler Mac + Cloud-Mac
Nicht jedes Notebook muss auf 64 GB. Häufiger 2026-Ansatz:
- Lokal 16–24 GB: Claude Code editieren, Review, leichte Tests
- Cloud Mac mini M4 (24–64 GB):
xcodebuild, nächtliche CI, parallele Subagents - Per SSH Agent auf der Cloud; lokal nur Ergebnisse — Speicherengpass wandert ins Rechenzentrum
Passt zu unserer Rechnungsanalyse: Zuklappen → Agent startet neu, kostet Tokens und Zeit. Ein dauerhaft online Cloud-Mac passt zu „langen Jobs wegschicken“.
Zu wenig RAM? Schwere Jobs an einen dauerhaft online Cloud-Mac
Nuvcloud bietet dedizierte M4 Mac minis (verschiedene RAM-Stufen), SSH/VNC, Abrechnung nach Tag/Woche/Monat. Lokal 16 GB coden, in der Cloud 64 GB für parallele Claude-Code-Agents + Xcode-Vollbuild — Preise ansehen.
10. Kauf-Übersicht nach Profil
| Ihr Profil | Empfohlenes RAM | Typische Hardware | Hinweis |
|---|---|---|---|
| Studium / Skripte / Ops-Automation | 16 GB | MacBook Air M4, Mac mini M4 | Mit .claudeignore + Cloud für Schweres |
| Full-Stack / Backend / Data | 24 GB | MacBook Pro 14 M4, Mac mini M4 | Bestes Preis-Leistungs-Verhältnis |
| iOS / macOS Solo-Entwickler | 24–36 GB | MacBook Pro 14 M4 Pro | Simulator dauerhaft: 36 GB+ |
| Tech Lead / Monorepo-Wartung | 48–64 GB | MacBook Pro 16 M4 Pro/Max, Mac mini Custom | Parallele Subagents Pflicht |
| Windows als Hauptrechner | Cloud 24 GB+ | Nuvcloud Mac mini | Kein zweiter Laptop nötig |
11. Häufige Fragen
| Frage | Antwort |
|---|---|
| Frisst Claude Code mehr RAM als Cursor? | Terminal schlanker; Agent startet aber eher Shell-Befehle → größere lokale Nebenwirkungen. Siehe IDE-Schichten-Artikel. |
| Beeinflusst RAM die Token-Rechnung? | Indirekt: Swap → Timeout → Retry → mehr Runden. Langsamer Rechner = höhere Rechnung. |
| Kann Unified Memory der GPU „mitgeben“? | Ja, Claude Code nutzt kaum lokale GPU. Unified Memory heißt: CPU- und I/O-lastige Tasks teilen einen Pool — Reserve lassen. |
| RAM später aufrüsten? | Nein. Apple Silicon ist verlötet — beim Kauf richtig wählen. |
| Linux-Desktop + Claude Code? | Unterstützt. Ebenfalls ab 24 GB empfohlen; ohne macOS-Toolchain oft günstiger. |
| Wann upgraden oder auslagern? | Beim Agent-Job memory_pressure — bei „warn“ oder steigendem Swap: mehr RAM oder Cloud. |
12. Fazit
Claude Code macht aus „Code schreiben“ „lokale Umgebung dirigieren“ — RAM-Wahl heißt: wie viele Prozesse startet der Agent parallel für Sie. Unsere Messungen:
- 16 GB: Leichtes Terminal reicht; IDE + volle Tests + Agent zusammen → Swap und Einbruch
- 24 GB: Sweet Spot 2026 für die meisten, ~80 % der Claude-Code-Workflows
- 64 GB: „Weniger Ärger-Steuer“ für parallele Agents, Xcode-Matrix, Docker-Schwere — gesparte Wartezeit, nicht Prestige
RAM ist verlötet — lieber eine CPU-Stufe sparen und RAM treffen. Bei knappem Budget oft lokal 24 GB + Cloud mit viel RAM besser als 16 GB durchpressen: ein Agent-Neustart kostet Zeit und Tokens für mehrere Cloud-Tage.