Agent skill

CCPM Project Management

by automazeio in automazeio/ccpm

Runs a spec-driven workflow from PRD to epic to GitHub issues to parallel agents, with status, standup and blocked-work reports from bundled scripts.

MITAuto-check passedProduct & Project Management

Install CCPM Project Management

skills CLI
$ npx skills add automazeio/ccpm --skill ccpm -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install automazeio/ccpm ccpm --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/automazeio/ccpm.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skill/ccpm .claude/skills/ccpm && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
ccpm
GitHub stars
8.4k
Token cost
~1.1k tokens
SKILL.md length
356 words
Files
21 (incl. references)
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Runs a spec-driven workflow from PRD to epic to GitHub issues to parallel agents, with status, standup and blocked-work reports from bundled scripts.

  • Works in 5 steps: Plan — Capture requirements → Structure — Break it down → Sync — Push to GitHub → …
  • Writing a PRD and turning it into an epic with tasks
  • SKILL.md covers Core Philosophy, File Conventions, The Five Phases and Script-First Rule, plus 1 more section
  • Runs Shell scripts from its folder; calls bash

What it does

Software delivery is organized around files and GitHub issues. A feature starts as a PRD, becomes a technical epic, is split into numbered task files with dependencies, is synced to GitHub issues, and is executed by parallel agents working in worktrees. The core idea is that requirements live in files, not in anyone's head.

Work is divided into five phases, each with its own reference note: plan, structure, sync, execute and track. Plan covers guided PRD writing and converting a PRD to an epic, sync pushes epics and tasks to GitHub and posts progress comments, execute analyzes parallel work streams, and track covers status, standups, what is blocked and what is next. A conventions file sets path standards and frontmatter schemas.

For read-and-report jobs the agent is told to run the bundled bash scripts directly instead of redoing the work by hand, for example status, standup, epic list, epic status, next and blocked. The skill steps aside for debugging, writing tests, reviewing PRs or plain GitHub issue operations.

When your agent uses it

  • Writing a PRD and turning it into an epic with tasks
  • Syncing an epic's tasks to GitHub issues
  • Starting parallel agents on several GitHub issues
  • Running a standup or checking what is blocked and what is next

Example prompts

  • “Write a PRD for a team invite feature and scope it out.”
  • “Parse the invites PRD into an epic and break it into tasks.”
  • “Sync the invites epic to GitHub and start working on the first issue.”
  • “Run the standup and tell me what is blocked.”

Requirements

  • A GitHub repository with Issues enabled
  • Bash and Git for the bundled scripts

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Plan — Capture requirements
  2. Structure — Break it down
  3. Sync — Push to GitHub
  4. Execute — Start building
  5. Track — Know where things stand

What it can do on your machine

Read from SKILL.md and the folder at commit 7d7e462. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships script files (Shell, from the files we listed), which the agent can run.

    Shell commands in SKILL.md call:

    • bash

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

CCPM Project Management loads about 1.1k tokens when it runs, and up to ~17k if it reads all its reference files. Until then it costs about 226 tokens; SKILL.md has 356 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~226
When it runs · the whole SKILL.md, loaded when a task matches
~1.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~17k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from automazeio/ccpm at commit 7d7e462, republished under its MIT licence (© automazeio). 356 words, ~1,118 tokens.

Download SKILL.mdSave it as .claude/skills/ccpm/SKILL.md (or your agent's skills folder). This skill also uses 20 other files; get the full folder from GitHub.
name
ccpm
description
CCPM - spec-driven project management: PRD → Epic → GitHub Issues → parallel agents → shipped code. Use this skill for anything in the software delivery lifecycle: writing a PRD ('write a PRD for X', 'let's plan X', 'scope this out'), parsing a PRD into an epic, decomposing an epic into tasks, syncing to GitHub ('sync the X epic', 'push tasks to github'), starting work on an issue ('start working on issue N', 'let's work on issue N'), analyzing parallel work streams, running standups ('standup', 'run the standup'), checking status ('what's next', 'what's blocked', 'what are we working on'), closing issues, or merging an epic. Use ccpm any time the user is talking about shipping a feature, managing work, or tracking progress — even if they don't say 'ccpm' or 'PRD'. Do NOT use for: debugging code, writing tests, reviewing PRs, or raw GitHub issue/PR operations with no delivery context.

CCPM - Claude Code Project Manager

A spec-driven development workflow: PRD → Epic → GitHub Issues → Parallel Agents → Shipped Code.

Core Philosophy

Requirements live in files, not heads. Every feature starts as a PRD, becomes a technical epic, decomposes into GitHub issues, and gets executed by parallel agents with full traceability.

File Conventions

Before doing anything, read references/conventions.md for path standards, frontmatter schemas, and GitHub operation rules. These apply to all phases.

The Five Phases

1. Plan — Capture requirements

When: User wants to define a new feature, product requirement, or scope of work. Read: references/plan.md Covers: Writing PRDs through guided brainstorming, converting PRDs to technical epics.

2. Structure — Break it down

When: An epic exists and needs to be decomposed into concrete tasks. Read: references/structure.md Covers: Epic decomposition into numbered task files with dependencies and parallelization.

3. Sync — Push to GitHub

When: Local epic/tasks need to become GitHub issues, progress needs to be posted as comments, or a bug is found and needs a linked issue created. Read: references/sync.md Covers: Epic sync (epic + tasks → GitHub issues), issue sync (progress comments), closing issues/epics, bug reporting against completed issues.

4. Execute — Start building

When: User wants to start working on one or more GitHub issues with parallel agents. Read: references/execute.md Covers: Issue analysis (parallel work stream identification), launching parallel agents, coordinating worktrees.

Show full SKILL.md (139 more words)Show less
5. Track — Know where things stand

When: User asks for status, standup report, what's blocked, what's next, or needs to validate state. Read: references/track.md Covers: Status, standup, search, in-progress, next priority, blocked items, validation.


Script-First Rule

For deterministic operations — anything that reads and reports without needing reasoning — always run the bash script directly rather than doing the work manually:

What the user wantsScript to run
Project statusbash references/scripts/status.sh
Standup reportbash references/scripts/standup.sh
List all epicsbash references/scripts/epic-list.sh
Show epic detailsbash references/scripts/epic-show.sh <name>
Epic statusbash references/scripts/epic-status.sh <name>
List PRDsbash references/scripts/prd-list.sh
PRD statusbash references/scripts/prd-status.sh
Search issues/tasksbash references/scripts/search.sh <query>
What's in progressbash references/scripts/in-progress.sh
What's nextbash references/scripts/next.sh
What's blockedbash references/scripts/blocked.sh
Validate project statebash references/scripts/validate.sh

Use the LLM for work that requires reasoning: writing PRDs, analyzing parallelism, launching agents, synthesizing updates.


Quick Reference

Plan a feature:     "I want to build X" or "create a PRD for X"
Parse to epic:      "turn the X PRD into an epic"
Decompose:          "break down the X epic into tasks"
Sync to GitHub:     "push the X epic to GitHub"
Start an issue:     "start working on issue 42"
Check status:       "what's our status" / "standup"
What's next:        "what should I work on next"
Merge epic:         "merge the X epic"
Report a bug:       "found a bug in issue 42" / "testing issue 42 revealed X"

© automazeio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 20 other files (references) in skill/ccpm of automazeio/ccpm.

  • SKILL.md
  • references/conventions.md
  • references/execute.md
  • references/plan.md
  • references/scripts/blocked.sh
  • references/scripts/epic-list.sh
  • references/scripts/epic-show.sh
  • references/scripts/epic-status.sh
  • references/scripts/help.sh
  • references/scripts/in-progress.sh
  • references/scripts/init.sh
  • references/scripts/next.sh
  • references/scripts/prd-list.sh
  • references/scripts/prd-status.sh
  • references/scripts/search.sh
  • references/scripts/standup.sh
  • references/scripts/status.sh
  • references/scripts/validate.sh
  • references/structure.md
  • … and 2 more

Open the folder on GitHubat commit 7d7e462

Compare with similar skills

CCPM Project Management next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

CCPM Project Management compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
CCPM Project Management this skillautomazeio/ccpm8.4k—~1.1kAutomated safety check: PassMIT
Sagawarpdotdev/common-skills608—~4.1kAutomated safety check: PassMIT
Reviewfossasia/eventyay-interpretation1.6k35 repos~996Automated safety check: PassApache-2.0
Gh Issuestrpc-group/trpc-agent-go1.8k8 repos~8.7kAutomated safety check: PassApache-2.0
Review Spdzhu1090093659/spec_driven_develop984—~1.5kAutomated safety check: PassMIT
GitHub Project Management Swarmruvnet/agentic-flow8166 repos~7.1kAutomated safety check: PassNone

Similar skills

  • Saga

    warpdotdev/common-skills

    Run an autonomous, spec-driven development "saga" for medium-to-large features using an orchestrator agent and a fleet of worker subagents.

    608 GitHub stars~4.1k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Review

    fossasia/eventyay-interpretation

    Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match…

    1.6k GitHub starsUsed in 35 repos~996 tokens
    Product & Project ManagementAuto-check passed
  • Gh Issues

    trpc-group/trpc-agent-go

    Fetch GitHub issues, spawn sub-agents to implement fixes and open PRs, then monitor and address PR review comments.

    1.8k GitHub starsUsed in 8 repos~8.7k tokens
    Agent WorkflowsAuto-check passed
  • Review Spd

    zhu1090093659/spec_driven_develop

    Findings-first code review workflow for AI coding agents. An agent skill from zhu1090093659/spec_driven_develop.

    984 GitHub stars~1.5k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed
  • Manages GitHub issues and project boards with swarm coordination: issue creation and triage, issue-to-task conversion, progress tracking and stale issue cleanup.

    816 GitHub starsUsed in 6 repos~7.1k tokens
    Product & Project ManagementAuto-check passed
  • GitHub Sync Helper

    OpenMinis/MinisSkills

    General GitHub basic operations + automation for GitHub platform objects (Issues/Labels/Milestones/Releases/Actions) in the Minis environment.

    444 GitHub stars~2.8k tokensUpdated today
    Product & Project ManagementAuto-check passed

Works with

Questions about CCPM Project Management

What does CCPM Project Management do?

Runs a spec-driven workflow from PRD to epic to GitHub issues to parallel agents, with status, standup and blocked-work reports from bundled scripts. Software delivery is organized around files and GitHub issues. A feature starts as a PRD, becomes a technical epic, is split into numbered task files with dependencies, is synced to GitHub issues, and is executed by parallel agents working in worktrees.

When should I use CCPM Project Management?

CCPM Project Management fits situations like: writing a PRD and turning it into an epic with tasks; syncing an epic's tasks to GitHub issues; starting parallel agents on several GitHub issues; running a standup or checking what is blocked and what is next.

How do I install CCPM Project Management in Claude Code?

Run `npx skills add automazeio/ccpm --skill ccpm -a claude-code`. Or copy the skill folder (skill/ccpm in automazeio/ccpm) into .claude/skills/ccpm in your project. Claude Code loads it when a task matches its description.

How do I install CCPM Project Management in Codex?

Run `npx skills add automazeio/ccpm --skill ccpm -a codex`. Or copy the skill folder (skill/ccpm in automazeio/ccpm) into .agents/skills/ccpm in your project. Codex loads it when a task matches its description.

Can I use CCPM Project Management in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add automazeio/ccpm --skill ccpm -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ccpm, .gemini/skills/ccpm, .github/skills/ccpm and .opencode/skills/ccpm in your project.

What does CCPM Project Management need to run?

Going by SKILL.md and its folder, CCPM Project Management needs a shell for the scripts in its folder and the command-line tools its instructions call (bash). Our summary lists: A GitHub repository with Issues enabled; Bash and Git for the bundled scripts.

Does CCPM Project Management access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is CCPM Project Management safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does CCPM Project Management use?

CCPM Project Management is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does CCPM Project Management use?

About 1.1k tokens (SKILL.md is roughly 4.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 16k tokens, read only when the agent opens those files.

What are the alternatives to CCPM Project Management?

Skills that share tags, products or a category with CCPM Project Management: Saga (warpdotdev/common-skills, 608 stars), Review (fossasia/eventyay-interpretation, 1.6k stars), Gh Issues (trpc-group/trpc-agent-go, 1.8k stars) and Review Spd (zhu1090093659/spec_driven_develop, 984 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains CCPM Project Management?

automazeio (a GitHub organization) maintains it in automazeio/ccpm, which has 8,408 GitHub stars. The repository was last updated on March 18, 2026.

Source: automazeio/ccpm on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.