⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
dev-pipeline
A pipeline that turns your AI assistant into a disciplined engineering team. 8 stages, each a standalone skill.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
dev-pipeline
A structured development pipeline for AI coding agents. 8 skills that turn your assistant into a disciplined engineering team.
Inspired by gstack. Built for 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 | /think | Idea validation, design doc | ~120 |
| plan | /plan | Architecture, error mapping, implementation order | ~170 |
| build | /build | Agent spawning, progress tracking | ~130 |
| review | /review | Two-pass code review, cross-model adversarial | ~190 |
| qa | /qa | Browser-based testing, health scoring | ~160 |
| ship | /ship | Clean commits, structured PR, deploy verification | ~140 |
| security | /security | OWASP, STRIDE, LLM audit, dependency supply chain | ~170 |
| investigate | /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)
fatalErroron 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
cd ~/.openclaw/workspace/skills
git clone https://github.com/DashLabsDev/dev-pipeline.git
Option 2: Copy individual skills
# 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
- Completeness is cheap with AI. Do the complete thing — the shortcut saves minutes, not hours.
- Fix first, ask second. Mechanical fixes get applied immediately.
- Name the file, function, line. Vague findings are worthless.
- Zero silent failures. Every failure visible to someone.
- Two-pass review. Critical blocks shipping. Informational informs decisions.
- No fix without root cause. Understand why before you change code.
- Cross-model adversarial. Two models finding the same bug = high confidence.
- 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
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
SKILL.md3.5 KBupstream ↗
# 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.README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/dashlabsdev-dev-pipeline.md