Was macht Continuous Learning v2.1 - Instinktbasierte Architektur?
Ein fortschrittliches Lernsystem, das deine Claude Code-Sitzungen durch atomare "Instinkte" in wiederverwendbares Wissen verwandelt – kleine erlernte Verhaltensweisen mit Konfidenz-Scoring.
v2.1 fügt projektbezogene Instinkte hinzu – React-Patterns bleiben in deinem React-Projekt, Python-Konventionen bleiben in deinem Python-Projekt, und universelle Patterns (wie "Eingaben immer validieren") werden global geteilt.
Wann aktivieren
- Einrichten des automatischen Lernens aus Claude Code-Sitzungen
- Konfigurieren der instinktbasierten Verhaltensextraktion via Hooks
- Anpassen der Konfidenzschwellen für erlernte Verhaltensweisen
- Überprüfen, Exportieren oder Importieren von Instinkt-Bibliotheken
- Instinkte zu vollständigen Skills, Befehlen oder Agents weiterentwickeln
- Verwalten von projektbezogenen vs. globalen Instinkten
- Instinkte vom Projekt in den globalen Bereich verschieben
Neu in v2.1
| Funktion | v2.0 | v2.1 |
|---|---|---|
| Speicher | Global (~/.claude/homunculus/) | Projektbezogen (${XDG_DATA_HOME:-~/.local/share}/ecc-homunculus/projects/<hash>/) |
| Bereich | Alle Instinkte überall anwendbar | Projektbezogen + global |
| Erkennung | Keine | Git-Remote-URL / Repo-Pfad |
| Promotion | Nicht vorhanden | Projekt → global, wenn in 2+ Projekten gesehen |
| Befehle | 4 (status/evolve/export/import) | 6 (+promote/projects) |
| Projektübergreifend | Kontaminationsrisiko | Standardmäßig isoliert |
Neu in v2 (vs. v1)
| Funktion | v1 | v2 |
|---|---|---|
| Beobachtung | Stop-Hook (Sitzungsende) | PreToolUse/PostToolUse (100% zuverlässig) |
| Analyse | Hauptkontext | Hintergrund-Agent (Haiku) |
| Granularität | Vollständige Skills | Atomare "Instinkte" |
| Konfidenz | Keine | 0,3-0,9 gewichtet |
| Evolution | Direkt zu Skills | Instinkte -> Cluster -> Skill/Befehl/Agent |
| Teilen | Keine | Instinkte exportieren/importieren |
Das Instinkt-Modell
Ein Instinkt ist ein kleines erlerntes Verhalten:
---
id: prefer-functional-style
trigger: "when writing new functions"
confidence: 0.7
domain: "code-style"
source: "session-observation"
scope: project
project_id: "a1b2c3d4e5f6"
project_name: "my-react-app"
---
# Bevorzuge funktionalen Stil
## Aktion
Verwende funktionale Patterns anstelle von Klassen, wenn angemessen.
## Nachweise
- Es wurden 5 Instanzen der Präferenz für funktionale Patterns beobachtet
- Benutzer korrigierte klassenbasierten Ansatz zu funktional am 15.01.2025
Eigenschaften:
- Atomar – ein Auslöser, eine Aktion
- Konfidenz-gewichtet – 0,3 = vorläufig, 0,9 = nahezu sicher
- Domänen-getaggt – code-style, testing, git, debugging, workflow, etc.
- Nachweisgestützt – verfolgt, welche Beobachtungen es erstellt haben
- Bereichsbewusst –
project(Standard) oderglobal
Wie es funktioniert
Sitzungsaktivität (in einem Git-Repo)
|
| Hooks erfassen Eingabeaufforderungen + Tool-Nutzung (100% zuverlässig)
| + erkennen Projektkontext (Git-Remote / Repo-Pfad)
v
+---------------------------------------------+
| projects/<project-hash>/observations.jsonl |
| (Eingabeauff., Tool-Aufrufe, Ergebnisse, Projekt)|
+---------------------------------------------+
|
| Observer liest (Hintergrund, Haiku)
v
+---------------------------------------------+
| MUSTERERKENNUNG |
| * Benutzerkorrekturen -> Instinkt |
| * Fehlerbehebungen -> Instinkt |
| * Wiederholte Arbeitsabläufe -> Instinkt |
| * Bereichsentscheidung: Projekt oder global? |
+---------------------------------------------+
|
| Erstellt/aktualisiert
v
+---------------------------------------------+
| projects/<project-hash>/instincts/personal/ |
| * prefer-functional.yaml (0,7) [Projekt] |
| * use-react-hooks.yaml (0,9) [Projekt] |
+---------------------------------------------+
| instincts/personal/ (GLOBAL) |
| * always-validate-input.yaml (0,85) [global]|
| * grep-before-edit.yaml (0,6) [global] |
+---------------------------------------------+
|
| /evolve-Cluster + /promote
v
+---------------------------------------------+
| projects/<hash>/evolved/ (projektbezogen) |
| evolved/ (global) |
| * commands/new-feature.md |
| * skills/testing-workflow.md |
| * agents/refactor-specialist.md |
+---------------------------------------------+
Projekterkennung
Das System erkennt automatisch dein aktuelles Projekt:
- Umgebungsvariable
CLAUDE_PROJECT_DIR(höchste Priorität) – wird als explizite Überschreibung gewürdigt, auch wenn das Verzeichnis kein Git-Repo ist (gehasht über den absoluten Pfad) git remote get-url origin– gehasht, um eine portable Projekt-ID zu erstellen (selbes Repo auf verschiedenen Rechnern erhält dieselbe ID)git rev-parse --show-toplevel– Fallback über den Repo-Pfad (rechnerspezifisch)- Globaler Fallback – wenn kein Projekt erkannt wird, gehen Instinkte in den globalen Bereich
Jedes Projekt erhält eine 12-stellige Hash-ID (z.B. a1b2c3d4e5f6). Eine Registry-Datei unter ${XDG_DATA_HOME:-~/.local/share}/ecc-homunculus/projects.json ordnet IDs lesbaren Namen zu.
Datenverzeichnis
Continuous-learning-v2 speichert Beobachterdaten außerhalb von ~/.claude, damit Claude Code's "Sensitive-Path"-Schutz das Schreiben von Hintergrundinstinkten nicht blockiert:
CLV2_HOMUNCULUS_DIRwenn auf einen absoluten Pfad gesetzt$XDG_DATA_HOME/ecc-homunculus$HOME/.local/share/ecc-homunculus
Bestehende Benutzer mit Daten unter ~/.claude/homunculus können einmalig migrieren:
bash skills/continuous-learning-v2/scripts/migrate-homunculus.sh
Schnellstart
1. Beobachtungs-Hooks aktivieren
Wenn als Plugin installiert (empfohlen):
Es ist kein zusätzlicher settings.json-Hook-Block erforderlich. Claude Code v2.1+ lädt das Plugin hooks/hooks.json automatisch, und observe.sh ist dort bereits registriert.
Wenn du zuvor observe.sh in ~/.claude/settings.json kopiert hast, entferne diesen doppelten PreToolUse/PostToolUse-Block. Das Duplizieren des Plugin-Hooks führt zur doppelten Ausführung und zu ${CLAUDE_PLUGIN_ROOT}-Auflösungsfehlern, da diese Variable nur innerhalb von Plugin-verwalteten hooks/hooks.json-Einträgen verfügbar ist.
Wenn manuell in ~/.claude/skills installiert, füge dies zu deiner ~/.claude/settings.json hinzu:
{
"hooks": {
"PreToolUse": [{
"matcher": "*",
"hooks": [{
"type": "command",
"command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh"
}]
}],
"PostToolUse": [{
"matcher": "*",
"hooks": [{
"type": "command",
"command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh"
}]
}]
}
}
2. Verzeichnisstruktur initialisieren
Das System erstellt Verzeichnisse automatisch bei der ersten Nutzung, du kannst sie aber auch manuell anlegen:
# Globale Verzeichnisse
mkdir -p "${XDG_DATA_HOME:-$HOME/.local/share}/ecc-homunculus"/{instincts/{personal,inherited},evolved/{agents,skills,commands},projects}
# Projektverzeichnisse werden automatisch erstellt, wenn der Hook zum ersten Mal in einem Git-Repo ausgeführt wird
3. Instinkt-Befehle verwenden
/instinct-status # Zeige gelernte Instinkte (Projekt + global)
/evolve # Gruppiere verwandte Instinkte zu Skills/Befehlen
/instinct-export # Exportiere Instinkte in eine Datei
/instinct-import # Importiere Instinkte von anderen
/promote # Verschiebe Projekt-Instinkte in den globalen Bereich
/projects # Liste alle bekannten Projekte und deren Instinkt-Anzahl auf
Befehle
| Befehl | Beschreibung |
|---|---|
/instinct-status | Zeige alle Instinkte (projektbezogen + global) mit Konfidenz |
/evolve | Gruppiere verwandte Instinkte zu Skills/Befehlen, schlage Promotionen vor |
/instinct-export | Exportiere Instinkte (filterbar nach Bereich/Domäne) |
/instinct-import <datei> | Importiere Instinkte mit Bereichskontrolle |
/promote [id] | Verschiebe Projekt-Instinkte in den globalen Bereich |
/projects | Liste alle bekannten Projekte und deren Instinkt-Anzahl auf |
Konfiguration
Bearbeite config.json, um den Hintergrund-Beobachter zu steuern:
{
"version": "2.1",
"observer": {
"enabled": false,
"run_interval_minutes": 5,
"min_observations_to_analyze": 20
}
}
| Schlüssel | Standard | Beschreibung |
|---|---|---|
observer.enabled | false | Aktiviere den Hintergrund-Beobachter-Agenten |
observer.run_interval_minutes | 5 | Wie oft der Beobachter Beobachtungen analysiert |
observer.min_observations_to_analyze | 20 | Mindestanzahl Beobachtungen vor Analysebeginn |
Andere Verhaltensweisen (Beobachtungserfassung, Instinktschwellen, Projektbereich, Promotionskriterien) werden über Code-Standards in instinct-cli.py und observe.sh konfiguriert.
Plattformunterstützung des Beobachters
Der Hintergrund-Beobachter benötigt WSL2, Linux oder macOS. Auf nativen Windows (Git Bash / MSYS2) startet er und meldet Erfolg, aber der Prozess wird beendet, wenn der auslösende Hook beendet wird und sein Job-Objekt geschlossen wird, sodass nie eine Analyse ausgeführt wird – observer.enabled: true ist dort effektiv ein No-Op (siehe Issue #2489).
observe.sh erkennt dies beim folgenden Hook-Aufruf und schreibt eine erklärende Warnung in observer-start.log, sobald der Beobachter mehrmals hintereinander nicht überlebt hat.
| Umgebungsvariable | Standard | Beschreibung |
|---|---|---|
ECC_OBSERVER_NOSURVIVE_WARN_AFTER | 3 | Aufeinanderfolgende Nicht-Überlebensfälle, bevor die Warnung protokolliert wird |
Dateistruktur
${XDG_DATA_HOME:-~/.local/share}/ecc-homunculus/
+-- identity.json # Dein Profil, technisches Niveau
+-- projects.json # Registry: Projekt-Hash -> Name/Pfad/Remote
+-- observations.jsonl # Globale Beobachtungen (Fallback)
+-- instincts/
| +-- personal/ # Global automatisch gelernte Instinkte
| +-- inherited/ # Global importierte Instinkte
+-- evolved/
| +-- agents/ # Global generierte Agents
| +-- skills/ # Global generierte Skills
| +-- commands/ # Global generierte Befehle
+-- projects/
+-- a1b2c3d4e5f6/ # Projekt-Hash (aus Git-Remote-URL)
| +-- project.json # Projekt-Metadaten-Spiegel (id/name/root/remote)
| +-- observations.jsonl
| +-- observations.archive/
| +-- instincts/
| | +-- personal/ # Projektspezifisch automatisch gelernt
| | +-- inherited/ # Projektspezifisch importiert
| +-- evolved/
| +-- skills/
| +-- commands/
| +-- agents/
+-- f6e5d4c3b2a1/ # Ein weiteres Projekt
+-- ...
Bereichsentscheidungs-Leitfaden
| Pattern-Typ | Bereich | Beispiele |
|---|---|---|
| Sprach-/Framework-Konventionen | Projekt | "React Hooks verwenden", "Django REST-Patterns befolgen" |
| Dateistruktur-Präferenzen | Projekt | "Tests in __tests__/", "Komponenten in src/components/" |
| Code-Stil | Projekt | "Funktionalen Stil verwenden", "Dataclasses bevorzugen" |
| Fehlerbehandlungsstrategien | Projekt | "Result-Typ für Fehler verwenden" |
| Sicherheitspraktiken | global | "Benutzereingaben validieren", "SQL bereinigen" |
| Allgemeine Best Practices | global | "Tests zuerst schreiben", "Fehler immer behandeln" |
| Tool-Workflow-Präferenzen | global | "Vor dem Bearbeiten grep", "Vor dem Schreiben lesen" |
| Git-Praktiken | global | "Konventionelle Commits", "Kleine fokussierte Commits" |
Instinkt-Promotion (Projekt -> Global)
Wenn derselbe Instinkt in mehreren Projekten mit hoher Konfidenz auftritt, ist er ein Kandidat für die Promotion in den globalen Bereich.
Auto-Promotionskriterien:
- Dieselbe Instinkt-ID in 2+ Projekten
- Durchschnittliche Konfidenz >= 0,8
So förderst du einen Instinkt:
# Einen bestimmten Instinkt fördern
python3 instinct-cli.py promote prefer-explicit-errors
# Alle qualifizierenden Instinkte automatisch fördern
python3 instinct-cli.py promote
# Vorschau ohne Änderungen
python3 instinct-cli.py promote --dry-run
Der Befehl /evolve schlägt ebenfalls Promotionskandidaten vor.
Konfidenz-Scoring
Die Konfidenz entwickelt sich im Laufe der Zeit:
| Punktzahl | Bedeutung | Verhalten |
|---|---|---|
| 0.3 | Vorläufig | Vorgeschlagen, aber nicht erzwungen |
| 0.5 | Mittel | Angewandt, wenn relevant |
| 0.7 | Stark | Automatisch für Anwendung genehmigt |
| 0.9 | Nahezu sicher | Kernverhalten |
Konfidenz steigt, wenn:
- Pattern wiederholt beobachtet wird
- Benutzer das vorgeschlagene Verhalten nicht korrigiert
- Ähnliche Instinkte aus anderen Quellen zustimmen
Konfidenz sinkt, wenn:
- Benutzer das Verhalten explizit korrigiert
- Pattern über längere Zeiträume nicht beobachtet wird
- Widersprüchliche Nachweise erscheinen
Warum Hooks vs. Skills für die Beobachtung?
"v1 verließ sich auf Skills zur Beobachtung. Skills sind probabilistisch – sie feuern ~50-80% der Zeit basierend auf Claude's Urteil."
Hooks feuern 100% der Zeit, deterministisch. Das bedeutet:
- Jeder Tool-Aufruf wird beobachtet
- Es werden keine Patterns verpasst
- Das Lernen ist umfassend
Abwärtskompatibilität
v2.1 ist vollständig kompatibel mit v2.0 und v1:
- Bestehende globale Instinkte können mit
scripts/migrate-homunculus.shvon~/.claude/homunculus/instincts/migriert werden - Bestehende v1-Skills aus
~/.claude/skills/learned/funktionieren weiterhin - Stop-Hook läuft noch (speist aber jetzt auch in v2 ein)
- Schrittweise Migration: beide parallel ausführen
Datenschutz
- Beobachtungen bleiben lokal auf deinem Rechner
- Projektbezogene Instinkte sind pro Projekt isoliert
- Nur Instinkte (Patterns) können exportiert werden – nicht rohe Beobachtungen
- Es werden keine tatsächlichen Code- oder Gesprächsinhalte geteilt
- Du kontrollierst, was exportiert und promoviert wird
Verwandtes
- ECC-Tools GitHub App - Generiere Instinkte aus der Repo-Historie
- Homunculus - Community-Projekt, das die v2-Instinkt-basierte Architektur inspirierte (atomare Beobachtungen, Konfidenz-Scoring, Instinkt-Evolutionspipeline)
- Der Longform-Leitfaden - Abschnitt "Kontinuierliches Lernen"
Instinktbasiertes Lernen: Claude deine Patterns beibringen, ein Projekt nach dem anderen.