# dev-pipeline Adopt this skill: https://proskills.md/skills/other/dashlabsdev-dev-pipeline Page: https://proskills.md/skills/other/dashlabsdev-dev-pipeline This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required. ## File: SKILL.md size: 3606 upstream: https://github.com/dashlabsdev/dev-pipeline/blob/HEAD/SKILL.md ````text # 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. ```` ## File: README.md upstream: https://github.com/dashlabsdev/dev-pipeline/blob/HEAD/README.md ````text # dev-pipeline A structured development pipeline for AI coding agents. 8 skills that turn your assistant into a disciplined engineering team. Inspired by [gstack](https://github.com/garrytan/gstack). Built for [OpenClaw](https://github.com/openclaw/openclaw). ## Why AI coding agents are fast but chaotic. They build features without reviewing them. They ship without testing. They fix symptoms instead of root causes. They say "the code looks good" when it's full of silent failures. This pipeline adds the discipline that AI agents lack: ``` THINK → PLAN → BUILD → REVIEW → QA → SHIP ``` Each stage catches problems that later stages can't: - **Think** prevents building the wrong thing - **Plan** prevents building it the wrong way - **Review** catches bugs that testing misses (silent failures, race conditions, security holes) - **QA** catches bugs that code review misses (UI glitches, broken flows, missing error states) - **Ship** prevents "it works on my machine" deploys ## The 8 Skills | Skill | Command | What It Does | Lines | |-------|---------|-------------|-------| | [think](skills/think/SKILL.md) | `/think` | Idea validation, design doc | ~120 | | [plan](skills/plan/SKILL.md) | `/plan` | Architecture, error mapping, implementation order | ~170 | | [build](skills/build/SKILL.md) | `/build` | Agent spawning, progress tracking | ~130 | | [review](skills/review/SKILL.md) | `/review` | Two-pass code review, cross-model adversarial | ~190 | | [qa](skills/qa/SKILL.md) | `/qa` | Browser-based testing, health scoring | ~160 | | [ship](skills/ship/SKILL.md) | `/ship` | Clean commits, structured PR, deploy verification | ~140 | | [security](skills/security/SKILL.md) | `/security` | OWASP, STRIDE, LLM audit, dependency supply chain | ~170 | | [investigate](skills/investigate/SKILL.md) | `/investigate` | Root cause debugging, Five Whys, hypothesis testing | ~210 | Total: ~1,290 lines across 9 files (8 skills + orchestrator). ## 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 ## Real Results Built and tested on two iOS apps in one session: - **Mission Control** (Next.js dashboard): Found 8 issues, fixed 6, QA'd 4 pages - **DinnerBell** (iOS meal planner): Found 12 issues (4 critical), fixed all, shipped Build 20 to TestFlight - **OneLedger** (iOS finance): Found 12 issues, fixed 11, shipped Build 77 to TestFlight Critical bugs caught that manual testing missed: - App silently served fake data when AI API failed (user had no idea) - `fatalError` on database migration = permanent crash loop - SQL injection via string interpolation in database queries - Vendor learning system flip-flopping categories across receipt types ## Install **Option 1: Clone into OpenClaw skills** ```bash cd ~/.openclaw/workspace/skills git clone https://github.com/DashLabsDev/dev-pipeline.git ``` **Option 2: Copy individual skills** ```bash # Just want /review and /investigate? mkdir -p ~/.openclaw/workspace/skills/dev-review cp dev-pipeline/skills/review/SKILL.md ~/.openclaw/workspace/skills/dev-review/ mkdir -p ~/.openclaw/workspace/skills/dev-investigate cp dev-pipeline/skills/investigate/SKILL.md ~/.openclaw/workspace/skills/dev-investigate/ ``` **Option 3: Use without OpenClaw** The skill files are just markdown instructions. Feed them to any AI coding assistant (Claude Code, Cursor, Copilot, etc.) as system context. ## Key Principles 1. **Completeness is cheap with AI.** Do the complete thing — the shortcut saves minutes, not hours. 2. **Fix first, ask second.** Mechanical fixes get applied immediately. 3. **Name the file, function, line.** Vague findings are worthless. 4. **Zero silent failures.** Every failure visible to someone. 5. **Two-pass review.** Critical blocks shipping. Informational informs decisions. 6. **No fix without root cause.** Understand why before you change code. 7. **Cross-model adversarial.** Two models finding the same bug = high confidence. 8. **Boring by default.** Proven tech. Earn your innovation tokens. ## Contributing PRs welcome. Areas that need work: - Language-specific review rules (Rust, Go, Python, etc.) - CI/CD integration patterns - Performance profiling stage - Accessibility testing checklist - Better test coverage detection per framework - Mobile-specific QA checklists (iOS, Android) ## License MIT ````