by automazeio
Project management skill system for Agents that uses GitHub Issues and Git worktrees for parallel agent execution.
# Add to your Claude Code skills
git clone https://github.com/automazeio/ccpmStop losing context. Stop blocking on tasks. Stop shipping bugs. CCPM gives your AI agent a structured PM brain: turn ideas into PRDs, PRDs into epics, epics into GitHub issues, and issues into production code — with full traceability at every step.
[!IMPORTANT] 📢 CCPM is now an AGENT SKILL! It works with any Agent Skills–compatible harness that supports skills: Claude Code, Codex, OpenCode, Factory, Amp, Cursor, and more.

No comments yet. Be the first to share your thoughts!
[!NOTE] Check out proof to get your agents capture visual proof of work of terminal output, browser interactions, and mobile simulator recordings.
Every team struggles with the same problems:
CCPM solves all of that.
graph LR
A[PRD Creation] --> B[Epic Planning]
B --> C[Task Decomposition]
C --> D[GitHub Sync]
D --> E[Parallel Execution]
"I want to build a notification system — where do we start?"
→ Guided brainstorming + PRD creation
"break down the notification-system epic"
→ Parallelizable task files with dependencies
"sync the notification-system epic to GitHub"
→ Epic issue + sub-issues + worktree
"start working on issue 42"
→ Parallel stream analysis + multiple agents launched
"what's our standup for today?"
→ Instant report from project files
| Traditional AI Development | CCPM | |---|---| | Context lost between sessions | Persistent context across all work | | One agent, one task | Parallel agents on independent streams | | Vibe coding from memory | Spec-driven with full traceability | | Progress hidden in chat logs | Transparent audit trail in GitHub | | Scattered status updates | Structured standup, blocked, next |
Most AI coding workflows operate in isolation — a single session with no shared state. CCPM uses GitHub Issues as the source of truth, which unlocks something fundamentally different:
Team collaboration — multiple agents (or humans) work on the same project simultaneously. Progress is visible in real-time through issue comments.
Seamless handoffs — an agent can start a task, a human can finish it, or vice versa. No "what did the AI do?" meetings.
Single source of truth — no separate databases or project management tools. Issue state is project state. Comments are the audit trail.
Works with what you have — no dependency on GitHub Projects. Integrates with existing labels, milestones, and PR workflows.
Every line of code must trace back to a specification.
CCPM enforces a strict 5-phase discipline:
No shortcuts. No assumptions. No regrets.
Traditional thinking: one issue = one agent = one task
Reality: a single "Implement user authentication" issue is actually:
All running simultaneously in the same worktree.
| Approach | Agents working | Wall time | |---|---|---| | Traditional (serial) | 1 | 5x | | CCPM (parallel streams) | 5 | 1x |
Each agent handles its own context in isolation. Your main conversation becomes the conductor — it never drowns in implementation details. Agents read from .claude/epics/ and commit progress back through Git.
🧠 Context preservation — project state lives in files, not in your head or chat history. Start a session anywhere, any time.
⚡ Parallel execution — tasks marked parallel: true run concurrently across multiple agents without conflicts.
🔗 GitHub native — works with tools your team already uses. No dependency on the Projects API.
📊 Full traceability — every decision documented. PRD → Epic → Task → Issue → Code → Commit.
🤖 Deterministic ops run as scripts — status, standup, search, validate all run as bash scripts: fast, consistent, no LLM token cost.
🌐 Harness-agnostic — follows the agentskills.io open standard. Works with Factory, Claude Code, Amp, OpenCode, Codex, Cursor, and more.
CCPM is a standard Agent Skill. Point your harness at skill/ccpm/ — that's it.
git clone https://github.com/automazeio/ccpm.git
# Symlink into your skills directory
ln -s /path/to/ccpm/skill/ccpm ~/.factory/skills/ccpm
In your project root, add a skills/ directory and symlink or copy the skill:
ln -s /path/to/ccpm/skill/ccpm .claude/skills/ccpm
Point it at skill/ccpm/. It follows the agentskills.io standard and works out of the box.
git and gh CLI (authenticated: gh auth login)CCPM activates automatically when your agent detects PM intent. Just talk naturally — no special syntax needed.
| What you say | What happens | |---|---| | "I want to build X" / "let's plan X" | Brainstorming + PRD creation | | "parse the X PRD" / "create an epic for X" | PRD → technical epic | | "break down the X epic" | Epic decomposition into tasks | | "sync the X epic to GitHub" | Issues created, worktree set up | | "start working on issue N" | Analysis + parallel agents launched | | "standup" / "what's our status" | Bash script runs instantly | | "what's next" / "what's blocked" | Priority queue from project files | | "close issue N" | Local + GitHub updated | | "merge the X epic" | Tests, merge, cleanup |
"I want to build a notification system — push, email, and in-app"
CCPM conducts guided brainstorming before writing anything. It asks about the problem, users, success criteria, constraints, and what's out of scope — then creates a structured PRD at .claude/prds/<name>.md.
When ready: "parse the notification-system PRD" → produces a technical epic at .claude/epics/notification-system/epic.md with architecture decisions, technical approach, and task preview.
"break down the notification-system epic into tasks"
Each task gets a file with acceptance criteria, effort estimate, depends_on, parallel, and conflicts_with metadata. Tasks are intelligently batched for parallel creation. ≤10 tasks per epic by default.
"sync the notification-system epic to GitHub"
Creates an epic issue, creates sub-issues for each task, renames local files to match GitHub issue numbers, sets up a dedicated worktree (../epic-notification-system/), and creates a mapping file for reference.
"start working on issue 42"
Analyzes the issue for independent work streams, launches parallel agents scoped to their own files, and sets up progress tracking. Each agent commits with Issue #N: description and coordinates through Git.
"standup" / "what's blocked" / "what's next"
All tracking operations run as bash scripts — instant output, no LLM overhead. The scripts scan .claude/epics/ and report what's in progress, what's next, and what's blocked.
skill/ccpm/
├── SKILL.md # Entry point — detects intent, routes to reference
└── references/
├── plan.md # PRD wr