Pipeline Guide — Full Workflow Guide

Overview#

cc-pipeline is an orchestration plugin that manages the Cocode team's project lifecycle through a 7-stage pipeline. It coordinates existing plugins (cc-bmad, cc-spec-clarity, cc-pm-*, cc-dev-cycle) from above without modifying them.

Pipeline Flow#

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  Discovery  │───▶│Specification│───▶│  Planning   │───▶│   Design    │
│  (Analysis) │    │(Spec Verify)│    │ (Planning)  │    │  (Design)   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
                          │                  │                   │
                   Specification       Analysis Gate      Solutioning Gate
                       Gate                  │                   │
                          │           ┌─────────────┐    ┌─────────────┐
                          │           │   Launch    │◀───│ Development │
                          │           │  (Launch)   │    │(Development)│
                          │           └─────────────┘    └─────────────┘
                          │                                      │
┌─────────────┐           │                               Implementation
│Epic Creation│───────────┘                                   Gate
│ (Creation)  │
└─────────────┘
       │
  Planning Gate

Getting Started#

New Project#

/project  " project description "

This command:

1. Generates project slug
2. Automatically determines BMAD level
3. Sequentially executes 7 stages (skippable stages auto-determined)

Individual Stage Entry#

Each stage can be executed independently:

/project:discover  " feature description " 
 /project:specify  " feature description " 
 /project:plan
/project:design
/project:epic
/project:develop --epic 42
/project:launch

Previous stage artifacts are automatically referenced if available.

Stage Details#

Stage 1: Discovery (Analysis)#

Performs user research, competitive analysis, and ideation.

• Source: cc-pm-discovery, cc-pm-strategy, cc-bmad
• Artifacts: docs/discovery-{slug}.md
• Skip: Level 0-1

Stage 2: Specification (Spec Verification)#

Exposes hidden assumptions through Socratic interviews, then creates Seed specs and ambiguity evaluation to secure implementation-quality specifications.

• Source: cc-spec-clarity (/spec:interview, /spec:seed, /spec:ambiguity, /spec:evaluate)
• Agents: contrarian (contrarian review), simplifier (complexity reduction) — parallel execution
• Gate: Specification Gate
• Artifacts: docs/seed-spec-{slug}.md, docs/socratic-discovery-{slug}.md, docs/decision-log-{slug}.md, docs/spec-evaluation-{slug}.md
• Skip: Level 0-1

Stage 3: Planning#

Writes product briefs, PRD/technical specifications, and defines BDD Acceptance Criteria.

• Source: cc-bmad, cc-pm-strategy
• Gate: Analysis Gate
• Artifacts: docs/prd-{slug}.md, docs/tech-spec-{slug}.md, docs/bdd-{slug}.md

Stage 4: Design#

Designs architecture and UX, then performs parallel review.

• Source: cc-bmad (Architect + UX Designer personas)
• Gate: Solutioning Gate
• Artifacts: docs/architecture-{slug}.md, docs/ux-spec-{slug}.md
• Skip: Level 0

Stage 5: Epic Creation#

Creates ZenHub Epics and Stories based on design artifacts.

• Source: cc-dev-cycle, cc-bmad
• Gate: Planning Gate
• Artifacts: ZenHub Epic + linked Stories
• Skip: Level 0

Stage 6: Development#

Iterates through Stories within an Epic, executing the 13-step development cycle for each.

• Source: cc-dev-cycle, cc-bmad
• Gate: Implementation Gate (per Story)
• Artifacts: Implementation code + PR
• Parallel mode: --parallel option for parallel development of independent Stories via Agent Teams

Stage 7: Launch#

Establishes GTM strategy, messaging, and analytics plan.

• Source: cc-pm-gtm, cc-pm-analytics
• Artifacts: docs/gtm-{slug}.md, docs/analytics-plan-{slug}.md
• Skip: Level 0-1

BMAD Level Guide#

Level 0: Hotfix (Simple Bug Fix)#

Planning → Development

Skips Discovery, Specification, Design, Epic Creation, and Launch.

Level 1: Minor Feature (Small-scale Feature Addition)#

Planning → Design → Epic Creation → Development

Skips Discovery, Specification, and Launch.

Level 2-3: Feature / Major Feature#

Discovery → Specification → Planning → Design → Epic Creation → Development → Launch

Executes the full pipeline.

Level 4: New Project#

Discovery (deep) → Specification → Planning → Design → Epic Creation → Development → Launch

Executes Discovery in deep mode.

Gates#

Each gate is a quality checkpoint.

Specification Gate (Specification → Planning)#

• Ambiguity score ≤ 0.2
• Convergence ≥ 0.95
• Contrarian unresolved Critical: 0
• Consensus: 3/3 unanimous

Analysis Gate (Planning → Design)#

• Requirement clarity
• Scope appropriateness
• Acceptance Criteria testability

Solutioning Gate (Design → Epic Creation)#

• Architect: Clean Architecture, DI, API, security
• UX Designer: CoUI, layout, interaction, accessibility

Planning Gate (Epic Creation → Development)#

• Epic/Story structure
• Story points
• Labeling
• Dependencies

Implementation Gate (Development, per Story)#

• Lint passed
• Tests passed
• Code review passed
• Branch naming convention

State Management#

Pipeline state is stored in .pipeline/{slug}.yaml.

# Check status
/pipeline:status

# Specific project
/pipeline:status community

# All projects
/pipeline:status --all

Artifact Management#

All artifacts are stored in the project's docs/ directory:

Suspend and Resume#

The pipeline can be suspended and resumed at any time:

# Check status after suspension
/pipeline:status community

# Resume from Design stage
/project --from design  " community feature "

The state file records the last position, so previous artifacts are automatically referenced.

Dependent Plugins#