team-pipeline
npx machina-cli add skill speson/not-my-reforge/team-pipeline --openclawTeam Pipeline
A structured 5-stage pipeline for executing complex tasks with Agent Teams.
Pipeline Stages
Stage 1: Plan
The planner agent creates an implementation plan:
- Analyze the codebase and task requirements
- Identify change points and dependencies
- Produce a structured plan with phases and steps
- Enter plan mode for lead approval
Stage 2: PRD (Product Requirements Document)
The lead converts the approved plan into concrete tasks:
- Create TaskCreate entries for each work unit
- Define clear acceptance criteria per task
- Set task dependencies (blockedBy/blocks)
- Assign tasks to workers
Stage 3: Execute
Workers implement in parallel:
- Each worker operates in an isolated git worktree
- Workers follow their task's acceptance criteria
- Researcher gathers information as needed (background)
- Tester writes tests for implementations
Stage 4: Verify
Reviewer validates all changes:
- Review each worker's diff against acceptance criteria
- Run full test suite
- Check for type errors and lint issues
- Verdict: APPROVE or REQUEST_CHANGES
Stage 5: Fix
If verification fails:
- Failed items return to Execute stage
- Workers address reviewer feedback
- Re-verify until all checks pass
- Maximum 3 Fix cycles before escalating to user
Usage
omo team 3 <task description>
The pipeline runs automatically when using the team command with the team-pipeline skill.
Quality Gates
Each stage transition requires:
- Plan → PRD: Lead approval of plan
- PRD → Execute: All tasks created with acceptance criteria
- Execute → Verify: All tasks marked complete
- Verify → Fix/Done: Reviewer verdict
- Fix → Verify: Worker fixes applied
Source
git clone https://github.com/speson/not-my-reforge/blob/main/skills/team-pipeline/SKILL.mdView on GitHub Overview
Team Pipeline provides a structured five-stage workflow for executing complex tasks with Agent Teams. It guides work from planning through PRD, parallel execution, verification, and fixes, with role-specific actions (planner, lead, workers, researcher, tester, reviewer). This approach clarifies dependencies, acceptance criteria, and stage gates to improve quality and coordination.
How This Skill Works
Plan: a planner analyzes the codebase and task requirements to produce a phased plan and enters plan mode for lead approval. PRD: the lead converts the plan into concrete tasks with acceptance criteria, dependencies, and assignments (blockedBy/blocks). Execute to Verify and Fix: workers implement in parallel in isolated git worktrees, researcher gathers background information, tester writes tests, reviewer validates diffs against criteria and the full test suite, and fixes cycles proceed up to three times before escalation.
When to Use It
- Coordinating a multi-module feature with clear dependencies across teams
- Executing parallel work with isolated git worktrees to reduce conflicts
- Tasks requiring explicit acceptance criteria and assignment
- Verifying changes via a full test suite and lint/type checks
- Managing iterative fixes with up to three cycles before escalation
Quick Start
- Step 1: Run 'omo team 3 <task description>' to initiate the pipeline.
- Step 2: Planner drafts the Plan and requests lead approval.
- Step 3: Lead creates PRD tasks with acceptance criteria and assigns workers.
Best Practices
- Define a clear Plan with phases and steps.
- Create TaskCreate entries for each work unit with explicit acceptance criteria.
- Define dependencies using blockedBy/blocks to enforce order.
- Run workers in isolated git worktrees to minimize conflicts.
- Enforce stage gates: plan approval, task readiness, reviewer verdict; cap Fix cycles.
Example Use Cases
- Coordinating a cross-module feature with multiple sub-tasks and dependencies
- Refactoring a service with parallel implementations behind a feature flag
- Adding a new data-processing step requiring end-to-end tests
- Triage and fix cycle for post-release defects across components
- Implementing API changes with clear acceptance criteria and testing
