@hegemonart/get-design-done 1.59.5 → 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 (18) hide show
  1. package/.claude-plugin/marketplace.json +4 -4
  2. package/.claude-plugin/plugin.json +2 -2
  3. package/CHANGELOG.md +54 -0
  4. package/README.md +219 -441
  5. package/SKILL.md +2 -2
  6. package/docs/i18n/README.de.md +212 -527
  7. package/docs/i18n/README.fr.md +203 -518
  8. package/docs/i18n/README.it.md +211 -526
  9. package/docs/i18n/README.ja.md +209 -524
  10. package/docs/i18n/README.ko.md +210 -525
  11. package/docs/i18n/README.zh-CN.md +215 -551
  12. package/package.json +1 -1
  13. package/reference/skill-graph.md +4 -1
  14. package/scripts/lib/install/doctor-codex-plugin.cjs +1 -1
  15. package/scripts/lib/install/doctor-cursor-marketplace.cjs +2 -2
  16. package/scripts/lib/manifest/skills.json +13 -0
  17. package/scripts/skill-templates/handoff/SKILL.md +99 -0
  18. package/skills/handoff/SKILL.md +99 -0
package/docs/i18n/README.de.md CHANGED
@@ -4,9 +4,11 @@
4
4
 
5
5
  [English](../../README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [한국어](README.ko.md) · [Français](README.fr.md) · [Italiano](README.it.md) · **Deutsch**
6
6
 
7
- **Eine Design-Quality-Pipeline für AI-Coding-Agenten: Brief → Explore → Plan → Implementierung → Verifikation.**
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
- **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.**
9
+ **Eine Design-Quality-Pipeline für AI-Coding-Agenten: Brief -> Explore -> Plan -> Design -> Verify.**
10
+
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.**
10
12
 
11
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)
12
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)
@@ -15,612 +17,315 @@
15
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/)
16
18
  [![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
17
19
 
18
- <br>
19
-
20
20
  ```bash
21
21
  npx @hegemonart/get-design-done@latest
22
22
  ```
23
23
 
24
24
  **Funktioniert auf macOS, Linux und Windows.**
25
25
 
26
- <br>
27
-
28
- *„AI-Coding-Agenten liefern UI schnell. Get Design Done sorgt dafür, dass sie Design liefern."*
29
-
30
- <br>
31
-
32
- [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)
33
27
 
34
28
  </div>
35
29
 
36
30
  ---
37
31
 
38
- > [!IMPORTANT]
39
- > ### Schon ein Claude-Design-Bundle?
40
- >
41
- > Wenn du ein Design aus [claude.ai/design](https://claude.ai/design) exportiert hast, kannst du die Stufen 1–3 vollständig überspringen:
42
- >
43
- > ```
44
- > /gdd:handoff ./my-design.html
45
- > ```
46
- >
47
- > 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.
48
-
49
- ---
50
-
51
- ## Warum ich es gebaut habe
52
-
53
- 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.
54
-
55
- 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.
56
-
57
- 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.
58
-
59
- 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.
60
-
61
- — **Hegemon**
62
-
63
- ---
64
-
65
- 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.
66
-
67
- 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.
68
-
69
- ---
70
-
71
- ## Was du bekommst
72
-
73
- - **Brief-gebundene Designarbeit** — jeder Zyklus beginnt mit Problem, Zielgruppe, Constraints, Erfolgskriterien und Must-haves.
74
- - **Design-System-Extraktion** — GDD inventarisiert Tokens, Typografie, Spacing, Komponenten, Motion, Accessibility, Dark Mode und Design Debt, bevor Änderungen geplant werden.
75
- - **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.
76
- - **Atomare Ausführung** — Design-Tasks werden nach Abhängigkeiten zerlegt, in sicheren Waves ausgeführt und unabhängig committet.
77
- - **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.
78
- - **Rollback bei fehlgeschlagener Validierung** — solidify-with-rollback validiert jeden Task, bevor er bestehen bleibt; fehlgeschlagene Arbeit wird automatisch revertet.
79
-
80
- ---
81
-
82
- ## Für wen ist das
32
+ ## Was es ist
83
33
 
84
- 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.
34
+ Get Design Done hilft AI-Coding-Agenten dabei, UI auszuliefern, die wirklich in dein Produkt gehört.
85
35
 
86
- 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.
36
+ Es verwandelt vage Anfragen wie „mach diesen Screen besser" in einen nachvollziehbaren Design-Workflow: Brief, Explore, Plan, Design, Verify.
87
37
 
88
- 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.
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.
89
39
 
90
- ### v1.24.0 Highlights — Multi-Runtime-Installer
40
+ ## Warum es existiert
91
41
 
92
- - **`@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.
93
- - **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.
94
- - **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.
95
- - **Mehrfachauswahl-Deinstallation** — `--uninstall` ohne Runtime-Flag wechselt ebenfalls in die interaktive Mehrfachauswahl, um die Runtimes zu wählen, aus denen entfernt werden soll.
42
+ AI-Agenten sind schnell darin, UI zu produzieren. Der schwierige Teil ist, diese UI kohärent zu machen.
96
43
 
97
- ### Frühere Releases
44
+ Ohne einen Design-Workflow driften generierte Oberflächen auseinander:
98
45
 
99
- - **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).
100
- - **v1.23.0** — SDK-Domain-Primitive (Solidify-with-Rollback-Gate, JSON-Output-Verträge, Auto-Kristallisation von `Touches:`-Mustern).
101
- - **v1.22.0** — SDK-Observability (~24 typisierte Event-Typen, Per-Tool-Call-Trajectory, append-only Event-Chain, Secret-Scrubber).
102
- - **v1.21.0** — Headless-SDK (`gdd-sdk`-CLI führt die volle Pipeline ohne Claude Code aus, parallele Researcher, Cross-Harness-MCP).
103
- - **v1.20.0** — SDK-Foundation (Resilienz-Primitive, lockfile-sichere `STATE.md`, `gdd-state` MCP-Server mit 11 typisierten Tools, TypeScript-Foundation).
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
104
51
 
105
- Vollständige Release-Notes in [CHANGELOG.md](CHANGELOG.md).
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.
106
53
 
107
- ---
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.
108
55
 
109
- <p align="center">
110
- <strong>Supported by</strong>
111
- </p>
56
+ ## Installation
112
57
 
113
- <div align="center">
114
- <a href="https://www.humbleteam.com/" aria-label="Humbleteam">
115
- <img src="docs/assets/sponsors/humbleteam.svg" alt="Humbleteam logo" width="180">
116
- </a>
117
- <br>
118
- <sub>Product design partner for ambitious startups and AI products.</sub>
119
- </div>
120
-
121
- ---
122
-
123
- ## Erste Schritte
58
+ ### npm
124
59
 
125
60
  ```bash
126
61
  npx @hegemonart/get-design-done@latest
127
62
  ```
128
63
 
129
- Der Installer fragt dich:
130
- 1. **Runtime** — Claude Code, OpenCode, Gemini, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline oder alle (interaktive Mehrfachauswahl)
131
- 2. **Speicherort** — Global (alle Projekte) oder Local (nur aktuelles Projekt)
132
-
133
- Verifizieren mit:
64
+ ### Claude Code
134
65
 
66
+ ```bash
67
+ /plugin marketplace add hegemonart/get-design-done
68
+ /plugin install get-design-done@get-design-done
69
+ /reload-plugins
135
70
  ```
136
- /gdd:help
137
- ```
138
-
139
- > [!TIP]
140
- > Starte Claude Code mit `--dangerously-skip-permissions` für eine reibungslose Automatisierungserfahrung. GDD ist für autonome mehrstufige Ausführung konzipiert.
141
71
 
142
- ### Aktuell bleiben
143
-
144
- GDD veröffentlicht häufig. Aktualisiere durch erneutes Ausführen des Installers (idempotent):
72
+ ### Codex
145
73
 
146
74
  ```bash
147
- npx @hegemonart/get-design-done@latest
75
+ codex plugin marketplace add hegemonart/get-design-done
148
76
  ```
149
77
 
150
- Oder in Claude Code:
78
+ ### agentskills.io
151
79
 
152
- ```
153
- /gdd:update
154
- ```
80
+ Durchsuche und installiere Get Design Done über die Skill-Registry [agentskills.io](https://agentskills.io).
155
81
 
156
- `/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.
157
-
158
- <details>
159
- <summary><strong>Nicht-interaktive Installation (Docker, CI, Skripte)</strong></summary>
82
+ ### Direkter Runtime-Installer
160
83
 
161
84
  ```bash
85
+ # Claude Code
162
86
  npx @hegemonart/get-design-done --claude --global
163
87
  npx @hegemonart/get-design-done --claude --local
164
- npx @hegemonart/get-design-done --opencode --global
165
- npx @hegemonart/get-design-done --gemini --global
166
- npx @hegemonart/get-design-done --kilo --global
88
+
89
+ # Andere Runtimes
167
90
  npx @hegemonart/get-design-done --codex --global
168
- npx @hegemonart/get-design-done --copilot --global
169
91
  npx @hegemonart/get-design-done --cursor --global
170
- npx @hegemonart/get-design-done --windsurf --global
171
- npx @hegemonart/get-design-done --antigravity --global
172
- npx @hegemonart/get-design-done --augment --global
173
- npx @hegemonart/get-design-done --trae --global
174
- npx @hegemonart/get-design-done --qwen --global
175
- npx @hegemonart/get-design-done --codebuddy --global
176
- npx @hegemonart/get-design-done --cline --global
177
-
178
- # Alle Runtimes
92
+ npx @hegemonart/get-design-done --gemini --global
93
+
94
+ # Multi-Runtime-Installation
179
95
  npx @hegemonart/get-design-done --all --global
180
96
 
181
- # Dry-Run
97
+ # Vorschau ohne Schreibvorgang
182
98
  npx @hegemonart/get-design-done --dry-run
183
-
184
- # Eigenes Config-Verzeichnis
185
- CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
186
99
  ```
187
100
 
188
- </details>
101
+ ## Erste Schritte
189
102
 
190
- <details>
191
- <summary><strong>Alternative: Claude Code CLI</strong></summary>
103
+ Führe einen schlanken ersten Durchlauf aus:
192
104
 
193
105
  ```bash
194
- claude plugin marketplace add hegemonart/get-design-done
195
- claude plugin install get-design-done@get-design-done
106
+ /gdd:start
196
107
  ```
197
108
 
198
- </details>
199
-
200
- ### Tier-2 Distribution Channels (v1.28.8+)
201
-
202
- 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:
203
-
204
- - **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.
205
- - **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`.
206
- - **Codex Plugin.** Installation via Codex GitHub-URL Plugin-Add:
207
-
208
- ```bash
209
- codex plugin marketplace add hegemonart/get-design-done
210
- ```
211
-
212
- Vollständige Details siehe [README.md](README.md) (Englisch, autoritativ).
213
-
214
- ### Capability-Gap-Telemetrie + Self-Authoring (v1.29.0+)
215
-
216
- 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.
217
-
218
- **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`.
219
-
220
- **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).
109
+ Oder durchlaufe den vollständigen Design-Zyklus:
221
110
 
222
- Scope-Guard: Authoring beschränkt sich auf `agents/` und `skills/` — niemals Runtimes / Transports / Hooks. Vollständige Details siehe [README.md](README.md) (Englisch, autoritativ).
223
-
224
-
225
- ## Wie es funktioniert
226
-
227
- > **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/`.
228
-
229
- ### 1. Brief
230
-
231
- ```
111
+ ```bash
232
112
  /gdd:brief
233
- ```
234
-
235
- 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.
236
-
237
- **Erstellt:** `.design/BRIEF.md`
238
-
239
- ---
240
-
241
- ### 2. Explore
242
-
243
- ```
244
113
  /gdd:explore
245
- ```
246
-
247
- 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.
248
-
249
- **Erstellt:** `.design/DESIGN.md`, `.design/DESIGN-DEBT.md`, `.design/DESIGN-CONTEXT.md`, `.design/map/{tokens,components,a11y,motion,visual-hierarchy}.{md,json}`
250
-
251
- ---
252
-
253
- ### 3. Plan
254
-
255
- ```
256
114
  /gdd:plan
115
+ /gdd:design
116
+ /gdd:verify
257
117
  ```
258
118
 
259
- 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.
260
-
261
- **Erstellt:** `.design/DESIGN-PLAN.md`
262
-
263
- ---
119
+ Für natursprachliches Routing:
264
120
 
265
- ### 4. Design
266
-
267
- ```
268
- /gdd:design
121
+ ```bash
122
+ /gdd:do improve the checkout page hierarchy, spacing, and empty states
269
123
  ```
270
124
 
271
- 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
272
126
 
273
- **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
274
128
 
275
- **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.
276
130
 
277
- ```
278
- ┌────────────────────────────────────────────────────────────────────┐
279
- │ WAVE-AUSFÜHRUNG │
280
- ├────────────────────────────────────────────────────────────────────┤
281
- │ │
282
- │ WAVE 1 (parallel) WAVE 2 (parallel) WAVE 3 │
283
- │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
284
- │ │ Task 01 │ │ Task 02 │ → │ Task 03 │ │ Task 04 │ → │ Task 05 │ │
285
- │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
286
- │ │ │ ↑ ↑ ↑ │
287
- │ └───────────┴──────────────┴───────────┴──────────────┘ │
288
- │ Touches:-Pfade steuern die Dependency-Analyse │
289
- │ │
290
- └────────────────────────────────────────────────────────────────────┘
131
+ ```bash
132
+ /gdd:do improve the settings page layout and component hierarchy
291
133
  ```
292
134
 
293
- ---
135
+ ### AI-Output zurück ins Design-System bringen
294
136
 
295
- ### 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.
296
138
 
297
- ```
139
+ ```bash
298
140
  /gdd:verify
299
141
  ```
300
142
 
301
- 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
302
144
 
303
- **Erstellt:** `.design/DESIGN-VERIFICATION.md`, Fix-Commits bei Problemen
145
+ Führe die Verifikation vor einem PR, Release oder Design-Handoff aus.
304
146
 
305
- ---
147
+ ```bash
148
+ /gdd:audit
149
+ ```
306
150
 
307
- ### 6. Ship → Reflect → Nächster Zyklus
151
+ ### Dark Mode reparieren
308
152
 
309
- ```
310
- /gdd:ship # Sauberen PR-Branch erzeugen (filtert .design/-Commits)
311
- /gdd:reflect # design-reflector liest Telemetrie + Lernergebnisse
312
- /gdd:apply-reflections # Vorschläge prüfen und selektiv anwenden
313
- /gdd:complete-cycle # Zyklus-Artefakte archivieren + EXPERIENCE.md schreiben
314
- /gdd:new-cycle # Neuen Design-Zyklus eröffnen
153
+ ```bash
154
+ /gdd:darkmode
315
155
  ```
316
156
 
317
- Oder Auto-Routing:
157
+ ### Einen Design-Handoff importieren
318
158
 
319
- ```
320
- /gdd:next # State automatisch erkennen und nächsten Schritt ausführen
159
+ ```bash
160
+ /gdd:handoff ./my-design.html
321
161
  ```
322
162
 
323
- 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.
163
+ Dies parst ein Claude-Design-Bundle, extrahiert CSS-Custom-Properties in Designentscheidungen und führt Handoff-Faithfulness-Checks aus.
324
164
 
325
- ---
165
+ ### Eine kleine, gezielte Korrektur vornehmen
326
166
 
327
- ### Fast-Modus
328
-
329
- ```
330
- /gdd:fast "<task>"
167
+ ```bash
168
+ /gdd:fast "fix contrast in pricing cards"
331
169
  ```
332
170
 
333
- 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
334
172
 
335
- ```
336
- /gdd:quick
337
- ```
173
+ ### Lokales Design-Wissen
338
174
 
339
- 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`.
340
-
341
- ---
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
- ## Warum es funktioniert
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
- ### Context-Engineering
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
- AI-Coding-CLIs sind mächtig, **wenn** du sie mit Kontext fütterst. Die meisten tun das nicht.
181
+ Vollständige Übersicht: [docs/KNOWLEDGE-BASE.md](docs/KNOWLEDGE-BASE.md)
348
182
 
349
- GDD erledigt das für dich:
183
+ ### Projektspezifischer Speicher
350
184
 
351
- | Datei | Zweck |
352
- |-------|-------|
353
- | `.design/BRIEF.md` | Problem, Zielgruppe, Erfolgsmetriken des Zyklus |
354
- | `.design/DESIGN.md` | Aktuelle Design-System-Snapshot (Tokens, Komponenten, Hierarchie) |
355
- | `.design/DESIGN-CONTEXT.md` | D-XX-Entscheidungen, Interview-Antworten, Upstream-/Downstream-Constraints |
356
- | `.design/DESIGN-PLAN.md` | Atomare Tasks, Wave-Choreografie, Dependencies |
357
- | `.design/DESIGN-VERIFICATION.md` | Verifikationsergebnis, Gap-Liste, Handoff-Faithfulness-Score |
358
- | `.design/intel/` | Abfragbarer Knowledge-Layer |
359
- | `.design/archive/cycle-N/EXPERIENCE.md` | Zyklus-Retrospektive, zyklusübergreifender Speicher |
360
- | `.design/telemetry/events.jsonl` | Typisierter Event-Stream über Stufen hinweg |
361
- | `.design/telemetry/posterior.json` | Bandit-Posterior (wenn `adaptive_mode != static`) |
185
+ GDD erstellt einen `.design/`-Arbeitsbereich, der jeden Zyklus geerdet hält:
362
186
 
363
- Größenlimits dort, wo Claudes Qualität abfällt. Bleib darunter, hol dir Konsistenz.
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
- ### 37 spezialisierte Agenten
197
+ Je länger du es nutzt, desto weniger muss der Agent neu entdecken.
366
198
 
367
- Jede Stufe ist ein leichtgewichtiger Orchestrator, der spezialisierte Agenten spawnt.
199
+ ### Verifikation vor dem Shipping
368
200
 
369
- | Stufe | Orchestrator | Agenten |
370
- |-------|--------------|---------|
371
- | Brief | Eine-Frage-Interview | (keine Sub-Agenten) |
372
- | Explore | spawnt 5 Mapper + Discussant | 5 parallele Mapper, design-discussant, research-synthesizer |
373
- | Plan | spawnt Researcher + Planner + Checker | design-phase-researcher (optional), design-planner (opus), design-plan-checker (haiku) |
374
- | Design | Wave-Koordination + Worktree-Isolation | design-executor pro Task, design-fixer bei Solidify-Fehlschlag |
375
- | Verify | spawnt Auditor + Verifier + Checker | design-auditor, design-verifier, design-integration-checker |
376
- | Reflect | liest Telemetrie + Lernergebnisse | design-reflector (opus), design-authority-watcher, design-update-checker |
201
+ GDD hört nicht auf, sobald die UI „fertig aussieht".
377
202
 
378
- ### 12 Tool-Verbindungen
203
+ Die Verify-Stufe prüft, ob das Ergebnis noch übereinstimmt mit:
379
204
 
380
- Alle optional — die Pipeline degradiert sauber, wenn eine Verbindung nicht verfügbar ist:
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
- - **Figma** (Lesen + Schreiben + Code Connect)
383
- - **Refero** — Design-Referenzsuche
384
- - **Pinterest** — visuelle Referenzverankerung
385
- - **Claude Design** — Handoff-Bundle-Import
386
- - **Storybook** — Komponenten-Spezifikations-Lookup
387
- - **Chromatic** — Visual-Regression-Baseline-Diff
388
- - **Preview** — Playwright + Claude Preview MCP Runtime-Screenshots
389
- - **paper.design** — MCP-Canvas-Read/Write
390
- - **pencil.dev** — Git-getrackte `.pen`-Spec-Dateien
391
- - **Graphify** — Knowledge-Graph-Export
392
- - **21st.dev Magic** — Vorbild-Suche vor Greenfield-Builds
393
- - **Magic Patterns** — DS-aware Komponenten-Generierung
213
+ Wenn Lücken auftauchen, erstellt GDD eine strukturierte Fix-Liste, anstatt das Review dem Bauchgefühl zu überlassen.
394
214
 
395
- ### Eingebettete Design-Referenzen
215
+ ### Skill-Behavior-Tests
396
216
 
397
- 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.
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
- ### Atomare Git-Commits
219
+ ## Wie es funktioniert
400
220
 
221
+ ```text
222
+ Brief -> Explore -> Plan -> Design -> Verify -> Ship
401
223
  ```
402
- abc123f docs(08-02): complete user-card token plan
403
- def456g feat(08-02): unify card surface tokens with --color-bg-elevated
404
- hij789k feat(08-02): replace inline padding with --space-* scale
405
- lmn012o test(08-02): assert card.spec passes WCAG contrast 4.5:1
406
- ```
407
-
408
- 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.
409
-
410
- ### Selbstverbesserungs-Loop
411
224
 
412
- 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.
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 |
413
232
 
414
- 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.
233
+ ### Kern-Outputs
415
234
 
416
- ### Kosten-Governance
417
-
418
- - **`gdd-router`-Skill** — deterministisches Intent → fast / quick / full Routing, ohne Modell-Aufruf.
419
- - **`gdd-cache-manager`** — expliziter Layer-B-Cache, SHA-256-Input-Hash, 5-Min-TTL-Awareness.
420
- - **`budget-enforcer` PreToolUse-Hook** — erzwingt Tier-Overrides, harte Caps und Lazy-Spawn-Gates aus `.design/budget.json`.
421
- - **Spawn-genaue Kosten-Telemetrie** — `.design/telemetry/costs.jsonl`-Zeilen speisen die regelbasierten Empfehlungen von `/gdd:optimize`.
422
-
423
- Zielt auf 50–70% Token-Kostenreduktion pro Task ohne Qualitätsregression.
424
-
425
- ---
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 |
426
243
 
427
244
  ## Befehle
428
245
 
429
- ### 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).
430
247
 
431
- | Befehl | Was er tut |
432
- |--------|------------|
433
- | `/gdd:brief` | Stufe 1 — Design-Brief erfassen |
434
- | `/gdd:explore` | Stufe 2 — Codebase-Inventar + Interview |
435
- | `/gdd:plan` | Stufe 3 — DESIGN-PLAN.md erzeugen |
436
- | `/gdd:design` | Stufe 4 — in Wellen ausführen |
437
- | `/gdd:verify` | Stufe 5 — gegen den Brief verifizieren |
438
- | `/gdd:ship` | Sauberen PR-Branch erzeugen |
439
- | `/gdd:next` | Auto-Routing zur nächsten Stufe gemäß STATE.md |
440
- | `/gdd:do <text>` | Natursprachlicher Router |
441
- | `/gdd:fast <text>` | One-Shot-triviale Korrektur, ohne Pipeline |
442
- | `/gdd:quick` | Ad-hoc-Task mit GDD-Garantien, aber übersprungenen optionalen Gates |
443
-
444
- ### Erstlauf + Onboarding
445
-
446
- | Befehl | Was er tut |
447
- |--------|------------|
448
- | `/gdd:start` | Erstlauf-Beweispfad — Top-3-Designprobleme im Repo |
449
- | `/gdd:new-project` | GDD-Projekt initialisieren |
450
- | `/gdd:connections` | Onboarding-Wizard für die 12 externen Integrationen |
451
-
452
- ### Zyklus-Lifecycle
453
-
454
- | Befehl | Was er tut |
455
- |--------|------------|
456
- | `/gdd:new-cycle` | Neuen Design-Zyklus eröffnen |
457
- | `/gdd:complete-cycle` | Zyklus-Artefakte archivieren + EXPERIENCE.md |
458
- | `/gdd:pause` / `/gdd:resume` | Nummerierte Checkpoints |
459
- | `/gdd:continue` | Alias für `/gdd:resume` |
460
- | `/gdd:timeline` | Narrative Retrospektive über Zyklen + Git-Log |
461
-
462
- ### Iteration + Entscheidungen
463
-
464
- | Befehl | Was er tut |
465
- |--------|------------|
466
- | `/gdd:discuss [topic]` | Adaptives Design-Interview |
467
- | `/gdd:list-assumptions` | Versteckte Designannahmen vor dem Plan offenlegen |
468
- | `/gdd:sketch [idea]` | HTML-Mockups in mehreren Varianten |
469
- | `/gdd:spike [idea]` | Zeitlich begrenztes Machbarkeitsexperiment |
470
- | `/gdd:sketch-wrap-up` / `/gdd:spike-wrap-up` | Findings als projektlokalen Skill bündeln |
471
- | `/gdd:audit` | Wrapper Verify + Audit + Reflector |
472
- | `/gdd:reflect` | Reflector on-demand starten |
473
- | `/gdd:apply-reflections` | Vorschläge prüfen und selektiv anwenden |
474
-
475
- ### Speicher + Knowledge-Layer
476
-
477
- | Befehl | Was er tut |
478
- |--------|------------|
479
- | `/gdd:recall <query>` | FTS5-Suche |
480
- | `/gdd:extract-learnings` | Muster/Entscheidungen/Lehren extrahieren |
481
- | `/gdd:note <text>` | Reibungsfreie Ideenerfassung |
482
- | `/gdd:plant-seed <idea>` | Vorausschauende Idee mit Trigger-Bedingung |
483
- | `/gdd:analyze-dependencies` | Token-Fanout, Call-Graph, Entscheidungsverfolgung |
484
- | `/gdd:skill-manifest` | Alle GDD-Skills und Agenten auflisten |
485
- | `/gdd:graphify` | Projekt-Knowledge-Graph bauen/abfragen/diffen |
486
- | `/gdd:watch-authorities` | Diff der Design-Autoritäts-Feed-Whitelist |
487
-
488
- ### Verbindungen
489
-
490
- | Befehl | Was er tut |
491
- |--------|------------|
492
- | `/gdd:figma-write` | Designentscheidungen zurück nach Figma schreiben |
493
- | `/gdd:handoff <bundle>` | Claude-Design-Bundle importieren |
494
- | `/gdd:darkmode` | Dark-Mode-Implementierung auditieren |
495
- | `/gdd:compare` | Delta DESIGN.md vs DESIGN-VERIFICATION.md berechnen |
496
- | `/gdd:style <Component>` | Komponenten-Handoff-Dokument generieren |
497
-
498
- ### Diagnose + Forensik
499
-
500
- | Befehl | Was er tut |
501
- |--------|------------|
502
- | `/gdd:scan` | Codebase-Design-System-Inventar |
503
- | `/gdd:map` | 5 parallele Codebase-Mapper |
504
- | `/gdd:debug [desc]` | Symptomgetriebene Designuntersuchung |
505
- | `/gdd:health` | Gesundheitsbericht für `.design/`-Artefakte |
506
- | `/gdd:progress` | Position in der Pipeline |
507
- | `/gdd:stats` | Zyklusstatistiken |
508
- | `/gdd:optimize` | Regelbasierte Kostenanalyse |
509
- | `/gdd:warm-cache` | Anthropic-Cache vorwärmen |
510
-
511
- ### Distribution + Update
512
-
513
- | Befehl | Was er tut |
514
- |--------|------------|
515
- | `/gdd:update` | GDD aktualisieren mit Changelog-Vorschau |
516
- | `/gdd:reapply-patches` | Lokale `reference/`-Modifikationen re-stitchen |
517
- | `/gdd:check-update` | Manueller Update-Check |
518
- | `/gdd:settings` | `.design/config.json` konfigurieren |
519
- | `/gdd:set-profile <profile>` | Modellprofil wechseln |
520
- | `/gdd:undo` | Sicherer Designänderungs-Revert |
521
- | `/gdd:pr-branch` | Sauberer PR-Branch |
522
-
523
- ### Backlog + Notizen
524
-
525
- | Befehl | Was er tut |
526
- |--------|------------|
527
- | `/gdd:todo` | Design-Tasks hinzufügen / auflisten / wählen |
528
- | `/gdd:add-backlog <idea>` | Idee für zukünftigen Zyklus parken |
529
- | `/gdd:review-backlog` | Geparkte Einträge prüfen |
530
-
531
- ### Hilfe
532
-
533
- | Befehl | Was er tut |
534
- |--------|------------|
535
- | `/gdd:help` | Vollständige Befehlsliste und Verwendung |
536
- | `/gdd:bandit-reset` | Adaptiv-Schicht-Posterior bei Anthropic-Modell-Release zurücksetzen |
248
+ ### Kernpipeline
537
249
 
538
- ---
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)
539
286
 
540
287
  ## Verbindungen
541
288
 
542
- GDD liefert 12 Tool-Verbindungen. Alle optional. Konfigurieren mit `/gdd:connections`.
543
-
544
- | Verbindung | Zweck | Probe |
545
- |------------|-------|-------|
546
- | **Figma** | Tokens, Komponenten, Screenshots lesen; Annotationen, Code Connect, Implementierungsstatus schreiben | `mcp__figma__get_metadata` + `use_figma` |
547
- | **Refero** | Design-Referenzsuche | `mcp__refero__search` |
548
- | **Pinterest** | Visuelle Referenz für Brand Voice + Stil | OAuth + MCP |
549
- | **Claude Design** | Handoff-Bundle-Import | URL oder lokale Datei |
550
- | **Storybook** | Komponenten-Spec-Lookup an Port 6006 | HTTP-Probe |
551
- | **Chromatic** | Visual-Regression-Baseline-Diff | API-Key |
552
- | **Preview** | Playwright + Claude Preview MCP Runtime-Screenshots | `mcp__Claude_Preview__preview_*` |
553
- | **paper.design** | MCP-Canvas-Read/Write | `mcp__paper__use_paper` |
554
- | **pencil.dev** | Git-getrackte `.pen`-Specs | `.pen`-Dateien im Repo |
555
- | **Graphify** | Knowledge-Graph-Export | `mcp__graphify__*` |
556
- | **21st.dev Magic** | Vorbildsuche vor Greenfield | `mcp__magic__search` |
557
- | **Magic Patterns** | DS-aware Komponenten-Generierung | `mcp__magic-patterns__generate` |
558
-
559
- Vollständige Details in [`connections/connections.md`](connections/connections.md).
560
-
561
- ---
562
-
563
- ## Konfiguration
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
- GDD speichert Projekteinstellungen in `.design/config.json`. Konfiguriere während `/gdd:new-project` oder aktualisiere mit `/gdd:settings`.
291
+ Die Verbindungsschicht umfasst diese Kategorien:
566
292
 
567
- ### Modellprofile
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
- | Profil | Planung | Ausführung | Verifikation |
570
- |--------|---------|------------|--------------|
571
- | `quality` | Opus | Opus | Sonnet |
572
- | `balanced` (Standard) | Opus | Sonnet | Sonnet |
573
- | `budget` | Sonnet | Sonnet | Haiku |
574
- | `inherit` | Inherit | Inherit | Inherit |
302
+ Konfiguriere Integrationen mit:
575
303
 
304
+ ```bash
305
+ /gdd:connections
576
306
  ```
577
- /gdd:set-profile budget
578
- ```
579
-
580
- ### Adaptiv-Modus
581
307
 
582
- `.design/budget.json#adaptive_mode`-Leiter (v1.23.5):
308
+ Die vollständige Verbindungsliste mit Probe-Mustern findest du in [connections/connections.md](connections/connections.md).
583
309
 
584
- | Modus | Was er tut |
585
- |-------|------------|
586
- | `static` (Standard) | Phase-10.1-Verhalten |
587
- | `hedge` | AdaNormalHedge-Ensemble + MMR-Reranking aktiviert. Sicherste Einführung. |
588
- | `full` | Bandit-Router + Hedge + MMR alle aktiv |
310
+ ## Voraussetzungen
589
311
 
590
- ### Parallelität
312
+ - Node.js 22 oder 24
313
+ - Git
314
+ - Eine unterstützte AI-Coding-Runtime
591
315
 
592
- | Einstellung | Standard | Steuert |
593
- |-------------|----------|---------|
594
- | `parallelism.enabled` | `true` | Unabhängige Tasks in Worktrees ausführen |
595
- | `parallelism.min_estimated_savings_seconds` | `30` | Unter dieser Schwelle Parallelisierung überspringen |
596
- | `parallelism.max_concurrent_workers` | `4` | Hartes Cap auf gleichzeitige Worker |
316
+ ## Multi-Runtime-Support
597
317
 
598
- ### Quality Gates
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.
599
319
 
600
- | Einstellung | Standard | Steuert |
601
- |-------------|----------|---------|
602
- | `solidify.rollback_mode` | `"stash"` | `stash` / `hard` / `none` |
603
- | `solidify.commands` | autodetect | Typecheck-/Build-/Test-Befehle überschreiben |
604
- | `verify.iterations_max` | `3` | Cap auf Verify→Fix-Loop |
605
- | `connection.figma_writeback` | `proposal` | `proposal` / `auto` |
606
-
607
- ---
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.
608
321
 
609
- ## Sicherheit
322
+ ## Sicherheit und Datenschutz
610
323
 
611
- ### Eingebaute Härtung
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.
612
325
 
613
- GDD liefert seit Phase 14.5 Defense-in-Depth:
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.
614
327
 
615
- - **`hooks/gdd-bash-guard.js`** — PreToolUse:Bash blockiert ~50 gefährliche Muster nach Unicode-NFKC- + ANSI-Normalisierung.
616
- - **`hooks/gdd-protected-paths.js`** — PreToolUse:Edit/Write/Bash erzwingt die `protected_paths`-Glob-Liste.
617
- - **`hooks/gdd-read-injection-scanner.ts`** — scannt eingehenden Read-Inhalt nach unsichtbarem Unicode, HTML-Kommentaren, Secret-Exfiltrations-Mustern.
618
- - **`scripts/lib/blast-radius.cjs`** — `design-executor`-Preflight verweigert Tasks über `max_files_per_task: 10` / `max_lines_per_task: 400`.
619
- - **`hooks/gdd-mcp-circuit-breaker.js`** — bricht aufeinanderfolgende Timeout-Schleifen auf `use_figma` / `use_paper` / `use_pencil`.
620
-
621
- ### Sensible Dateien schützen
622
-
623
- Füge sensible Pfade der Deny-List deines Runtimes hinzu:
328
+ Füge sensible Pfade der Deny-List deiner Runtime hinzu:
624
329
 
625
330
  ```json
626
331
  {
@@ -629,7 +334,6 @@ Füge sensible Pfade der Deny-List deines Runtimes hinzu:
629
334
  "Read(.env)",
630
335
  "Read(.env.*)",
631
336
  "Read(**/secrets/*)",
632
- "Read(**/*credential*)",
633
337
  "Read(**/*.pem)",
634
338
  "Read(**/*.key)"
635
339
  ]
@@ -637,77 +341,58 @@ Füge sensible Pfade der Deny-List deines Runtimes hinzu:
637
341
  }
638
342
  ```
639
343
 
640
- > [!IMPORTANT]
641
- > 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.
642
-
643
- ---
644
-
645
- ## Fehlersuche
646
-
647
- **Befehle nach Installation nicht gefunden?**
648
- - Runtime neu starten
649
- - `~/.claude/skills/get-design-done/` (global) oder `./.claude/skills/get-design-done/` (lokal) prüfen
650
- - `/gdd:help` zur Bestätigung der Registrierung
344
+ Lies: [SECURITY.md](SECURITY.md) · [PRIVACY.md](PRIVACY.md)
651
345
 
652
- **Pipeline mitten in einer Stufe blockiert?**
653
- - `/gdd:resume` — vom letzten nummerierten Checkpoint wiederherstellen
654
- - `/gdd:health` — `.design/`-Artefaktprobleme diagnostizieren
655
- - `/gdd:progress --forensic` — 6-Punkte-Integritätsaudit
346
+ ## Aktualisieren
656
347
 
657
- **Kostenüberschreitung?**
658
- - `/gdd:optimize` — regelbasierte Empfehlungen
659
- - `/gdd:set-profile budget` — auf Budget-Tier umstellen
660
- - `adaptive_mode: "full"` in `.design/budget.json` setzen — der Bandit lernt
661
-
662
- **Auf die neueste Version aktualisieren?**
663
348
  ```bash
664
349
  npx @hegemonart/get-design-done@latest
665
350
  ```
666
351
 
667
- **Docker / Container?**
352
+ Oder aus Claude Code heraus:
668
353
 
669
354
  ```bash
670
- CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
355
+ /gdd:update
671
356
  ```
672
357
 
673
- ### Deinstallieren
358
+ Die vollständige Release-Historie findest du in [CHANGELOG.md](CHANGELOG.md).
674
359
 
675
- ```bash
676
- # Globale Deinstallation (pro Runtime)
677
- npx @hegemonart/get-design-done --claude --global --uninstall
678
- npx @hegemonart/get-design-done --opencode --global --uninstall
679
- # ... gleiches Muster --<runtime> --global --uninstall für die 14 Runtimes
360
+ ## Fehlersuche
680
361
 
681
- # Interaktive Mehrfachauswahl-Deinstallation (ohne Runtime-Flag)
682
- npx @hegemonart/get-design-done --uninstall
362
+ ### Befehle erscheinen nicht
683
363
 
684
- # Lokale Deinstallation
685
- npx @hegemonart/get-design-done --claude --local --uninstall
686
- # ... mit --local-Flag
687
- ```
364
+ Starte deine Runtime neu und führe aus:
688
365
 
689
- Entfernt alle GDD-Befehle, Agenten, Hooks und Einstellungen, ohne deine anderen Konfigurationen zu beeinflussen.
366
+ ```bash
367
+ /gdd:help
368
+ ```
690
369
 
691
- ---
370
+ ### Pipeline hängt fest
692
371
 
693
- ## Feedback-Kanal (ab v1.30.0)
372
+ ```bash
373
+ /gdd:health
374
+ /gdd:resume
375
+ ```
694
376
 
695
- GDD enthält jetzt einen einwilligungsbasierten GitHub-Issue-Reporter über den Slash-Befehl `/gdd:report-issue`.
377
+ ### Kosten sind zu hoch
696
378
 
697
- - **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.
698
- - **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.
699
- - **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.
700
- - **`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
+ ```
701
382
 
702
- 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
703
384
 
704
- **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
+ ```
705
390
 
706
- ---
391
+ Lies: [CONTRIBUTING.md](CONTRIBUTING.md)
707
392
 
708
393
  ## Lizenz
709
394
 
710
- 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.
711
396
 
712
397
  ---
713
398