Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
jnmetacode avatar

Writing Plans

  • 890 installs
  • 7.5k repo stars
  • Updated July 31, 2026
  • jnmetacode/superpowers-zh

writing-plans is a Claude Code skill that produces detailed step-by-step implementation plans from specifications for developers who need AI agents to execute multi-step features with zero prior codebase context.

About

writing-plans is a version 1.0.0 MIT skill from the superpowers-zh fork that turns specifications into comprehensive implementation plans before any code is written. The skill assumes the executing engineer has zero codebase context and documents every file to create or modify, code changes, tests, documentation references, and verification steps in small incremental tasks following DRY, YAGNI, and TDD principles. Plans save to docs/superpowers/plans/YYYY-MM-DD-feature-name.md and are designed to run inside a dedicated worktree created by the brainstorming skill. Developers reach for writing-plans when a multi-step feature spec needs a handoff-ready plan that an AI agent or junior engineer can follow without guessing file boundaries or test strategy.

  • Announces skill use at start
  • Requires dedicated worktree from brainstorming
  • Saves plans to docs/superpowers/plans/
  • Enforces 2-5 minute task granularity with TDD and frequent commits

Writing Plans by the numbers

  • 890 all-time installs (skills.sh)
  • +22 installs in the week ending Aug 4, 2026 (Skillselion tracking)
  • Ranked #545 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/jnmetacode/superpowers-zh --skill writing-plans

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs890
repo stars7.5k
Last updatedJuly 31, 2026
Repositoryjnmetacode/superpowers-zh

How do you write an AI-ready implementation plan from a spec?

Produces detailed, step-by-step implementation plans from specs before any code is written, optimized for AI agents with zero codebase context.

Who is it for?

Engineers or AI agents starting a multi-step feature who need a zero-context implementation plan with file boundaries and TDD steps.

Skip if: Single-file bug fixes, exploratory prototyping without a spec, or teams that already have detailed tickets and architecture docs.

When should I use this skill?

A specification or requirement exists for a multi-step task and code has not yet been written.

What you get

A dated markdown implementation plan listing files, tasks, tests, documentation references, and incremental commit steps under docs/superpowers/plans/.

  • Implementation plan markdown
  • File-level task breakdown
  • Test and commit step list

By the numbers

  • Version 1.0.0 MIT skill from jnmetacode/superpowers-zh
  • Default plan output path docs/superpowers/plans/YYYY-MM-DD-feature-name.md

Files

SKILL.mdMarkdownGitHub ↗

编写计划

概述

编写全面的实现计划,假设工程师对我们的代码库零上下文,且品味存疑。记录他们需要知道的一切:每个任务要修改哪些文件、代码、测试、可能需要查阅的文档、如何测试。将整个计划拆成小步骤任务。DRY。YAGNI。TDD。频繁 commit。

假设他们是有经验的开发者,但对我们的工具链和问题领域几乎一无所知。假设他们不太擅长测试设计。

开始时宣布: "我正在使用 writing-plans 技能创建实现计划。"

上下文: 此技能应在专用 worktree 中运行(由 brainstorming 技能创建)。

计划保存位置: docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md

  • (用户对计划位置的偏好优先于此默认值)

范围检查

如果规格涵盖了多个独立子系统,它应该在头脑风暴阶段就被拆分为子项目规格。如果没有,建议将其拆分为独立的计划——每个子系统一个。每个计划应该能独立产出可工作、可测试的软件。

文件结构

在定义任务之前,先列出将要创建或修改的文件以及每个文件的职责。这是锁定分解决策的地方。

  • 设计边界清晰、接口定义良好的单元。每个文件应有一个明确的职责。
  • 你对能一次放入上下文的代码推理得最好,文件越专注你的编辑越可靠。优先选择小而专注的文件,而非承担过多功能的大文件。
  • 一起变更的文件应放在一起。按职责拆分,而非按技术层级拆分。
  • 在现有代码库中,遵循已有模式。如果代码库使用大文件,不要单方面重构——但如果你正在修改的文件已经变得难以管理,在计划中包含拆分是合理的。

此结构决定了任务分解。每个任务应产出独立的、有意义的变更。

小步骤任务粒度

每步是一个操作(2-5 分钟):

  • "编写失败的测试" - 一步
  • "运行它确认失败" - 一步
  • "实现最少代码让测试通过" - 一步
  • "运行测试确认通过" - 一步
  • "Commit" - 一步

计划文档头部

每个计划必须以此头部开始:

# [功能名称] 实现计划

> **面向 AI 代理的工作者:** 必需子技能:使用 superpowers:subagent-driven-development(推荐)或 superpowers:executing-plans 逐任务实现此计划。步骤使用复选框(`- [ ]`)语法来跟踪进度。

**目标:** [一句话描述要构建什么]

**架构:** [2-3 句话描述方案]

**技术栈:** [关键技术/库]

---

任务结构

````markdown

任务 N:[组件名称]

文件:

  • 创建:exact/path/to/file.py
  • 修改:exact/path/to/existing.py:123-145
  • 测试:tests/exact/path/to/test.py
  • [ ] 步骤 1:编写失败的测试
def test_specific_behavior():
    result = function(input)
    assert result == expected
  • [ ] 步骤 2:运行测试验证失败

运行:pytest tests/path/test.py::test_name -v 预期:FAIL,报错 "function not defined"

  • [ ] 步骤 3:编写最少实现代码
def function(input):
    return expected
  • [ ] 步骤 4:运行测试验证通过

运行:pytest tests/path/test.py::test_name -v 预期:PASS

  • [ ] 步骤 5:Commit
git add tests/path/test.py src/path/file.py
git commit -m "feat: add specific feature"

````

禁止占位符

每个步骤都必须包含工程师需要的实际内容。以下是计划缺陷——绝不要写出来:

  • "待定"、"TODO"、"后续实现"、"补充细节"
  • "添加适当的错误处理" / "添加验证" / "处理边界情况"
  • "为上述代码编写测试"(没有实际测试代码)
  • "类似任务 N"(重复代码——工程师可能不按顺序阅读任务)
  • 只描述做什么而不展示怎么做的步骤(代码步骤必须有代码块)
  • 引用了未在任何任务中定义的类型、函数或方法

注意事项

  • 始终使用精确的文件路径
  • 每个步骤都包含完整代码——如果步骤涉及代码变更,就展示代码
  • 精确的命令和预期输出
  • DRY、YAGNI、TDD、频繁 commit

自检

编写完整计划后,以全新视角审视规格并对照检查计划。这是你自己执行的检查清单——不是子代理调度。

1. 规格覆盖度: 浏览规格中的每个章节/需求。你能指出实现它的任务吗?列出所有遗漏。

2. 占位符扫描: 搜索计划中的红旗——上方"禁止占位符"章节中的任何模式。修复它们。

3. 类型一致性: 后续任务中使用的类型、方法签名和属性名是否与前面任务中定义的一致?任务 3 中叫 clearLayers() 但任务 7 中叫 clearFullLayers() 就是 bug。

如果发现问题,直接内联修复。无需重新审查——修好继续推进。如果发现规格中的需求没有对应任务,就添加任务。

执行交接

保存计划后,提供执行选项:

"计划已完成并保存到 `docs/superpowers/plans/<filename>.md`。两种执行方式:

1. 子代理驱动(推荐) - 每个任务调度一个新的子代理,任务间进行审查,快速迭代

2. 内联执行 - 在当前会话中使用 executing-plans 执行任务,批量执行并设有检查点

选哪种方式?"

如果选择子代理驱动:

  • 必需子技能: 使用 superpowers:subagent-driven-development
  • 每个任务一个新子代理 + 两阶段审查

如果选择内联执行:

  • 必需子技能: 使用 superpowers:executing-plans
  • 批量执行并设有检查点供审查

Related skills

How it compares

Pick writing-plans over brainstorming when a spec already exists and you need a file-level execution plan rather than open-ended design exploration.

FAQ

Where does writing-plans save implementation plans?

writing-plans saves plans to docs/superpowers/plans/YYYY-MM-DD-feature-name.md by default, though a user's preferred plan location overrides that path when specified during the session.

What assumptions does writing-plans make about the executor?

writing-plans assumes the executor is an experienced developer with near-zero knowledge of the project's toolchain and domain, and that they need explicit file lists, test steps, and small incremental tasks to deliver working software.

Should writing-plans run before or after coding starts?

writing-plans runs before any code is written, turning a specification or requirement into a comprehensive handoff plan that an AI agent or engineer can follow step by step inside a dedicated worktree.

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.