Claude Code im Detail: Kernarchitektur eines führenden AI-Coding-Tools

Die meisten Artikel über Claude Code enden bei „CLI installieren, Diff posten“. In einem echten Team wird schnell klar: Die Kernarchitektur eines führenden AI-Coding-Tools ist nie nur der Agent-Prozess im Terminal — sondern wie Diff, Fact, Context und Workflow im Cloud Mac AI Stack Aufgaben teilen und den Kreislauf schließen.

Dieser Text ist die L6-Q02 Säulen-Karte (L6-Q02): Mit Claude Code als Einstieg zeichnen wir die Stack-Gesamtarchitektur, die Anbindungsreihenfolge der fünf Module und den geschlossenen Systemkreis. Für die operative Hauptlinie: L6-Q01 Komplett-Handbuch; für Permission-Schwellen: L3 Einführungsentscheidung — hier geht es nur um die Karte.

Claude Code selbst: die 10%-Einordnung (die restlichen 90 % sind der Stack)

Architektur · Claude Code Kern

Zuerst Claude Code für sich definieren, dann seine Ebene. Es ist ein Terminal-Coding-Agent, kein IDE-Plugin:

Einzelner Agent-Loop (kann iterieren)

  CLAUDE.md + Repo-Context lesen
           │
           ▼
  Planen (welche Dateien, welche Befehle)
           │
           ▼
  Ausführen (Write / Edit / Bash / optional MCP Tool)
           │
           ▼
  Validieren (Ihr test / lint)
           │
           └──► Ergebnis Diff (git-auditierbare Änderungen)

• Grenzen — CLAUDE.md und Permission-Policy legen fest, was angefasst werden darf; siehe Handbuch · Projektgrenzen
• Erweiterte Sinne — MCP bindet GitHub Issues, CodeGraph, APIs in Context ein; siehe MCP Triple Connect Hub
• Abgrenzung zu Cursor — Editor-Completion vs. Cross-File + Shell-Agent; siehe vs Cursor

Das ist nur L3. Die „Kernarchitektur“, der Organisationen vertrauen, ist die Stack-Gesamtkarte unten.

Cloud Mac AI Stack Gesamtkarte (Verantwortungsebenen)

Architektur · Site-Gesamtkarte

Das ist das einheitliche L0–L5-Modell dieser Site — bei jedem Fachartikel hierher zurückkehren. Wichtig: Das sind Verantwortungsebenen, keine Laufzeit-Aufrufreihenfolge.

Ergebnisse: Inference · Diff · Fact · Context · Workflow

                 ┌──────────────┐
                 │  OpenHands   │  L5 · Workflow (Ist die Anforderung durch?)
                 └──────┬───────┘
                        │
                 ┌──────▼───────┐
                 │     MCP      │  L4 · Context (Was sieht der Agent?)
                 └──────┬───────┘
                        │
                 ┌──────▼───────┐
                 │ Claude Code  │  L3 · Diff (Was hat sich geändert?) ← Einstieg
                 └──────┬───────┘
                        │
                 ┌──────▼───────┐
                 │    Ollama    │  L2 · Inference (optional · lokale private Rechenleistung)
                 └──────┬───────┘
                        │
                 ┌──────▼───────┐
                 │ GitHub Runner│  L1 · Fact (Vertraut die Organisation dem Ergebnis?)
                 └──────┬───────┘
                        │
                 ┌──────▼───────┐
                 │  Cloud Mac   │  L0 · Infrastruktur (24/7 macOS-Knoten)
                 └──────────────┘

L0 trägt die Rechenleistung, L1 trägt Fact — erst darüber kommen Diff, Context und Workflow. Wie stark Claude Code auch ist: ohne L1 bleibt Diff nur lokales Experimentieren.

Fünf Module (+ Basis): Rollen und Ergebnisse

Architektur · Modul-Referenz

Workflow (L5) und Fact (L1): OpenHands wiederholt während einer Aufgabe Context, produziert Diff und validiert mit Fact — nicht „erst nach Workflow kommt CI“. Siehe OpenHands · Ergebnis-Beziehungen.

Empfohlene Anbindungsreihenfolge: zuerst Fact, dann Diff

Architektur · Deployment-Pfad

Die übliche Hype-Reihenfolge: zuerst Claude Code → dann MCP → CI als Nachgedanke. Wir empfehlen diese Deployment-Sequenz (anders als die Ebenen im Strukturdiagramm):

 ① Cloud Mac (L0 Basis)
      │  Dauerhaftes macOS · SSH · Egress-IP
      ▼
 ② GitHub Runner (L1 · Fact)
      │  push → wiederholbares grün/rot · Workspace-Isolation
      ▼
 ③ Ollama (L2 · Inference, optional)
      │  lokale Embeddings / kleine Modelle · Speicher mit L1/L3 planen
      ▼
 ④ Claude Code (L3 · Diff)
      │  CLAUDE.md · Permissions · Pilot am ersten Tag
      ▼
 ⑤ MCP (L4 · Context)
      │  GitHub / CodeGraph / Fetch · Minimalrechte
      ▼
 ⑥ OpenHands (L5 · Workflow)
      │  mehrstufige Issues · Agent-Loop · schichtet auf L3
      ▼
 ⑦ Geschlossener Systemkreis
      Delegation → Diff → PR → Runner Fact → Review → Merge

1. ① L0 — Ohne 24/7-macOS-Knoten konkurrieren Runner und Agent um Laptop-RAM; siehe Kaufen oder mieten
2. ② L1 — Zuerst verlässliches Fact für die Organisation; Isolation: Ein Job, ein Workspace
3. ③ L2 — Optional; auf demselben Host wie Claude Code und Runner: paralleles Scheduling
4. ④–⑥ — AI-Schichten erst nach stabilem Fact; Handbuch: L6-Q01
5. ⑦ Kreislauf — nächster Abschnitt

Geschlossener Kreislauf: von der Claude-Code-Delegation bis zum grünen PR

Architektur · Kreislauf

Das letzte Stück der „Kernarchitektur“ ist wie Daten zurückfließen — der Agent darf nicht in einem isolierten Terminal leben:

Mensch in der Schleife · L3
  Entwickler ──delegiert──► Claude Code (+ MCP Context)
                        │
                        │  Diff (Commit)
                        ▼
                   Feature-Branch / PR
                        │
Maschinelle Abnahme · L1        ▼
              GitHub Runner (Fact)
                   xcodebuild / test / lint
                        │
                        ├── rot ──► Feedback an Agent (Diff ↔ Fact)
                        │
                        └── grün ──► menschliches Review ──► Merge

Optional · L5
  OpenHands räumt nachts Issue-Queue ──► gleicher PR + Runner-Kreislauf

Drei harte Bedingungen für einen funktionierenden Kreislauf: Runner und Agent-Umgebung isoliert, PR muss CI bestehen, Produktions-Secrets nicht in der Agent-Shell. Produktions-Checkliste: L6-Q01 · Produktionsreif.

Site-weiter Link-Hub: nach Ebene springen

Dieser Artikel ist die Kartenseite der Stack-Serie. Einstieg nach aktuellem Engpass:

FAQ

Was ist die Kernarchitektur von Claude Code? Terminal-Agent-Loop produziert Diff; produktionsreif braucht es zusätzlich CLAUDE.md, MCP Context und unabhängigen Runner-Fact.

Muss Ollama vor Claude Code installiert werden? Nein. L2 ist optional; das Diagramm zeigt Verantwortungsebenen, keine Aufrufreihenfolge.

Worin unterscheidet sich dies vom L6-Q01 Handbuch? Q01 ist die operative Hauptlinie (Installation→CI); Q02 ist die Stack-Gesamtkarte (dieser Artikel).

Kann OpenHands Claude Code ersetzen? Nein. L5 orchestriert Workflow; L3 liefert Diff im Pairing — schichtweise nutzen.

• L6-Q01 · Claude Code Komplett-Handbuch
• L1 · GitHub Runner Execution Engine
• L4 · MCP Triple Connect Hub