# Dev Pipeline — Structured Software Development for AI Agents

A pipeline that turns your AI assistant into a disciplined engineering team. 8 stages, each a standalone skill.

**Trigger on:** "build this", "review this", "test this", "ship this", "pipeline", any stage command

---

## The Pipeline

Every feature flows through stages. Skip what doesn't apply, but never skip review or test for production code.

```
  THINK → PLAN → BUILD → REVIEW → QA → SHIP
    │       │       │        │      │      │
  validate design  spawn   2-pass browser  PR +
  idea     doc    agents  review   test   deploy
                                    
  SECURITY ← run before any public release
  INVESTIGATE ← run when something breaks
```

## Stages

| # | Stage | Command | Skill | What It Does |
|---|-------|---------|-------|-------------|
| 1 | **Think** | `/think` | `skills/think/` | Idea validation. Six forcing questions. Design doc output. |
| 2 | **Plan** | `/plan` | `skills/plan/` | Architecture, error mapping, test plan, implementation order. |
| 3 | **Build** | `/build` | `skills/build/` | Spawn the right agent with the right context. Monitor & verify. |
| 4 | **Review** | `/review` | `skills/review/` | Two-pass code review. Cross-model adversarial for big diffs. |
| 5 | **QA** | `/qa` | `skills/qa/` | Browser-based testing. Health scoring. Fix-and-retest loop. |
| 6 | **Ship** | `/ship` | `skills/ship/` | Clean commits, structured PR, deploy, verify. |
| 7 | **Security** | `/security` | `skills/security/` | OWASP Top 10, STRIDE threat model, LLM-specific audit. |
| 8 | **Investigate** | `/investigate` | `skills/investigate/` | Root cause debugging. No fix without diagnosis. |

## Quick Paths

**New feature:** `/think` → `/plan` → `/build` → `/review` → `/qa` → `/ship`

**Bug fix:** `/investigate` → `/build` → `/review` → `/qa` → `/ship`

**Codebase audit:** `/review` → `/qa` → `/security`

**Something broke:** `/investigate`

**"Just review this repo":** `/review` (standalone, no other stages needed)

## Principles

1. **Completeness is cheap with AI.** The delta between a shortcut and the complete solution is minutes, not days. Do the complete thing.
2. **Fix first, ask second.** Mechanical fixes get applied. Only ask on real tradeoffs.
3. **Name the file, function, line.** Vague findings are useless.
4. **Every error has a name.** Don't say "handle errors." Name the specific exception.
5. **Zero silent failures.** Every failure must be visible to someone — user, log, or alert.
6. **Two passes: critical blocks, informational informs.** Don't treat everything as a blocker.
7. **Cross-model review catches blind spots.** Two models finding the same bug = high confidence.
8. **Boring by default.** Use proven technology. Earn your innovation tokens.
9. **No fix without root cause.** Changing random things until it works is gambling, not engineering.

## How to Read a Stage

Each stage skill follows the same structure:
- **When to Use** — triggers and context
- **Hard Rules** — non-negotiable constraints
- **Process** — step-by-step procedure
- **Output Format** — what the stage produces
- **Anti-Patterns** — common mistakes to avoid

## For OpenClaw

This pipeline is built for [OpenClaw](https://github.com/openclaw/openclaw) agents. It uses:
- OpenClaw's sub-agent spawning for parallel builds
- OpenClaw's browser tool for QA testing
- OpenClaw's file system for plans, designs, and reports
- Standard git/gh CLI for shipping

But the principles and processes work with any AI coding assistant.