Home
cd ../playbooks
Project ManagementAdvanced

Spec-Driven Project Manager (CCPM)

A complete PRD-to-shipped-code workflow: write PRDs, parse them into technical epics, decompose into GitHub issues, launch parallel agents via git worktrees, and track it all with deterministic status scripts.

15 minutes
By AutomazeSource
#project-management#prd#github-issues#git-worktrees#parallel-agents#epic-planning#task-tracking#spec-driven-development

Your requirements live in three Slack threads, a Google Doc nobody updated, and someone's memory. Six months later nobody can say why a feature works the way it does — the actual specification evaporated the moment the sprint ended.

Who it's for: engineering teams wanting full requirement-to-code traceability, tech leads coordinating parallel work across multiple engineers or agents, solo developers who want PM discipline without PM overhead, teams already living in GitHub Issues who want the workflow formalized, anyone tired of specs that exist nowhere durable

Example

"I want to build a notification preferences feature" → A structured PRD through guided brainstorming, parsed into a technical epic capped at 10 tasks, decomposed into numbered task files with dependency and parallelization metadata, synced to GitHub as linked issues with a dedicated git worktree, executed by parallel subagents each scoped to non-conflicting files, and tracked end-to-end with status/standup/blocked scripts

CLAUDE.md Template

New here? 3-minute setup guide → | Already set up? Copy the template below.

Or install from your terminal:
npx ccplaybooks add spec-driven-project-manager
# Spec-Driven Project Manager

## Your Role

You run a spec-driven delivery workflow: PRD → Epic → GitHub Issues → parallel agents → shipped code. Requirements live in files, not in anyone's head. Every feature starts as a PRD, becomes a technical epic, decomposes into GitHub issues, and gets executed by parallel agents with full traceability back to the original requirement.

Use this workflow any time I'm talking about shipping a feature, managing work, or tracking progress — even if I don't use these exact terms. Don't use it for debugging code, writing tests, reviewing PRs, or raw GitHub issue operations with no delivery context — those are separate concerns.

---

## File Conventions

Get new playbooks like this one

One email a week with new Claude Code workflows. Free, like everything here.

No spam. Unsubscribe anytime.

README.md

What This Does

A full delivery lifecycle, not just a triage checklist: Plan → Structure → Sync → Execute → Track. Every feature starts as a written PRD, gets parsed into a technical epic, decomposes into numbered tasks with explicit dependency and parallelization metadata, syncs to GitHub as real linked issues, and gets built by parallel subagents working in isolated git worktrees — each one scoped to a specific set of files so they don't step on each other.

The whole point: requirements live in files with frontmatter, not in chat history. Six months from now, git blame and the epic file both explain why a feature works the way it does.


Quick Start

Step 1: Create a Project Folder

cd ~/your-project

Step 2: Download the Template

Click Download above, then:

mv ~/Downloads/CLAUDE.md ./

Step 3: Start Planning

claude

Then say: "I want to build [feature]" or "create a PRD for [feature]"


The Five Phases

Phase Trigger phrases Produces
Plan "I want to build X", "create a PRD for X" .claude/prds/<name>.md → .claude/epics/<name>/epic.md
Structure "decompose the X epic into tasks" Numbered task files with dependency + parallelization metadata
Sync "push the X epic to GitHub" Real GitHub issues, a dedicated epic/<name> worktree
Execute "start working on issue 42" Parallel subagents, each scoped to non-conflicting files
Track "what's our status", "standup" Deterministic script output — no reconstruction from memory

File Structure It Creates

.claude/
├── prds/<feature-name>.md
├── epics/<feature-name>/
│   ├── epic.md
│   ├── <N>.md                    # renamed to GitHub issue number after sync
│   ├── <N>-analysis.md           # parallel work stream breakdown
│   ├── github-mapping.md
│   └── updates/<issue_N>/        # per-stream progress tracking

Tips & Best Practices

  • Cap epics at roughly 10 tasks. The workflow explicitly favors simplicity over completeness — if an epic wants more than that, it's probably two epics.
  • Task numbers change on sync — never hard-code dependencies by filename. Tasks start as 001.md, 002.md and get renamed to their real GitHub issue number after sync. The depends_on array is rewritten automatically; anything referencing the old sequential number breaks silently if you bypass this.
  • Conflicts pause, they never auto-resolve. When two parallel agents hit the same file, the correct behavior is to stop and report — not to guess at a merge. This is a deliberate safety rule, not a limitation to work around.
  • Tracking is script-first by design. Status, standup, and blocked-item queries run a deterministic bash script rather than having the model reconstruct project state from files — faster and immune to the model misreading a frontmatter field.
  • The repository safety check matters. Every GitHub write operation checks the git remote first, so a misconfigured clone can't accidentally push issues to the wrong repository.

Limitations

  • Requires the GitHub CLI (gh) authenticated, and works best with the gh-sub-issue extension installed for true parent/child issue linking — without it, tasks become flat labeled issues instead of GitHub sub-issues
  • Built around git worktrees for parallel execution — teams uncomfortable with worktrees will need to adapt the Execute phase or run tasks sequentially instead
  • Designed for engineering delivery specifically (PRD → code), not general project management — non-technical PM workflows should look elsewhere on this site
  • The 10-task epic guideline is a default, not a hard rule — very large features genuinely need more, but the workflow nudges toward splitting rather than growing a single epic indefinitely

$Related Playbooks

Project Management

Scrum Master Coach

Facilitate sprint ceremonies, coach agile practices, run effective retrospectives, remove impediments, track team health metrics, and generate ceremony templates.

10 minutes
Intermediate
Project Management

Wayfinder: Decision-Ticket Planning for Oversized Efforts

Plan work too big for one agent session as a shared map of decision tickets — questions to resolve, not slices of a build to execute — and work through them one at a time until the way to the destination is clear.

10 minutes
Advanced
Project Management

Trello Board Automation

Automate Trello board management, card workflows, power-ups, and team collaboration

10 minutes
Advanced
Project Management

Product Roadmap Communication

Transform product roadmaps into audience-specific communications for executives, customers, sales teams, and engineering.

5 minutes
Beginner
Project Management

Project Charter & Kickoff Documentation

Create project charters with scope definition, stakeholder analysis, risk assessment, and kickoff materials for new initiatives.

5 minutes
Beginner
Project Management

Project Status & Health Reporting

Generate project health dashboards with RAG status, milestone tracking, risk updates, and stakeholder-ready summaries.

5 minutes
Beginner
Project Management

Requirements Documentation

Transform stakeholder needs into structured requirements documents with user stories, acceptance criteria, and traceability matrices.

10 minutes
Intermediate
Project Management

Sprint Planning & Backlog Refinement

Structure sprint planning sessions with story estimation, capacity planning, sprint goals, and backlog grooming frameworks.

10 minutes
Intermediate
Project Management

Stakeholder Analysis & Communication Planning

Map project stakeholders by influence and interest, design tailored communication strategies, and build engagement plans.

5 minutes
Beginner
Project Management

Project Status Artifact

Generate and publish an opinionated, tabbed project status page for work too big for one update — success criteria, a workstream sequence, next steps, risks — then refresh it in place on the same URL, reporting only what changed instead of re-narrating the whole project.

10 minutes
Intermediate
Project Management

Project Management Bootstrapper

Initialize a comprehensive project management system with folder structures, TODO tracking, resource catalogs, and Claude-specific project configuration.

15 minutes
Intermediate
Project Management

Team Capacity & Resource Planner

Analyze team workload, identify capacity gaps, and model resource allocation scenarios for staffing decisions.

15 minutes
Intermediate

Browse all Project Management playbooks →