**Das Harness-native Operator-System für agentische Arbeit. Von einem Gewinner eines Anthropic-Hackathons.**
Nicht nur Konfigurationen. Ein vollständiges System: Skills, Instincts, Speicheroptimierung, Continuous Learning, Security-Scanning und research-first-Entwicklung. Produktionsreife Agents, Skills, Hooks, Rules, MCP-Konfigurationen und Legacy-Command-Shims, die über mehr als 10 Monate intensiver täglicher Nutzung beim Bau echter Produkte entstanden sind.
Funktioniert über **Claude Code**, **Codex**, **Cursor**, **OpenCode**, **Gemini**, **Zed**, **GitHub Copilot** und andere KI-Agent-Harnesses hinweg.
ECC v2.0.0-rc.1 ergänzt diese wiederverwendbare Schicht um die öffentliche Hermes-Operator-Story: Beginne mit dem [Hermes-Setup-Leitfaden](../../docs/HERMES-SETUP.md), prüfe anschließend die [rc.1-Release-Notes](../../docs/releases/2.0.0-rc.1/release-notes.md) und die [Cross-Harness-Architektur](../../docs/architecture/cross-harness.md).
<sub>**OSS bleibt kostenlos.** Dieses Repo ist für immer MIT-lizenziert. ECC Pro ist die gehostete GitHub App für private Repos. <a href="https://github.com/sponsors/affaan-m">Sponsoren</a> und <a href="https://ecc.tools/pricing">Pro-Abonnenten</a> finanzieren die Arbeit — deshalb liefert ein einzelner Maintainer wöchentlich über 7 Harnesses hinweg aus.</sub>
---
## Die Leitfäden
Dieses Repo enthält ausschließlich den rohen Code. Die Leitfäden erklären alles.
- **Dashboard-GUI** — Neue Tkinter-basierte Desktop-Anwendung (`ecc_dashboard.py` oder `npm run dashboard`) mit Umschalter für dunkles/helles Theme, Schriftanpassung und Projektlogo in Kopfzeile und Taskleiste.
- **Öffentliche Oberfläche mit dem Live-Repo synchronisiert** — Metadaten, Katalogzahlen, Plugin-Manifeste und Install-bezogene Dokumentation entsprechen jetzt der tatsächlichen OSS-Oberfläche: 60 Agents, 232 Skills und 75 Legacy-Command-Shims.
- **Erweiterung von Operator- und Outbound-Workflows** — `brand-voice`, `social-graph-ranker`, `connections-optimizer`, `customer-billing-ops`, `ecc-tools-cost-audit`, `google-workspace-ops`, `project-flow-ops` und `workspace-surface-audit` runden die Operator-Spur ab.
- **Medien- und Launch-Tooling** — `manim-video`, `remotion-video-creation` und verbesserte Social-Publishing-Oberflächen machen technische Erklärinhalte und Launch-Content zum Teil desselben Systems.
- **Wachstum der Framework- und Produktoberfläche** — `nestjs-patterns`, reichhaltigere Codex/OpenCode-Install-Oberflächen und erweitertes Cross-Harness-Packaging halten das Repo auch über Claude Code allein hinaus nutzbar.
- **ECC 2.0 Alpha ist im Tree** — der Rust-Control-Plane-Prototyp in `ecc2/` baut jetzt lokal und stellt die Befehle `dashboard`, `start`, `sessions`, `status`, `stop`, `resume` und `daemon` bereit. Er ist als Alpha nutzbar, aber noch kein allgemeines Release.
- **Operator-Status-Snapshots** — `ecc status --markdown --write status.md` verwandelt den lokalen State Store in eine portable Übergabe, die Bereitschaft, aktive Sessions, Skill-Run-Gesundheit, Install-Gesundheit, ausstehende Governance-Events und verknüpfte Arbeitselemente aus Linear/GitHub/Handovers abdeckt. Nutze `ecc work-items upsert ...` für manuelle Einträge, `ecc work-items sync-github --repo owner/repo` für den Queue-Status von PRs/Issues und `ecc status --exit-code`, um Automatisierung scheitern zu lassen, wenn die Bereitschaft Aufmerksamkeit erfordert.
- **Ökosystem-Härtung** — AgentShield, ECC-Tools-Kostenkontrollen, Arbeiten am Billing-Portal und Website-Refreshes werden weiterhin rund um das Kern-Plugin ausgeliefert, statt in separate Silos abzudriften.
- **Architektur für selektive Installation** — Manifest-gesteuerte Install-Pipeline mit `install-plan.js` und `install-apply.js` für gezielte Komponenteninstallation. Der State Store verfolgt, was installiert ist, und ermöglicht inkrementelle Updates.
- **6 neue Agents** — `typescript-reviewer`, `pytorch-build-resolver`, `java-build-resolver`, `java-reviewer`, `kotlin-reviewer`, `kotlin-build-resolver` erweitern die Sprachabdeckung auf 10 Sprachen.
- **Neue Skills** — `pytorch-patterns` für Deep-Learning-Workflows, `documentation-lookup` für API-Referenzrecherche, `bun-runtime` und `nextjs-turbopack` für moderne JS-Toolchains sowie 8 operative Domänen-Skills und `mcp-server-patterns`.
- **Session- & State-Infrastruktur** — SQLite-State-Store mit Query-CLI, Session-Adapter für strukturierte Aufzeichnung, Grundlage für Skill-Evolution für sich selbst verbessernde Skills.
- **Orchestrierungsüberarbeitung** — Harness-Audit-Scoring deterministisch gemacht, Orchestrierungsstatus und Launcher-Kompatibilität gehärtet, Verhinderung von Observer-Loops mit 5-Schichten-Schutz.
- **Observer-Zuverlässigkeit** — Fix für Memory-Explosion mit Throttling und Tail-Sampling, Fix für Sandbox-Zugriff, Lazy-Start-Logik und Re-Entrancy-Guard.
- **12 Sprach-Ökosysteme** — Neue Rules für Java, PHP, Perl, Kotlin/Android/KMP, C++ und Rust treten zu den bestehenden Rules für TypeScript, Python, Go und den common-Rules hinzu.
- **Community-Beiträge** — Koreanische und chinesische Übersetzungen, Optimierung des biome-Hooks, Skills zur Videoverarbeitung, operative Skills, PowerShell-Installer, Antigravity-IDE-Unterstützung.
- **CI-Härtung** — 19 Fixes für Testfehler, Durchsetzung der Katalogzahlen, Validierung des Install-Manifests und vollständige Test-Suite grün.
- **Harness-First-Release** — ECC ist nun ausdrücklich als Performance-System für Agent-Harnesses positioniert, nicht nur als Config-Paket.
- **Überarbeitung der Hook-Zuverlässigkeit** — SessionStart-Root-Fallback, Session-Zusammenfassungen in der Stop-Phase und skriptbasierte Hooks, die fragile Inline-Einzeiler ersetzen.
- **Hook-Laufzeitsteuerung** — `ECC_HOOK_PROFILE=minimal|standard|strict` und `ECC_DISABLED_HOOKS=...` für Laufzeit-Gating ohne Bearbeitung von Hook-Dateien.
- **Breitere Tool-Abdeckung** — Cursor-, Codex- und OpenCode-Unterstützung verschärft, sodass dasselbe Repo sauber über alle großen Harnesses hinweg ausgeliefert wird
- **992 interne Tests** — Erweiterte Validierung und Regressionsabdeckung über Plugin, Hooks, Skills und Packaging
- **AgentShield-Integration** — Der `/security-scan`-Skill führt AgentShield direkt aus Claude Code aus; 1282 Tests, 102 Rules
- **GitHub Marketplace** — ECC-Tools-GitHub-App live unter [github.com/marketplace/ecc-tools](https://github.com/marketplace/ecc-tools) mit Free-/Pro-/Enterprise-Stufen
- **30+ Community-PRs gemergt** — Beiträge von 30 Contributors über 6 Sprachen hinweg
- **978 interne Tests** — Erweiterte Validierungs-Suite über Agents, Skills, Commands, Hooks und Rules
### v1.4.1 — Bugfix (Februar 2026)
- **Inhaltsverlust beim Instinct-Import behoben** — `parse_instinct_file()` verwarf während `/instinct-import` stillschweigend sämtlichen Inhalt nach dem Frontmatter (Abschnitte Action, Evidence, Examples). ([#148](https://github.com/affaan-m/ECC/issues/148), [#161](https://github.com/affaan-m/ECC/pull/161))
- **Interaktiver Installationsassistent** — Der neue `configure-ecc`-Skill bietet ein geführtes Setup mit Merge-/Überschreiben-Erkennung
- **PM2 & Multi-Agent-Orchestrierung** — 6 neue Befehle (`/pm2`, `/multi-plan`, `/multi-execute`, `/multi-backend`, `/multi-frontend`, `/multi-workflow`) zur Verwaltung komplexer Multi-Service-Workflows
- **Architektur für mehrsprachige Rules** — Rules von Flat-Dateien in die Verzeichnisse `common/` + `typescript/` + `python/` + `golang/` umstrukturiert. Installiere nur die Sprachen, die du brauchst
- **Chinesische (zh-CN) Übersetzungen** — Vollständige Übersetzung aller Agents, Commands, Skills und Rules (80+ Dateien)
- **GitHub-Sponsors-Unterstützung** — Unterstütze das Projekt über GitHub Sponsors
- **Erweiterte CONTRIBUTING.md** — Detaillierte PR-Vorlagen für jeden Beitragstyp
- **Vollständige OpenCode-Integration** — 12 Agents, 24 Commands, 16 Skills mit Hook-Unterstützung über das Plugin-System von OpenCode (20+ Event-Typen)
Den vollständigen Changelog findest du unter [Releases](https://github.com/affaan-m/ECC/releases).
---
## Schnellstart
In unter 2 Minuten einsatzbereit:
### Wähle nur einen Pfad
Die meisten Claude-Code-Nutzer sollten genau einen Installationspfad verwenden:
- **Empfohlene Voreinstellung:** Installiere das Claude-Code-Plugin und kopiere dann nur die Rule-Ordner, die du tatsächlich willst.
- **Verwende den manuellen Installer nur dann, wenn** du feinere Kontrolle wünschst, den Plugin-Pfad ganz vermeiden willst oder dein Claude-Code-Build Probleme hat, den selbst gehosteten Marketplace-Eintrag aufzulösen.
Falls du bereits mehrere Installationen übereinandergelegt hast und Dinge doppelt aussehen, springe direkt zu [ECC zurücksetzen / deinstallieren](#ecc-zurücksetzen--deinstallieren).
### Low-Context-/No-Hooks-Pfad
Falls sich Hooks zu global anfühlen oder du nur ECCs Rules, Agents, Commands und Kern-Workflow-Skills willst, überspringe das Plugin und nutze das minimale manuelle Profil:
Dieses Profil schließt `hooks-runtime` absichtlich aus.
Falls du das normale core-Profil willst, aber Hooks deaktiviert brauchst, verwende:
```bash
./install.sh --profile core --without baseline:hooks --target claude
```
Füge Hooks später nur hinzu, wenn du Laufzeit-Durchsetzung willst:
```bash
./install.sh --target claude --modules hooks-runtime
```
### Finde zuerst die richtigen Komponenten
Falls du nicht sicher bist, welches ECC-Profil oder welche Komponente du installieren sollst, frage den mitgelieferten Advisor aus jedem beliebigen Projekt:
Er liefert passende Komponenten, verwandte Profile sowie Preview-/Install-Befehle zurück. Verwende den Preview-Befehl vor der Installation, falls du den exakten Dateiplan inspizieren willst.
Halte die Installation für produktive ML-/MLOps-Workflows opt-in und komponentenbezogen:
> NOTE: Das Plugin ist bequem, aber der OSS-Installer unten ist weiterhin der zuverlässigste Pfad, falls dein Claude-Code-Build Probleme hat, selbst gehostete Marketplace-Einträge aufzulösen.
Das ist beabsichtigt. Anthropic-Marketplace-/Plugin-Installationen werden über einen kanonischen Plugin-Bezeichner gekeyt, daher verwendet ECC `ecc@ecc`, um Tool-Namen und Slash-Command-Namespaces kurz genug für strenge Desktop-/API-Validatoren zu halten. Ältere Beiträge zeigen möglicherweise noch den früheren langen Marketplace-Bezeichner; behandle diesen lediglich als Legacy-Alias. Das npm-Paket blieb davon getrennt bei `ecc-universal`, daher verwenden npm-Installationen und Marketplace-Installationen absichtlich unterschiedliche Namen.
### Schritt 2: Rules nur installieren, wenn du sie brauchst
> WARNING: **Wichtig:** Claude-Code-Plugins können `rules` nicht automatisch verteilen.
> Falls du ECC bereits über `/plugin install` installiert hast, **führe danach nicht `./install.sh --profile full`, `.\install.ps1 --profile full` oder `npx ecc-universal install --profile full` aus**. Das Plugin lädt ECC-Skills, -Commands und -Hooks bereits. Wird der vollständige Installer nach einer Plugin-Installation ausgeführt, kopiert er dieselben Oberflächen in deine Benutzerverzeichnisse und kann doppelte Skills sowie doppeltes Laufzeitverhalten erzeugen.
> Kopiere für Plugin-Installationen manuell nur die `rules/`-Verzeichnisse, die du willst, nach `~/.claude/rules/ecc/`. Beginne mit `rules/common` plus einem Sprach- oder Framework-Paket, das du tatsächlich verwendest. Kopiere nicht jedes Rules-Verzeichnis, es sei denn, du willst diesen gesamten Kontext ausdrücklich in Claude haben.
>
> Verwende den vollständigen Installer nur dann, wenn du eine vollständig manuelle ECC-Installation statt des Plugin-Pfads durchführst.
>
> Falls dein lokales Claude-Setup gelöscht oder zurückgesetzt wurde, bedeutet das nicht, dass du ECC erneut kaufen musst. Beginne mit `node scripts/ecc.js list-installed`, führe dann `node scripts/ecc.js doctor` und `node scripts/ecc.js repair` aus, bevor du irgendetwas neu installierst. Das stellt ECC-verwaltete Dateien üblicherweise wieder her, ohne dein Setup neu aufzubauen. Falls das Problem im Konto- oder Marketplace-Zugriff für ECC Tools liegt, behandle die Konto-/Abrechnungswiederherstellung separat.
Anweisungen zur manuellen Installation findest du in der README im `rules/`-Ordner. Kopiere Rules manuell stets als ganzes Sprachverzeichnis (zum Beispiel `rules/common` oder `rules/golang`), nicht die darin enthaltenen Dateien, damit relative Verweise weiterhin funktionieren und Dateinamen nicht kollidieren.
### Vollständig manuelle Installation (Fallback)
Verwende dies nur, wenn du den Plugin-Pfad absichtlich überspringst:
Wenn du diesen Pfad wählst, höre dort auf. Führe nicht zusätzlich `/plugin install` aus.
### ECC zurücksetzen / deinstallieren
Falls sich ECC doppelt, aufdringlich oder kaputt anfühlt, installiere es nicht weiter über sich selbst.
- **Plugin-Pfad:** Entferne das Plugin aus Claude Code, lösche dann die konkreten Rule-Ordner, die du manuell unter `~/.claude/rules/ecc/` kopiert hast.
- **Manueller Installer / CLI-Pfad:** Sieh dir die Entfernung vom Repo-Root aus zuerst in der Vorschau an:
```bash
node scripts/uninstall.js --dry-run
```
Entferne anschließend ECC-verwaltete Dateien:
```bash
node scripts/uninstall.js
```
Du kannst auch den Lifecycle-Wrapper verwenden:
```bash
node scripts/ecc.js list-installed
node scripts/ecc.js doctor
node scripts/ecc.js repair
node scripts/ecc.js uninstall --dry-run
```
ECC entfernt nur Dateien, die in seinem Install-State erfasst sind. Es löscht keine fremden Dateien, die es nicht installiert hat.
Falls du Methoden gestapelt hast, räume in dieser Reihenfolge auf:
1. Entferne die Claude-Code-Plugin-Installation.
2. Führe den ECC-Uninstall-Befehl vom Repo-Root aus, um über den Install-State verwaltete Dateien zu entfernen.
3. Lösche alle zusätzlichen Rule-Ordner, die du manuell kopiert hast und nicht mehr willst.
4. Installiere einmal neu, über einen einzigen Pfad.
### Schritt 3: Loslegen
```bash
# Skills sind die primäre Workflow-Oberfläche.
# Bestehende Slash-artige Command-Namen funktionieren weiterhin, während ECC von commands/ wegmigriert.
# Die Plugin-Installation verwendet die kanonische Namespace-Form
/ecc:plan "Benutzerauthentifizierung hinzufügen"
# Die manuelle Installation behält die kürzere Slash-Form bei:
# /plan "Benutzerauthentifizierung hinzufügen"
# Verfügbare Commands prüfen
/plugin list ecc@ecc
```
**Das war's!** Du hast nun Zugriff auf 60 Agents, 232 Skills und 75 Legacy-Command-Shims.
### Dashboard-GUI
Starte das Desktop-Dashboard, um ECC-Komponenten visuell zu erkunden:
```bash
npm run dashboard
# oder
python3 ./ecc_dashboard.py
```
**Funktionen:**
- Oberfläche mit Reitern: Agents, Skills, Commands, Rules, Settings
> WARNING: `multi-*`-Befehle sind durch die obige Basis-Plugin-/Rules-Installation **nicht** abgedeckt.
>
> Um `/multi-plan`, `/multi-execute`, `/multi-backend`, `/multi-frontend` und `/multi-workflow` zu nutzen, musst du zusätzlich die `ccg-workflow`-Runtime installieren.
>
> Initialisiere sie mit `npx ccg-workflow`.
>
> Diese Runtime stellt die externen Abhängigkeiten bereit, die diese Befehle erwarten, darunter:
> - `~/.claude/bin/codeagent-wrapper`
> - `~/.claude/.ccg/prompts/*`
>
> Ohne `ccg-workflow` laufen diese `multi-*`-Befehle nicht korrekt.
---
## Cross-Platform-Unterstützung
Dieses Plugin unterstützt nun vollständig **Windows, macOS und Linux**, neben enger Integration über große IDEs (Cursor, Zed, OpenCode, Antigravity) und CLI-Harnesses hinweg. Alle Hooks und Skripte wurden für maximale Kompatibilität in Node.js neu geschrieben.
### Paketmanager-Erkennung
Das Plugin erkennt deinen bevorzugten Paketmanager (npm, pnpm, yarn oder bun) automatisch mit folgender Priorität:
# Oder löst automatisch bei einem Push auf den Default-Branch aus
```
Beide Optionen erzeugen:
- **SKILL.md-Dateien** - sofort einsatzbereite Skills für Claude Code
- **Instinct-Sammlungen** - für continuous-learning-v2
- **Musterextraktion** - lernt aus deiner Commit-Historie
### AgentShield — Security-Auditor
> Gebaut beim Claude Code Hackathon (Cerebral Valley x Anthropic, Februar 2026). 1282 Tests, 98 % Coverage, 102 statische Analyse-Rules.
Scanne deine Claude-Code-Konfiguration auf Schwachstellen, Fehlkonfigurationen und Injection-Risiken.
```bash
# Schneller Scan (keine Installation nötig)
npx ecc-agentshield scan
# Sichere Probleme automatisch beheben
npx ecc-agentshield scan --fix
# Tiefenanalyse mit drei Opus-4.6-Agents
npx ecc-agentshield scan --opus --stream
# Sichere Konfiguration von Grund auf generieren
npx ecc-agentshield init
```
**Was es scannt:** CLAUDE.md, settings.json, MCP-Konfigurationen, Hooks, Agent-Definitionen und Skills über 5 Kategorien — Secrets-Erkennung (14 Muster), Berechtigungs-Audit, Analyse von Hook-Injection, Risikoprofilierung von MCP-Servern und Review der Agent-Konfiguration.
**Das `--opus`-Flag** führt drei Claude-Opus-4.6-Agents in einer Red-Team-/Blue-Team-/Auditor-Pipeline aus. Der Angreifer findet Exploit-Ketten, der Verteidiger bewertet die Schutzmaßnahmen, und der Auditor synthetisiert beides zu einer priorisierten Risikobewertung. Adversariales Schlussfolgern, nicht nur Mustererkennung.
**Ausgabeformate:** Terminal (farblich nach A-F abgestuft), JSON (CI-Pipelines), Markdown, HTML. Exit-Code 2 bei kritischen Befunden für Build-Gates.
Verwende `/security-scan` in Claude Code, um es auszuführen, oder füge es per [GitHub Action](https://github.com/affaan-m/agentshield) zur CI hinzu.
Das Instinct-basierte Lernsystem lernt deine Muster automatisch:
```bash
/instinct-status # Gelernte Instincts mit Konfidenz anzeigen
/instinct-import <file> # Instincts von anderen importieren
/instinct-export # Eigene Instincts zum Teilen exportieren
/evolve # Verwandte Instincts zu Skills clustern
```
Die vollständige Dokumentation findest du unter `skills/continuous-learning-v2/`.
Behalte `continuous-learning/` nur dann, wenn du den Legacy-v1-Stop-Hook-Flow für gelernte Skills ausdrücklich willst.
---
## Voraussetzungen
### Version der Claude Code CLI
**Mindestversion: v2.1.0 oder neuer**
Dieses Plugin erfordert die Claude Code CLI v2.1.0+ aufgrund von Änderungen daran, wie das Plugin-System Hooks verarbeitet.
Prüfe deine Version:
```bash
claude --version
```
### Wichtig: Verhalten beim automatischen Laden von Hooks
> WARNING: **Für Contributors:** Füge KEIN `"hooks"`-Feld zu `.claude-plugin/plugin.json` hinzu. Das wird durch einen Regressionstest erzwungen.
Claude Code v2.1+ **lädt automatisch**`hooks/hooks.json` aus jedem installierten Plugin per Konvention. Es explizit in `plugin.json` zu deklarieren, verursacht einen Fehler durch Duplikaterkennung:
```
Duplicate hooks file detected: ./hooks/hooks.json resolves to already-loaded file
```
**Historie:** Dies hat in diesem Repo wiederholte Fix-/Revert-Zyklen verursacht ([#29](https://github.com/affaan-m/ECC/issues/29), [#52](https://github.com/affaan-m/ECC/issues/52), [#103](https://github.com/affaan-m/ECC/issues/103)). Das Verhalten änderte sich zwischen Claude-Code-Versionen, was zu Verwirrung führte. Wir haben jetzt einen Regressionstest, der verhindert, dass dies erneut eingeführt wird.
---
## Installation
### Option 1: Als Plugin installieren (empfohlen)
Der einfachste Weg, dieses Repo zu nutzen - als Claude-Code-Plugin installieren:
Oder füge es direkt zu deiner `~/.claude/settings.json` hinzu:
```json
{
"extraKnownMarketplaces":{
"ecc":{
"source":{
"source":"github",
"repo":"affaan-m/ECC"
}
}
},
"enabledPlugins":{
"ecc@ecc":true
}
}
```
Dies gibt dir sofortigen Zugriff auf alle Commands, Agents, Skills und Hooks.
> **Hinweis:** Das Claude-Code-Plugin-System unterstützt das Verteilen von `rules` über Plugins nicht ([Upstream-Einschränkung](https://code.claude.com/docs/en/plugins-reference)). Du musst Rules manuell installieren:
>
> ```bash
> # Zuerst das Repo klonen
> git clone https://github.com/affaan-m/ECC.git
> cd ECC
>
> # Option A: Rules auf Benutzerebene (gilt für alle Projekte)
# Optional: gepflegte Slash-Command-Kompatibilität während der Migration behalten
mkdir -p ~/.claude/commands
cp commands/*.md ~/.claude/commands/
# Ausgemusterte Shims liegen in legacy-command-shims/commands/.
# Kopiere einzelne Dateien von dort nur, wenn du alte Namen wie /tdd noch brauchst.
```
#### Hooks installieren
Kopiere die rohe Repo-Datei `hooks/hooks.json` nicht in `~/.claude/settings.json` oder `~/.claude/hooks/hooks.json`. Diese Datei ist plugin-/repo-orientiert und dafür gedacht, über den ECC-Installer installiert oder als Plugin geladen zu werden, daher ist rohes Kopieren kein unterstützter manueller Installationspfad.
Verwende den Installer, um nur die Claude-Hook-Runtime zu installieren, damit Command-Pfade korrekt umgeschrieben werden:
```bash
# macOS / Linux
bash ./install.sh --target claude --modules hooks-runtime
Das schreibt aufgelöste Hooks nach `~/.claude/hooks/hooks.json` und lässt eine bestehende `~/.claude/settings.json` unberührt.
Falls du ECC über `/plugin install` installiert hast, kopiere diese Hooks nicht in `settings.json`. Claude Code v2.1+ lädt Plugin-`hooks/hooks.json` bereits automatisch, und sie in `settings.json` zu duplizieren, verursacht doppelte Ausführung und Cross-Platform-Hook-Konflikte.
Windows-Hinweis: Das Claude-Konfigurationsverzeichnis ist `%USERPROFILE%\\.claude`, nicht `~/claude`.
#### MCPs konfigurieren
Claude-Plugin-Installationen aktivieren die mitgelieferten MCP-Server-Definitionen von ECC absichtlich nicht automatisch. Das vermeidet überlange Plugin-MCP-Tool-Namen auf strengen Drittanbieter-Gateways und hält gleichzeitig das manuelle MCP-Setup verfügbar.
Verwende den `/mcp`-Befehl von Claude Code oder das CLI-verwaltete MCP-Setup für Live-Änderungen an Claude-Code-Servern. Verwende `/mcp` für Laufzeit-Deaktivierungen in Claude Code; Claude Code speichert diese Entscheidungen in `~/.claude.json`.
Für repo-lokalen MCP-Zugriff kopiere die gewünschten MCP-Server-Definitionen aus `mcp-configs/mcp-servers.json` in eine projektbezogene `.mcp.json`.
Falls du bereits eigene Kopien der von ECC mitgelieferten MCPs betreibst, setze:
ECC-verwaltete Install- und Codex-Sync-Flows überspringen oder entfernen diese mitgelieferten Server, statt Duplikate erneut hinzuzufügen. `ECC_DISABLED_MCPS` ist ein ECC-Install-/Sync-Filter, kein Live-Toggle für Claude Code.
**Wichtig:** Ersetze die `YOUR_*_HERE`-Platzhalter durch deine tatsächlichen API-Keys.
---
## Kernkonzepte
### Agents
Subagents bearbeiten delegierte Aufgaben mit begrenztem Umfang. Beispiel:
```markdown
---
name:code-reviewer
description:Reviews code for quality, security, and maintainability
tools:["Read","Grep","Glob","Bash"]
model:opus
---
You are a senior code reviewer...
```
### Skills
Skills sind die primäre Workflow-Oberfläche. Sie können direkt aufgerufen, automatisch vorgeschlagen und von Agents wiederverwendet werden. ECC liefert während der Migration weiterhin gepflegte `commands/` aus, während ausgemusterte Kurznamen-Shims unter `legacy-command-shims/` nur zur ausdrücklichen Opt-in-Nutzung liegen. Neue Workflow-Entwicklung sollte zuerst in `skills/` landen.
```markdown
# TDD Workflow
1. Define interfaces first
2. Write failing tests (RED)
3. Implement minimal code (GREEN)
4. Refactor (IMPROVE)
5. Verify 80%+ coverage
```
### Hooks
Hooks feuern bei Tool-Events. Beispiel - Warnung vor console.log:
typescript/ # TS/JS-spezifische Patterns und Tools
python/ # Python-spezifische Patterns und Tools
golang/ # Go-spezifische Patterns und Tools
swift/ # Swift-spezifische Patterns und Tools
php/ # PHP-spezifische Patterns und Tools
arkts/ # HarmonyOS / ArkTS-Patterns und -Beschränkungen
```
Details zu Installation und Struktur findest du in [`rules/README.md`](../../rules/README.md).
---
## Welchen Agent sollte ich verwenden?
Nicht sicher, wo du anfangen sollst? Verwende diese Kurzreferenz. Skills sind die kanonische Workflow-Oberfläche; gepflegte Slash-Einträge bleiben für command-first-Workflows verfügbar.
| Ich möchte… | Diese Oberfläche verwenden | Verwendeter Agent |
Die Slash-Formen unten werden dort gezeigt, wo sie Teil der gepflegten Command-Oberfläche bleiben. Ausgemusterte Kurznamen-Shims wie `/tdd` und `/eval` liegen in `legacy-command-shims/` nur zur ausdrücklichen Opt-in-Nutzung.
<summary><b>Wie prüfe ich, welche Agents/Commands installiert sind?</b></summary>
```bash
/plugin list ecc@ecc
```
Dies zeigt alle verfügbaren Agents, Commands und Skills aus dem Plugin.
</details>
<details>
<summary><b>Meine Hooks funktionieren nicht / ich sehe den Fehler "Duplicate hooks file"</b></summary>
Das ist das häufigste Problem. **Füge KEIN `"hooks"`-Feld zu `.claude-plugin/plugin.json` hinzu.** Claude Code v2.1+ lädt `hooks/hooks.json` aus installierten Plugins automatisch. Es explizit zu deklarieren, verursacht Fehler durch Duplikaterkennung. Siehe [#29](https://github.com/affaan-m/ECC/issues/29), [#52](https://github.com/affaan-m/ECC/issues/52), [#103](https://github.com/affaan-m/ECC/issues/103).
</details>
<details>
<summary><b>Kann ich ECC mit Claude Code an einem benutzerdefinierten API-Endpoint oder Modell-Gateway verwenden?</b></summary>
Ja. ECC hat keine Anthropic-gehosteten Transporteinstellungen fest verdrahtet. Es läuft lokal über die normale CLI-/Plugin-Oberfläche von Claude Code, daher funktioniert es mit:
- Anthropic-gehostetem Claude Code
- Offiziellen Claude-Code-Gateway-Setups mit `ANTHROPIC_BASE_URL` und `ANTHROPIC_AUTH_TOKEN`
- Kompatiblen benutzerdefinierten Endpoints, die die von Claude Code erwartete Anthropic-API sprechen
Falls dein Gateway Modellnamen umbildet, konfiguriere das in Claude Code statt in ECC. ECCs Hooks, Skills, Commands und Rules sind modellanbieter-agnostisch, sobald die `claude`-CLI bereits funktioniert.
<summary><b>Mein Kontextfenster schrumpft / Claude geht der Kontext aus</b></summary>
Zu viele MCP-Server fressen deinen Kontext. Jede MCP-Tool-Beschreibung verbraucht Token aus deinem 200k-Fenster und reduziert es möglicherweise auf ~70k. Der SessionStart-Kontext ist standardmäßig auf 8000 Zeichen begrenzt; senke ihn mit `ECC_SESSION_START_MAX_CHARS=4000` oder deaktiviere ihn mit `ECC_SESSION_START_CONTEXT=off` für Setups mit lokalem Modell oder wenig Kontext.
**Lösung:** Deaktiviere ungenutzte MCPs aus Claude Code mit `/mcp`. Claude Code schreibt diese Laufzeitentscheidungen nach `~/.claude.json`; `.claude/settings.json` und `.claude/settings.local.json` sind keine zuverlässigen Toggles für bereits geladene MCP-Server.
Halte unter 10 MCPs aktiviert und unter 80 Tools aktiv.
</details>
<details>
<summary><b>Kann ich nur einige Komponenten verwenden (z. B. nur Agents)?</b></summary>
Ja. Verwende Option 2 (manuelle Installation) und kopiere nur, was du brauchst:
```bash
# Nur Agents
cp agents/*.md ~/.claude/agents/
# Nur Rules
mkdir -p ~/.claude/rules/ecc/
cp -r rules/common ~/.claude/rules/ecc/
```
Jede Komponente ist vollständig unabhängig.
</details>
<details>
<summary><b>Funktioniert das mit Cursor / OpenCode / Codex / Antigravity / GitHub Copilot?</b></summary>
Ja. ECC ist Cross-Platform:
- **Cursor**: Vorübersetzte Konfigurationen in `.cursor/`. Siehe [Cursor-IDE-Unterstützung](#cursor-ide-unterstützung).
- **Gemini CLI**: Experimentelle projektlokale Unterstützung über `.gemini/GEMINI.md` und gemeinsam genutzte Installer-Verdrahtung.
- **OpenCode**: Vollständige Plugin-Unterstützung in `.opencode/`. Siehe [OpenCode-Unterstützung](#opencode-unterstützung).
- **Codex**: Erstklassige Unterstützung sowohl für die macOS-App als auch die CLI, mit Adapter-Drift-Guards und SessionStart-Fallback. Siehe PR [#257](https://github.com/affaan-m/ECC/pull/257).
- **GitHub Copilot (VS Code)**: Instruction- und Prompt-Schicht über `.github/copilot-instructions.md`, `.vscode/settings.json` und `.github/prompts/`. Siehe [GitHub-Copilot-Unterstützung](#github-copilot-unterstützung).
- **Antigravity**: Eng integriertes Setup für Workflows, Skills und abgeflachte Rules in `.agents/`. Siehe [Antigravity-Leitfaden](../../docs/ANTIGRAVITY-GUIDE.md).
- **JoyCode / CodeBuddy**: Projektlokale Adapter für selektive Installation von Commands, Agents, Skills und abgeflachten Rules. Siehe [JoyCode-Adapter-Leitfaden](../../docs/JOYCODE-GUIDE.md).
- **Qwen CLI**: Adapter für selektive Installation im Home-Verzeichnis für Commands, Agents, Skills, Rules und Qwen-Konfiguration. Siehe [Qwen-CLI-Adapter-Leitfaden](../../docs/QWEN-GUIDE.md).
- **Zed**: Projektlokaler Adapter für selektive Installation von `.zed/settings.json`, abgeflachten Rules, Commands, Agents und Skills.
- **Nicht-native Harnesses**: Manueller Fallback-Pfad für Grok und ähnliche Oberflächen. Siehe [Leitfaden zur manuellen Anpassung](../../docs/MANUAL-ADAPTATION-GUIDE.md).
- **Claude Code**: Nativ — dies ist das primäre Ziel.
</details>
<details>
<summary><b>Wie steuere ich einen neuen Skill oder Agent bei?</b></summary>
Siehe [CONTRIBUTING.md](../../CONTRIBUTING.md). Die Kurzfassung:
1. Forke das Repo
2. Erstelle deinen Skill in `skills/your-skill-name/SKILL.md` (mit YAML-Frontmatter)
3. Oder erstelle einen Agent in `agents/your-agent.md`
4. Reiche einen PR mit einer klaren Beschreibung ein, was er tut und wann er zu verwenden ist
</details>
---
## Tests ausführen
Das Plugin enthält eine umfassende Test-Suite:
```bash
# Alle Tests ausführen
node tests/run-all.js
# Einzelne Testdateien ausführen
node tests/lib/utils.test.js
node tests/lib/package-manager.test.js
node tests/hooks/hooks.test.js
```
---
## Beitragen
**Beiträge sind willkommen und erwünscht.**
Dieses Repo soll eine Community-Ressource sein. Falls du Folgendes hast:
- Nützliche Agents oder Skills
- Clevere Hooks
- Bessere MCP-Konfigurationen
- Verbesserte Rules
Bitte trage bei! Richtlinien findest du in [CONTRIBUTING.md](../../CONTRIBUTING.md).
### Ideen für Beiträge
- Sprachspezifische Skills (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift, TypeScript und HarmonyOS/ArkTS sind bereits enthalten
- Framework-spezifische Konfigurationen (Rails, FastAPI) — Django, NestJS, Spring Boot und Laravel sind bereits enthalten
- Domänenspezifisches Wissen (ML, Data Engineering, Mobile)
### Hinweise zum Community-Ökosystem
Diese werden nicht mit ECC mitgeliefert und nicht von diesem Repo auditiert, aber sie sind wissenswert, falls du das breitere Claude-Code-Skills-Ökosystem erkundest:
- [claude-seo](https://github.com/AgriciDaniel/claude-seo) — SEO-fokussierte Skill- und Agent-Sammlung
- [claude-ads](https://github.com/AgriciDaniel/claude-ads) — Sammlung von Ad-Audit- und Paid-Growth-Workflows
- [claude-cybersecurity](https://github.com/AgriciDaniel/claude-cybersecurity) — sicherheitsorientierte Skill- und Agent-Sammlung
---
## Cursor-IDE-Unterstützung
ECC bietet Cursor-IDE-Unterstützung mit Hooks, Rules, Agents, Skills, Commands und MCP-Konfigurationen, die an Cursors Projektlayout angepasst sind.
### Schnellstart (Cursor)
```bash
# macOS/Linux
./install.sh --target cursor typescript
./install.sh --target cursor python golang swift php
```
```powershell
# Windows PowerShell
.\install.ps1--targetcursortypescript
.\install.ps1--targetcursorpythongolangswiftphp
```
### Was ist enthalten
| Komponente | Anzahl | Details |
|-----------|-------|---------|
| Hook-Events | 15 | sessionStart, beforeShellExecution, afterFileEdit, beforeMCPExecution, beforeSubmitPrompt und 10 weitere |
| Hook-Skripte | 16 | Schlanke Node.js-Skripte, die über einen gemeinsamen Adapter an `scripts/hooks/` delegieren |
| Agents | 48 | `.cursor/agents/ecc-*.md` bei Installation; präfixiert, um Kollisionen mit Benutzer- oder Marketplace-Agents zu vermeiden |
| Skills | Gemeinsam + mitgeliefert | `.cursor/skills/` für übersetzte Ergänzungen |
| Commands | Gemeinsam | `.cursor/commands/` falls installiert |
| MCP-Konfiguration | Gemeinsam | `.cursor/mcp.json` falls installiert |
### Hinweise zum Laden in Cursor
ECC installiert keine Root-`AGENTS.md` in `.cursor/`. Cursor behandelt verschachtelte `AGENTS.md`-Dateien als Verzeichniskontext, daher würde das Kopieren von ECCs Repo-Identität in ein Host-Projekt dieses Projekt verunreinigen.
Das Cursor-native Ladeverhalten kann je nach Cursor-Build variieren. ECC installiert Agents als `.cursor/agents/ecc-*.md`; falls dein Cursor-Build keine Projekt-Agents bereitstellt, funktionieren diese Dateien weiterhin als explizite Referenzdefinitionen statt als versteckter globaler Prompt-Kontext.
### Hook-Architektur (DRY-Adapter-Muster)
Cursor hat **mehr Hook-Events als Claude Code** (20 vs. 8). Das Modul `.cursor/hooks/adapter.js` transformiert Cursors stdin-JSON in das Format von Claude Code und erlaubt so die Wiederverwendung bestehender `scripts/hooks/*.js` ohne Duplizierung.
Cursor-Rules verwenden YAML-Frontmatter mit `description`, `globs` und `alwaysApply`:
```yaml
---
description:"TypeScript coding style extending common rules"
globs:["**/*.ts","**/*.tsx","**/*.js","**/*.jsx"]
alwaysApply:false
---
```
---
## Codex-macOS-App- + CLI-Unterstützung
ECC bietet **erstklassige Codex-Unterstützung** sowohl für die macOS-App als auch die CLI, mit einer Referenzkonfiguration, einem Codex-spezifischen AGENTS.md-Zusatz und gemeinsam genutzten Skills.
### Schnellstart (Codex-App + CLI)
```bash
# Codex CLI im Repo ausführen — AGENTS.md und .codex/ werden automatisch erkannt
codex
# Automatisches Setup: ECC-Assets (AGENTS.md, Skills, MCP-Server) nach ~/.codex synchronisieren
# oder: bun install && bash scripts/sync-ecc-to-codex.sh
# Oder manuell: die Referenzkonfiguration in dein Home-Verzeichnis kopieren
cp .codex/config.toml ~/.codex/config.toml
```
Das Sync-Skript merged ECC-MCP-Server sicher in deine bestehende `~/.codex/config.toml` mit einer **add-only**-Strategie — es entfernt oder verändert deine bestehenden Server nie. Führe es mit `--dry-run` aus, um Änderungen in der Vorschau zu sehen, oder mit `--update-mcp`, um ein erzwungenes Refresh der ECC-Server auf die neueste empfohlene Konfiguration zu erzwingen.
Für Context7 verwendet ECC den kanonischen Codex-Abschnittsnamen `[mcp_servers.context7]`, startet aber weiterhin das Paket `@upstash/context7-mcp`. Falls du bereits einen veralteten `[mcp_servers.context7-mcp]`-Eintrag hast, migriert `--update-mcp` ihn auf den kanonischen Abschnittsnamen.
Codex-macOS-App:
- Öffne dieses Repository als deinen Workspace.
- Die Root-`AGENTS.md` wird automatisch erkannt.
-`.codex/config.toml` und `.codex/agents/*.toml` funktionieren am besten, wenn sie projektlokal gehalten werden.
- Die Referenz-`.codex/config.toml` pinnt `model` oder `model_provider` absichtlich nicht, sodass Codex seine eigene aktuelle Voreinstellung verwendet, sofern du sie nicht überschreibst.
- Optional: Kopiere `.codex/config.toml` nach `~/.codex/config.toml` für globale Voreinstellungen; halte die Multi-Agent-Rollendateien projektlokal, sofern du nicht auch `.codex/agents/` kopierst.
Skills unter `.agents/skills/` werden von Codex automatisch geladen:
Kanonische Anthropic-Skills wie `claude-api`, `frontend-design` und `skill-creator` werden hier absichtlich nicht erneut mitgeliefert. Installiere diese aus [`anthropics/skills`](https://github.com/anthropics/skills), wenn du die offiziellen Versionen willst.
| Skill | Beschreibung |
|-------|-------------|
| agent-introspection-debugging | Agent-Verhalten, -Routing und Prompt-Grenzen debuggen |
| agent-sort | Agent-Kataloge und Zuweisungsoberflächen sortieren |
| api-design | REST-API-Design-Patterns |
| article-writing | Langform-Texte aus Notizen und Stimm-Referenzen |
| video-editing | KI-unterstützte Videobearbeitungs-Workflows mit FFmpeg und Remotion |
| x-api | X-/Twitter-API-Integration für Posting und Analytics |
### Wesentliche Einschränkung
Codex bietet **noch keine Claude-artige Parität bei der Hook-Ausführung**. Die ECC-Durchsetzung dort ist instruction-basiert über `AGENTS.md`, optionale `model_instructions_file`-Overrides sowie Sandbox-/Approval-Einstellungen.
- Aktiviere `features.multi_agent = true` in `.codex/config.toml`
- Definiere Rollen unter `[agents.<name>]`
- Verweise jede Rolle auf eine Datei unter `.codex/agents/`
- Verwende `/agent` in der CLI, um Kind-Agents zu inspizieren oder zu steuern
ECC liefert drei Beispiel-Rollenkonfigurationen aus:
| Rolle | Zweck |
|------|---------|
| `explorer` | Read-only-Sammlung von Codebase-Belegen vor Bearbeitungen |
| `reviewer` | Review von Korrektheit, Sicherheit und fehlenden Tests |
| `docs_researcher` | Dokumentations- und API-Verifikation vor Release-/Docs-Änderungen |
---
## Zed-Unterstützung
ECC bietet Zed-Projektunterstützung über einen konservativen `.zed`-Adapter für projektlokale Einstellungen, abgeflachte Rules, Agents, Commands und Skills.
```bash
./install.sh --profile minimal --target zed
```
```powershell
.\install.ps1--profileminimal--targetzed
```
Der Adapter schreibt ECC-verwaltete Dateien unter `.zed/` und hält BYOK-/OpenRouter-Credentials aus dem Repo heraus. Konfiguriere das Zed-Konto oder API-Keys über Zeds eigene Einstellungs-UI oder deine lokalen Benutzereinstellungen.
---
## OpenCode-Unterstützung
ECC bietet **vollständige OpenCode-Unterstützung** einschließlich Plugins und Hooks.
### Schnellstart
```bash
# OpenCode installieren
npm install -g opencode
# Im Repository-Root ausführen
opencode
```
Die Konfiguration wird automatisch aus `.opencode/opencode.json` erkannt.
| `/learn-eval` | Muster vor dem Speichern extrahieren und evaluieren |
| `/setup-pm` | Paketmanager konfigurieren |
| `/harness-audit` | Harness-Zuverlässigkeit, Eval-Bereitschaft und Risikolage auditieren |
| `/loop-start` | Kontrolliertes agentisches Loop-Ausführungsmuster starten |
| `/loop-status` | Aktiven Loop-Status und Checkpoints inspizieren |
| `/quality-gate` | Quality-Gate-Prüfungen für Pfade oder das gesamte Repo ausführen |
| `/model-route` | Aufgaben nach Komplexität und Budget an Modelle routen |
### Plugin-Installation
**Option 1: Direkt verwenden**
```bash
cd ECC
opencode
```
**Option 2: Als npm-Paket installieren**
```bash
npm install ecc-universal
```
Füge es dann zu deiner `opencode.json` hinzu:
```json
{
"plugin":["ecc-universal"]
}
```
Dieser npm-Plugin-Eintrag aktiviert ECCs veröffentlichtes OpenCode-Plugin-Modul (Hooks/Events und Plugin-Tools).
Er fügt **nicht** automatisch ECCs vollständigen Command-/Agent-/Instruction-Katalog zu deiner Projektkonfiguration hinzu.
Für das vollständige ECC-OpenCode-Setup entweder:
- OpenCode innerhalb dieses Repositorys ausführen, oder
- die mitgelieferten `.opencode/`-Konfigurations-Assets in dein Projekt kopieren und die `instructions`-, `agent`- und `command`-Einträge in `opencode.json` verdrahten
- **LLM-Dokumentation**: `llms.txt` (vollständige OpenCode-Dokumentation für LLMs)
---
## GitHub-Copilot-Unterstützung
ECC bietet **GitHub-Copilot-Unterstützung** für VS Code über das native Instruction- und Prompt-Datei-System von Copilot Chat — kein zusätzliches Tooling erforderlich.
| Build-Fix-Prompt | `.github/prompts/build-fix.prompt.md` | Systematische Behebung von Build- und CI-Fehlern |
| Refactor-Prompt | `.github/prompts/refactor.prompt.md` | Beseitigung von totem Code und Vereinfachung |
### Schnellstart (GitHub Copilot)
Die Dateien sind bereits vorhanden — öffne ein beliebiges Repo, das dieses Projekt enthält, und GitHub Copilot Chat nimmt `.github/copilot-instructions.md` automatisch auf.
Die eingecheckte `.vscode/settings.json` aktiviert `chat.promptFiles`, sodass VS Code die wiederverwendbaren Prompts aus `.github/prompts/` laden kann.
So verwendest du die Workflow-Prompts in Copilot Chat:
1. Öffne das Copilot-Chat-Panel in VS Code.
2. Klicke auf das **Büroklammer-/Anhängen-Symbol** und wähle **Prompt...**, oder tippe `/` und wähle einen Prompt.
GitHub Copilot in VS Code liest zwei Dateitypen automatisch:
- **`.github/copilot-instructions.md`** — Instructions auf Repository-Ebene, die in jede Copilot-Chat-Anfrage injiziert werden. Enthält ECCs Kern-Coding-Standards, Sicherheits-Checkliste, Testanforderungen und Git-Workflow.
- **`.github/prompts/*.prompt.md`** — wiederverwendbare Prompt-Dateien, die Nutzer bei Bedarf aufrufen. Jeder Prompt führt Copilot durch einen bestimmten ECC-Workflow wie Planung, TDD, Security-Review, Build-Fix oder Refactor.
Die **`.vscode/settings.json`** fügt aufgabenspezifische Instruction-Overlays hinzu, sodass Copilot für Codegenerierung, Testgenerierung und Commit-Nachrichten den richtigen Kontext erhält.
| Behebung von Build-Fehlern | `build-fix`-Prompt |
| Refactoring | `refactor`-Prompt |
| Commit-Nachrichten-Format | Aufgabenspezifische Instruction in `settings.json` |
| Hooks / Automatisierung | Nicht unterstützt (Copilot hat kein Hook-System) |
| Agents / Delegation | Nicht unterstützt (Copilot hat keine Subagent-API) |
### Einschränkungen
GitHub Copilot hat kein Hook-System und keine Subagent-API, daher sind ECCs Hook-Automatisierungen (Auto-Formatierung, TypeScript-Prüfung, Session-Persistenz, Dev-Server-Guard) sowie die Agent-Delegation nicht verfügbar. Die Instruction- und Prompt-Schicht bringt dennoch die vollständige ECC-Coding-Philosophie — Standards, Sicherheit, TDD und Workflow — in jede Copilot-Chat-Session.
---
## Cross-Tool-Feature-Parität
ECC ist das **erste Plugin, das jedes große KI-Coding-Tool ausreizt**. So vergleicht sich jeder Harness:
| Feature | Claude Code | Cursor IDE | Codex CLI | OpenCode | GitHub Copilot |
- **AGENTS.md** im Root ist die universelle Cross-Tool-Datei (gelesen von Claude Code, Cursor, Codex und OpenCode — GitHub Copilot verwendet stattdessen `.github/copilot-instructions.md`)
- Das **DRY-Adapter-Muster** lässt Cursor die Hook-Skripte von Claude Code ohne Duplizierung wiederverwenden
- Das **Skills-Format** (SKILL.md mit YAML-Frontmatter) funktioniert über Claude Code, Codex und OpenCode hinweg
- Codex' fehlende Hooks werden durch `AGENTS.md`, optionale `model_instructions_file`-Overrides und Sandbox-Berechtigungen kompensiert
---
## Hintergrund
Ich nutze Claude Code seit dem experimentellen Rollout. Habe im September 2025 den Anthropic-x-Forum-Ventures-Hackathon mit [@DRodriguezFX](https://x.com/DRodriguezFX) gewonnen — [zenith.chat](https://zenith.chat) wurde vollständig mit Claude Code gebaut.
Diese Konfigurationen sind über mehrere produktive Anwendungen hinweg im Praxiseinsatz erprobt.
---
## Token-Optimierung
Die Nutzung von Claude Code kann teuer werden, wenn du den Token-Verbrauch nicht steuerst. Diese Einstellungen senken die Kosten erheblich, ohne die Qualität zu opfern.
### Empfohlene Einstellungen
Füge zu `~/.claude/settings.json` hinzu:
```json
{
"model":"sonnet",
"env":{
"MAX_THINKING_TOKENS":"10000",
"CLAUDE_AUTOCOMPACT_PCT_OVERRIDE":"50"
}
}
```
| Einstellung | Standard | Empfohlen | Auswirkung |
|---------|---------|-------------|--------|
| `model` | opus | **sonnet** | ~60 % Kostensenkung; bewältigt 80 %+ der Coding-Aufgaben |
| `MAX_THINKING_TOKENS` | 31.999 | **10.000** | ~70 % Reduktion der versteckten Thinking-Kosten pro Anfrage |
| `/cost` | Token-Ausgaben während der Session überwachen |
Falls du ein Claude-Abonnement nutzt und die API-Rate-Schätzungen des Kontext-Monitors nicht nützlich sind, setze `ECC_CONTEXT_MONITOR_COST_WARNINGS=off`. Das unterdrückt nur die agentenseitigen Kostenwarnungen; es deaktiviert keine Warnungen zu Kontexterschöpfung, Scope oder Loops.
### Strategische Compaction
Der `strategic-compact`-Skill (in diesem Plugin enthalten) schlägt `/compact` an logischen Bruchstellen vor, statt sich auf die Auto-Compaction bei 95 % Kontext zu verlassen. Den vollständigen Entscheidungsleitfaden findest du in `skills/strategic-compact/SKILL.md`.
**Wann kompaktieren:**
- Nach Recherche/Erkundung, vor der Implementierung
- Nach Abschluss eines Meilensteins, vor Beginn des nächsten
- Nach dem Debugging, vor der Fortsetzung der Feature-Arbeit
- Nach einem gescheiterten Ansatz, vor dem Versuch eines neuen
**Wann NICHT kompaktieren:**
- Mitten in der Implementierung (du verlierst Variablennamen, Dateipfade, partiellen Zustand)
### Kontextfenster-Verwaltung
**Kritisch:** Aktiviere nicht alle MCPs auf einmal. Jede MCP-Tool-Beschreibung verbraucht Token aus deinem 200k-Fenster und reduziert es möglicherweise auf ~70k.
- Halte unter 10 MCPs pro Projekt aktiviert
- Halte unter 80 Tools aktiv
- Verwende `/mcp`, um ungenutzte Claude-Code-MCP-Server zu deaktivieren; diese Laufzeitentscheidungen bleiben in `~/.claude.json` erhalten
- Verwende `ECC_DISABLED_MCPS` nur, um ECC-generierte MCP-Konfigurationen während der Install-/Sync-Flows zu filtern
### Kostenwarnung zu Agent-Teams
Agent-Teams erzeugen mehrere Kontextfenster. Jeder Teammate verbraucht Token unabhängig. Verwende sie nur für Aufgaben, bei denen Parallelität einen klaren Mehrwert bietet (Arbeit über mehrere Module, parallele Reviews). Für einfache sequentielle Aufgaben sind Subagents token-effizienter.
---
## WARNING: Wichtige Hinweise
### Token-Optimierung
Erreichst du die Tageslimits? Siehe den **[Token-Optimierungs-Leitfaden](../../docs/token-optimization.md)** für empfohlene Einstellungen und Workflow-Tipps.
Schnelle Gewinne:
```json
// ~/.claude/settings.json
{
"model":"sonnet",
"env":{
"MAX_THINKING_TOKENS":"10000",
"CLAUDE_AUTOCOMPACT_PCT_OVERRIDE":"50",
"CLAUDE_CODE_SUBAGENT_MODEL":"haiku"
}
}
```
Verwende `/clear` zwischen voneinander unabhängigen Aufgaben, `/compact` an logischen Bruchstellen und `/cost`, um die Ausgaben zu überwachen.
### Anpassung
Diese Konfigurationen funktionieren für meinen Workflow. Du solltest:
1. Mit dem beginnen, was dich anspricht
2. Für deinen Stack anpassen
3. Entfernen, was du nicht nutzt
4. Eigene Patterns hinzufügen
---
## Community-Projekte
Projekte, die auf ECC aufbauen oder davon inspiriert sind:
| Projekt | Beschreibung |
|---------|-------------|
| [EVC](https://github.com/SaigonXIII/evc) | Marketing-Agent-Workspace — 42 Commands für Content-Operatoren, Brand-Governance und Multi-Channel-Publishing. [Visuelle Übersicht](https://saigonxiii.github.io/evc). |
| [trading-skills](https://github.com/VictorVVedtion/trading-skills) | 68 trading-thematische Claude-Code-Skills mit Pre-Trade-Review-Prompts und Risiko-Gates, inspiriert von Marktteilnehmern. |
Etwas mit ECC gebaut? Öffne einen PR, um es hier hinzuzufügen.
---
## Sponsoren
Dieses Projekt ist kostenlos und Open Source. Sponsoren helfen, es gepflegt und wachsend zu halten.
