Work Pipeline

What Is Work Pipeline?

The Work Pipeline skill for Claude Code is a specialized automation trigger designed to manage and orchestrate structured development workflows based on user requests. When a user message begins with a square-bracket tag (such as [new-feature], [bugfix], or any [custom-tag]), the Work Pipeline skill automatically initiates the WORK-PIPELINE process. This process coordinates multiple sub-agents—such as specifier, planner, scheduler, builder, verifier, and committer—to systematically process, track, and execute development tasks in a controlled pipeline. The skill ensures consistent execution, reference management, and user feedback throughout the workflow.

The Work Pipeline skill is especially valuable in teams or environments where clear task delineation, traceability, and automation are critical for software development and maintenance. It is implemented as part of the buildwithclaude ecosystem and is open source, allowing integration and extension as required by specific workflows.

Why Use Work Pipeline?

Development projects often require standardized processes to ensure that requirements are understood, tasks are properly planned, and code changes are reliably reviewed and committed. Manual management of these steps can be error-prone and inefficient, especially as project complexity increases.

By leveraging the Work Pipeline skill, you gain several advantages:

• Automation: Tasks are systematically routed through the appropriate sub-agents, reducing manual intervention.
• Consistency: Every request starting with a [tag] is handled in the same structured manner, minimizing ambiguity.
• Traceability: Artifacts such as requirement documents are generated and stored, ensuring a clear audit trail.
• User Feedback: The workflow is designed to present interim outputs (like requirement summaries) for explicit user approval, enhancing communication and reducing misunderstandings.
• Extensibility: The pipeline is modular, making it easy to add or modify steps as your workflow evolves.

How to Get Started

To integrate and use the Work Pipeline skill in your Claude Code environment, follow these steps:

1. Install the Skill
   Clone the repository and ensure the work-pipeline skill is available within your Claude Code plugins directory:

   bash

   git clone https://github.com/davepoon/buildwithclaude.git

2. Configure the Skill
   The skill is typically located at:

   plaintext

   plugins/agents-uc-taskmanager/skills/work-pipeline/

3. Triggering the Pipeline
   When you want to initiate the workflow, start your user request with a square-bracket tag. For example:

   plaintext

   [new-feature] Add support for user profile avatars

   or

   plaintext

   [bugfix] Fix incorrect calculation in invoice total

4. Pipeline Orchestration
   When triggered, the skill reads the orchestration flow from the agent flow definition file:

   plaintext

   ../skills/sdd-pipeline/references/agent-flow.md

5. Reference Directory Management
   The skill determines the REFERENCES_DIR based on its own directory:

   python

   # Example in Python
   import os
   
   base_dir = "/absolute/path/to/skills/work-pipeline"
   references_dir = os.path.abspath(os.path.join(base_dir, "../sdd-pipeline/references"))

   This path must be provided to every sub-agent invocation.

6. User Approval
   After the specifier agent analyzes the requirement and generates the initial documentation, the pipeline pauses and presents a summary to the user for explicit approval before proceeding to further stages.

Key Features

• Automatic Trigger Detection
  Any user message beginning with a [tag] (e.g., [new-feature], [bugfix], [enhancement], [WORK start]) launches the entire pipeline.

• Reference Directory Propagation
  The absolute path to the references directory is included at the top of every sub-agent prompt:

  plaintext

  REFERENCES_DIR=/absolute/path/to/sdd-pipeline/references

  This ensures all agents have access to necessary reference files and prevents execution loops.

• Orchestrated Multi-Agent Workflow
  The pipeline coordinates several specialized agents:

  • Specifier: Analyzes requirements and determines execution mode.
  • Planner/Scheduler/Builder/Verifier/Committer: Each handles a distinct phase of the development process.

• Explicit User Approval Step
  After the specifier agent completes its analysis, the process waits for the user's confirmation before proceeding, ensuring full transparency and control.

• Customizable Workflow
  The modular design allows for easy customization and extension to fit your team's processes.

Best Practices

• Always Start Messages with [tag]
  To leverage the Work Pipeline, ensure your requests start with a relevant square-bracket tag.

• Maintain Reference Directory Integrity
  Always propagate the correct REFERENCES_DIR to each sub-agent. Failure to do so will break the workflow.

• Review Interim Summaries Carefully
  Use the approval checkpoint to validate the specifier's output before allowing the workflow to continue.

• Use Clear, Specific Tags
  Adopt a consistent tagging convention for clarity and traceability (e.g., [bugfix], [feature-request], [improvement]).

• Monitor Reference Files
  Ensure that agent-flow.md and associated reference files are kept up to date and in sync with your workflow logic.

Important Notes

• REFERENCE_DIR is Critical:
  If any sub-agent does not receive the absolute reference directory path, it will not find its required files and may enter a loop or fail.

• Strict User Approval Checkpoint:
  The pipeline must present the specifier's output and wait for user approval before invoking subsequent agents. This is non-negotiable and essential for safe operation.

• Custom Tags Supported:
  The skill will trigger for any [custom-tag], not just predefined ones, enabling flexible workflow integration.

• Do Not Skip Steps:
  Bypassing the orchestrated flow or omitting required references can result in unpredictable behavior or workflow breakdowns.

• Stay Within Workflow Boundaries:
  The Work Pipeline is designed for structured, agent-driven development tasks. For ad hoc or non-development requests, use standard workflows or other skills.

For more details, refer to the official repository and review the latest documentation prior to integration.