myclaude/dev-workflow/README.md

/dev - Minimal Dev Workflow

Overview

A freshly designed lightweight development workflow with no legacy baggage, focused on delivering high-quality code fast.

Flow

/dev trigger
  ↓
AskUserQuestion (backend selection)
  ↓
AskUserQuestion (requirements clarification)
  ↓
codeagent analysis (plan mode + task typing + UI auto-detection)
  ↓
dev-plan-generator (create dev doc)
  ↓
codeagent concurrent development (2–5 tasks, backend routing)
  ↓
codeagent testing & verification (≥90% coverage)
  ↓
Done (generate summary)

Step 0 + The 6 Steps

0. Select Allowed Backends (FIRST ACTION)

• Use AskUserQuestion with multiSelect to ask which backends are allowed for this run
• Options (user can select multiple):
  • codex - Stable, high quality, best cost-performance (default for most tasks)
  • claude - Fast, lightweight (for quick fixes and config changes)
  • gemini - UI/UX specialist (for frontend styling and components)
• If user selects ONLY codex, ALL subsequent tasks must use codex (including UI/quick-fix)

1. Clarify Requirements

• Use AskUserQuestion to ask the user directly
• No scoring system, no complex logic
• 2–3 rounds of Q&A until the requirement is clear

2. codeagent Analysis + Task Typing + UI Detection

• Call codeagent to analyze the request in plan mode style
• Extract: core functions, technical points, task list (2–5 items)
• For each task, assign exactly one type: default / ui / quick-fix
• UI auto-detection: needs UI work when task involves style assets (.css, .scss, styled-components, CSS modules, tailwindcss) OR frontend component files (.tsx, .jsx, .vue); output yes/no plus evidence

3. Generate Dev Doc

• Call the dev-plan-generator agent
• Produce a single dev-plan.md
• Append a dedicated UI task when Step 2 marks needs_ui: true
• Include: task breakdown, type, file scope, dependencies, test commands

4. Concurrent Development

• Work from the task list in dev-plan.md
• Route backend per task type (with user constraints + fallback):
  • default → codex
  • ui → gemini (enforced when allowed)
  • quick-fix → claude
  • Missing type → treat as default
  • If the preferred backend is not allowed, fallback to an allowed backend by priority: codex → claude → gemini
• Independent tasks → run in parallel
• Conflicting tasks → run serially

5. Testing & Verification

• Each codeagent task:
  • Implements the feature
  • Writes tests
  • Runs coverage
  • Reports results (≥90%)

6. Complete

• Summarize task status
• Record coverage

Usage

/dev "Implement user login with email + password"

No CLI flags required; workflow starts with an interactive backend selection.

Output Structure

.claude/specs/{feature_name}/
└──  dev-plan.md      # Dev document generated by agent

Only one file—minimal and clear.

Core Components

Tools

• AskUserQuestion: interactive requirement clarification
• codeagent skill: analysis, development, testing; supports --backend for codex / claude / gemini
• dev-plan-generator agent: generate dev doc (subagent via Task tool, saves context)

Backend Selection & Routing

• Step 0: user selects allowed backends; if 仅 codex, all tasks use codex
• UI detection standard: style files (.css, .scss, styled-components, CSS modules, tailwindcss) OR frontend component code (.tsx, .jsx, .vue) trigger needs_ui: true
• Task type field: each task in dev-plan.md must have type: default|ui|quick-fix
• Routing: default→codex, ui→gemini, quick-fix→claude; if disallowed, fallback to an allowed backend by priority: codex→claude→gemini

Key Features

✅ Fresh Design

• No legacy project residue
• No complex scoring logic
• No extra abstraction layers

✅ Minimal Orchestration

• Orchestrator controls the flow directly
• Only three tools/components
• Steps are straightforward

✅ Concurrency

• Tasks split based on natural functional boundaries
• Auto-detect dependencies and conflicts
• codeagent executes independently with optimal backend

✅ Quality Assurance

• Enforces 90% coverage
• codeagent tests and verifies its own work
• Automatic retry on failure

Example

# Trigger
/dev "Add user login feature"

# Step 0: Select backends
Q: Which backends are allowed? (multiSelect)
A: Selected: codex, claude

# Step 1: Clarify requirements
Q: What login methods are supported?
A: Email + password
Q: Should login be remembered?
A: Yes, use JWT token

# Step 2: codeagent analysis
Output:
- Core: email/password login + JWT auth
- Task 1: Backend API (type=default)
- Task 2: Password hashing (type=default)
- Task 3: Frontend form (type=ui)
UI detection: needs_ui = true (tailwindcss classes in frontend form)

# Step 3: Generate doc
dev-plan.md generated with typed tasks ✓

# Step 4-5: Concurrent development (routing + fallback)
[task-1] Backend API (codex) → tests → 92% ✓
[task-2] Password hashing (codex) → tests → 95% ✓
[task-3] Frontend form (fallback to codex; gemini not allowed) → tests → 91% ✓

Directory Structure

dev-workflow/
├── README.md                          # This doc
├── commands/
│   └── dev.md                         # /dev workflow orchestrator definition
└── agents/
    └── dev-plan-generator.md          # Dev plan document generator agent

Minimal structure, only three files.

When to Use

✅ Good for:

• Any feature size
• Fast iterations
• High test coverage needs
• Wanting concurrent speed-up

Design Principles

1. KISS: keep it simple
2. Disposable: no persistent config
3. Quality first: enforce 90% coverage
4. Concurrency first: leverage codeagent
5. No legacy baggage: clean-slate design

---

Philosophy: zero tolerance for complexity—ship the smallest usable solution, like Linus would.