A deliberate engineering workflow for Claude Code.
- Inspired by Get Shit Done
- Derived from 6D-plugin by jkerdels
duh is a Claude Code plugin implementing a rigorous, six-stage software development process. Each stage is an interactive conversation with a specialized AI assistant, producing a concrete artifact that feeds the next stage. The workflow enforces engineering discipline: explicit assumptions, measurable goals, empirical validation before implementation, and structured retrospectives.
Discover → Design → Demonstrate → Develop → Document → Debrief
For small changes (bug fixes, minor features, small refactors) that don't warrant the full six-stage cycle:
/duh quick
Runs a compressed Discover-Design-Develop cycle in a single session. Same engineering discipline — explicit assumptions, design alternatives, honest risk assessment — but without separate sessions, formal artifacts, or context resets. Produces a lightweight log at .duh/docs/quick-<slug>.md and one atomic commit.
If the change turns out bigger than expected, the skill will recommend upgrading to a full /duh new cycle.
| # | Stage | What Happens | Artifact |
|---|---|---|---|
| 1 | Discover | Deep problem domain exploration. Surfaces assumptions, defines measurable success criteria, maps constraints and stakeholders. No implementation talk. | .duh/docs/01-discover.md |
| 2 | Design | Hardware-aware implementation design. Data layouts, compute kernels, module structure — driven by the hardware's capabilities, not the problem's semantics. | .duh/docs/02-design.md |
| 3 | Demonstrate | Empirical validation of critical design assumptions. Minimal isolated test programs, measured against theoretical hardware limits. Failures caught here, not in production. | .duh/design-verification/DESIGN_VERIFICATION.md |
| 4 | Develop | Production code implementation. Structure defined and agreed before a single line is written. Incremental validation throughout. | (codebase) |
| 5 | Document | Developer-facing Hugo documentation site. Synthesizes all upstream artifacts into architecture docs, design decisions, internals, and codebase map. | docs/ Hugo site |
| 6 | Debrief | Structured retrospective. Root-cause analysis of what worked and what didn't, with findings written back into the skill configurations for the next cycle. | .duh/docs/06-debrief.md |
- Claude Code CLI v1.0.33 or later
/plugin marketplace add policecar/duh
/plugin install duh@policecar
restart claude
claude --plugin-dir ./path/to/duhAll commands can be prefixed with the namespace /duh:, but the search in claude code omits this.
/duh new
The orchestrator asks for a project name and type, creates the state file, and drops you into the Discover stage.
/duh
/duh quick
/duh status
/duh done
Writes the stage artifact, commits it to git, and prompts you to /clear before the next stage (each stage runs with a clean context window).
/duh-discover
/duh-design
/duh-demonstrate
/duh-develop
/duh-document
/duh-debrief
/duh pause
Snapshots the conversation context (decisions, open questions, next steps) to .duh/context.md and commits. Safe to quit or restart Claude Code.
/duh resume
Restores the snapshot, loads stage artifacts, and re-enters the stage with full awareness of prior progress.
/duh back design
Records the reason in the state file and reloads that stage's context.
Explicit assumptions. The primary cause of project failure is implicit assumptions. Every stage is designed to surface and challenge them.
Measure, never guess. Goals must be quantifiable. Performance claims must be benchmarked against hardware limits. "Fast" is not a result; "23 ms at 67% of theoretical peak" is.
Hardware drives structure. The Design stage shapes code around what CPUs and memory hierarchies can do efficiently — not around domain semantics or class hierarchies.
Validate before implementing. The Demonstrate stage exists specifically to catch design flaws before they are baked into production code.
Honest retrospectives. The Debrief stage writes findings back into the skill configurations themselves, so the process improves with every cycle.
Loose coupling. Functional interfaces over OOP. Flat data structures over pointer-chasing. Templates over inheritance.
.claude-plugin/
plugin.json — plugin manifest (name, version, description)
skills/
duh/ — orchestrator: state, context loading, stage transitions
duh-quick/ — compressed single-session cycle for small changes
duh-discover/ — domain exploration and planning
duh-design/ — hardware-aware implementation design
duh-demonstrate/ — empirical design validation
duh-develop/ — production code implementation
duh-document/ — Hugo documentation site generator
duh-debrief/ — retrospective facilitator
README.md
The workflow maintains all its data under .duh/ in your project repository:
.duh/
state.md — current cycle state (stage, artifacts, backtracks)
context.md — pause/resume snapshot (present only when paused mid-stage)
docs/ — stage artifacts (discover, design, debrief documents)
design-verification/ — demonstrate stage test programs and report
archive/ — completed cycles, numbered sequentially
001-retina-pipeline/
state.md
docs/
design-verification/
The state file is committed to git at each stage transition. When a cycle completes (debrief done) or a new cycle starts, the current artifacts are moved to .duh/archive/<NNN>-<project-name>/ (sequentially numbered), preserving the full history.
MIT