← 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 →