Mache aus Claude Code einen persoenlichen KI-Assistenten — mit persistentem Gedaechtnis, eigenen Skills und strukturierten Workflows.
Dieses Starter Kit ist aus einem realen persoenlichen Orchestrator extrahiert, der taeglich fuer Engineering, Recherche und Wissensmanagement im Einsatz ist. Was du hier siehst, sind die grundlegenden Bausteine — die Architektur und Muster, die alles andere erst ermoeglichen. Obsidian und SQLite sind optionale Erweiterungen — das Kit funktioniert standalone mit reinen Markdown-Dateien.
Du verbringst jeden Montagmorgen 10 Minuten damit, dein Projekt neu zu erklaeren. Du baust den gleichen Zusammenfassungs-Workflow zum dritten Mal, weil die Session von letzter Woche weg ist. Du hast 5 Tabs offen, und Claude weiss von keinem. Deine Qualitaet schwankt, weil es keine Feedback-Schleife gibt — nur Single-Pass-Generierung und Hoffen.
Dieses Kit aendert das.
Du Claude (mit Orchestrator)
───────────────────────────── ──────────────────────────────────
"Fasse diesen Artikel zusammen" → Phase: Klaeren
Ruft distill Skill auf
Liefert strukturierte Zusammenfassung
Naechster Schritt: /express
"Ist diese Analyse solide?" → Phase: Fertig machen
Ruft signal-check Skill auf
Evaluiert ueber 4 Achsen
Naechster Schritt: /express zum Verbessern
"Was kann an dem Plan schiefgehen?" → Phase: Fertig machen
Ruft challenge Skill auf
Stress-Test aus 3 Perspektiven
Naechster Schritt: /express zum Haerten
"Ist diese Analyse korrekt?" → Phase: Fertig machen
Ruft quality-gate Skill auf
Triage → Deep Check (Stufe 2)
Verifiziert Claims, berechnet Quality-Score
Naechster Schritt: /express zum Ueberarbeiten
"Zustand sichern fuer naechstes Mal" → Ruft handoff Skill auf
Erfasst Entscheidungen + Kontext
Schreibt Projekt-State-Datei
Naechste Session knuepft nahtlos an
flowchart TB
subgraph INPUT ["🎯 Deine Nachricht"]
direction LR
msg["'Fasse diesen Artikel zusammen'"]
end
subgraph BRAIN ["🧠 CLAUDE.md — Das Orchestrator-Gehirn"]
direction TB
mode["Modus-Erkennung<br/><i>Kognitiver Zustand → Skill-Cluster</i>"]
route["Routing-Regeln<br/><i>Schluesselwort → Skill-Zuordnung</i>"]
patterns["User Patterns<br/><i>Gelernte Praeferenzen</i>"]
end
subgraph SKILLS ["⚡ Skills"]
direction LR
capture["📥 capture"]
distill["🔬 distill"]
express["✍️ express"]
analyze["🔍 analyze"]
signal["🎯 signal-check"]
challenge["⚔️ challenge"]
qgate["🛡️ quality-gate"]
handoff["💾 handoff"]
end
subgraph MEMORY ["💾 Drei-Schichten-Gedaechtnis"]
direction TB
short["Kurzzeit<br/><i>Context Window (1 Session)</i>"]
mid["Mittelzeit<br/><i>Routing-Log + Handoffs (Wochen)</i>"]
long["Langzeit<br/><i>CLAUDE.md + Memory-Dateien (Permanent)</i>"]
end
subgraph OUTPUT ["📤 Output"]
result["Strukturiertes Ergebnis<br/>+ naechster Schritt"]
end
INPUT --> BRAIN
BRAIN --> SKILLS
SKILLS --> MEMORY
MEMORY --> SKILLS
SKILLS --> OUTPUT
style INPUT stroke:#e94560
style BRAIN stroke:#0f3460
style SKILLS stroke:#16213e
style MEMORY stroke:#533483
style OUTPUT stroke:#e94560
Jede Aufgabe durchlaeuft drei Phasen — keine ueberspringen:
Klaeren Machen Fertig machen
───────────────── ───────────────── ─────────────────
Was ist das Problem? Output produzieren Ist es gut genug?
analyze express signal-check
distill capture quality-gate
challenge
Das verhindert zielloses Skill-Chaining. Jeder Skill gehoert zu einer Phase, und jede Phase hat eine klare Frage, die beantwortet werden muss.
| Schicht | Was | Wo | Lebensdauer | |
|---|---|---|---|---|
| 1 | Kurzzeit | Aktuelle Konversation | Context Window | 1 Session |
| 2 | Mittelzeit | Vergangene Sessions, Routing-Log | orchestrator/routing-log.jsonl, Projekt-States |
Wochen bis Monate |
| 3 | Langzeit | Regeln, Praeferenzen, Wissen | CLAUDE.md, memory/, Obsidian |
Permanent |
┌─────────────────────────────────────────────────────┐
│ ░░░░░░░░ KURZZEIT (Context Window) ░░░░░░░░░░░░ │
│ Aktuelle Konversation, temporaere Ergebnisse │
│ ⏱ Lebensdauer: 1 Session │
├─────────────────────────────────────────────────────┤
│ ▒▒▒▒▒▒▒ MITTELZEIT (State + Episodic) ▒▒▒▒▒▒▒▒ │
│ Vergangene Sessions, Routing-Entscheidungen │
│ ⏱ Lebensdauer: Wochen bis Monate │
├─────────────────────────────────────────────────────┤
│ ████████ LANGZEIT (CLAUDE.md + Wissen) ██████████ │
│ Routing-Regeln, Praeferenzen, Glossar, Kontext │
│ ⏱ Lebensdauer: Permanent │
└─────────────────────────────────────────────────────┘
Jeder Skill ist eine SKILL.md-Datei — Anweisungen, kein Code. Sie sagen Claude, wie es sich verhalten, welche Tools es nutzen und welchen Output es produzieren soll.
| Skill | Zweck | Du sagst... | |
|---|---|---|---|
| 📥 | capture | Schnelle Notizen | "Notiere das", "Idee festhalten" |
| 🔬 | distill | Zusammenfassen und verdichten | "Zusammenfassen", "Kernaussagen" |
| ✍️ | express | Ausgefeilten Output schreiben | "Schreibe", "Formuliere" |
| 🔍 | analyze | Tiefenanalyse mit strukturiertem Denken | "Analysiere", "Untersuche" |
| 🎯 | signal-check | Qualitaetspruefung / Faktencheck | "Ist das solide?", "Substanz-Check" |
| ⚔️ | challenge | Adversarischer Stress-Test | "Was kann schiefgehen?", "Stress-Test" |
| 🛡️ | quality-gate | Output-Qualitaetsorchestrierung | "Prüf das", "Ist das korrekt?" |
| 💾 | handoff | Session-Zustand fuer naechstes Mal sichern | "Zustand sichern", "Handoff" |
Diese 8 Skills bilden vier kraftvolle Feedback-Schleifen:
Evaluator-Optimizer-Schleife — Schreiben, evaluieren, verbessern:
flowchart LR
E["✍️ express<br/><i>Output generieren</i>"]
S["🎯 signal-check<br/><i>Qualitaet evaluieren</i>"]
E2["✍️ express<br/><i>Basierend auf Feedback optimieren</i>"]
E -->|"evaluieren"| S
S -->|"optimieren"| E2
style E stroke:#e94560
style S stroke:#0f3460
style E2 stroke:#e94560
Evaluator-Challenger-Schleife — Schreiben, Stress-Test, haerten:
flowchart LR
E["✍️ express<br/><i>Output generieren</i>"]
CH["⚔️ challenge<br/><i>Adversarischer Stress-Test</i>"]
E2["✍️ express<br/><i>Gegen Einwaende haerten</i>"]
E -->|"stress-testen"| CH
CH -->|"haerten"| E2
style E stroke:#e94560
style CH stroke:#e94560
style E2 stroke:#e94560
Evaluator-Gate-Optimizer-Schleife — Schreiben, mit Triage verifizieren, verbessern:
flowchart LR
E["✍️ express<br/><i>Output generieren</i>"]
QG["🛡️ quality-gate<br/><i>Triage + verifizieren</i>"]
E2["✍️ express<br/><i>Basierend auf Findings ueberarbeiten</i>"]
E -->|"verifizieren"| QG
QG -->|"ueberarbeiten"| E2
style E stroke:#e94560
style QG stroke:#0f3460
style E2 stroke:#e94560
Wissenszyklus — Erfassen, verarbeiten, ausgeben, pruefen:
flowchart LR
C["📥 capture"]
D["🔬 distill"]
X["✍️ express"]
S["🎯 signal-check"]
A["🔍 analyze"]
H["💾 handoff"]
C --> D --> X --> S
S -.->|"zurueck zu"| A
A -.-> H
H -.-> C
style C stroke:#533483
style D stroke:#533483
style X stroke:#e94560
style S stroke:#0f3460
style A stroke:#16213e
style H stroke:#16213e
Die CLAUDE.md-Datei enthaelt Routing-Regeln, die Schluesselwoerter auf Skills abbilden. Wenn du etwas sagst, prueft Claude auf passende Muster und ruft automatisch den richtigen Skill auf.
Du: "Fasse diesen Artikel zusammen"
│
▼
CLAUDE.md Routing-Tabelle
│ erkennt "zusammenfassen" → distill
▼
Ruft distill Skill auf
│
▼
Strukturierte Zusammenfassung → schlaegt vor: /express fuer Output
Das memory/-Verzeichnis bietet Langzeitspeicherung:
memory/
├── glossary.md — Fachbegriffe und Jargon
├── context/
│ └── company.md — Arbeitskontext (Rolle, Unternehmen, Tools)
├── people/ — Wichtige Kontakte und Stakeholder
├── projects/ — Aktive Projektdokumentation
├── decisions/ — Entscheidungslog mit Begruendung
└── workflows/ — Bewaehrte Workflows und Best Practices
Dauer: ~5 Minuten | Voraussetzungen: Claude Code + ein Terminal
# 1. Klonen
git clone https://github.com/janrummel/claude-orchestrator-starter.git
cd claude-orchestrator-starter
# 2. In deine Claude-Konfiguration kopieren
cp CLAUDE.md.example ~/.claude/CLAUDE.md
cp -r orchestrator/ ~/.claude/orchestrator/
cp -r memory/ ~/.claude/memory/
cp -r hooks/ ~/.claude/hooks/
# 3. Claude Code starten — fertig.
claudeClaude wird jetzt:
CLAUDE.mdbeim Start lesen und seine Rolle verstehen- Deine Anfragen weiterleiten an passende Skills
- Kontext merken ueber Sessions hinweg via Memory-Dateien
Wenn der Context voll wird, musst du kein neues Terminal mehr oeffnen. Die Hooks regeln das automatisch:
# claude-loop statt claude verwenden
claude-loop
# Wenn der Context knapp wird, sichert Claude den Zustand automatisch.
# Druecke J fuer eine neue Session — sie knuepft nahtlos an.Siehe hooks/README.md fuer die Einrichtung.
🟣 Obsidian-Integration
Verbinde deinen Obsidian-Vault als Claudes Wissensbasis. Skills wie capture schreiben hinein, analyze und express lesen daraus.
Siehe Obsidian-Einrichtung fuer die Anleitung.
🗃️ Wissensdatenbank (SQLite)
Fuer strukturierte Datenspeicherung (Recherche-Ergebnisse, importierte Datensaetze, Skill-Nutzungsstatistiken).
Siehe Knowledge DB Setup fuer die Anleitung.
Siehe den Skill Development Guide fuer eine ausfuehrliche Anleitung.
Die Kurzversion:
# 1. Skill-Verzeichnis erstellen
mkdir -p ~/.claude/orchestrator/skills/mein-skill
# 2. SKILL.md schreiben
cat > ~/.claude/orchestrator/skills/mein-skill/SKILL.md << 'EOF'
---
name: mein-skill
description: Was dieser Skill tut und wann er verwendet werden soll.
---
# Mein Skill
Anweisungen fuer Claude, wie dieser Skill auszufuehren ist.
## Workflow
1. Schritt eins
2. Schritt zwei
3. Schritt drei
EOF
# 3. Routing-Regeln in CLAUDE.md ergaenzen
# Schluesselwort → Skill-Zuordnung zur Routing-Tabelle hinzufuegenDie meisten nutzen Claude Code als zustandsloses Tool — maechtig, aber vergesslich. Jede Session ist ein leeres Blatt.
Dieses Starter Kit macht daraus einen zustandsbehafteten Assistenten, der mit dir waechst:
| Ohne Orchestrator | Mit Orchestrator | |
|---|---|---|
| Gedaechtnis | Vergisst alles nach jeder Session | Erinnert Entscheidungen, Kontext, Praeferenzen |
| Workflows | Du beschreibst die gleichen Schritte jedes Mal | Skills automatisieren deine gaengigen Muster |
| Qualitaet | Output-Qualitaet schwankt unberechenbar | Evaluator-Optimizer-Schleife erkennt Schwaechen |
| Wissen | Verstreut ueber Tools und Notizen | Zentralisiert in Memory-Dateien (+ optional Obsidian/SQLite) |
| Kontinuitaet | "Wo waren wir?" jeden Morgen | Handoff knuepft genau dort an, wo du aufgehoert hast |
Die Kernerkenntnis: Claude ist bereits intelligent. Was ihm fehlt, ist Struktur, Gedaechtnis und Gewohnheiten. Genau das liefert ein Orchestrator — nicht mehr Intelligenz, sondern bessere Infrastruktur drumherum.
Dieses Kit gibt dir die Architektur und Muster. Es ist bewusst fokussiert — 8 Skills, Drei-Phasen-Workflow, grundlegendes Gedaechtnis.
Von hier aus kannst du:
- Domainenspezifische Skills ergaenzen (Recherche, Strategie, Entscheidungsfindung)
- Obsidian verbinden als Langzeit-Wissensbasis (Einrichtung)
- SQLite-Datenbank ergaenzen fuer strukturierte Daten (Einrichtung)
- Workflow-Ketten bauen, die mehrere Skills fuer komplexe Aufgaben kombinieren
Das Ziel ist nicht, dir alles zu geben. Es ist, dir die Bausteine zu zeigen — damit du dein eigenes System darauf aufbauen kannst.
claude-orchestrator-starter/
│
├── CLAUDE.md.example ← Das Gehirn: Routing-Regeln + Gedaechtnis-Architektur
│
├── orchestrator/
│ ├── skills/
│ │ ├── capture/ ← 📥 Schnelles Erfassen
│ │ ├── distill/ ← 🔬 Zusammenfassen und verdichten
│ │ ├── express/ ← ✍️ Ausgefeilten Output schreiben
│ │ ├── analyze/ ← 🔍 Tiefe strukturierte Analyse
│ │ ├── signal-check/ ← 🎯 Qualitaets- und Substanz-Check
│ │ ├── challenge/ ← ⚔️ Adversarischer Stress-Test
│ │ ├── quality-gate/ ← 🛡️ Output-Qualitaetsorchestrierung
│ │ └── handoff/ ← 💾 Session-Zustand sichern
│ ├── routing-log.jsonl.example
│ ├── user-patterns.md.example
│ └── workflow-templates.md
│
├── memory/ ← Langzeit-Wissensbasis
│ ├── glossary.md.example
│ ├── context/company.md.example
│ ├── people/
│ ├── projects/
│ ├── decisions/
│ └── workflows/
│
├── hooks/ ← Session-Lifecycle-Hooks + Session-Verkettung
├── obsidian/ ← Obsidian-Vault-Integrationsanleitung
├── knowledge-db/ ← SQLite-Wissensdatenbank
└── docs/ ← Architektur, Anleitungen, FAQ
| Ressource | Beschreibung |
|---|---|
| Getting Started | Schritt-fuer-Schritt-Einrichtung |
| Architektur | Deep Dive ins Drei-Schichten-Modell |
| Skill Development | Eigene Skills erstellen |
| FAQ | Haeufige Fragen beantwortet |
| Obsidian-Einrichtung | Obsidian-Vault verbinden |
| Knowledge DB | SQLite-Datenbank einrichten |
MIT — nutzen, forken, zu deinem machen.
So sieht eine typische Session mit dem Orchestrator aus:
$ claude-loop
> Dein aktives Projekt ist EV-Ladeanalyse. Naechster Schritt: Datenquellen verifizieren. Weiter?
Du: "Ja, pruef ob der DOE-Datensatz noch aktuell ist"
Claude: Nutze analyze Skill...
→ Pruefe Knowledge DB: 3 Eintraege fuer DOE/Ladedaten gefunden
→ Letzter Stand: 2025-11-15. Luecke: 4 Monate.
→ Suche nach Updates...
Ergebnis: DOE AFDC Datensatz aktualisiert am 2026-02-28.
Deine lokalen Daten sind veraltet. Soll ich aktualisieren?
Du: "Ja, dann fasse zusammen was sich geaendert hat"
Claude: Phase: Machen → rufe distill Skill auf
→ 47 neue Stationen, 3 stillgelegt
→ Neuer Schnelllade-Korridor: I-80 Nevada-Abschnitt
→ Zusammenfassung gespeichert in memory/projects/ev-charging.md
Naechster Schritt: /signal-check um die Zahlen zu verifizieren?
Jede Antwort folgt dem Drei-Phasen-Workflow. Kontext bleibt ueber Sessions erhalten. Skills verketten sich automatisch.
- 100% lokal. Alle Memory-Dateien, Routing-Logs und Projekt-States liegen in
~/.claude/auf deinem Rechner. - Kein Cloud-Upload. Der Orchestrator ist reines Markdown — kein Server, keine Telemetrie, keine Analytics.
- Keine API-Keys noetig fuer das Kern-Kit. Nur Claude Code selbst braucht einen Anthropic-Account.
- Dir gehoert alles. Alle Dateien sind Plain Text. Exportieren, sichern oder loeschen jederzeit.
Optionale Erweiterungen (Obsidian, SQLite) laufen ebenfalls lokal.
Das ist eine bewusste Entscheidung, keine Einschraenkung. Der Orchestrator nutzt spezifische Claude Code Faehigkeiten:
- CLAUDE.md wird beim Start automatisch gelesen — kein Plugin oder Wrapper noetig
- Hooks (Context Monitor, Session Chaining) nutzen Claude Codes natives Hook-System
- Skills sind
SKILL.md-Dateien, die Claude Code ueber seinen Skill-Mechanismus laedt
Die Architektur-Muster (Drei-Phasen-Workflow, Memory-Schichten, Quality Loops) sind uebertragbar. Aber die Implementierung nutzt, was Claude Code einzigartig gut kann: Markdown als ausfuehrbare Anweisungen behandeln.
Beitraege willkommen! Siehe CONTRIBUTING.md.