开源项目 GitHub Topic ai-coding 2026-07-06T12:02 正文 ok 1725 words

CCPM – 项目经理智能体

英文标题：📦 automazeio/ccpm

CCPM 是一套面向 AI 智能体的项目管理技能系统，通过 GitHub Issues 和 Git 工作树实现多个智能体的并行执行。它将需求编写为 PRD，分解为史诗和任务，同步到 GitHub，并支持以脚本化方式跟踪进度。评测显示 CCPM 使任务并行数从 1 提升至 5–8，bug 率降低 75%，整体评估得分 100%。该系统作为 Agent Skills 标准技能，可集成到 Claude Code、Codex、Cursor 等多种编码助手，为开发者提供可追溯、可协作的规范驱动开发流程。

打开原文相关 2.1 · 机会 6

1.3 KB

1.2 KB

1.3 KB

2.7 KB

213.6 KB

62.8 KB

65.2 KB

中文

CCPM – 项目经理智能体

Eval Score

面向 AI 智能体的规范驱动开发 —— 更快地交付，更重要的是更稳健地交付，使用 PRD、GitHub Issues 和并行运行的多个智能体。

不再丢失上下文，不再因任务阻塞而等待，不再交付 bug。CCPM 为你的 AI 智能体赋予结构化的项目管理大脑：将想法转为 PRD，PRD 转为史诗，史诗转为 GitHub Issues，Issue 转为生产代码 —— 每一步都可完整追溯。

重要

📢 CCPM 现已成为一个智能体技能！ 它适用于任何支持技能的 Agent Skills–兼容运行器，包括：Claude Code、Codex、OpenCode、Factory、Amp、Cursor 等。

提示

可查看 proof，让你的智能体捕获终端输出、浏览器交互和移动模拟器录制的工作凭证。

每个团队都会遇到同样的问题：

上下文在会话之间消散，迫使反复重新发现
并行工作会产生冲突，当多个智能体接触同一代码时
需求漂移，口头决策覆盖书面规范
进度在最后阶段之前不可见

CCPM 解决了所有这些问题。

graph LR
    A[PRD 创建] --> B[史诗规划]
    B --> C[任务分解]
    C --> D[GitHub 同步]
    D --> E[并行执行]

加载中

"我想构建一个通知系统——我们从哪开始？"
→ 引导式头脑风暴 + PRD 创建

"分解通知系统史诗"
→ 带依赖关系的可并行任务文件

"将通知系统史诗同步到 GitHub"
→ 史诗 issue + 子 issue + 工作树

"开始处理 issue 42"
→ 并行流分析 + 启动多个智能体

"我们今天的站会状态是什么？"
→ 从项目文件即时生成报告

有什么不同

传统 AI 开发	CCPM
上下文在会话间丢失	持久上下文贯穿所有工作
一个智能体处理一个任务	并行智能体处理独立工作流
靠记忆的 vibe coding	规范驱动且完全可追溯
进度隐藏在聊天日志中	透明的审计线索存在于 GitHub
零散的状态更新	结构化的站会、阻塞项、下一步

大多数 AI 编码工作流是孤立的——单个会话没有共享状态。CCPM 将 GitHub Issues 作为事实来源，这解锁了根本性的不同：

团队协作 —— 多个智能体（或人）同时在同一项目中工作。进度通过 issue 评论实时可见。

无缝交接 —— 智能体可以开始一个任务，人类可以完成它，反之亦然。无需“AI 做了什么？”的会议。

单一事实来源 —— 不需要单独的数据库或项目管理工具。Issue 状态即是项目状态。评论就是审计线索。

与现有工具协作 —— 不依赖 GitHub Projects。与已有的标签、里程碑和 PR 工作流集成。

核心原则：杜绝无规范编码

每一行代码都必须能追溯到一个规范。

CCPM 强制执行严格的五阶段纪律：

🧠 头脑风暴 —— 比舒适区想得更深
📝 文档化 —— 编写不留解释余地的规范
📐 规划 —— 带有明确技术决策的架构设计
⚡ 执行 —— 严格按规范构建
📊 追踪 —— 每一步都保持透明进度

没有捷径，没有假设，没有后悔。

并行执行系统

传统思维：一个 issue = 一个智能体 = 一个任务

现实：一个“实现用户认证”的 issue 实际上包含：

智能体 1：数据库表和迁移
智能体 2：服务层和业务逻辑
智能体 3：API 端点和中间件
智能体 4：UI 组件和表单
智能体 5：测试套件和文档

所有智能体在 同一工作树中同时运行。

方式	工作智能体数	耗时
传统（串行）	1	5 倍
CCPM（并行流）	5	1 倍

每个智能体在隔离的上下文中处理自己的部分。你的主对话成为指挥者——它永远不会淹没在实现细节中。智能体从 .claude/epics/ 读取文件，并通过 Git 提交进度。

🧠 上下文保留 —— 项目状态存在于文件中，而非你的大脑或聊天历史里。随时随地在任意会话中开始工作。

⚡ 并行执行 —— 标记为 parallel: true 的任务会跨多个智能体并发运行，无冲突。

🔗 GitHub 原生 —— 使用团队已有的工具，不依赖 Projects API。

📊 完整可追溯性 —— 每个决定都被记录。PRD → 史诗 → 任务 → Issue → 代码 → 提交。

🤖 确定性操作以脚本形式运行 —— 状态、站会、搜索、验证均作为 bash 脚本运行：快速、一致、无 LLM token 成本。

🌐 运行器无关 —— 遵循 agentskills.io 开放标准。适用于 Factory、Claude Code、Amp、OpenCode、Codex、Cursor 等。

CCPM 是一个标准的 Agent Skill。将你的运行器指向 skill/ccpm/ —— 就这么简单。

git clone https://github.com/automazeio/ccpm.git


# 符号链接到你的 skills 目录
ln -s /path/to/ccpm/skill/ccpm ~/.factory/skills/ccpm

在你的项目根目录中，添加一个 skills/ 目录并符号链接或复制技能：

ln -s /path/to/ccpm/skill/ccpm .claude/skills/ccpm

任何其他 Agent Skills–兼容的运行器

将其指向 skill/ccpm/。它遵循 agentskills.io 标准，开箱即用。

git 和 gh CLI（已认证：gh auth login）
一个用于项目的 GitHub 仓库

CCPM 在智能体检测到项目管理意图时自动激活。用自然语言交流——不需要特殊语法。

自然语言触发

你说什么	会发生什么
“我想构建 X” / “我们来规划 X”	头脑风暴 + PRD 创建
“解析 X PRD” / “为 X 创建史诗”	PRD → 技术史诗
“分解 X 史诗”	史诗分解为任务
“将 X 史诗同步到 GitHub”	Issues 创建，工作树设置
“开始处理 issue N”	分析 + 启动并行智能体
“站会” / “我们状态如何”	Bash 脚本即时运行
“下一步是什么” / “什么被阻塞了”	从项目文件生成优先级队列
“关闭 issue N”	本地 + GitHub 更新
“合并 X 史诗”	测试、合并、清理

1. 规划 —— 捕获需求

"我想构建一个通知系统——推送、邮件和应用内"

CCPM 在编写任何内容之前进行引导式头脑风暴。它会询问问题领域、用户、成功标准、约束以及范围之外的内容——然后在 .claude/prds/<name>.md 创建结构化的 PRD。

准备好后：“解析通知系统 PRD” → 在 .claude/epics/notification-system/epic.md 生成技术史诗，包含架构决策、技术方法和任务预览。

2. 结构化 —— 分解任务

"将通知系统史诗分解为任务"

每个任务得到一个带有验收标准、工作估算、depends_on、parallel 和 conflicts_with 元数据的文件。任务会被智能地批处理以并行创建。默认每个史诗 ≤10 个任务。

"将通知系统史诗同步到 GitHub"

创建史诗 issue，为每个任务创建子 issue，将本地文件重命名以匹配 GitHub issue 编号，设置专用的工作树（../epic-notification-system/），并创建一个映射文件供参考。

4. 执行 —— 开始构建

"开始处理 issue 42"

分析 issue 中的独立工作流，启动限定在自己文件中的并行智能体，并设置进度跟踪。每个智能体使用 Issue #N: 描述 提交，并通过 Git 协调。

5. 追踪 —— 了解当前状态

"站会" / "什么被阻塞了" / "下一步是什么"

所有追踪操作都以 bash 脚本运行——即时输出，无 LLM 开销。脚本扫描 .claude/epics/ 并报告进行中、下一步以及阻塞的内容。

skill/ccpm/
├── SKILL.md                  # 入口点——检测意图，路由到参考文档
└── references/
    ├── plan.md               # PRD 编写 + 解析为史诗
    ├── structure.md          # 史诗分解为任务
    ├── sync.md               # GitHub 同步、进度评论、关闭、合并
    ├── execute.md            # Issue 分析 + 并行智能体启动
    ├── track.md              # 状态、站会、搜索、下一步、阻塞
    ├── conventions.md        # 文件格式、frontmatter 模式、git 规则
    └── scripts/              # 确定性操作的 bash 脚本
        ├── status.sh
        ├── standup.sh
        ├── epic-list.sh
        ├── search.sh
        └── ...               # 共 14 个脚本

你的项目文件位于项目根目录下的 .claude/ 中：

.claude/
├── prds/                     # 产品需求文档
├── epics/
│   └── <feature>/
│       ├── epic.md           # 技术史诗
│       ├── <N>.md            # 任务文件（同步后按 GitHub issue 编号命名）
│       ├── <N>-analysis.md   # 并行工作流分析
│       └── updates/          # 智能体进度跟踪
└── (archived epics)

文件是真实来源——存于仓库中的纯 markdown，无需外部服务。

你：“我想构建一个 Stripe 支付集成——订阅和一次性付款”

CCPM：就范围、用户、成功标准等提出 5 个澄清问题……

你：[回答]

CCPM：✅ PRD 已创建：.claude/prds/payment-integration.md
       准备创建技术史诗吗？

你：“是的，解析它”

CCPM：✅ 史诗已创建：.claude/epics/payment-integration/epic.md
       已识别 8 个任务类别。准备分解吗？

你：“分解它”

CCPM：✅ 已创建 7 个任务——5 个并行，2 个串行
       准备推送到 GitHub？

你：“同步它”

CCPM：✅ 史诗 #1234 已创建
       ✅ 7 个子 issue 已创建（#1235–#1241）
       ✅ 工作树：../epic-payment-integration/

你：“开始处理 issue 1235”

CCPM：分析出 3 个并行流：
       流 A：Stripe 客户端设置 ✓ 已开始
       流 B：Webhook 处理器 ✓ 已开始
       流 C：数据库模型 ⏸ 等待 A

你：“我们的站会状态如何？”

CCPM：[即时运行 standup.sh]
       📅 每日站会 —— 2026-03-18
       🔄 进行中：Issue #1235（payment-integration）—— 60%
       ⏭️ 下一步：Issue #1236 —— 订阅计费逻辑
       📊 任务：2 个进行中，5 个未开启，0 个已关闭

采用该系统的团队报告：

减少 89% 上下文切换耗时
5–8 个并行任务，而之前只有 1 个
Bug 率降低 75% —— 得益于编码前细致的任务分解
功能交付速度提升至 3 倍

在对照评测中，比较搭载 CCPM 的智能体与基线（无技能）：

场景	搭载 CCPM	未搭载
PRD 创建（头脑风暴优先，路径正确）	✅ 4/4	❌ 2/4
Issue 执行（分析 + 工作树检查）	✅ 4/4	❌ 0/4
站会（运行脚本，真实数据）	✅ 3/3	❌ 1/3
总体	100%	27.7%

操作	本地	GitHub
PRD 创建	✅	—
实现规划	✅	—
任务分解	✅	✅（同步时）
执行	✅	—
进度更新	✅	✅（同步时）
最终交付物	—	✅

GitHub 集成 —— 使用 gh-sub-issue 扩展建立正确的父子关系。若未安装则回退到任务列表。安装方式：gh extension install yahsan2/gh-sub-issue

文件命名 —— 任务在分解时始于 001.md、002.md。GitHub 同步后，重命名为 {issue-id}.md（如 1234.md）。Issue #1234 = 文件 1234.md。

设计决策 —— 有意避开了 GitHub Projects API 的复杂性。

English / 原文

CCPM – The Project Manager Agent

Eval Score

Spec-driven development for AI agents – ship faster better using PRDs, GitHub issues, and multiple agents running in parallel.

Stop 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.

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:

Context evaporates between sessions, forcing constant re-discovery
Parallel work creates conflicts when multiple agents touch the same code
Requirements drift as verbal decisions override written specs
Progress becomes invisible until the very end

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

What Makes This Different

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.

Core Principle: No Vibe Coding

Every line of code must trace back to a specification.

CCPM enforces a strict 5-phase discipline:

🧠 Brainstorm — think deeper than comfortable
📝 Document — write specs that leave nothing to interpretation
📐 Plan — architect with explicit technical decisions
⚡ Execute — build exactly what was specified
📊 Track — maintain transparent progress at every step

No shortcuts. No assumptions. No regrets.

The Parallel Execution System

Traditional thinking: one issue = one agent = one task

Reality: a single "Implement user authentication" issue is actually:

Agent 1 : Database tables and migrations
Agent 2 : Service layer and business logic
Agent 3 : API endpoints and middleware
Agent 4 : UI components and forms
Agent 5 : Test suites and documentation

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

Any other Agent Skills–compatible harness

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)
A GitHub repository for your project

CCPM activates automatically when your agent detects PM intent. Just talk naturally — no special syntax needed.

Natural language triggers

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

1. Plan — Capture requirements

"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.

2. Structure — Break it down

"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.

4. Execute — Start building

"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.

5. Track — Know where things stand

"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 writing + parsing to epic
    ├── structure.md          # Epic decomposition into tasks
    ├── sync.md               # GitHub sync, progress comments, close, merge
    ├── execute.md            # Issue analysis + parallel agent launch
    ├── track.md              # Status, standup, search, next, blocked
    ├── conventions.md        # File formats, frontmatter schemas, git rules
    └── scripts/              # Bash scripts for deterministic operations
        ├── status.sh
        ├── standup.sh
        ├── epic-list.sh
        ├── search.sh
        └── ...               # 14 scripts total

Your project files live in .claude/ in your project root:

.claude/
├── prds/                     # Product requirement documents
├── epics/
│   └── <feature>/
│       ├── epic.md           # Technical epic
│       ├── <N>.md            # Task files (named by GitHub issue number after sync)
│       ├── <N>-analysis.md   # Parallel work stream analysis
│       └── updates/          # Agent progress tracking
└── (archived epics)

Files are the source of truth — plain markdown that lives in your repo, no external services.

You: "I want to build a payment integration with Stripe — subscriptions and one-time charges"

CCPM: Asks 5 clarifying questions about scope, users, success criteria...

You: [answers]

CCPM: ✅ PRD created: .claude/prds/payment-integration.md
      Ready to create the technical epic?

You: "yes, parse it"

CCPM: ✅ Epic created: .claude/epics/payment-integration/epic.md
      8 task categories identified. Ready to decompose?

You: "break it down"

CCPM: ✅ Created 7 tasks — 5 parallel, 2 sequential
      Ready to push to GitHub?

You: "sync it"

CCPM: ✅ Epic #1234 created
      ✅ 7 sub-issues created (#1235–#1241)
      ✅ Worktree: ../epic-payment-integration/

You: "start working on issue 1235"

CCPM: Analyzed 3 parallel streams:
      Stream A: Stripe client setup ✓ Started
      Stream B: Webhook handler ✓ Started
      Stream C: Database models ⏸ Waiting on A

You: "what's our standup?"

CCPM: [runs standup.sh instantly]
      📅 Daily Standup — 2026-03-18
      🔄 In Progress: Issue #1235 (payment-integration) — 60%
      ⏭️ Next: Issue #1236 — Subscription billing logic
      📊 Tasks: 2 in progress, 5 open, 0 closed

Teams using this system report:

89% less time lost to context switching
5–8 parallel tasks vs 1 previously
75% reduction in bug rates — due to detailed task breakdown before coding
Up to 3× faster feature delivery

In structured evals comparing CCPM-equipped agents vs baseline (no skill):

Scenario	With CCPM	Without
PRD creation (brainstorm-first, correct paths)	✅ 4/4	❌ 2/4
Issue execution (analysis + worktree checks)	✅ 4/4	❌ 0/4
Standup (runs script, real data)	✅ 3/3	❌ 1/3
Overall	100%	27.7%

Operation	Local	GitHub
PRD creation	✅	—
Implementation planning	✅	—
Task breakdown	✅	✅ (on sync)
Execution	✅	—
Progress updates	✅	✅ (on sync)
Final deliverables	—	✅

GitHub integration — uses gh-sub-issue extension for proper parent-child relationships. Falls back to task lists if not installed. Install with: gh extension install yahsan2/gh-sub-issue

File naming — tasks start as 001.md, 002.md during decomposition. After GitHub sync, renamed to {issue-id}.md (e.g. 1234.md). Issue #1234 = file 1234.md.

Design decisions — intentionally avoids GitHub Projects API complexity. All operations work on local files first for speed. GitHub sync is explicit and controlled. Worktrees provide clean git isolation for parallel work.

Looking for v1? — The original /pm:* Claude Code slash command system is preserved on the v1 branch.

Who's behind this project

CCPM was developed at Automaze for developers who ship, by developers who ship.

If CCPM helps your team ship better software:

Tip

Ship faster with Automaze. We partner with founders to bring their vision to life, scale their business, and optimize for success. Visit Automaze to book a call ›

CCPM – 项目经理智能体

中文

CCPM – 项目经理智能体

面向 AI 智能体的规范驱动开发 —— 更快地交付，更重要的是更 稳健 地交付，使用 PRD、GitHub Issues 和并行运行的多个智能体。

有什么不同

核心原则：杜绝无规范编码

并行执行系统

任何其他 Agent Skills–兼容的运行器

自然语言触发

1. 规划 —— 捕获需求

2. 结构化 —— 分解任务

4. 执行 —— 开始构建

5. 追踪 —— 了解当前状态

English / 原文

CCPM – The Project Manager Agent

Spec-driven development for AI agents – ship faster better using PRDs, GitHub issues, and multiple agents running in parallel.

What Makes This Different

Core Principle: No Vibe Coding

The Parallel Execution System

Any other Agent Skills–compatible harness

Natural language triggers

1. Plan — Capture requirements

2. Structure — Break it down

4. Execute — Start building

5. Track — Know where things stand

Who's behind this project

面向 AI 智能体的规范驱动开发 —— 更快地交付，更重要的是更稳健地交付，使用 PRD、GitHub Issues 和并行运行的多个智能体。