@hegemonart/get-design-done 1.59.6 → 1.59.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/.claude-plugin/marketplace.json +2 -2
  2. package/.claude-plugin/plugin.json +1 -1
  3. package/CHANGELOG.md +22 -0
  4. package/README.md +4 -13
  5. package/docs/i18n/README.de.md +210 -527
  6. package/docs/i18n/README.fr.md +201 -518
  7. package/docs/i18n/README.it.md +209 -526
  8. package/docs/i18n/README.ja.md +207 -524
  9. package/docs/i18n/README.ko.md +208 -525
  10. package/docs/i18n/README.zh-CN.md +213 -551
  11. package/package.json +1 -1
  12. package/scripts/lib/install/doctor-codex-plugin.cjs +1 -1
  13. package/scripts/lib/install/doctor-cursor-marketplace.cjs +2 -2
package/docs/i18n/README.de.md CHANGED
@@ -6,9 +6,9 @@
6
6
 
7
7
  > Hinweis: Diese Übersetzung kann hinter der englischen Version zurückliegen. Die maßgebliche Version ist [README.md](../../README.md) (translation may lag behind English; see README.md for the canonical version).
8
8
 
9
- **Eine Design-Quality-Pipeline für AI-Coding-Agenten: Brief → Explore → Plan → Implementierung → Verifikation.**
9
+ **Eine Design-Quality-Pipeline für AI-Coding-Agenten: Brief -> Explore -> Plan -> Design -> Verify.**
10
10
 
11
- **Get Design Done hält AI-generierte UI an deinen Brief, dein Design-System, deine Referenzen und deine Quality Gates gebunden. Funktioniert mit Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy und Cline.**
11
+ **Get Design Done hält AI-generierte UI an deinen Brief, dein Design-System, dein lokales Design-Wissen und deine Quality Gates gebunden. Gebaut für Claude Code und installierbar über Codex, Cursor, Gemini, OpenCode, Copilot, Windsurf und mehr.**
12
12
 
13
13
  [![npm version](https://img.shields.io/npm/v/@hegemonart/get-design-done?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/@hegemonart/get-design-done)
14
14
  [![npm downloads](https://img.shields.io/npm/dm/@hegemonart/get-design-done?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/@hegemonart/get-design-done)
@@ -17,612 +17,315 @@
17
17
  [![Node](https://img.shields.io/badge/node-22%20%7C%2024-339933?style=for-the-badge&logo=node.js&logoColor=white)](https://nodejs.org/)
18
18
  [![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
19
19
 
20
- <br>
21
-
22
20
  ```bash
23
21
  npx @hegemonart/get-design-done@latest
24
22
  ```
25
23
 
26
24
  **Funktioniert auf macOS, Linux und Windows.**
27
25
 
28
- <br>
29
-
30
- *„AI-Coding-Agenten liefern UI schnell. Get Design Done sorgt dafür, dass sie Design liefern."*
31
-
32
- <br>
33
-
34
- [Warum ich es gebaut habe](#warum-ich-es-gebaut-habe) · [Wie es funktioniert](#wie-es-funktioniert) · [Befehle](#befehle) · [Verbindungen](#verbindungen) · [Warum es funktioniert](#warum-es-funktioniert)
26
+ [Installation](#installation) · [Erste Schritte](#erste-schritte) · [Anwendungsfälle](#anwendungsfälle) · [Wie es funktioniert](#wie-es-funktioniert) · [Befehle](#befehle) · [Verbindungen](#verbindungen) · [Sicherheit](#sicherheit-und-datenschutz)
35
27
 
36
28
  </div>
37
29
 
38
30
  ---
39
31
 
40
- > [!IMPORTANT]
41
- > ### Schon ein Claude-Design-Bundle?
42
- >
43
- > Wenn du ein Design aus [claude.ai/design](https://claude.ai/design) exportiert hast, kannst du die Stufen 1–3 vollständig überspringen:
44
- >
45
- > ```
46
- > /gdd:handoff ./my-design.html
47
- > ```
48
- >
49
- > Parst die CSS-Custom-Properties des Bundles in D-XX-Designentscheidungen, führt den Verifikationslauf mit Handoff-Faithfulness-Scoring aus und schreibt optional den Implementierungsstatus zurück nach Figma.
50
-
51
- ---
52
-
53
- ## Warum ich es gebaut habe
54
-
55
- Ich bin Designer und liefere mit AI-Coding-Agenten aus. Der Code-Workflow ist reif: Specs, Tasks, Tests, Commits, Review-Loops. Der Design-Workflow war es nicht.
56
-
57
- Worauf ich immer wieder gestoßen bin: Der Agent konnte einen Screen erzeugen, der isoliert gut aussah, aber die Arbeit blieb *zusammenhanglos*. Tokens passten nicht zum bestehenden System. Kontrastverhältnisse rutschten unter WCAG. Hierarchie wurde pro Bildschirm neu erfunden. Alte Anti-Patterns landeten in neuen Komponenten. Und weil nichts den Output gegen den ursprünglichen Brief verifizierte, tauchten die Probleme spät auf: im PR-Review oder nach dem Handoff.
58
-
59
- Also habe ich Get Design Done gebaut: eine Design-Pipeline, die AI-Coding-Agenten dieselbe Struktur gibt, die Entwickler aus Engineering-Workflows bereits erwarten. Sie erfasst den Brief, kartiert das aktuelle Design-System, verankert Entscheidungen in Referenzen, zerlegt Arbeit in atomare Tasks, führt diese Tasks aus und verifiziert das Ergebnis vor dem Shipping.
60
-
61
- Hinter den Kulissen: 37 spezialisierte Agenten, ein abfragbarer Intel-Store, Tier-bewusstes Modell-Routing, 12 optionale Tool-Verbindungen, atomare Commits und eine No-Regret-Adaptiv-Schicht, die aus Solidify-with-Rollback-Ergebnissen lernt. Im Alltag nutzt du ein paar `/gdd:*`-Befehle, die Designarbeit kohärent halten.
62
-
63
- — **Hegemon**
64
-
65
- ---
66
-
67
- AI-generiertes Design hat denselben Fehlermodus wie AI-generierter Code: Du beschreibst, was du willst, bekommst etwas Plausibles, und bei Skalierung bricht es auseinander, weil kein System den Output zurück an den Brief bindet.
68
-
69
- Get Design Done ist die Context-Engineering-Schicht für Designarbeit. Es verwandelt „mach diese UI besser" in einen nachvollziehbaren Zyklus: Brief → Inventar → Referenzen → Plan → Implementierung → Verifikation.
70
-
71
- ---
72
-
73
- ## Was du bekommst
32
+ ## Was es ist
74
33
 
75
- - **Brief-gebundene Designarbeit** — jeder Zyklus beginnt mit Problem, Zielgruppe, Constraints, Erfolgskriterien und Must-haves.
76
- - **Design-System-Extraktion** — GDD inventarisiert Tokens, Typografie, Spacing, Komponenten, Motion, Accessibility, Dark Mode und Design Debt, bevor Änderungen geplant werden.
77
- - **Referenzgestützte Entscheidungen** — Agenten nutzen eingebettete Design-Referenzen plus optionale Verbindungen zu Figma, Refero, Pinterest, Storybook, Chromatic, Preview, Claude Design, paper.design, pencil.dev, Graphify, 21st.dev Magic und Magic Patterns.
78
- - **Atomare Ausführung** — Design-Tasks werden nach Abhängigkeiten zerlegt, in sicheren Waves ausgeführt und unabhängig committet.
79
- - **Verifikation vor dem Shipping** — Audits prüfen Brief-Fit, Token-Integration, WCAG-Kontrast, Komponenten-Konformität, Motion-Konsistenz, Dark-Mode-Architektur und Design-Anti-Patterns.
80
- - **Rollback bei fehlgeschlagener Validierung** — solidify-with-rollback validiert jeden Task, bevor er bestehen bleibt; fehlgeschlagene Arbeit wird automatisch revertet.
34
+ Get Design Done hilft AI-Coding-Agenten dabei, UI auszuliefern, die wirklich in dein Produkt gehört.
81
35
 
82
- ---
83
-
84
- ## Für wen ist das
85
-
86
- GDD ist für Engineers, Designer, Design Engineers, Founders und Product Builder, die UI mit AI-Coding-Agenten ausliefern und wollen, dass das Ergebnis über den ersten Screenshot hinaus trägt.
87
-
88
- Nutze es, wenn dir wichtig ist, dass Tokens passen, Kontrast WCAG besteht, Motion kohärent bleibt, Komponenten deinem System folgen und die finale Implementierung noch immer deiner Anfrage entspricht.
89
-
90
- Du musst kein Designer sein. Die Pipeline bringt Design-Disziplin in den Agenten-Workflow: Sie extrahiert Kontext, fragt nur nach fehlenden Entscheidungen, verankert Arbeit in Referenzen und fängt Probleme ab, die man sonst zu spät findet.
36
+ Es verwandelt vage Anfragen wie „mach diesen Screen besser" in einen nachvollziehbaren Design-Workflow: Brief, Explore, Plan, Design, Verify.
91
37
 
92
- ### v1.24.0 Highlights — Multi-Runtime-Installer
38
+ Anstatt einen Agenten allein aus seinem Geschmack heraus improvisieren zu lassen, gibt GDD ihm einen strukturierten Prozess, lokales Design-Wissen, projektspezifischen Speicher, optionale Design-Tool-Verbindungen und eine Verifikation, bevor die Arbeit ausgeliefert wird.
93
39
 
94
- - **`@clack/prompts` interaktive Mehrfachauswahl** — `npx @hegemonart/get-design-done` ohne Flags öffnet jetzt eine polierte Checkbox-UI für alle 14 unterstützten Runtimes (Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline) plus ein Global-/Local-Radio.
95
- - **Idempotent + sicher gegen fremde AGENTS.md** — den Installer erneut auszuführen dupliziert nie Einträge und überschreibt nie runtime-spezifische Anweisungsdateien, die du hinzugefügt hast. Bestätigungsschritt vor jedem Schreibvorgang.
96
- - **Skriptfähige CI-Schnittstelle erhalten** — alle bestehenden Flags (`--claude`, `--cursor`, `--all`, `--global`, `--local`, `--uninstall`, `--config-dir`) funktionieren unverändert weiter. Der interaktive Modus aktiviert sich nur, wenn kein Runtime-Flag übergeben wurde.
97
- - **Mehrfachauswahl-Deinstallation** — `--uninstall` ohne Runtime-Flag wechselt ebenfalls in die interaktive Mehrfachauswahl, um die Runtimes zu wählen, aus denen entfernt werden soll.
40
+ ## Warum es existiert
98
41
 
99
- ### Frühere Releases
42
+ AI-Agenten sind schnell darin, UI zu produzieren. Der schwierige Teil ist, diese UI kohärent zu machen.
100
43
 
101
- - **v1.23.5** — No-Regret-Adaptiv-Schicht (Thompson-Sampling-Bandit + AdaNormalHedge-Ensemble + MMR-Reranking; single-user-tauglich durch Informed-Prior-Bootstrap, ohne Opt-in-Shared-Telemetrie).
102
- - **v1.23.0** — SDK-Domain-Primitive (Solidify-with-Rollback-Gate, JSON-Output-Verträge, Auto-Kristallisation von `Touches:`-Mustern).
103
- - **v1.22.0** — SDK-Observability (~24 typisierte Event-Typen, Per-Tool-Call-Trajectory, append-only Event-Chain, Secret-Scrubber).
104
- - **v1.21.0** — Headless-SDK (`gdd-sdk`-CLI führt die volle Pipeline ohne Claude Code aus, parallele Researcher, Cross-Harness-MCP).
105
- - **v1.20.0** — SDK-Foundation (Resilienz-Primitive, lockfile-sichere `STATE.md`, `gdd-state` MCP-Server mit 11 typisierten Tools, TypeScript-Foundation).
44
+ Ohne einen Design-Workflow driften generierte Oberflächen auseinander:
106
45
 
107
- Vollständige Release-Notes in [CHANGELOG.md](CHANGELOG.md).
46
+ - Farben und Abstände passen nicht mehr zum System
47
+ - Komponenten werden neu erfunden
48
+ - Kontrast und Barrierefreiheit verschlechtern sich
49
+ - die Hierarchie ändert sich von Screen zu Screen
50
+ - die Implementierung entspricht nicht mehr dem ursprünglichen Brief
108
51
 
109
- ---
52
+ GDD ergänzt die fehlende Design-Disziplin rund um AI-Coding-Workflows. Es erfasst das Problem, kartiert das aktuelle Design-System, plant abgegrenzte Änderungen, führt sie in atomaren Schritten aus und verifiziert das Ergebnis gegen den Brief, die Tokens, die Barrierefreiheit und Design-Quality-Rubriken.
110
53
 
111
- <p align="center">
112
- <strong>Supported by</strong>
113
- </p>
54
+ Hinter den Kulissen: 64 spezialisierte Agenten, ein abfragbarer Intel-Store, Tier-bewusstes Modell-Routing und 39 optionale Tool-Verbindungen. Im Alltag nutzt du eine Handvoll `/gdd:*`-Befehle.
114
55
 
115
- <div align="center">
116
- <a href="https://www.humbleteam.com/" aria-label="Humbleteam">
117
- <img src="docs/assets/sponsors/humbleteam.svg" alt="Humbleteam logo" width="180">
118
- </a>
119
- <br>
120
- <sub>Product design partner for ambitious startups and AI products.</sub>
121
- </div>
56
+ ## Installation
122
57
 
123
- ---
124
-
125
- ## Erste Schritte
58
+ ### npm
126
59
 
127
60
  ```bash
128
61
  npx @hegemonart/get-design-done@latest
129
62
  ```
130
63
 
131
- Der Installer fragt dich:
132
- 1. **Runtime** — Claude Code, OpenCode, Gemini, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline oder alle (interaktive Mehrfachauswahl)
133
- 2. **Speicherort** — Global (alle Projekte) oder Local (nur aktuelles Projekt)
134
-
135
- Verifizieren mit:
64
+ ### Claude Code
136
65
 
137
- ```
138
- /gdd:help
66
+ ```bash
67
+ /plugin marketplace add hegemonart/get-design-done
68
+ /plugin install get-design-done@get-design-done
69
+ /reload-plugins
139
70
  ```
140
71
 
141
- > [!TIP]
142
- > Starte Claude Code mit `--dangerously-skip-permissions` für eine reibungslose Automatisierungserfahrung. GDD ist für autonome mehrstufige Ausführung konzipiert.
143
-
144
- ### Aktuell bleiben
145
-
146
- GDD veröffentlicht häufig. Aktualisiere durch erneutes Ausführen des Installers (idempotent):
72
+ ### Codex
147
73
 
148
74
  ```bash
149
- npx @hegemonart/get-design-done@latest
75
+ codex plugin marketplace add hegemonart/get-design-done
150
76
  ```
151
77
 
152
- Oder in Claude Code:
153
-
154
- ```
155
- /gdd:update
156
- ```
78
+ ### agentskills.io
157
79
 
158
- `/gdd:update` zeigt das Changelog vor dem Anwenden in einer Vorschau. Lokale Modifikationen unter `reference/` bleiben erhalten — wenn ein strukturelles Update ein Re-Stitching erfordert, führe `/gdd:reapply-patches` aus.
80
+ Durchsuche und installiere Get Design Done über die Skill-Registry [agentskills.io](https://agentskills.io).
159
81
 
160
- <details>
161
- <summary><strong>Nicht-interaktive Installation (Docker, CI, Skripte)</strong></summary>
82
+ ### Direkter Runtime-Installer
162
83
 
163
84
  ```bash
85
+ # Claude Code
164
86
  npx @hegemonart/get-design-done --claude --global
165
87
  npx @hegemonart/get-design-done --claude --local
166
- npx @hegemonart/get-design-done --opencode --global
167
- npx @hegemonart/get-design-done --gemini --global
168
- npx @hegemonart/get-design-done --kilo --global
88
+
89
+ # Andere Runtimes
169
90
  npx @hegemonart/get-design-done --codex --global
170
- npx @hegemonart/get-design-done --copilot --global
171
91
  npx @hegemonart/get-design-done --cursor --global
172
- npx @hegemonart/get-design-done --windsurf --global
173
- npx @hegemonart/get-design-done --antigravity --global
174
- npx @hegemonart/get-design-done --augment --global
175
- npx @hegemonart/get-design-done --trae --global
176
- npx @hegemonart/get-design-done --qwen --global
177
- npx @hegemonart/get-design-done --codebuddy --global
178
- npx @hegemonart/get-design-done --cline --global
179
-
180
- # Alle Runtimes
92
+ npx @hegemonart/get-design-done --gemini --global
93
+
94
+ # Multi-Runtime-Installation
181
95
  npx @hegemonart/get-design-done --all --global
182
96
 
183
- # Dry-Run
97
+ # Vorschau ohne Schreibvorgang
184
98
  npx @hegemonart/get-design-done --dry-run
185
-
186
- # Eigenes Config-Verzeichnis
187
- CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
188
99
  ```
189
100
 
190
- </details>
101
+ ## Erste Schritte
191
102
 
192
- <details>
193
- <summary><strong>Alternative: Claude Code CLI</strong></summary>
103
+ Führe einen schlanken ersten Durchlauf aus:
194
104
 
195
105
  ```bash
196
- claude plugin marketplace add hegemonart/get-design-done
197
- claude plugin install get-design-done@get-design-done
106
+ /gdd:start
198
107
  ```
199
108
 
200
- </details>
201
-
202
- ### Tier-2 Distribution Channels (v1.28.8+)
203
-
204
- Zusätzlich zu den Phase-28.7-Datei-Installationspfaden oben (Standard, weiterhin funktionsfähig) fügt v1.28.8 drei neue Tier-2-Vertriebskanäle hinzu:
205
-
206
- - **agentskills.io Plattform-übergreifende Portabilität.** Unsere `skills/` sind spec-konform nach dem [agentskills.io](https://agentskills.io) Standard. Runtimes, die agentskills.io-Kompatibilität beanspruchen (Codex, Kilo, Augment, Hermes, Qwen), können unsere Skills direkt konsumieren.
207
- - **Cursor Marketplace.** Installation via Cursor Marketplace-UI; Veröffentlichung steht aus, abhängig von der Cursor-Team-Prüfung — siehe `docs/cursor-marketplace-field-test.md`.
208
- - **Codex Plugin.** Installation via Codex GitHub-URL Plugin-Add:
209
-
210
- ```bash
211
- codex plugin marketplace add hegemonart/get-design-done
212
- ```
213
-
214
- Vollständige Details siehe [README.md](README.md) (Englisch, autoritativ).
215
-
216
- ### Capability-Gap-Telemetrie + Self-Authoring (v1.29.0+)
217
-
218
- Die Reflector-Schleife verfolgt "Capability-Lookup fehlgeschlagen"-Signale jetzt als erstklassige Telemetrie und kann — sobald genügend wiederkehrende Lücken auftauchen — neue Agents oder Skills als Vorschläge zur Überprüfung entwerfen.
219
-
220
- **Stufe 0 — Telemetrie (sofort verfügbar).** Drei Lookup-Fail-Punkte emittieren typisierte `capability_gap`-Events: `skills/fast` No-Skill-Match-Pfade, `gdd-router` Unmatched-Intent-Pfade und die Pattern-Detection-Pass des Reflectors. Anzeigen mit `gdd-events --type capability_gap`.
221
-
222
- **Stufe 1 — Self-Authoring (Opt-in, sobald Daten das Gate überschreiten).** Wenn K=3 stabile Cluster über M=10 Reflexions-Zyklen auftauchen, fordert `/gdd:apply-reflections` Sie einmalig auf, Stufe 1 zu aktivieren. Der Reflector entwirft dann Inkubator-Artefakte unter `.design/reflections/incubator/<slug>/` mit Phase-28.5-konformen Frontmatter. Vier Aktionen: `accept` / `reject` / `defer` / `edit`. Strict proposal-only — `/gdd:apply-reflections` bleibt der einzige menschliche Gate (Phase 11 SC-8).
223
-
224
- Scope-Guard: Authoring beschränkt sich auf `agents/` und `skills/` — niemals Runtimes / Transports / Hooks. Vollständige Details siehe [README.md](README.md) (Englisch, autoritativ).
109
+ Oder durchlaufe den vollständigen Design-Zyklus:
225
110
 
226
-
227
- ## Wie es funktioniert
228
-
229
- > **Du startest in einer bestehenden Codebase?** Führe zuerst `/gdd:map` aus. Es dispatcht 5 Spezial-Mapper parallel (Tokens, Components, Visual Hierarchy, A11y, Motion) und schreibt strukturiertes JSON nach `.design/map/`.
230
-
231
- ### 1. Brief
232
-
233
- ```
111
+ ```bash
234
112
  /gdd:brief
235
- ```
236
-
237
- Erfasst das Designproblem vor jedem Scan oder jeder Exploration. Der Skill interviewt via `AskUserQuestion`, eine Frage nach der anderen — nur für unbeantwortete Abschnitte: Problem, Zielgruppe, Constraints, Erfolgsmetriken, Scope.
238
-
239
- **Erstellt:** `.design/BRIEF.md`
240
-
241
- ---
242
-
243
- ### 2. Explore
244
-
245
- ```
246
113
  /gdd:explore
247
- ```
248
-
249
- Inventarisiert das Design-System der aktuellen Codebase — Farben, Typografie, Abstände, Komponenten, Motion, A11y, Dark-Mode. Fünf parallele Mapper + ein `design-discussant`-Interview produzieren drei Artefakte. Verbindungs-Probes erkennen die Verfügbarkeit von 12 externen Tools.
250
-
251
- **Erstellt:** `.design/DESIGN.md`, `.design/DESIGN-DEBT.md`, `.design/DESIGN-CONTEXT.md`, `.design/map/{tokens,components,a11y,motion,visual-hierarchy}.{md,json}`
252
-
253
- ---
254
-
255
- ### 3. Plan
256
-
257
- ```
258
114
  /gdd:plan
115
+ /gdd:design
116
+ /gdd:verify
259
117
  ```
260
118
 
261
- Zerlegt die Explore-Ausgabe in atomare, wave-koordinierte, dependency-analysierte Design-Tasks. Jeder Task trägt explizite `Touches:`-Pfade, Parallel-Safe-Tags und Akzeptanzkriterien. `design-planner` (opus) verfasst; `design-plan-checker` (haiku) gate-checkt vor der Ausführung.
262
-
263
- **Erstellt:** `.design/DESIGN-PLAN.md`
264
-
265
- ---
266
-
267
- ### 4. Design
119
+ Für natursprachliches Routing:
268
120
 
269
- ```
270
- /gdd:design
121
+ ```bash
122
+ /gdd:do improve the checkout page hierarchy, spacing, and empty states
271
123
  ```
272
124
 
273
- Führt Tasks in Wave-Reihenfolge aus. Jeder Task erhält einen dedizierten `design-executor`-Agent mit frischem 200k-Kontext, atomarem Git-Commit und automatischer Abweichungsbehandlung gemäß In-Context-Regeln. Parallel-sichere Tasks laufen in Worktrees.
125
+ ## Anwendungsfälle
274
126
 
275
- **Solidify-with-Rollback** (v1.23.0) — jeder Task validiert (Typecheck + Build + gezielter Test) vor dem Fixieren. Validierung scheitert → Revert via `git stash`.
127
+ ### Einen bestehenden Screen verbessern
276
128
 
277
- **Erstellt:** ein `.design/tasks/task-NN.md` pro Task, einen atomaren Git-Commit pro Task
129
+ Nutze GDD, wenn ein Screen technisch funktioniert, sich aber visuell inkonsistent, unklar oder unterdesignt anfühlt.
278
130
 
279
- ```
280
- ┌────────────────────────────────────────────────────────────────────┐
281
- │ WAVE-AUSFÜHRUNG │
282
- ├────────────────────────────────────────────────────────────────────┤
283
- │ │
284
- │ WAVE 1 (parallel) WAVE 2 (parallel) WAVE 3 │
285
- │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
286
- │ │ Task 01 │ │ Task 02 │ → │ Task 03 │ │ Task 04 │ → │ Task 05 │ │
287
- │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
288
- │ │ │ ↑ ↑ ↑ │
289
- │ └───────────┴──────────────┴───────────┴──────────────┘ │
290
- │ Touches:-Pfade steuern die Dependency-Analyse │
291
- │ │
292
- └────────────────────────────────────────────────────────────────────┘
131
+ ```bash
132
+ /gdd:do improve the settings page layout and component hierarchy
293
133
  ```
294
134
 
295
- ---
135
+ ### AI-Output zurück ins Design-System bringen
296
136
 
297
- ### 5. Verify
137
+ Nutze es, wenn ein Agent UI generiert hat, die plausibel aussieht, aber nicht zu deinen Tokens, Abständen, Zuständen oder Komponenten passt.
298
138
 
299
- ```
139
+ ```bash
300
140
  /gdd:verify
301
141
  ```
302
142
 
303
- Verifiziert gegen den Brief — Must-Haves, NN/g-Heuristiken, Audit-Rubrik, Token-Integration. Drei Agenten laufen sequenziell: `design-auditor` (6-Säulen-Score 1–4), `design-verifier` (ziel-rückwärts), `design-integration-checker` (greppt D-XX-Entscheidungen zurück in den Code). Bei Fehlschlägen produziert er eine strukturierte Gap-Liste und tritt in eine Verify→Fix-Schleife via `design-fixer` ein.
143
+ ### Audit vor dem Shipping
304
144
 
305
- **Erstellt:** `.design/DESIGN-VERIFICATION.md`, Fix-Commits bei Problemen
145
+ Führe die Verifikation vor einem PR, Release oder Design-Handoff aus.
306
146
 
307
- ---
147
+ ```bash
148
+ /gdd:audit
149
+ ```
308
150
 
309
- ### 6. Ship → Reflect → Nächster Zyklus
151
+ ### Dark Mode reparieren
310
152
 
311
- ```
312
- /gdd:ship # Sauberen PR-Branch erzeugen (filtert .design/-Commits)
313
- /gdd:reflect # design-reflector liest Telemetrie + Lernergebnisse
314
- /gdd:apply-reflections # Vorschläge prüfen und selektiv anwenden
315
- /gdd:complete-cycle # Zyklus-Artefakte archivieren + EXPERIENCE.md schreiben
316
- /gdd:new-cycle # Neuen Design-Zyklus eröffnen
153
+ ```bash
154
+ /gdd:darkmode
317
155
  ```
318
156
 
319
- Oder Auto-Routing:
157
+ ### Einen Design-Handoff importieren
320
158
 
159
+ ```bash
160
+ /gdd:handoff ./my-design.html
321
161
  ```
322
- /gdd:next # State automatisch erkennen und nächsten Schritt ausführen
323
- ```
324
-
325
- Jeder Zyklus erhält Brief, Scan, Plan, Ausführung, Verifikation und ein zyklusspezifisches `EXPERIENCE.md` (~100–200 Zeilen: Ziel / getroffene Entscheidungen / Graduierte Lernergebnisse / Was gestorben ist / Übergabe an den nächsten Zyklus), das zur höchstpriorisierten Quelle für den Decision-Injector-Hook wird.
326
162
 
327
- ---
163
+ Dies parst ein Claude-Design-Bundle, extrahiert CSS-Custom-Properties in Designentscheidungen und führt Handoff-Faithfulness-Checks aus.
328
164
 
329
- ### Fast-Modus
165
+ ### Eine kleine, gezielte Korrektur vornehmen
330
166
 
331
- ```
332
- /gdd:fast "<task>"
167
+ ```bash
168
+ /gdd:fast "fix contrast in pricing cards"
333
169
  ```
334
170
 
335
- Für triviale Single-File-Fixes, die keine vollständige Pipeline brauchen. Überspringt Router, Cache-Manager und Telemetrie. Gleiche Atomic-Commit-Garantien.
171
+ ## Was es anders macht
336
172
 
337
- ```
338
- /gdd:quick
339
- ```
173
+ ### Lokales Design-Wissen
340
174
 
341
- Für Ad-hoc-Tasks, die GDD-Garantien brauchen, aber optionale Gates überspringen (kein Phase-Researcher, kein Assumptions-Analyzer, kein Integration-Checker). Schneller als die volle Pipeline; sicherer als `/gdd:fast`.
175
+ GDD bringt eine umfangreiche lokale Referenzbibliothek für Designarbeit mit. Agenten können sie nutzen, ohne für grundlegende Design-Entscheidungen auf eine Live-Websuche angewiesen zu sein.
342
176
 
343
- ---
177
+ Sie deckt Barrierefreiheit, WCAG, Typografie, Abstände, Raster, Farbe, Kontrast, Surfaces, Motion, UX-Writing, Formulare, Empty States, visuelle Hierarchie, Dark Mode, responsives Verhalten, i18n, Forschungsmethoden, Audit-Scoring und Design-Anti-Patterns ab.
344
178
 
345
- ## Warum es funktioniert
179
+ Der Agent startet nicht von einem leeren Prompt. Er verfügt über ein gemeinsames Design-Vokabular und konkrete Standards, die er bei Planung, Implementierung und Verifikation anwenden kann.
346
180
 
347
- ### Context-Engineering
181
+ Vollständige Übersicht: [docs/KNOWLEDGE-BASE.md](docs/KNOWLEDGE-BASE.md)
348
182
 
349
- AI-Coding-CLIs sind mächtig, **wenn** du sie mit Kontext fütterst. Die meisten tun das nicht.
183
+ ### Projektspezifischer Speicher
350
184
 
351
- GDD erledigt das für dich:
185
+ GDD erstellt einen `.design/`-Arbeitsbereich, der jeden Zyklus geerdet hält:
352
186
 
353
- | Datei | Zweck |
354
- |-------|-------|
355
- | `.design/BRIEF.md` | Problem, Zielgruppe, Erfolgsmetriken des Zyklus |
356
- | `.design/DESIGN.md` | Aktuelle Design-System-Snapshot (Tokens, Komponenten, Hierarchie) |
357
- | `.design/DESIGN-CONTEXT.md` | D-XX-Entscheidungen, Interview-Antworten, Upstream-/Downstream-Constraints |
358
- | `.design/DESIGN-PLAN.md` | Atomare Tasks, Wave-Choreografie, Dependencies |
359
- | `.design/DESIGN-VERIFICATION.md` | Verifikationsergebnis, Gap-Liste, Handoff-Faithfulness-Score |
360
- | `.design/intel/` | Abfragbarer Knowledge-Layer |
361
- | `.design/archive/cycle-N/EXPERIENCE.md` | Zyklus-Retrospektive, zyklusübergreifender Speicher |
362
- | `.design/telemetry/events.jsonl` | Typisierter Event-Stream über Stufen hinweg |
363
- | `.design/telemetry/posterior.json` | Bandit-Posterior (wenn `adaptive_mode != static`) |
187
+ | Artefakt | Zweck |
188
+ | --- | --- |
189
+ | `.design/BRIEF.md` | Problem, Zielgruppe, Scope, Erfolgsmetriken |
190
+ | `.design/DESIGN.md` | Aktuelle Design-System-Snapshot |
191
+ | `.design/DESIGN-CONTEXT.md` | Entscheidungen, Constraints, Referenzen |
192
+ | `.design/DESIGN-PLAN.md` | Atomarer Implementierungsplan |
193
+ | `.design/DESIGN-VERIFICATION.md` | Finales Audit und Gap-Report |
194
+ | `.design/intel/` | Abfragbares Projektwissen: Tokens, Komponenten, Beziehungen, Entscheidungen |
195
+ | `.design/archive/` | Verlauf abgeschlossener Zyklen und Lernergebnisse |
364
196
 
365
- Größenlimits dort, wo Claudes Qualität abfällt. Bleib darunter, hol dir Konsistenz.
197
+ Je länger du es nutzt, desto weniger muss der Agent neu entdecken.
366
198
 
367
- ### 37 spezialisierte Agenten
199
+ ### Verifikation vor dem Shipping
368
200
 
369
- Jede Stufe ist ein leichtgewichtiger Orchestrator, der spezialisierte Agenten spawnt.
201
+ GDD hört nicht auf, sobald die UI „fertig aussieht".
370
202
 
371
- | Stufe | Orchestrator | Agenten |
372
- |-------|--------------|---------|
373
- | Brief | Eine-Frage-Interview | (keine Sub-Agenten) |
374
- | Explore | spawnt 5 Mapper + Discussant | 5 parallele Mapper, design-discussant, research-synthesizer |
375
- | Plan | spawnt Researcher + Planner + Checker | design-phase-researcher (optional), design-planner (opus), design-plan-checker (haiku) |
376
- | Design | Wave-Koordination + Worktree-Isolation | design-executor pro Task, design-fixer bei Solidify-Fehlschlag |
377
- | Verify | spawnt Auditor + Verifier + Checker | design-auditor, design-verifier, design-integration-checker |
378
- | Reflect | liest Telemetrie + Lernergebnisse | design-reflector (opus), design-authority-watcher, design-update-checker |
203
+ Die Verify-Stufe prüft, ob das Ergebnis noch übereinstimmt mit:
379
204
 
380
- ### 12 Tool-Verbindungen
205
+ - dem ursprünglichen Brief
206
+ - den Design-System-Tokens
207
+ - den Barrierefreiheits-Schwellenwerten
208
+ - den Komponenten-Konventionen
209
+ - der visuellen Hierarchie
210
+ - den Motion- und Interaktionsregeln
211
+ - den festgehaltenen Designentscheidungen
381
212
 
382
- Alle optional — die Pipeline degradiert sauber, wenn eine Verbindung nicht verfügbar ist:
213
+ Wenn Lücken auftauchen, erstellt GDD eine strukturierte Fix-Liste, anstatt das Review dem Bauchgefühl zu überlassen.
383
214
 
384
- - **Figma** (Lesen + Schreiben + Code Connect)
385
- - **Refero** — Design-Referenzsuche
386
- - **Pinterest** — visuelle Referenzverankerung
387
- - **Claude Design** — Handoff-Bundle-Import
388
- - **Storybook** — Komponenten-Spezifikations-Lookup
389
- - **Chromatic** — Visual-Regression-Baseline-Diff
390
- - **Preview** — Playwright + Claude Preview MCP Runtime-Screenshots
391
- - **paper.design** — MCP-Canvas-Read/Write
392
- - **pencil.dev** — Git-getrackte `.pen`-Spec-Dateien
393
- - **Graphify** — Knowledge-Graph-Export
394
- - **21st.dev Magic** — Vorbild-Suche vor Greenfield-Builds
395
- - **Magic Patterns** — DS-aware Komponenten-Generierung
215
+ ### Skill-Behavior-Tests
396
216
 
397
- ### Eingebettete Design-Referenzen
217
+ GDDs eigene Skills werden unter adversarialen Drucksituationen getestet (Zeitdruck, Sunk-Cost, Autorität, Scope-Minimierung), um zu bestätigen, dass sie ihre Disziplin wahren, statt einzuknicken. Siehe [CONTRIBUTING.md](CONTRIBUTING.md) dazu, wie man ein Drucksituations-Szenario hinzufügt.
398
218
 
399
- Das Plugin liefert **18+ Referenzdateien** — NN/g 10, Don Normans emotionales Design, Dieter Rams' 10 Prinzipien, Disneys 12 (Motion), Sonner / Emil Kowalski Component-Authoring-Linse, Peak-End, Loss Aversion, Cognitive Load, Aesthetic-Usability, Doherty, Flow, 35 Komponenten-Spezifikationen, Gestalt, visuelle Hierarchie, Brand Voice, 161 Branchen-Paletten, 67 UI-Ästhetiken, 12 Motion-Easings, 8 Transition-Familien, WCAG 2.1 AA, Plattformen (iOS/Android/web/visionOS/watchOS), RTL/CJK, Form-Patterns, Anti-Pattern-Katalog.
400
-
401
- ### Atomare Git-Commits
219
+ ## Wie es funktioniert
402
220
 
221
+ ```text
222
+ Brief -> Explore -> Plan -> Design -> Verify -> Ship
403
223
  ```
404
- abc123f docs(08-02): complete user-card token plan
405
- def456g feat(08-02): unify card surface tokens with --color-bg-elevated
406
- hij789k feat(08-02): replace inline padding with --space-* scale
407
- lmn012o test(08-02): assert card.spec passes WCAG contrast 4.5:1
408
- ```
409
-
410
- Git-Bisect findet exakt den fehlgeschlagenen Task. Jeder Task ist unabhängig revertierbar. Solidify-with-Rollback fügt ein Validierungsgate auf Task-Ebene hinzu, sodass ein kaputter Task 3 die Tasks 4–10 nie korrumpiert, bevor Verify läuft.
411
-
412
- ### Selbstverbesserungs-Loop
413
-
414
- Nach jedem Zyklus liest `design-reflector` (opus) `events.jsonl`, `agent-metrics.json`, `learnings/` und schlägt Diffs vor — Tier-Overrides, Parallelisierungsregeln, Referenz-Ergänzungen, Frontmatter-Updates. `/gdd:apply-reflections` zeigt das Diff und fragt vor dem Anwenden.
415
224
 
416
- Die **No-Regret-Adaptiv-Schicht** (v1.23.5) legt darauf einen Thompson-Sampling-Bandit + AdaNormalHedge-Ensemble + MMR-Reranking, single-user-tauglich durch Informed-Prior-Bootstrap.
225
+ | Stufe | Befehl | Output |
226
+ | --- | --- | --- |
227
+ | Brief | `/gdd:brief` | Erfasst das Designproblem |
228
+ | Explore | `/gdd:explore` | Kartiert UI-System, Debt, Tokens, Komponenten |
229
+ | Plan | `/gdd:plan` | Erstellt atomare Design-Tasks |
230
+ | Design | `/gdd:design` | Führt Tasks mit Validierung aus |
231
+ | Verify | `/gdd:verify` | Auditiert das finale Ergebnis |
417
232
 
418
- ### Kosten-Governance
233
+ ### Kern-Outputs
419
234
 
420
- - **`gdd-router`-Skill** — deterministisches Intent → fast / quick / full Routing, ohne Modell-Aufruf.
421
- - **`gdd-cache-manager`** — expliziter Layer-B-Cache, SHA-256-Input-Hash, 5-Min-TTL-Awareness.
422
- - **`budget-enforcer` PreToolUse-Hook** — erzwingt Tier-Overrides, harte Caps und Lazy-Spawn-Gates aus `.design/budget.json`.
423
- - **Spawn-genaue Kosten-Telemetrie** — `.design/telemetry/costs.jsonl`-Zeilen speisen die regelbasierten Empfehlungen von `/gdd:optimize`.
424
-
425
- Zielt auf 50–70% Token-Kostenreduktion pro Task ohne Qualitätsregression.
426
-
427
- ---
235
+ | Datei | Was sie macht |
236
+ | --- | --- |
237
+ | `.design/BRIEF.md` | Problem, Zielgruppe und Erfolgsmetriken des Zyklus |
238
+ | `.design/DESIGN.md` | Aktuelle Design-System-Snapshot |
239
+ | `.design/DESIGN-CONTEXT.md` | Designentscheidungen und Constraints |
240
+ | `.design/DESIGN-PLAN.md` | Atomare Tasks, Waves, Dependencies |
241
+ | `.design/DESIGN-VERIFICATION.md` | Verifikationsergebnis und Gap-Liste |
242
+ | `.design/intel/` | Abfragbarer Knowledge-Layer für dieses Projekt |
428
243
 
429
244
  ## Befehle
430
245
 
431
- ### Kernpipeline
246
+ GDD liefert 96 Skills. Dies sind die, die die meisten Nutzer im Alltag brauchen. Die vollständige Referenz findest du in [SKILL.md](SKILL.md).
432
247
 
433
- | Befehl | Was er tut |
434
- |--------|------------|
435
- | `/gdd:brief` | Stufe 1 — Design-Brief erfassen |
436
- | `/gdd:explore` | Stufe 2 — Codebase-Inventar + Interview |
437
- | `/gdd:plan` | Stufe 3 — DESIGN-PLAN.md erzeugen |
438
- | `/gdd:design` | Stufe 4 — in Wellen ausführen |
439
- | `/gdd:verify` | Stufe 5 — gegen den Brief verifizieren |
440
- | `/gdd:ship` | Sauberen PR-Branch erzeugen |
441
- | `/gdd:next` | Auto-Routing zur nächsten Stufe gemäß STATE.md |
442
- | `/gdd:do <text>` | Natursprachlicher Router |
443
- | `/gdd:fast <text>` | One-Shot-triviale Korrektur, ohne Pipeline |
444
- | `/gdd:quick` | Ad-hoc-Task mit GDD-Garantien, aber übersprungenen optionalen Gates |
445
-
446
- ### Erstlauf + Onboarding
447
-
448
- | Befehl | Was er tut |
449
- |--------|------------|
450
- | `/gdd:start` | Erstlauf-Beweispfad — Top-3-Designprobleme im Repo |
451
- | `/gdd:new-project` | GDD-Projekt initialisieren |
452
- | `/gdd:connections` | Onboarding-Wizard für die 12 externen Integrationen |
453
-
454
- ### Zyklus-Lifecycle
455
-
456
- | Befehl | Was er tut |
457
- |--------|------------|
458
- | `/gdd:new-cycle` | Neuen Design-Zyklus eröffnen |
459
- | `/gdd:complete-cycle` | Zyklus-Artefakte archivieren + EXPERIENCE.md |
460
- | `/gdd:pause` / `/gdd:resume` | Nummerierte Checkpoints |
461
- | `/gdd:continue` | Alias für `/gdd:resume` |
462
- | `/gdd:timeline` | Narrative Retrospektive über Zyklen + Git-Log |
463
-
464
- ### Iteration + Entscheidungen
465
-
466
- | Befehl | Was er tut |
467
- |--------|------------|
468
- | `/gdd:discuss [topic]` | Adaptives Design-Interview |
469
- | `/gdd:list-assumptions` | Versteckte Designannahmen vor dem Plan offenlegen |
470
- | `/gdd:sketch [idea]` | HTML-Mockups in mehreren Varianten |
471
- | `/gdd:spike [idea]` | Zeitlich begrenztes Machbarkeitsexperiment |
472
- | `/gdd:sketch-wrap-up` / `/gdd:spike-wrap-up` | Findings als projektlokalen Skill bündeln |
473
- | `/gdd:audit` | Wrapper Verify + Audit + Reflector |
474
- | `/gdd:reflect` | Reflector on-demand starten |
475
- | `/gdd:apply-reflections` | Vorschläge prüfen und selektiv anwenden |
476
-
477
- ### Speicher + Knowledge-Layer
478
-
479
- | Befehl | Was er tut |
480
- |--------|------------|
481
- | `/gdd:recall <query>` | FTS5-Suche |
482
- | `/gdd:extract-learnings` | Muster/Entscheidungen/Lehren extrahieren |
483
- | `/gdd:note <text>` | Reibungsfreie Ideenerfassung |
484
- | `/gdd:plant-seed <idea>` | Vorausschauende Idee mit Trigger-Bedingung |
485
- | `/gdd:analyze-dependencies` | Token-Fanout, Call-Graph, Entscheidungsverfolgung |
486
- | `/gdd:skill-manifest` | Alle GDD-Skills und Agenten auflisten |
487
- | `/gdd:graphify` | Projekt-Knowledge-Graph bauen/abfragen/diffen |
488
- | `/gdd:watch-authorities` | Diff der Design-Autoritäts-Feed-Whitelist |
489
-
490
- ### Verbindungen
491
-
492
- | Befehl | Was er tut |
493
- |--------|------------|
494
- | `/gdd:figma-write` | Designentscheidungen zurück nach Figma schreiben |
495
- | `/gdd:handoff <bundle>` | Claude-Design-Bundle importieren |
496
- | `/gdd:darkmode` | Dark-Mode-Implementierung auditieren |
497
- | `/gdd:compare` | Delta DESIGN.md vs DESIGN-VERIFICATION.md berechnen |
498
- | `/gdd:style <Component>` | Komponenten-Handoff-Dokument generieren |
499
-
500
- ### Diagnose + Forensik
501
-
502
- | Befehl | Was er tut |
503
- |--------|------------|
504
- | `/gdd:scan` | Codebase-Design-System-Inventar |
505
- | `/gdd:map` | 5 parallele Codebase-Mapper |
506
- | `/gdd:debug [desc]` | Symptomgetriebene Designuntersuchung |
507
- | `/gdd:health` | Gesundheitsbericht für `.design/`-Artefakte |
508
- | `/gdd:progress` | Position in der Pipeline |
509
- | `/gdd:stats` | Zyklusstatistiken |
510
- | `/gdd:optimize` | Regelbasierte Kostenanalyse |
511
- | `/gdd:warm-cache` | Anthropic-Cache vorwärmen |
512
-
513
- ### Distribution + Update
514
-
515
- | Befehl | Was er tut |
516
- |--------|------------|
517
- | `/gdd:update` | GDD aktualisieren mit Changelog-Vorschau |
518
- | `/gdd:reapply-patches` | Lokale `reference/`-Modifikationen re-stitchen |
519
- | `/gdd:check-update` | Manueller Update-Check |
520
- | `/gdd:settings` | `.design/config.json` konfigurieren |
521
- | `/gdd:set-profile <profile>` | Modellprofil wechseln |
522
- | `/gdd:undo` | Sicherer Designänderungs-Revert |
523
- | `/gdd:pr-branch` | Sauberer PR-Branch |
524
-
525
- ### Backlog + Notizen
526
-
527
- | Befehl | Was er tut |
528
- |--------|------------|
529
- | `/gdd:todo` | Design-Tasks hinzufügen / auflisten / wählen |
530
- | `/gdd:add-backlog <idea>` | Idee für zukünftigen Zyklus parken |
531
- | `/gdd:review-backlog` | Geparkte Einträge prüfen |
532
-
533
- ### Hilfe
534
-
535
- | Befehl | Was er tut |
536
- |--------|------------|
537
- | `/gdd:help` | Vollständige Befehlsliste und Verwendung |
538
- | `/gdd:bandit-reset` | Adaptiv-Schicht-Posterior bei Anthropic-Modell-Release zurücksetzen |
248
+ ### Kernpipeline
539
249
 
540
- ---
250
+ | Befehl | Zweck |
251
+ | --- | --- |
252
+ | `/gdd:brief` | Den Design-Brief erfassen |
253
+ | `/gdd:explore` | Das aktuelle UI-System inventarisieren |
254
+ | `/gdd:plan` | Den Design-Plan erstellen |
255
+ | `/gdd:design` | Den Plan ausführen |
256
+ | `/gdd:verify` | Das Ergebnis verifizieren |
257
+ | `/gdd:ship` | Einen sauberen PR-Branch vorbereiten |
258
+ | `/gdd:next` | Automatisch zur nächsten Stufe routen |
259
+
260
+ ### Tägliche Nutzung
261
+
262
+ | Befehl | Zweck |
263
+ | --- | --- |
264
+ | `/gdd:do <task>` | Natursprachlicher Router |
265
+ | `/gdd:fast <task>` | Kleine, gezielte Korrektur |
266
+ | `/gdd:quick` | Schlanker Task-Flow |
267
+ | `/gdd:audit` | Design-Quality-Audit |
268
+ | `/gdd:darkmode` | Dark-Mode-Audit |
269
+ | `/gdd:style <component>` | Komponenten-Style-Handoff |
270
+ | `/gdd:health` | Pipeline-Zustand diagnostizieren |
271
+ | `/gdd:progress` | Aktuellen Zyklus-Fortschritt anzeigen |
272
+ | `/gdd:resume` | Vom Checkpoint fortsetzen |
273
+
274
+ ### Design-Tools und Handoff
275
+
276
+ | Befehl | Zweck |
277
+ | --- | --- |
278
+ | `/gdd:connections` | Optionale Integrationen konfigurieren |
279
+ | `/gdd:figma-extract` | Figma-Design-System-Kontext extrahieren |
280
+ | `/gdd:figma-write` | Entscheidungen und Status zurück nach Figma schreiben |
281
+ | `/gdd:handoff <bundle>` | Ein Claude-Design-Bundle importieren |
282
+ | `/gdd:sketch <idea>` | HTML-Mockups in mehreren Varianten generieren |
283
+ | `/gdd:spike <idea>` | Zeitlich begrenzter Machbarkeitsdurchlauf |
284
+
285
+ Vollständige Befehlsreferenz: [SKILL.md](SKILL.md)
541
286
 
542
287
  ## Verbindungen
543
288
 
544
- GDD liefert 12 Tool-Verbindungen. Alle optional. Konfigurieren mit `/gdd:connections`.
545
-
546
- | Verbindung | Zweck | Probe |
547
- |------------|-------|-------|
548
- | **Figma** | Tokens, Komponenten, Screenshots lesen; Annotationen, Code Connect, Implementierungsstatus schreiben | `mcp__figma__get_metadata` + `use_figma` |
549
- | **Refero** | Design-Referenzsuche | `mcp__refero__search` |
550
- | **Pinterest** | Visuelle Referenz für Brand Voice + Stil | OAuth + MCP |
551
- | **Claude Design** | Handoff-Bundle-Import | URL oder lokale Datei |
552
- | **Storybook** | Komponenten-Spec-Lookup an Port 6006 | HTTP-Probe |
553
- | **Chromatic** | Visual-Regression-Baseline-Diff | API-Key |
554
- | **Preview** | Playwright + Claude Preview MCP Runtime-Screenshots | `mcp__Claude_Preview__preview_*` |
555
- | **paper.design** | MCP-Canvas-Read/Write | `mcp__paper__use_paper` |
556
- | **pencil.dev** | Git-getrackte `.pen`-Specs | `.pen`-Dateien im Repo |
557
- | **Graphify** | Knowledge-Graph-Export | `mcp__graphify__*` |
558
- | **21st.dev Magic** | Vorbildsuche vor Greenfield | `mcp__magic__search` |
559
- | **Magic Patterns** | DS-aware Komponenten-Generierung | `mcp__magic-patterns__generate` |
560
-
561
- Vollständige Details in [`connections/connections.md`](connections/connections.md).
562
-
563
- ---
289
+ GDD funktioniert ohne externe Tools, kann sich aber mit 39 optionalen Integrationen verbinden. Alle sind optional; die Pipeline degradiert sauber auf Fallbacks, wenn eine Verbindung nicht verfügbar ist.
564
290
 
565
- ## Konfiguration
291
+ Die Verbindungsschicht umfasst diese Kategorien:
566
292
 
567
- GDD speichert Projekteinstellungen in `.design/config.json`. Konfiguriere während `/gdd:new-project` oder aktualisiere mit `/gdd:settings`.
293
+ - **Design-Surfaces** - Figma (Lesen + Schreiben + Code Connect), paper.design, pencil.dev, Penpot, Framer, Webflow, Plasmic
294
+ - **Referenz und Research** - Refero, Pinterest, Lazyweb, Mobbin, Claude-Design-Handoff
295
+ - **Komponenten-Generierung** - 21st.dev Magic, Magic Patterns, v0.dev, Builder.io
296
+ - **Komponenten-Spec und visuelle QA** - Storybook, Chromatic, Preview (Playwright + Claude Preview MCP)
297
+ - **Knowledge-Graph** - Graphify
298
+ - **Native und Nicht-Web-Output** - Xcode Simulator, Android Emulator, Litmus / Email-on-Acid, Print-Renderer
299
+ - **Motion-Verifikation** - Lottie, Rive
300
+ - **Team-Surfaces** - Slack, Discord, Linear, Jira, Notion, GitHub PR
568
301
 
569
- ### Modellprofile
302
+ Konfiguriere Integrationen mit:
570
303
 
571
- | Profil | Planung | Ausführung | Verifikation |
572
- |--------|---------|------------|--------------|
573
- | `quality` | Opus | Opus | Sonnet |
574
- | `balanced` (Standard) | Opus | Sonnet | Sonnet |
575
- | `budget` | Sonnet | Sonnet | Haiku |
576
- | `inherit` | Inherit | Inherit | Inherit |
577
-
578
- ```
579
- /gdd:set-profile budget
304
+ ```bash
305
+ /gdd:connections
580
306
  ```
581
307
 
582
- ### Adaptiv-Modus
583
-
584
- `.design/budget.json#adaptive_mode`-Leiter (v1.23.5):
585
-
586
- | Modus | Was er tut |
587
- |-------|------------|
588
- | `static` (Standard) | Phase-10.1-Verhalten |
589
- | `hedge` | AdaNormalHedge-Ensemble + MMR-Reranking aktiviert. Sicherste Einführung. |
590
- | `full` | Bandit-Router + Hedge + MMR alle aktiv |
308
+ Die vollständige Verbindungsliste mit Probe-Mustern findest du in [connections/connections.md](connections/connections.md).
591
309
 
592
- ### Parallelität
310
+ ## Voraussetzungen
593
311
 
594
- | Einstellung | Standard | Steuert |
595
- |-------------|----------|---------|
596
- | `parallelism.enabled` | `true` | Unabhängige Tasks in Worktrees ausführen |
597
- | `parallelism.min_estimated_savings_seconds` | `30` | Unter dieser Schwelle Parallelisierung überspringen |
598
- | `parallelism.max_concurrent_workers` | `4` | Hartes Cap auf gleichzeitige Worker |
312
+ - Node.js 22 oder 24
313
+ - Git
314
+ - Eine unterstützte AI-Coding-Runtime
599
315
 
600
- ### Quality Gates
316
+ ## Multi-Runtime-Support
601
317
 
602
- | Einstellung | Standard | Steuert |
603
- |-------------|----------|---------|
604
- | `solidify.rollback_mode` | `"stash"` | `stash` / `hard` / `none` |
605
- | `solidify.commands` | autodetect | Typecheck-/Build-/Test-Befehle überschreiben |
606
- | `verify.iterations_max` | `3` | Cap auf Verify→Fix-Loop |
607
- | `connection.figma_writeback` | `proposal` | `proposal` / `auto` |
608
-
609
- ---
318
+ GDD installiert über 14 AI-Coding-Runtimes: Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Kilo, Copilot, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy und Cline. Dieselben Quell-Skills und -Agenten werden durch Per-Runtime-Konverter in das native Layout jeder Runtime kompiliert (`skills/`, `command/`, `agents/` oder `.clinerules`), sodass die Pipeline mit dir über Editoren hinweg mitreist.
610
319
 
611
- ## Sicherheit
320
+ Claude Code ist das Flaggschiff. Die volle Erfahrung läuft dort von Anfang bis Ende: jeder Agent, die Defense-in-Depth-Hooks und die MCP-gestützten Verbindungen. Auf den anderen Runtimes erhältst du dieselben Skills und Agenten in ihrer nativen Form, MCP-gestützte Verbindungen leuchten auf den MCP-fähigen Hosts auf, und die Hook-Schicht ist spezifisch für Claude Code.
612
321
 
613
- ### Eingebaute Härtung
322
+ ## Sicherheit und Datenschutz
614
323
 
615
- GDD liefert seit Phase 14.5 Defense-in-Depth:
324
+ GDD ist standardmäßig Local-First. Es schreibt Projektartefakte unter `.design/`, nutzt optionale Integrationen nur, wenn sie konfiguriert sind, und hält das Issue-Reporting einwilligungsbasiert.
616
325
 
617
- - **`hooks/gdd-bash-guard.js`** — PreToolUse:Bash blockiert ~50 gefährliche Muster nach Unicode-NFKC- + ANSI-Normalisierung.
618
- - **`hooks/gdd-protected-paths.js`** — PreToolUse:Edit/Write/Bash erzwingt die `protected_paths`-Glob-Liste.
619
- - **`hooks/gdd-read-injection-scanner.ts`** — scannt eingehenden Read-Inhalt nach unsichtbarem Unicode, HTML-Kommentaren, Secret-Exfiltrations-Mustern.
620
- - **`scripts/lib/blast-radius.cjs`** — `design-executor`-Preflight verweigert Tasks über `max_files_per_task: 10` / `max_lines_per_task: 400`.
621
- - **`hooks/gdd-mcp-circuit-breaker.js`** — bricht aufeinanderfolgende Timeout-Schleifen auf `use_figma` / `use_paper` / `use_pencil`.
326
+ Das Plugin enthält Defense-in-Depth-Hooks für geschützte Pfade, das Blockieren gefährlicher Befehle, Injection-Scanning, MCP-Circuit-Breaking und Budget-Enforcement. GDD stellt außerdem 13 schreibgeschützte MCP-Tools für eine sichere Projekt-Introspektion bereit.
622
327
 
623
- ### Sensible Dateien schützen
624
-
625
- Füge sensible Pfade der Deny-List deines Runtimes hinzu:
328
+ Füge sensible Pfade der Deny-List deiner Runtime hinzu:
626
329
 
627
330
  ```json
628
331
  {
@@ -631,7 +334,6 @@ Füge sensible Pfade der Deny-List deines Runtimes hinzu:
631
334
  "Read(.env)",
632
335
  "Read(.env.*)",
633
336
  "Read(**/secrets/*)",
634
- "Read(**/*credential*)",
635
337
  "Read(**/*.pem)",
636
338
  "Read(**/*.key)"
637
339
  ]
@@ -639,77 +341,58 @@ Füge sensible Pfade der Deny-List deines Runtimes hinzu:
639
341
  }
640
342
  ```
641
343
 
642
- > [!IMPORTANT]
643
- > Da GDD Markdown-Dateien generiert, die zu LLM-Systemprompts werden, ist jeder benutzergesteuerte Text, der in `.design/`-Artefakte fließt, ein potenzieller indirekter Prompt-Injection-Vektor. Der Injection-Scanner fängt solche Vektoren auf mehreren Ebenen — aber Defense-in-Depth bleibt Best Practice.
644
-
645
- ---
344
+ Lies: [SECURITY.md](SECURITY.md) · [PRIVACY.md](PRIVACY.md)
646
345
 
647
- ## Fehlersuche
346
+ ## Aktualisieren
648
347
 
649
- **Befehle nach Installation nicht gefunden?**
650
- - Runtime neu starten
651
- - `~/.claude/skills/get-design-done/` (global) oder `./.claude/skills/get-design-done/` (lokal) prüfen
652
- - `/gdd:help` zur Bestätigung der Registrierung
653
-
654
- **Pipeline mitten in einer Stufe blockiert?**
655
- - `/gdd:resume` — vom letzten nummerierten Checkpoint wiederherstellen
656
- - `/gdd:health` — `.design/`-Artefaktprobleme diagnostizieren
657
- - `/gdd:progress --forensic` — 6-Punkte-Integritätsaudit
658
-
659
- **Kostenüberschreitung?**
660
- - `/gdd:optimize` — regelbasierte Empfehlungen
661
- - `/gdd:set-profile budget` — auf Budget-Tier umstellen
662
- - `adaptive_mode: "full"` in `.design/budget.json` setzen — der Bandit lernt
663
-
664
- **Auf die neueste Version aktualisieren?**
665
348
  ```bash
666
349
  npx @hegemonart/get-design-done@latest
667
350
  ```
668
351
 
669
- **Docker / Container?**
352
+ Oder aus Claude Code heraus:
670
353
 
671
354
  ```bash
672
- CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
355
+ /gdd:update
673
356
  ```
674
357
 
675
- ### Deinstallieren
358
+ Die vollständige Release-Historie findest du in [CHANGELOG.md](CHANGELOG.md).
676
359
 
677
- ```bash
678
- # Globale Deinstallation (pro Runtime)
679
- npx @hegemonart/get-design-done --claude --global --uninstall
680
- npx @hegemonart/get-design-done --opencode --global --uninstall
681
- # ... gleiches Muster --<runtime> --global --uninstall für die 14 Runtimes
360
+ ## Fehlersuche
682
361
 
683
- # Interaktive Mehrfachauswahl-Deinstallation (ohne Runtime-Flag)
684
- npx @hegemonart/get-design-done --uninstall
362
+ ### Befehle erscheinen nicht
685
363
 
686
- # Lokale Deinstallation
687
- npx @hegemonart/get-design-done --claude --local --uninstall
688
- # ... mit --local-Flag
689
- ```
364
+ Starte deine Runtime neu und führe aus:
690
365
 
691
- Entfernt alle GDD-Befehle, Agenten, Hooks und Einstellungen, ohne deine anderen Konfigurationen zu beeinflussen.
366
+ ```bash
367
+ /gdd:help
368
+ ```
692
369
 
693
- ---
370
+ ### Pipeline hängt fest
694
371
 
695
- ## Feedback-Kanal (ab v1.30.0)
372
+ ```bash
373
+ /gdd:health
374
+ /gdd:resume
375
+ ```
696
376
 
697
- GDD enthält jetzt einen einwilligungsbasierten GitHub-Issue-Reporter über den Slash-Befehl `/gdd:report-issue`.
377
+ ### Kosten sind zu hoch
698
378
 
699
- - **Was er tut.** Führt Sie durch das Melden eines Fehlers oder einer Funktionslücke, mit Vorschau der Nutzlast vor dem Absenden. Lokal-first, einwilligungsbasiert, kein Auto-Modus.
700
- - **Pseudonymisierung, KEINE Anonymisierung.** Direkte Identifikatoren (Benutzername, Hostname, absolute Pfade, Git-Identität, Umgebungsvariablen-Werte, E-Mails, IP-Adressen) werden durch stabile Pseudonyme ersetzt — aber die interne Korrelation bleibt erhalten, damit Maintainer debuggen können. Seitenkanäle (Schreibstil, Code-Muster, Repo-Fingerabdrücke) können weiterhin re-identifizieren. Sie sehen die vollständige Nutzlast vor dem Absenden und stimmen pro Issue ausdrücklich zu.
701
- - **Notausschalter.** Setzen Sie `GDD_DISABLE_ISSUE_REPORTER=1` (Umgebung) oder fügen Sie `{ "issue_reporter": false }` in `.design/config.json` hinzu, um die Übermittlung vor jedem Netzwerkaufruf zu stoppen.
702
- - **`gh`-Fallback.** Falls die GitHub-CLI nicht installiert ist, wird die Nutzlast auf die Festplatte unter `.design/issue-drafts/` geschrieben und die Issue-Template-URL in die Zwischenablage kopiert.
379
+ ```bash
380
+ /gdd:optimize
381
+ ```
703
382
 
704
- Siehe die englische [`README.md`](README.md) für die vollständigen Details, [`reference/pseudonymization-rules.md`](reference/pseudonymization-rules.md) für den Regelkatalog (R1..R8) und [`reference/known-failure-modes.md`](reference/known-failure-modes.md) für bekannte Fehlermodi.
383
+ ## Mitwirken
705
384
 
706
- **v1.30.5-Update** — der Katalog umfasst jetzt 22 Einträge (vorher 10 in v1.30.0) und ein neues deterministisches Fuzzy-Matching-Modul (`scripts/lib/failure-mode-matcher.cjs`) liefert Top-N-Kandidaten mit Konfidenzwerten. Reflector + Authority-Watcher können neue Einträge über `/gdd:apply-reflections` vorschlagen (6. Vorschlagsklasse) — strikt nur Vorschläge, jeder Eintrag durchläuft die Nutzerprüfung.
385
+ ```bash
386
+ npm install
387
+ npm test
388
+ npm run typecheck
389
+ ```
707
390
 
708
- ---
391
+ Lies: [CONTRIBUTING.md](CONTRIBUTING.md)
709
392
 
710
393
  ## Lizenz
711
394
 
712
- MIT-Lizenz. Siehe [LICENSE](LICENSE) für Details.
395
+ MIT-Lizenz. Siehe [LICENSE](LICENSE) für Details. Drittanbieter-Attributionen sind in [NOTICE](NOTICE) aufgeführt.
713
396
 
714
397
  ---
715
398