ln-200-scope-decomposer：自动化项目范围分解与用户故事编排工具

ln-200-scope-decomposer by levnikolaevich/claude-code-skills

153 周安装量

245 GitHub Stars

安装命令

npx skills add https://github.com/levnikolaevich/claude-code-skills --skill ln-200-scope-decomposer

🇨🇳中文介绍

路径说明： 文件路径（shared/、references/、../ln-*）是相对于技能仓库根目录的。如果在当前工作目录未找到，请定位此 SKILL.md 文件所在目录并向上返回一级以找到仓库根目录。如果缺少 shared/ 目录，请通过 WebFetch 从 https://raw.githubusercontent.com/levnikolaevich/claude-code-skills/master/skills/{path} 获取文件。

范围分解器（顶层编排器）

从范围到用户故事，通过史诗和故事协调器进行完整计划分解的顶层编排器。

目的

此技能的作用

协调新计划的完整分解流水线：

从 kanban_board.md 自动发现团队 ID
阶段 1： 发现（团队 ID）
阶段 2： 史诗分解（委托给 ln-210-epic-coordinator）
阶段 3： 故事分解循环（按史诗顺序委托给 ln-220-story-coordinator）
阶段 4： RICE 优先级排序循环（可选，按史诗顺序委托给 ln-230-story-prioritizer）

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

何时使用此技能

此技能应在以下情况使用：

启动需要完整分解的新计划（范围 → 史诗 → 故事）
在单一工作流中自动化史诗 + 故事创建
相对于手动逐步调用，更倾向于使用完整流水线
新项目的高效时间方法（端到端 2-3 小时）

替代方案： 如需精细控制，请手动调用协调器：

ln-210-epic-coordinator - 创建/重新规划史诗
ln-220-story-coordinator - 创建/重新规划故事（每个史诗一次）
ln-230-story-prioritizer - RICE 优先级排序（每个史诗一次）

在以下情况下请不要使用：

计划已有史诗 → 改用 ln-210-epic-coordinator 的重新规划模式
需要重新规划现有故事 → 为每个史诗使用 ln-220-story-coordinator 的重新规划模式
仅需创建史诗 → 直接使用 ln-210-epic-coordinator
仅需为特定史诗创建故事 → 直接使用 ln-220-story-coordinator

ln-200-scope-decomposer 是纯粹的协调器 - 它不直接执行工作：

✅ 发现上下文（团队 ID）
✅ 做出路由决策（调用哪个协调器）
✅ 通过技能工具委托所有工作（ln-210、ln-220、ln-230）
✅ 管理工作流状态（史诗创建 → 故事循环）
❌ 不研究项目文档（ln-210 负责此项）
❌ 不生成史诗/故事文档（ln-210/ln-220 负责此项）
❌ 不创建 Linear 问题（协调器负责此项）
❌ 不提示用户（协调器处理所有用户交互）

ln-210-epic-coordinator： 创建 3-7 个史诗（如果适用，史诗 0 用于基础设施，史诗 1-N 用于业务领域）
ln-220-story-coordinator： 为每个史诗创建 5-10 个故事（包含内联标准研究）

关键约束： 史诗 N 的故事必须在史诗 N+1 开始前完成（ln-220 包含用户交互 — 跨史诗的交互式对话无法并行化）。

为何顺序执行？

ln-220-story-coordinator 包含用户交互（故事预览确认）
交互式对话无法并行化（用户必须审查每个史诗的故事）
确保史诗 N 的故事在开始史诗 N+1 前已获批准并创建

示例： 6 个史诗 → ln-220 被顺序调用 6 次（史诗 0 → 史诗 1 → 史诗 2 → ... → 史诗 5）

基础设施史诗 = 史诗 0

保留编号： 史诗 0 保留给基础设施史诗（如果由 ln-210 提议）。

如果存在基础设施史诗 → 史诗 0（基础设施），史诗 1-N（业务领域）
否则 → 史诗 1-N（仅业务领域）

决策： ln-210-epic-coordinator 阶段 1 步骤 3 自动确定是否需要基础设施史诗（新项目、多技术栈、安全/监控要求）。

团队 ID： 从 docs/tasks/kanban_board.md 的 Linear 配置表中自动发现（参见 CLAUDE.md 的“配置自动发现”部分）。

后备方案： 如果缺少 kanban_board.md → ln-210-epic-coordinator 将直接询问用户

阶段 1：发现（自动化）

从 docs/tasks/kanban_board.md 自动发现团队 ID。

团队 ID 存在于 kanban_board.md 中
如果缺失 → 跳过（ln-210 将向用户请求）

编排器层面无用户确认 - 协调器处理所有用户交互。

输出： 团队 ID（如果未找到则为 None）

阶段 2：史诗分解（委托）

目标： 为计划创建所有史诗。

委托给 ln-210-epic-coordinator：

🔄 [ORCHESTRATOR] 阶段 2：将史诗创建委托给 ln-210-epic-coordinator

Skill(skill: "ln-210-epic-coordinator")

ln-210-epic-coordinator 将：

阶段 1：研究项目文档（requirements.md、architecture.md、tech_stack.md）
阶段 2：自动提议领域 + 基础设施史诗（史诗 0） → 用户确认领域列表
阶段 3：构建理想史诗计划（史诗 0-N）
阶段 5a：从文档自动提取 Q1-Q4 → 生成所有史诗文档 → 显示批量预览 → 用户确认 → 创建所有史诗
返回：史诗 URL + 摘要

完成后： 在 Linear 中创建史诗，更新 kanban_board.md。

输出： 创建 3-7 个史诗（如果适用，史诗 0 用于基础设施，史诗 1-N 用于业务领域）

阶段 3：故事分解循环（顺序，委托）

目标： 为每个史诗创建故事（顺序处理）。

顺序循环逻辑：

FOR EACH Epic (Epic 0, Epic 1, ..., Epic N):
    1. 为当前史诗调用 ln-220-story-coordinator
    2. 等待完成
    3. 验证故事已在 kanban_board.md 中创建
    4. 移至下一个史诗

停止条件（分解循环）

条件	操作
所有史诗已处理（故事 + 可选的 RICE）	停止 — 进入总结阶段
ln-220 对某个史诗失败（协调器错误）	停止 — 报告部分结果，列出已完成的史诗
用户在故事确认期间取消	停止 — 报告已完成的史诗，跳过剩余部分
故事总数超过 80	停止 — 警告：“范围可能过大。继续吗？”

每个史诗的调用：

🔄 [ORCHESTRATOR] 阶段 3：将史诗 N 的故事创建委托给 ln-220-story-coordinator

Skill(skill: "ln-220-story-coordinator", epic_number="Epic N")

ln-220-story-coordinator 将（每个史诗）：

阶段 1：从史诗自动提取 Q1-Q6 + 后备搜索（requirements.md、tech_stack.md）
阶段 2：内联研究标准 MCP 参考（自动）
阶段 3：构建理想故事计划（5-10 个故事）
阶段 4a：生成所有故事文档 → 显示预览 → 用户确认 → 创建所有故事
返回：故事 URL + 摘要

顺序约束说明：

ln-220 包含用户交互（故事预览确认）
无法并行化 - 用户必须按顺序审查每个史诗的故事
史诗 N 的故事获批准 → 史诗 N+1 的故事生成

每个史诗后： 在 Linear 中创建故事，更新 kanban_board.md。

输出： 总计 30-60 个故事（每个史诗 5-10 个 × 3-7 个史诗）

TodoWrite 格式（强制）： 在开始前将阶段和史诗迭代添加到待办事项：

- Phase 1: Discovery (in_progress)
- Phase 2: Delegate to ln-210-epic-coordinator (pending)
- Phase 3: Delegate to ln-220 for Epic 0 (pending)
- Phase 3: Delegate to ln-220 for Epic 1 (pending)
- Phase 3: Delegate to ln-220 for Epic 2 (pending)
... (每个史诗一个待办事项)
- Phase 4: Delegate to ln-230 for Epic 0 (pending)
- Phase 4: Delegate to ln-230 for Epic 1 (pending)
... (每个史诗一个待办事项，可选)
- Phase 5: Summary (pending)

开始时标记为进行中，协调器返回成功时标记为已完成。

阶段 4：RICE 优先级排序循环（可选，顺序，委托）

目标： 使用市场研究，通过 RICE 评分对每个史诗的故事进行优先级排序。

可选： 询问用户“为所有史诗运行 RICE 优先级排序吗？”如果用户拒绝，则跳至阶段 5。

顺序循环逻辑：

FOR EACH Epic (Epic 0, Epic 1, ..., Epic N):
    1. 为当前史诗调用 ln-230-story-prioritizer
    2. 等待完成
    3. 验证 prioritization.md 已在 docs/market/[epic-slug]/ 中创建
    4. 移至下一个史诗

每个史诗的调用：

Skill(skill: "ln-230-story-prioritizer", args: "epic=\"Epic N\"")

ln-230-story-prioritizer 将（每个史诗）：

从 Linear 加载故事元数据
研究每个故事的市场规模和竞争情况
计算 RICE 分数并分配优先级（P0-P3）
生成 docs/market/[epic-slug]/prioritization.md

跳过条件： 如果史诗仅包含技术/基础设施故事（没有业务价值需要排序），则跳过该史诗。

每个史诗后： 优先级排序表保存到 docs/market/[epic-slug]/prioritization.md。

输出： 所有适用史诗的优先级排序表。

阶段 5：总结和后续步骤

目标： 提供完整的分解概览。

🔄 [ORCHESTRATOR] 阶段 5：完整分解完成

计划分解摘要：
- 创建的史诗：N 个项目（史诗 0：基础设施[如果存在]，史诗 1-N：业务领域）
- 创建的故事：M 个问题（按史诗细分）
- 位置：docs/tasks/kanban_board.md

后续步骤：
1. 运行 ln-310-multi-agent-validator 以验证所有故事
2. 使用 ln-400-story-executor 处理每个故事（任务 → 执行 → 完成）
   或使用 ln-300-task-coordinator 为每个故事手动创建任务

输出： 包含完整分解结果的摘要消息

1. 编排器层面无用户提示

编排器不提示用户：

❌ 没有“继续分解吗？”确认（冗余 - 协调器已确认）
❌ 没有时间估算（误导 - 实际时间会变化）
❌ 没有史诗/故事预览（协调器处理此项）

所有用户交互委托给协调器：

ln-210 阶段 2：领域批准（用户控制点 1）
ln-210 阶段 5a：史诗批量预览（用户控制点 2）
ln-220 阶段 4a：每个史诗的故事预览（用户控制点 3，N 次）

在完成工作前，验证所有检查点：

✅ 团队 ID 已发现（阶段 1）：

团队 ID 已从 kanban_board.md 加载或已跳过（ln-210 将请求）

✅ 史诗分解完成（阶段 2）：

已委托给 ln-210-epic-coordinator
创建了 3-7 个史诗（如果适用，史诗 0 用于基础设施，史诗 1-N 用于业务领域）
返回了史诗 URL
史诗在 kanban_board.md 中可见

✅ 故事分解完成（阶段 3）：

已为每个史诗委托给 ln-220-story-coordinator（顺序）
每个史诗创建了 5-10 个故事
为每个史诗返回了故事 URL
所有故事在 kanban_board.md 中可见（待办事项部分）

✅ RICE 优先级排序完成（阶段 4，可选）：

已询问用户关于优先级排序（如果拒绝则跳过）
已为每个适用史诗委托给 ln-230-story-prioritizer
优先级排序表已保存到 docs/market/[epic-slug]/

✅ 已提供摘要（阶段 5）：

显示了总计数量（史诗、故事、按史诗细分）
显示了 kanban_board.md 位置
提供了后续步骤（验证、任务创建）

输出： 包含完整分解结果的摘要消息（史诗 + 每个史诗的故事）

与生态系统的集成

用户直接调用：“分解计划：[计划名称]”或“为[项目]创建史诗和故事”

调用（通过技能工具）

ln-210-epic-coordinator（阶段 2）- 创建模式（批量史诗创建，带批量预览）
ln-220-story-coordinator（阶段 3，顺序循环）- 每个史诗的创建模式（故事创建，带预览）
ln-230-story-prioritizer（阶段 4，可选顺序循环）- 每个史诗的 RICE 优先级排序

ln-200-scope-decomposer 完成后：

ln-310-multi-agent-validator - 在任务创建前验证所有已创建的故事
ln-400-story-executor - 处理每个故事（任务 → 执行 → 完成）
- 或 ln-300-task-coordinator - 为每个故事手动创建任务

信任协调器结果： 协调器返回摘要，编排器不重新验证。

错误处理： 如果协调器返回错误，向用户报告并停止流水线。

现实估算： 完整分解需要 2-3 小时（6 个史诗 × 平均 7 个故事 = 42 个故事）。

阶段 2（史诗创建）：30-45 分钟（批量预览减少时间）
阶段 3（故事创建）：1.5-2 小时（6 个史诗 × 每个史诗 15-20 分钟）
阶段 4（总结）：2 分钟

不要向用户提供时间估算 - 根据项目复杂性和用户响应时间而变化。

"Decompose initiative: E-commerce Platform"

阶段 1：发现
- 从 kanban_board.md 加载团队 ID
阶段 2：史诗分解
- 调用 ln-210-epic-coordinator
- ln-210 创建 6 个史诗：
  - 史诗 11（基础设施史诗 0 模式）
  - 史诗 12-16（业务领域）
- 输出：6 个史诗 URL
阶段 3：故事分解循环（顺序）
- 史诗 11： 调用 ln-220 → 6 个故事（US017-US022）
- 史诗 12： 调用 ln-220 → 7 个故事（US023-US029）
- 史诗 13： 调用 ln-220 → 5 个故事（US030-US034）
- 史诗 14： 调用 ln-220 → 6 个故事（US035-US040）
- 史诗 15： 调用 ln-220 → 7 个故事（US041-US047）
- 史诗 16： 调用 ln-220 → 5 个故事（US048-US052）
- 输出：总计 36 个故事
阶段 4：总结

🔄 [ORCHESTRATOR] 完整分解完成

计划：电子商务平台

- 创建的史诗：6 个项目（史诗 11：基础设施，史诗 12-16：业务领域）
- 创建的故事：36 个问题
  - 史诗 11：6 个故事
  - 史诗 12：7 个故事
  - 史诗 13：5 个故事
  - 史诗 14：6 个故事
  - 史诗 15：7 个故事
  - 史诗 16：5 个故事
- 位置：docs/tasks/kanban_board.md

后续步骤：
1. 运行 ln-310-multi-agent-validator 以验证所有故事
2. 使用 ln-400-story-executor 处理每个故事（任务 → 执行 → 完成）

结果： 通过完整流水线自动化创建了 6 个史诗 + 36 个故事

阶段 6：元分析

强制阅读： 加载 shared/references/meta_analysis_protocol.md

技能类型：planning-coordinator。在所有阶段完成后运行。使用 planning-coordinator 格式输出到聊天。

配置源： docs/tasks/kanban_board.md（团队 ID，下一个史诗编号）
史诗协调器： ln-210-epic-coordinator/SKILL.md
故事协调器： ln-220-story-coordinator/SKILL.md
故事优先级排序器： ln-230-story-prioritizer/SKILL.md
编号约定： shared/references/numbering_conventions.md（史诗 0 保留）

使用表情符号前缀进行视觉区分：

🔄 [ORCHESTRATOR] - ln-200-scope-decomposer（顶层编排器）

目的： 帮助用户在委托给多个协调器时跟踪编排器进度。

版本： 2.0.0 最后更新： 2025-11-20

🇺🇸English

Paths: File paths (shared/, references/, ../ln-*) are relative to skills repo root. If not found at CWD, locate this SKILL.md directory and go up one level for repo root. If shared/ is missing, fetch files via WebFetch from https://raw.githubusercontent.com/levnikolaevich/claude-code-skills/master/skills/{path}.

Scope Decomposer (Top Orchestrator)

Top-level orchestrator for complete initiative decomposition from scope to User Stories through Epic and Story coordinators.

Purpose

What This Skill Does

Coordinates the complete decomposition pipeline for new initiatives:

Auto-discovers Team ID from kanban_board.md
Phase 1: Discovery (Team ID)
Phase 2: Epic Decomposition (delegates to ln-210-epic-coordinator)
Phase 3: Story Decomposition Loop (delegates to ln-220-story-coordinator per Epic, sequential)
Phase 4: RICE Prioritization Loop (optional, delegates to ln-230-story-prioritizer per Epic, sequential)
Phase 5: Summary (total counts + next steps)

When to Use This Skill

This skill should be used when:

Start new initiative requiring full decomposition (scope → Epics → Stories)
Automate Epic + Story creation in single workflow
Prefer full pipeline over manual step-by-step invocation
Time-efficient approach for new projects (2-3 hours end-to-end)

Alternative: For granular control, invoke coordinators manually:

ln-210-epic-coordinator - CREATE/REPLAN Epics
ln-220-story-coordinator - CREATE/REPLAN Stories (once per Epic)
ln-230-story-prioritizer - RICE prioritization (once per Epic)

When NOT to Use

Do NOT use if:

Initiative already has Epics → Use ln-210-epic-coordinator REPLAN mode instead
Need to replan existing Stories → Use ln-220-story-coordinator REPLAN mode per Epic
Only need Epic creation → Use ln-210-epic-coordinator directly
Only need Story creation for specific Epic → Use ln-220-story-coordinator directly

Core Concepts

Orchestrator Pattern

ln-200-scope-decomposer is a pure coordinator - it does NOT execute work directly:

✅ Discovers context (Team ID)
✅ Makes routing decisions (which coordinator to invoke)
✅ Delegates all work via Skill tool (ln-210, ln-220, ln-230)
✅ Manages workflow state (Epic creation → Story loop)
❌ Does NOT research project docs (ln-210 does this)
❌ Does NOT generate Epic/Story documents (ln-210/ln-220 do this)
❌ Does NOT create Linear issues (coordinators do this)
❌ Does NOT prompt user (coordinators handle all user interaction)

Coordinators:

ln-210-epic-coordinator: Creates 3-7 Epics (Epic 0 for Infrastructure if applicable, Epic 1-N for business domains)
ln-220-story-coordinator: Creates 5-10 Stories per Epic (with inline standards research)

Sequential Story Decomposition

CRITICAL CONSTRAINT: Epic N Stories MUST complete before Epic N+1 starts (ln-220 includes user interaction — interactive dialog cannot be parallelized across Epics).

Why sequential?

ln-220-story-coordinator includes user interaction (Story preview confirmation)
Interactive dialog cannot be parallelized (user must review each Epic's Stories)
Ensures Epic N Stories are approved and created before starting Epic N+1

Example: 6 Epics → ln-220 invoked 6 times sequentially (Epic 0 → Epic 1 → Epic 2 → ... → Epic 5)

Infrastructure Epic = Epic 0

Reserved number: Epic 0 is reserved for Infrastructure Epic (if proposed by ln-210).

Numbering:

IF Infrastructure Epic exists → Epic 0 (Infrastructure), Epic 1-N (business domains)
ELSE → Epic 1-N (business domains only)

Decision: ln-210-epic-coordinator Phase 1 Step 3 automatically determines if Infrastructure Epic is needed (new project, multi-stack, security/monitoring requirements).

Auto-Discovery

Team ID : Auto-discovered from docs/tasks/kanban_board.md Linear Configuration table (see CLAUDE.md "Configuration Auto-Discovery").

Fallback: If kanban_board.md missing → ln-210-epic-coordinator will ask user directly

Workflow

Phase 1: Discovery (Automated)

Auto-discovers Team ID from docs/tasks/kanban_board.md.

Validation:

Team ID exists in kanban_board.md
If missing → Skip (ln-210 will request from user)

NO user confirmation at orchestrator level - coordinators handle all user interaction.

Output: Team ID (or None if not found)

Phase 2: Epic Decomposition (Delegated)

Objective: Create all Epics for initiative.

Delegate to ln-210-epic-coordinator:

🔄 [ORCHESTRATOR] Phase 2: Delegating Epic creation to ln-210-epic-coordinator

Skill(skill: "ln-210-epic-coordinator")

ln-210-epic-coordinator will:

Phase 1: Research project docs (requirements.md, architecture.md, tech_stack.md)
Phase 2: Auto-propose domains + Infrastructure Epic (Epic 0) → User confirms domain list
Phase 3: Build IDEAL Epic plan (Epic 0-N)
Phase 5a: Auto-extract Q1-Q4 from docs → Generate ALL Epic documents → Show batch preview → User confirms → Create all Epics
Return: Epic URLs + summary

After completion: Epics created in Linear, kanban_board.md updated.

Output: 3-7 Epics created (Epic 0 for Infrastructure if applicable, Epic 1-N for business domains)

Phase 3: Story Decomposition Loop (Sequential, Delegated)

Objective: Create Stories for EACH Epic (sequential processing).

Sequential Loop Logic:

FOR EACH Epic (Epic 0, Epic 1, ..., Epic N):
    1. Invoke ln-220-story-coordinator for current Epic
    2. Wait for completion
    3. Verify Stories created in kanban_board.md
    4. Move to next Epic

Stop Conditions (Decomposition Loops)

Condition	Action
All Epics processed (Stories + optional RICE)	STOP — proceed to Summary
ln-220 fails for an Epic (coordinator error)	STOP — report partial results, list completed Epics
User cancels during Story confirmation	STOP — report completed Epics, skip remaining
Total Story count exceeds 80	STOP — WARN: "Scope may be too large. Continue?"

Invocation per Epic:

🔄 [ORCHESTRATOR] Phase 3: Delegating Story creation for Epic N to ln-220-story-coordinator

Skill(skill: "ln-220-story-coordinator", epic_number="Epic N")

ln-220-story-coordinator will (per Epic):

Phase 1: Auto-extract Q1-Q6 from Epic + Fallback search (requirements.md, tech_stack.md)
Phase 2: Research standards inline MCP Ref (auto)
Phase 3: Build IDEAL Story plan (5-10 Stories)
Phase 4a: Generate ALL Story documents → Show preview → User confirms → Create all Stories
Return: Story URLs + summary

Sequential constraint explanation:

ln-220 includes user interaction (Story preview confirmation)
Cannot parallelize - user must review each Epic's Stories sequentially
Epic N Stories approved → Epic N+1 Stories generated

After each Epic: Stories created in Linear, kanban_board.md updated.

Output: 30-60 Stories total (5-10 per Epic × 3-7 Epics)

TodoWrite format (mandatory): Add phases and Epic iterations to todos before starting:

- Phase 1: Discovery (in_progress)
- Phase 2: Delegate to ln-210-epic-coordinator (pending)
- Phase 3: Delegate to ln-220 for Epic 0 (pending)
- Phase 3: Delegate to ln-220 for Epic 1 (pending)
- Phase 3: Delegate to ln-220 for Epic 2 (pending)
... (one todo per Epic)
- Phase 4: Delegate to ln-230 for Epic 0 (pending)
- Phase 4: Delegate to ln-230 for Epic 1 (pending)
... (one todo per Epic, optional)
- Phase 5: Summary (pending)

Mark each as in_progress when starting, completed when coordinator returns success.

Phase 4: RICE Prioritization Loop (Optional, Sequential, Delegated)

Objective: Prioritize Stories per Epic using RICE scoring with market research.

OPTIONAL: Ask user "Run RICE prioritization for all Epics?" If user declines, skip to Phase 5.

Sequential Loop Logic:

FOR EACH Epic (Epic 0, Epic 1, ..., Epic N):
    1. Invoke ln-230-story-prioritizer for current Epic
    2. Wait for completion
    3. Verify prioritization.md created in docs/market/[epic-slug]/
    4. Move to next Epic

Invocation per Epic:

Skill(skill: "ln-230-story-prioritizer", args: "epic=\"Epic N\"")

ln-230-story-prioritizer will (per Epic):

Load Stories metadata from Linear
Research market size and competition per Story
Calculate RICE score and assign Priority (P0-P3)
Generate docs/market/[epic-slug]/prioritization.md

Skip condition: If Epic contains only technical/infrastructure Stories (no business value to prioritize), skip that Epic.

After each Epic: Prioritization table saved to docs/market/[epic-slug]/prioritization.md.

Output: Prioritization tables for all applicable Epics.

Phase 5: Summary and Next Steps

Objective: Provide complete decomposition overview.

🔄 [ORCHESTRATOR] Phase 5: Full decomposition complete

Initiative Decomposition Summary:
- Epics created: N Projects (Epic 0: Infrastructure [if exists], Epic 1-N: Business domains)
- Stories created: M Issues (breakdown per Epic)
- Location: docs/tasks/kanban_board.md

Next Steps:
1. Run ln-310-multi-agent-validator to validate all Stories
2. Use ln-400-story-executor to process each Story (tasks → execution → Done)
   OR use ln-300-task-coordinator to create tasks manually for each Story

Output: Summary message with full decomposition results

Critical Rules

1. No User Prompts at Orchestrator Level

Orchestrator does NOT prompt user:

❌ NO "Proceed with decomposition?" confirmation (redundant - coordinators already confirm)
❌ NO time estimates (misleading - actual time varies)
❌ NO Epic/Story previews (coordinators handle this)

All user interaction delegated to coordinators:

ln-210 Phase 2: Domain approval (USER CONTROL POINT 1)
ln-210 Phase 5a: Epic batch preview (USER CONTROL POINT 2)
ln-220 Phase 4a: Story preview per Epic (USER CONTROL POINT 3, N times)

Definition of Done

Before completing work, verify ALL checkpoints:

✅ Team ID Discovered (Phase 1):

Team ID loaded from kanban_board.md OR skipped (ln-210 will request)

✅ Epic Decomposition Complete (Phase 2):

Delegated to ln-210-epic-coordinator
3-7 Epics created (Epic 0 for Infrastructure if applicable, Epic 1-N for business domains)
Epic URLs returned
Epics visible in kanban_board.md

✅ Story Decomposition Complete (Phase 3):

Delegated to ln-220-story-coordinator for EACH Epic (sequential)
5-10 Stories created per Epic
Story URLs returned for each Epic
All Stories visible in kanban_board.md (Backlog section)

✅ RICE Prioritization Complete (Phase 4, optional):

User asked about prioritization (skip if declined)
Delegated to ln-230-story-prioritizer for each applicable Epic
Prioritization tables saved to docs/market/[epic-slug]/

✅ Summary Provided (Phase 5):

Total counts displayed (Epics, Stories, breakdown per Epic)
kanban_board.md location shown
Next steps provided (validation, task creation)

Output: Summary message with full decomposition results (Epics + Stories per Epic)

Integration with Ecosystem

Called By

Users directly: "Decompose initiative: [initiative name]" or "Create epics and stories for [project]"

Calls (via Skill tool)

ln-210-epic-coordinator (Phase 2) - CREATE mode (batch Epic creation with batch preview)
ln-220-story-coordinator (Phase 3, sequential loop) - CREATE mode per Epic (Story creation with preview)
ln-230-story-prioritizer (Phase 4, optional sequential loop) - RICE prioritization per Epic

Downstream

After ln-200-scope-decomposer completes:

ln-310-multi-agent-validator - validates all created Stories before task creation
ln-400-story-executor - processes each Story (tasks → execution → Done)
- OR ln-300-task-coordinator - creates tasks manually for each Story

Best Practices

Coordinator Trust

Trust coordinator results: Coordinators return summary, orchestrator doesn't re-verify.

Error handling: If coordinator returns error, report to user and stop pipeline.

Time Estimates

Realistic estimate: 2-3 hours for full decomposition (6 Epics × 7 Stories avg = 42 Stories).

Breakdown:

Phase 2 (Epic creation): 30-45 min (batch preview reduces time)
Phase 3 (Story creation): 1.5-2 hours (6 Epics × 15-20 min per Epic)
Phase 4 (Summary): 2 min

Do NOT provide time estimates to user - varies based on project complexity and user response time.

Example Usage

Request:

"Decompose initiative: E-commerce Platform"

Execution:

Phase 1: Discovery
- Team ID loaded from kanban_board.md
Phase 2: Epic Decomposition
- Invoke ln-210-epic-coordinator
- ln-210 creates 6 Epics:
  - Epic 11 (Infrastructure Epic 0 pattern)
  - Epic 12-16 (business domains)
- Output: 6 Epic URLs
Phase 3: Story Decomposition Loop (Sequential)
- Epic 11: Invoke ln-220 → 6 Stories (US017-US022)
- Epic 12: Invoke ln-220 → 7 Stories (US023-US029)
- Epic 13: Invoke ln-220 → 5 Stories (US030-US034)
- Epic 14: Invoke ln-220 → 6 Stories (US035-US040)
- Epic 15: Invoke ln-220 → 7 Stories (US041-US047)
- Epic 16: Invoke ln-220 → 5 Stories (US048-US052)
- Output: 36 Stories total
Phase 4: Summary

🔄 [ORCHESTRATOR] Full decomposition complete

Initiative: E-commerce Platform

- Epics created: 6 Projects (Epic 11: Infrastructure, Epic 12-16: Business domains)
- Stories created: 36 Issues
  - Epic 11: 6 Stories
  - Epic 12: 7 Stories
  - Epic 13: 5 Stories
  - Epic 14: 6 Stories
  - Epic 15: 7 Stories
  - Epic 16: 5 Stories
- Location: docs/tasks/kanban_board.md

Next Steps:
1. Run ln-310-multi-agent-validator to validate all Stories
2. Use ln-400-story-executor to process each Story (tasks → execution → Done)

Result: 6 Epics + 36 Stories created through full pipeline automation

Phase 6: Meta-Analysis

MANDATORY READ: Load shared/references/meta_analysis_protocol.md

Skill type: planning-coordinator. Run after all phases complete. Output to chat using the planning-coordinator format.

Reference Files

Configuration source: docs/tasks/kanban_board.md (Team ID, Next Epic Number)
Epic coordinator: ln-210-epic-coordinator/SKILL.md
Story coordinator: ln-220-story-coordinator/SKILL.md
Story prioritizer: ln-230-story-prioritizer/SKILL.md
Numbering conventions: shared/references/numbering_conventions.md (Epic 0 reserved)

Chat Output Prefix

Use emoji prefix for visual differentiation:

🔄 [ORCHESTRATOR] - ln-200-scope-decomposer (top orchestrator)

Purpose: Helps users track orchestrator progress when delegating to multiple coordinators.

Version: 2.0.0 Last Updated: 2025-11-20

Weekly Installs

153

Repository

levnikolaevich/…e-skills

GitHub Stars

245

First Seen

Jan 24, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

claude-code138

opencode138

codex137

gemini-cli136

cursor134

github-copilot131

通过 LiteLLM 代理让 Claude Code 对接 GitHub Copilot 运行 | 高级变通方案指南

36,300 周安装