Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

CCPM

Agent Skill that turns PRDs into GitHub issues and runs parallel coding agents in Git worktrees

AI Skills & PluginsOpen source

CCPM at a glance

Pricing
Open source
License
Open source
Language
Shell
Tool type
Agent skill
Data location
Project state stays as Markdown in the repository's .claude/ folder; issues, labels and comments go to the user's GitHub repository through the gh CLI, and the optional Neon script uses the user's Neon project. Automaze runs no service.
Works with
claude code, codex, opencode, factory, amp, Cursor
Maker
automazeio
Founded
2025
HQ
London, United Kingdom

What is CCPM?

CCPM is a spec-driven project management workflow for AI coding agents, published by Automaze under the MIT license at automazeio/ccpm on GitHub. It takes a feature from an idea to a product requirements document (PRD), from the PRD to a technical epic, from the epic to numbered task files, and from those files to GitHub issues: one epic issue with one sub-issue per task. Each issue is then split into streams that several agents implement at the same time in a dedicated Git worktree, with progress posted back as issue comments. The repository was created on August 18, 2025.

The name comes from Claude Code PM, the original project, and the skill file still expands it as Claude Code Project Manager. Version 1 was a set of Claude Code slash commands in a /pm:* namespace, copied into a project by an installer script. On March 18, 2026 the project was relaunched as v2: a standard Agent Skill that, according to the README, works with Claude Code, Codex, OpenCode, Factory, Amp, Cursor and other harnesses that support Agent Skills. The slash command system is kept on the v1 branch, which is marked as archived and no longer maintained.

There are no GitHub releases or Git tags, so the version shown here is the default branch. The latest commit, 0bcfabb of November 4, 2026, fixed epic sync (empty issue bodies on GNU sed, sub-issue linking, safe re-runs after an interruption) and made the next, standup, blocked and validate scripts dependency-aware. The same day added a database guide and the optional neon-branch.sh script. A funding.json file from October 2026 states that development had slowed after March 2026 and proposes a maintenance plan with quarterly tagged releases.

skill/ccpm/ holds SKILL.md, which detects project management intent in plain language and routes to five reference files (plan, structure, sync, execute, track) plus a conventions file, and 16 Bash files: the 15 scripts the README counts plus a shared lib.sh. Status, standup, search and validation run as scripts; the model writes PRDs, analyses streams and launches agents. Project state is Markdown with YAML frontmatter in the project's .claude/ folder, and GitHub Issues, reached through the gh CLI, is the shared remote state. The GitHub Projects API is not used.

Automaze Ltd states its headquarters in London; its website describes a CTO-as-a-service offering and names Ran Aroussi as founder. The README lists Neon as a supporter. CCPM has no hosted service or user interface, and GitHub is the only tracker it syncs with; the changelog lists GitLab and Linear as researched, not built. Similar projects on iThub include Superpowers and Claude Forge, while Emdash and Orca are desktop apps that run coding agents in parallel Git worktrees.

Key capabilities

  • Guided PRD writing Before anything is written, the plan reference has the agent ask about the problem, the affected users, what success looks like, what is out of scope and the constraints. The result is .claude/prds/<name>.md with fixed sections from executive summary to dependencies. Quality gates forbid placeholder text and require user stories with acceptance criteria, measurable success criteria and an explicit out-of-scope list; feature names must be kebab-case.
  • PRD to technical epic Parsing a PRD produces .claude/epics/<name>/epic.md with architecture decisions, a technical approach split into frontend, backend and infrastructure, an implementation strategy and a task breakdown preview. The epic links back to its PRD in frontmatter. The instructions aim for 10 tasks or fewer per epic.
  • Task files with dependency metadata Decomposition writes numbered files (001.md, 002.md and so on) with a description, acceptance criteria, an XS to XL size, an hour estimate and a definition of done. Three frontmatter fields control scheduling: depends_on, parallel and conflicts_with for tasks that touch the same files. Circular dependencies are treated as an error, and large epics are decomposed by up to five agents at once.
  • GitHub sync with sub-issues Sync creates an epic issue labelled epic, epic:<name> and feature, then one issue per task labelled task and epic:<name>. With the gh-sub-issue extension the tasks become sub-issues of the epic; without it the README says CCPM falls back to task lists. Local files are renamed to their issue numbers and a github-mapping.md index is written. Already synced files are skipped, so an interrupted sync can be repeated.
  • One worktree and branch per epic After sync the agent creates branch epic/<name> from an up-to-date main and a worktree at ../epic-<name>/ next to the project root. Commits inside an epic use the format Issue #N: description, and the conventions forbid --force in any Git operation.
  • Parallel stream analysis Before an issue is started, CCPM writes <N>-analysis.md, which splits the work into streams such as database, service, API, UI and tests. Each stream lists its scope, files, start condition, hours and dependencies, plus shared files, conflict risk and a parallelization factor from 1 to 5.
  • Parallel agent launch Starting an issue launches one agent per stream that can begin immediately, each limited to its own files and told to commit often and record progress in updates/<N>/stream-X.md. The issue is assigned to the current GitHub user and labelled in-progress; streams with unmet dependencies are queued and launched later. Conflicts are never resolved automatically: an agent reports them and pauses. The execute reference phrases the launch as a Task call to a general-purpose subagent.
  • Whole-epic execution Starting a full epic sorts every task into ready, blocked, in progress or complete, analyses ready tasks that have no analysis yet and launches agents for them. Tasks marked parallel: false or listed in each other's conflicts_with are not run together, and an execution-status.md file lists active and queued work. Uncommitted changes block the start.
  • Progress comments on issues Issue sync posts a comment with completed work, work in progress, technical notes, acceptance criteria status, next steps and blockers, built from the local progress files. A last_sync field and a sync marker prevent duplicate comments, and the agent asks for confirmation when the last sync is less than five minutes old.
  • Closing issues and merging epics Closing a task updates its file, comments on and closes the GitHub issue, ticks the task in the epic issue body and recalculates epic progress. Merging an epic runs the project's detected test command (for example npm test, pytest, cargo test or go test), merges the epic branch into main with --no-ff, pushes, removes the worktree and branch, moves the epic to .claude/epics/archived/ and closes the epic issue.
  • Bug reports linked to their issue Added in March 2026: when testing reveals a bug in an issue, CCPM creates a bug task file with a bug_for field and a GitHub issue labelled bug whose body starts with a follow-up reference to the original issue, so GitHub links the two.
  • Script-first tracking The skill maps 14 operations to Bash scripts: status, standup, epic list, epic details, epic status, PRD list, PRD status, search, in progress, next, blocked, validate, and the create and cleanup modes of neon-branch.sh. The README describes these as running without model token cost. next.sh and standup.sh hold back tasks whose dependencies are still open or that conflict with work in progress.
  • State validation validate.sh checks frontmatter consistency on PRDs, epics and tasks, orphaned files, missing GitHub links, dependency integrity and conflicts_with references, and exits with status 1 when it finds errors.
  • Project initialization init.sh checks for the GitHub CLI and installs it with Homebrew or apt-get when missing, runs gh auth login if needed, installs the yahsan2/gh-sub-issue extension, creates .claude/prds, epics, rules, agents and scripts/pm, creates epic and task labels and writes a starter CLAUDE.md if none exists. Its closing hints and help.sh still print the v1 /pm:* command names. Before any GitHub write, the skill stops if origin still points to automazeio/ccpm.
  • Optional database branches with Neon neon-branch.sh creates a Neon branch epic/<name> for an epic and, with --issue, a child branch per writing issue, writes DATABASE_URL and DATABASE_URL_UNPOOLED into the worktree's env file, adds env patterns to .gitignore and deletes the branches on merge. It needs the Neon CLI, Node.js 20.19 or newer and NEON_PROJECT_ID, and exits without changes when they are missing. The guide also describes the same setup with one Postgres database, schema or container per writer.
  • Installation per harness The README install is a git clone of the repository. For Claude Code, skill/ccpm is symlinked or copied to .claude/skills/ccpm in the project; for Factory it is symlinked to ~/.factory/skills/ccpm; other Agent Skills harnesses are pointed at skill/ccpm/. Prerequisites are git, an authenticated gh CLI and a GitHub repository for the project. The scripts are Bash, and the changelog records that Windows needs a POSIX shell.
  • Archived v1 slash commands The v1 branch contains 38 command files in the /pm:* namespace, among them prd-new, prd-parse, epic-decompose, epic-sync, epic-oneshot, issue-analyze, issue-start, issue-sync, next, standup, sync and import, plus /context:* and /testing:* commands, four agents and 11 rule files. Its README installs it with curl -sSL https://automaze.io/ccpm/install | bash; the installer script clones the repository into the current folder and deletes its .git directory.
  • Project-reported results The README states that teams using CCPM report 89% less time lost to context switching, 5 to 8 parallel tasks instead of 1, 75% fewer bugs and up to 3 times faster delivery. Its eval table shows CCPM-equipped agents passing 100% of PRD creation, issue execution and standup checks against 27.7% without the skill. The underlying eval runs are not published.

Where CCPM fits

Planning a feature before code is written

A request such as "I want to build a notification system" starts the plan phase. The agent asks clarifying questions, writes the PRD to .claude/prds/ and offers to parse it into a technical epic. PRD and epic are ordinary Markdown files in the repository, so they can be edited, reviewed and committed like code. Planning, epic writing and decomposition work locally without GitHub; the README's local versus remote table lists GitHub only for task breakdown and progress updates on sync and for final deliverables.

Turning an epic into a shared GitHub backlog

After decomposition, "sync the notification-system epic to GitHub" creates the epic issue, one sub-issue per task with labels, renames the task files to issue numbers and sets up the epic worktree. The README presents GitHub Issues as the single source of truth for a team: agents and people can pick up the same issues, progress appears as issue comments, and existing labels, milestones and pull request workflows stay in use. A GitHub Projects board is not required.

Running several agents on one issue

"Start working on issue 42" first analyses the issue into streams, for example database migrations, service logic, API endpoints, UI and tests, then launches one agent per stream in the epic worktree. Each agent is restricted to its files, commits with the issue number and writes progress to its own stream file, while the main conversation coordinates. The README illustrates this with five agents splitting a user authentication issue and a table comparing serial and parallel wall time.

Standups and status from project files

Questions such as "standup", "what's next" or "what's blocked" are answered by running the Bash scripts against .claude/epics/ rather than by the model. The standup lists work completed, work in progress and blockers; next.sh shows open tasks whose dependencies are closed and that do not conflict with active work; validate.sh reports inconsistent frontmatter, orphaned files and broken dependency references.

Closing tasks, handling bugs and merging an epic

"Close issue N" updates the local file and the GitHub issue and recalculates epic progress. A bug found while testing an issue becomes its own linked bug task and issue. "Merge the X epic" refuses to run with uncommitted changes in the worktree, warns about open tasks, runs the project's tests, merges the epic branch into main, cleans up the worktree and branch, archives the epic folder and closes the epic issue.

Separate databases for parallel agents

Worktrees separate files but not data: agents in one worktree share its .env and therefore one database. The database guide maps one database to each epic and one more to each task that writes while another writer is active, and makes schema changes a sequential task that others depend on. With Neon configured, epic sync and merge create and delete the branches automatically; without Neon the guide describes equivalent setups with separate Postgres databases, schemas or containers.

Install

git clone https://github.com/automazeio/ccpm.git, then in the project root: ln -s /path/to/ccpm/skill/ccpm .claude/skills/ccpm

Reviews of CCPM

No reviews yet

Be the first to share your experience with CCPM.

Loading review form…

Found CCPM useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.

Related guides

All guides

Similar to CCPM

Compare:CCPM vs SuperpowersCCPM vs Claude ForgeCCPM vs Elephant-Goldfish Model

  1. SuperpowersComposable skills that guide coding agents through design, planning, testing, and code review.AI Skills & Plugins4 views
  2. Claude ForgeClaude Code bundle of agents, slash commands, skills, hooks and rules with an adversarial review loopAI Skills & Plugins0 views
  3. Elephant-Goldfish ModelPlugin for coding agents that drafts design specs with full context and reviews them with fresh-context subagentsDevelopment & Code Skills1 views
  4. agent-browserBrowser automation skills and a native CLI for AI agents.AI Skills & Plugins19 views
  5. CBClaude BlogClaude Blog researches, drafts and reviews blog posts inside Claude Code.AI Skills & Plugins4 views
  6. AI Job SearchA Claude Code workflow for evaluating jobs, tailoring CVs and preparing interviewsAI Skills & Plugins26 views
  7. Ffacebook-skillsAI agent skills for drafting, reviewing and planning Facebook Page content with approval before publishing.AI Skills & Plugins5 views
  8. PonytailRuleset and plugin that makes AI coding agents reuse code and write the smallest complete changeAI Skills & Plugins3 views