Saas Pipeline

SaaS Pipeline Coordinator

Coordinate, never execute. Read project state, route to the correct skill, track progress, delegate all work.

• Explicit invocation only - activate only when invoked
• Stack-agnostic - read tech stack from project's CLAUDE.md (## Tech Stack). If absent, ask before phase 4
• Progressive disclosure - load references/phase-N-*.md only when entering a phase
• No duplication - delegate to skills, never reimplement their work
• Desync safety - verify actual file existence, not just status.json claims
• Skill-aware delegation - MANDATORY: every subagent prompt must include a === READ FIRST === block with relevant skills (see Skill Injection Rule)

---

State Management

Initialize

When .claude/saas-project/ does not exist, create it with status.json:

{
  "project_name": "<ask user>",
  "created_at": "<ISO-8601>",
  "updated_at": "<ISO-8601>",
  "current_phase": 1,
  "stack": { "frontend": "<from CLAUDE.md or null>", "backend": "<from CLAUDE.md or null>" },
  "phases": {
    "1-idea": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "2-business": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "3-product": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "4-architecture": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "5-design": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "6-implementation": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "7-deployment": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] },
    "8-marketing": { "status": "pending", "started_at": null, "completed_at": null, "outputs": [] }
  }
}

Update

After each significant action, update updated_at, phase status/timestamps, outputs array, and current_phase.

---

Router

Execute on every invocation:

Step 1: Load State

Read .claude/saas-project/status.json. If missing, initialize first.

Step 2: Classify Intent

Step 3: Auto-Route

phase = phases[current_phase]
IF pending   → read references/phase-N-*.md, invoke first skill
IF in_progress → find next pending skill in phase, invoke it
IF completed → advance current_phase, start next

Skill Injection Rule

MANDATORY for every subagent dispatch. Always run the scan — never skip it.

Before dispatching any agent (Task tool or Agent Team):

1. Scan ~/.claude/skills/ — match skill names/descriptions to the agent's task technology and type 2. Select up to 4-5 relevant skills 3. For each selected skill, read its SKILL.md and check for a Reference Guide table or references/ directory. Include references whose topics match the agent's task 4. Prepend a === READ FIRST === block listing each skill's SKILL.md AND its matching references. If no skills match, dispatch without the block — not every task needs skills

=== READ FIRST ===
Read: ~/.claude/skills/{skill-a}/SKILL.md
Read: ~/.claude/skills/{skill-a}/references/{matching-ref}.md
Read: ~/.claude/skills/{skill-b}/SKILL.md
=== END READ ===

Example — Flutter frontend implementer (skill with references):

The flutter-expert SKILL.md has a Reference Guide table. Task involves Riverpod state and navigation → include those references:

Task("Implement Task 2: User dashboard screen

=== READ FIRST ===
Read: ~/.claude/skills/flutter-expert/SKILL.md
Read: ~/.claude/skills/flutter-expert/references/riverpod-state.md
Read: ~/.claude/skills/flutter-expert/references/gorouter-navigation.md
Read: ~/.claude/skills/flutter-expert/references/widget-patterns.md
Read: ~/.claude/skills/test-driven-development/SKILL.md
=== END READ ===

=== TASK ===
You are implementing Task 2: User dashboard screen
[... full task text, context, requirements ...]
=== END TASK ===
")

Example — backend implementer (skill without references):

nodejs-backend-patterns has no reference files, so only SKILL.md is needed:

Task("Implement Task 3: Auth module

=== READ FIRST ===
Read: ~/.claude/skills/nodejs-backend-patterns/SKILL.md
Read: ~/.claude/skills/test-driven-development/SKILL.md
=== END READ ===

=== TASK ===
You are implementing Task 3: Auth module
[... full task text, context, requirements ...]
=== END TASK ===
")

When using `subagent-driven-development`: its implementer-prompt.md does NOT include skill injection. You MUST prepend the === READ FIRST === block before the template content — the block goes at the very top, before "You are implementing Task N."

For the full scanning algorithm, see references/skill-injection-protocol.md.

Dashboard

Display on status requests:

╔══════════════════════════════════════════════╗
║          PROJECT: {project_name}             ║
║          Stack: {frontend} + {backend}       ║
╠══════════════════════════════════════════════╣
║  Phase 1 - Idea          ████████████ 100%   ║
║  Phase 2 - Business      ████████░░░░  67%   ║
║  Phase 3 - Product       ░░░░░░░░░░░░   0%   ║
║  Phase 4 - Architecture  ░░░░░░░░░░░░   0%   ║
║  Phase 5 - Design        ░░░░░░░░░░░░   0%   ║
║  Phase 6 - Implementation░░░░░░░░░░░░   0%   ║
║  Phase 7 - Deployment    ░░░░░░░░░░░░   0%   ║
║  Phase 8 - Marketing     ░░░░░░░░░░░░   0%   ║
║                                              ║
║  Current: Phase 2 → Next: startup-biz-models ║
╚══════════════════════════════════════════════╝

Calculate percentage: skills completed / total skills in phase.

---

The 8 Phases

When entering a phase, read its reference file for detailed workflow.

Gateway Skills

Always invoke these before their dependent work:

Utility Skills (always available)

find-skills (discover/install), skill-creator (create custom), dispatching-parallel-agents (orchestrate teams)

---

Agent Teams

Three parallelism opportunities via dispatching-parallel-agents. Always offer sequential as alternative.

Before dispatching agents, apply the Skill Injection Rule. Each agent gets skills matching its domain (frontend tech skills for frontend agent, backend tech skills for backend agent, plus methodology skills like TDD).

1. Phases 4+5: Architecture + Design

When project has separate frontend/backend stack:

Agent A: backend-architect → API design, data models
Agent B: ui-ux-pro-max → UI architecture + design system
Sync: align API contracts with UI data needs

2. Phase 6: Frontend + Backend

When API contracts are defined:

Agent A: Frontend → implement UI against contracts (mock responses)
Agent B: Backend → implement API endpoints matching contracts
Sync: integration testing

3. Phase 8: All Marketing

All 5 skills are fully independent:

Agent A: landing-page-copywriter
Agent B: email-sequence
Agent C: marketing-ideas
Agent D: conversion-optimization-expert
Agent E: remotion-best-practices

On team acceptance: read relevant references/, use dispatching-parallel-agents to set up, give each agent project context + phase requirements.

---

Auto-Install Missing Skills

On every invocation, verify skills for current and next phase are installed.

FOR each skill in current_phase:
  CHECK ~/.claude/skills/{skill-name}/ exists
  IF missing → read references/install-commands.md, inform user, offer install command, block phase if declined

---

Stack-Specific Skill Discovery

Discover stack-matching skills dynamically. Never hardcode stack-to-skill mappings.

Trigger at: 1. Project initialization (after reading stack from CLAUDE.md) 2. Phase 4 start (before architecture work)

READ stack from CLAUDE.md
FOR each technology in stack:
  CHECK ~/.claude/skills/ for matching skill
  IF not found → RUN: npx skills find {technology}
  PRESENT results, OFFER install with -g -y

---

Non-Linear Navigation

• Skip ahead: allowed if target phase's required inputs exist (phase 4 needs design doc, phase 6 needs architecture + contracts, phase 8 needs .claude/product-marketing-context.md)
• Go back: always allowed, never deletes previous outputs
• Partial phases: track individual skill completion; resume from last incomplete skill, not phase start

FOR each skill in phase.skills:
  IF output in phase.outputs → skip
  ELSE → next skill to execute

saas-pipeline

A Claude Code skill that orchestrates 28 skills across 8 phases to take a SaaS project from idea to launch.

What it does

saas-pipeline is a coordinator — it never executes work itself. Instead, it:

• Tracks your project's current phase in .claude/saas-project/status.json
• Routes you to the right skill based on where you are
• Manages transitions between phases with exit criteria
• Offers parallel execution with agent teams when possible

The 8 Phases

Install

npx skills add <repo-url>@saas-pipeline -g -y

Usage

Invoke in any project:

/saas-pipeline

The coordinator will: 1. Initialize a new project (if none exists) 2. Show the dashboard with current progress 3. Suggest the next skill to run 4. Auto-install missing skills as needed

Common commands

Stack-agnostic

The skill reads your tech stack from your project's CLAUDE.md (## Tech Stack section). If no stack is defined, it asks before Phase 4 (Architecture).

It dynamically discovers stack-specific skills using find-skills — no hardcoded stack assumptions.

Agent Teams

Three opportunities for parallel execution:

1. Phases 4+5 — Architecture + Design in parallel (separate frontend/backend) 2. Phase 6 — Frontend + Backend implementation in parallel (when API contracts exist) 3. Phase 8 — All 5 marketing skills simultaneously (fully independent)

Structure

saas-pipeline/
├── SKILL.md                          # Coordinator logic (router, state, phases)
└── references/
    ├── install-commands.md           # Skill install commands (loaded on demand)
    ├── phase-1-idea.md               # Ideation workflow
    ├── phase-2-business.md           # Business model workflow
    ├── phase-3-product.md            # Product definition workflow
    ├── phase-4-architecture.md       # Architecture workflow
    ├── phase-5-design.md             # Design system workflow
    ├── phase-6-implementation.md     # Implementation workflow
    ├── phase-7-deployment.md         # Deployment workflow
    └── phase-8-marketing.md          # Marketing workflow

License

MIT

Install Commands

Load this file when a required skill is missing and needs installation.

Phase 1: Ideation

Objective

Transform a raw idea into a structured, validated design document ready for business analysis.

Skills

Workflow

Step 1: Invoke Brainstorming

Delegate to brainstorming with the user's initial idea. The skill handles intent exploration, problem mapping, alternative generation, convergence, and documentation.

Step 2: Save Design Document

Ensure the output is saved to:

docs/plans/{project-name}-design.md

Step 3: Commit

git add docs/plans/
git commit -m "docs: add design document for {project-name}"

Exit Criteria

• [ ] Design document exists in docs/plans/
• [ ] Document covers problem, audience, solution, MVP features
• [ ] Document committed to the repository
• [ ] User has reviewed and approved the direction

Phase 2: Business Model

Objective

Define a sustainable business model with clear revenue streams, pricing strategy, and unit economics.

Skills

Workflow

Step 1: Business Model Canvas

Delegate to business-model-canvas with the Phase 1 design document (docs/plans/{project-name}-design.md).

Target: canvas score >= 60. If below, iterate on weak blocks before proceeding.

Step 2: Pricing and Unit Economics

Delegate to startup-business-models with the canvas output.

Step 3: Save Documents

docs/business/
  business-model-canvas.md
  pricing-strategy.md

Exit Criteria

• [ ] Business Model Canvas completed with score >= 60
• [ ] Revenue model type selected and justified
• [ ] Pricing tiers defined (at least free + paid, or trial + paid)
• [ ] Unit economics estimated (LTV, CAC, gross margin)
• [ ] Documents saved to docs/business/

Notes

• Usage-based pricing needs metering infrastructure — capture as input for Phase 4

Phase 3: Product Definition

Objective

Create a PRD with acceptance criteria and establish the product marketing context for Phase 8.

Skills

Workflow

Step 1: Product Requirements Document

Delegate to product-manager-toolkit with:

• Phase 1: Design document (docs/plans/{project-name}-design.md)
• Phase 2: Business model (docs/business/)

Save to docs/product/prd.md.

Step 2: Product Marketing Context

Delegate to product-marketing-context.

Creates .claude/product-marketing-context.md — gateway requirement for Phase 8. Without this file, marketing skills lack essential context.

Step 3: Verify Outputs

docs/product/
  prd.md
.claude/
  product-marketing-context.md

Exit Criteria

• [ ] PRD exists with feature specs and acceptance criteria
• [ ] Features prioritized (RICE or similar)
• [ ] User stories defined for MVP features
• [ ] .claude/product-marketing-context.md created and populated
• [ ] User has reviewed and approved the PRD

Phase 4: Technical Architecture

Contents

• Objective
• Skills
• Prerequisites
• Workflow
• Team Opportunity
• Exit Criteria

Objective

Define technical architecture, API contracts, and data models. Ensure stack-specific skills are available.

Skills

Prerequisites

Stack must be defined before starting. Read ## Tech Stack from project's CLAUDE.md. If absent, ask the user. Update status.json with chosen stack.

Workflow

Step 1: UX Flows

Delegate to ux-flow-designer with PRD from phase 3. Produces user flow diagrams, screen maps, and HTML wireframes.

Save to docs/architecture/ux-flows/.

Step 2: Stack-Specific Skill Discovery

FOR each technology in stack:
  RUN: npx skills find {technology}
  PRESENT results, OFFER install

Step 3: Backend Architecture

Delegate to backend-architect with context from phases 1-3, UX flows from Step 1, and backend stack.

Save to docs/architecture/backend-architecture.md.

Step 4: UI Architecture

Delegate to ui-ux-pro-max with PRD, UX flows from Step 1, API contracts from Step 3, and frontend stack.

Save to docs/architecture/ui-architecture.md.

Step 5: API Contract Alignment

Verify backend contracts align with UI data needs. Resolve mismatches.

Save final contracts to docs/architecture/api-contracts.md.

Team Opportunity

Phases 4+5 can run in parallel if separate frontend/backend stack:

Agent A: backend-architect → backend architecture
Agent B: ui-ux-pro-max → UI architecture + design system (phase 5)
Sync: API contract alignment after both complete

Exit Criteria

• [ ] User flow diagrams and screen maps created
• [ ] Backend architecture documented
• [ ] UI architecture documented
• [ ] API contracts defined and aligned
• [ ] Stack-specific skills discovered and installed
• [ ] All documents in docs/architecture/

Notes

• API contracts are the critical handoff for Phase 6 parallel implementation
• Consider billing/metering requirements from Phase 2

Phase 5: Design System

Objective

Define the product's visual language: colors, typography, spacing, components, and interaction patterns.

Skills

Workflow

Step 1: Create Design System

Delegate to ui-ux-pro-max with:

• Phase 3: PRD (user personas, product positioning)
• Phase 4: UI architecture (component hierarchy, navigation)
• Stack: frontend technology from CLAUDE.md

The skill handles all design system decisions (palette, typography, spacing, components, interactions).

Step 2: Save

docs/design/
  design-system.md

If using a component framework (shadcn/ui, Material, etc.), document which pre-built components to use vs custom.

Team Opportunity

Can run in parallel with Phase 4 as part of the architecture-design team. See Phase 4 reference for details.

Exit Criteria

• [ ] Color palette defined (primary, secondary, semantic, neutrals)
• [ ] Typography scale defined
• [ ] Core component designs specified
• [ ] Design system saved to docs/design/
• [ ] User has approved the visual direction

Phase 6: Implementation

Contents

• Objective
• Skills
• Workflow (Steps 1-6)
• Team Opportunity
• Exit Criteria

Objective

Build the product following TDD, code review, and verification practices.

Skills

Workflow

Step 1: Write Implementation Plan

Delegate to writing-plans with architecture docs, design system, and PRD.

Step 2: Set Up Workspace

Delegate to using-git-worktrees for isolated feature branch.

Step 3: Execute

Choose one:

• `executing-plans` — step by step with review checkpoints (solo work)
• `subagent-driven-development` — parallel execution (independent tasks)

MANDATORY pre-dispatch checklist (every agent, regardless of execution skill):

• [ ] Scanned ~/.claude/skills/ for skills matching the agent's task
• [ ] Identified relevant skills (stack-specific + methodology like TDD)
• [ ] Prepended === READ FIRST === block to the agent's prompt, BEFORE task content

When using subagent-driven-development: its template has NO skill injection — you MUST prepend the block at the top. Include matching reference files from each skill (check their SKILL.md Reference Guide table):

=== READ FIRST ===
Read: ~/.claude/skills/{stack-skill}/SKILL.md
Read: ~/.claude/skills/{stack-skill}/references/{matching-ref}.md
Read: ~/.claude/skills/test-driven-development/SKILL.md
=== END READ ===

You are implementing Task N: [task name]
[... template continues ...]

During execution, apply continuously:

• test-driven-development — before writing any implementation code
• systematic-debugging — when tests fail or unexpected behavior occurs

Step 4: Code Review

1. requesting-code-review — package changes, document what and why 2. receiving-code-review — verify suggestions before applying

If issues found: fix → re-test → re-review.

Step 5: Verify

Delegate to verification-before-completion. Do not proceed until it passes.

Step 6: Finish Branch

Delegate to finishing-a-development-branch.

Team Opportunity

Frontend + Backend in parallel when API contracts exist.

Apply the Skill Injection Rule (see SKILL.md) before dispatching each agent:

• Frontend agent: frontend stack skill (SKILL.md + matching references) + TDD + methodology skills
• Backend agent: backend stack skill (SKILL.md + matching references) + TDD + methodology skills

Each agent's prompt MUST start with === READ FIRST === listing its domain-specific skills and their relevant reference files.

Agent A: Frontend → implement UI against contracts (mock responses)
Agent B: Backend → implement API endpoints matching contracts
Sync: integration testing after both complete

Each agent follows the same inner loop:

writing-plans → git-worktrees → executing-plans
  + TDD + debugging (during)
  → code-review → verification → finish-branch (after)

Exit Criteria

• [ ] All planned features implemented
• [ ] All tests pass (unit, integration)
• [ ] Code review completed and approved
• [ ] Verification confirms all acceptance criteria
• [ ] Branch merged or PR created

Notes

• Never skip TDD — catches design issues early
• If implementation reveals architecture issues, go back to Phase 4

Phase 7: Deployment

Contents

• Objective
• Skills
• Workflow (Steps 1-3)
• Exit Criteria

Objective

Containerize the application and prepare for production deployment.

Skills

Workflow

Step 1: Gather Context

Before delegating, collect:

• Stack from CLAUDE.md (determines base images, build steps)
• Architecture from Phase 4 (docs/architecture/)
• Environment variables and external service dependencies

Step 2: Containerize

Delegate to docker-expert with full application context. The skill handles Dockerfiles, docker-compose, and health checks.

Step 3: Verify

docker compose build
docker compose up -d
docker compose ps       # all containers healthy
docker compose logs     # no startup errors

Run test suite against containerized environment.

Save deployment docs to docs/deployment/docker-setup.md.

Exit Criteria

• [ ] Dockerfile(s) with multi-stage builds
• [ ] docker-compose.yml with all services
• [ ] Health checks configured
• [ ] docker compose build succeeds
• [ ] docker compose up starts all services healthy
• [ ] Application works correctly in containers
• [ ] Deployment docs created

Notes

• For mobile apps (Flutter mobile, React Native), adapt to CI/CD + app store deployment instead of Docker

Phase 8: Marketing

Contents

• Objective
• Skills
• Prerequisites
• Workflow
• Team Opportunity
• Exit Criteria

Objective

Create all marketing assets: landing page, email sequences, strategy, CRO, and promotional video.

Skills

All 5 are independent — run in any order or in parallel.

Prerequisites

Required: .claude/product-marketing-context.md (created in Phase 3).

All marketing skills reference this file. If missing, go back to Phase 3 and run product-marketing-context.

Workflow

Delegate to each skill with .claude/product-marketing-context.md as context. Each produces independent output.

Save all to:

docs/marketing/
  landing-page-copy.md
  email-sequences.md
  marketing-strategy.md
  cro-recommendations.md
  video/

Optional second pass: conversion-optimization-expert reviews landing-page-copywriter output.

Team Opportunity

Best phase for parallel execution — all 5 skills are fully independent:

Agent A: landing-page-copywriter
Agent B: email-sequence
Agent C: marketing-ideas
Agent D: conversion-optimization-expert
Agent E: remotion-best-practices

No synchronization needed.

Exit Criteria

• [ ] Landing page copy with headlines, value props, CTAs
• [ ] At least one email sequence (welcome/onboarding)
• [ ] Marketing strategy with prioritized tactics
• [ ] CRO recommendations documented
• [ ] Promotional video project created (optional)
• [ ] All outputs in docs/marketing/

Notes

• Remotion requires React/TypeScript. If not using React, run as standalone project or skip

Skill Injection Protocol

Quick version: See the Skill Injection Rule in SKILL.md for the inline rule and example. This file provides the full algorithm for complex cases.

When delegating tasks to any agent (Task tool subagent or Agent Team teammate), identify relevant skills and instruct the agent to read them.

IMPORTANT: Always instruct agents to read the full SKILL.md file plus any matching reference files. Never summarize or paraphrase skill contents — this prevents information loss and interpretation bias.

Protocol

Before dispatching any agent:

Step 1: Define the task profile

Determine for the agent's task:

• Technologies involved (languages, frameworks, platforms)
• Task type (implementation, architecture, design, testing, marketing, deployment, etc.)
• Project stack from .claude/saas-project/status.json (stack.frontend, stack.backend)

Step 2: Scan installed skills

FOR each directory in ~/.claude/skills/:
  READ SKILL.md frontmatter (name, description fields)
  EVALUATE: does this skill's purpose align with the agent's task?
  Match criteria (any of):
    - Skill name or description mentions a technology the task uses
    - Skill description matches the task type (e.g., testing skill for implementation tasks)
    - Skill is listed in the current phase's skill table AND is relevant to this specific subtask
  IF match → add to candidate list

Step 3: Select and prioritize

From candidates, select the most relevant (max 4-5 per agent):

• Prioritize skills that directly match the task's primary technology or purpose
• Include methodology skills applicable during execution (e.g., a testing skill for an implementation task)
• Exclude skills the agent will not realistically use for its specific subtask
• If a skill is the SAME one the agent is executing, always include it

Step 4: Identify relevant skill files (MANDATORY)

Skills often contain reference files with detailed patterns, syntax, and implementation guidance that SKILL.md alone does not cover. Skipping references makes skills like flutter-expert, mql-developer, and others effectively useless — the real value is in their reference files.

For each selected skill:

READ the skill's SKILL.md
CHECK for a Reference Guide table or references/ directory
IF references exist:
  MATCH reference topics against the agent's task
  ADD every matching reference file path to the reading list

Rules:

• Always include the skill's SKILL.md (entry point)
• Always check for and include matching references — do not skip this step
• Include a reference when its topic overlaps with the agent's task (e.g., task involves Riverpod state → include riverpod-state.md)
• Do not include references with no connection to the task (e.g., skip performance.md for a navigation-only task)

Step 5: Instruct the agent to read the skills

For ALL agent types (subagents and teammates alike), include reading directives in the agent's prompt. The agent must read the actual files — never pass summaries.

=== READ FIRST ===
Read: ~/.claude/skills/{skill-a}/SKILL.md
Read: ~/.claude/skills/{skill-a}/references/{relevant-file}.md
Read: ~/.claude/skills/{skill-b}/SKILL.md
=== END READ ===

=== TASK ===
[task details, context, requirements]
=== END TASK ===

Notes

• If no relevant skills are found, dispatch without the READ FIRST block — not every task needs skills
• Run this protocol at delegation time, not at phase start (skills may be installed mid-phase)
• For parallel agents (frontend + backend), each agent gets different skills matching their domain
• Never summarize or paraphrase skill contents to agents — always instruct them to read the source files
• Always check skills for reference files and include those matching the task — but don't dump entire skill directories