← Zurück zum Tech-Blog

Claude Code optimale PC-Konfiguration:
16GB vs 24GB vs 64GB RAM im Test

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.

In einem Satz: Beim Rechner für Claude Code geht es nicht um „Modell lauffähig“, sondern um „kein Ruckeln, wenn der Agent zugreift“.

2. Testumgebung und Methodik

PunktSpezifikation
HardwareMac mini M4 (drei Geräte, 16 / 24 / 64 GB RAM, je 512 GB SSD)
SystemmacOS 15.5, iCloud-Desktop-Sync aus, Energiesparmodus einheitlich aus
Claude CodeVersion 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)
MessungJe Szenario 3 Läufe, Median; memory_pressure + Aktivitätsanzeige für Peak und Swap
ZeitWall-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:

ZustandResidentPeak
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

  1. Nur eine „schwere“ App gleichzeitig: Beim Agent-Test Cursor-Fenster mit TS-LSP schließen
  2. .claudeignore setzen, weniger sinnloses Indexieren (wie in der Rechnungsanalyse — spart auch RAM)
  3. Nach Subtasks sofort /clear, damit der Kontext-Snowball keinen Extra-Puffer frisst
  4. xcodebuild, Docker, lange CI-Läufe an Cloud-Mac; lokal nur Editieren und leichte Checks
Speicherdruck schnell prüfen (Terminal)
# 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)
Empfehlung: Full-Stack / Backend / DevOps: 24 GB ist das Minimum ohne Workarounds. iOS-Entwickler mit lokalem Build als Hauptweg: direkt 64 GB oder Hybrid-Cloud.

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

SignalWarum 64 GB
Oft 2+ iOS-Simulatoren für UI-TestsEin Simulator ~3–5 GB, Xcode selbst ~4–6 GB
Parallele Subagents mit Claude CodeJede 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 gleichzeitigKein 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

KomponenteEinfluss auf Claude CodeEmpfehlung
SSDAgent liest viele Dateien; bei Swap entscheidet Disk-Geschwindigkeit über RuckelnAb 512 GB, 1 TB entspannter; langsames externes Laufwerk für Repos vermeiden
ChipLokale Builds, nicht Modell-InferenzM4 reicht; M4 Pro schneller bei Multi-Core-Builds, siehe MacBook-Pro-Kaufberatung
NetzwerkStreaming, großer Kontext-Upload; Offline bricht Agent abStabiles Kabel oder 5-GHz-WLAN; Hotspot bei langen Jobs meiden
KühlungLange Builds + Sommerhitze → DauerleistungStänder fürs Notebook; 7×24 eher Mac mini / Cloud
DisplayKein direkter RAM-Effekt, aber Dual-Screen = mehr IDE-Fenster residentExternes Display → mehr RAM-Reserve einplanen

9. Hybrid: Lokaler Mac + Cloud-Mac

Nicht jedes Notebook muss auf 64 GB. Häufiger 2026-Ansatz:

  1. Lokal 16–24 GB: Claude Code editieren, Review, leichte Tests
  2. Cloud Mac mini M4 (24–64 GB): xcodebuild, nächtliche CI, parallele Subagents
  3. 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 ProfilEmpfohlenes RAMTypische HardwareHinweis
Studium / Skripte / Ops-Automation16 GBMacBook Air M4, Mac mini M4Mit .claudeignore + Cloud für Schweres
Full-Stack / Backend / Data24 GBMacBook Pro 14 M4, Mac mini M4Bestes Preis-Leistungs-Verhältnis
iOS / macOS Solo-Entwickler24–36 GBMacBook Pro 14 M4 ProSimulator dauerhaft: 36 GB+
Tech Lead / Monorepo-Wartung48–64 GBMacBook Pro 16 M4 Pro/Max, Mac mini CustomParallele Subagents Pflicht
Windows als HauptrechnerCloud 24 GB+Nuvcloud Mac miniKein zweiter Laptop nötig

11. Häufige Fragen

FrageAntwort
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.

Tarife →