The writing-plans Skill for Creating Implementation Plans with Claude Code
機械翻訳 / Machine-translated
機械翻訳 / Machine-translated
Original article: Claude Codeで実装計画を作る writing-plansスキル (cccskills)
Skill page: writing-plans
Key takeaways from this article
With writing-plans installed, you can generate an implementation plan simply by providing a spec or requirements document.
The result is a plan — complete with files to change, function types, tests, and verification commands — that is ready before a single line of code is written.
This article explains what goes into the plan document, what the self-check covers, and how to install the skill in Claude Code or Codex.
The latter half also covers how to hand the plan off to another agent for implementation.
When you provide a spec, a single plan document is produced before any code is touched.
It includes the files to change and the test procedures for each task.
For example, you might ask:
Please create an implementation plan from the attached spec.
Do not write any code yet.
The agent first declares that it will use writing-plans, then saves the plan to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md.
At the top of the document you'll find the purpose, structural approach, technologies used, and the location of the source spec.
Below that come the constraints that apply to the entire spec, followed by a "Review Focus" section.
The Review Focus lists inputs and failure conditions that no task's tests currently cover.
Each task is written with the following three elements:
| Element | Contents |
|---|---|
| Files | Paths of files to create, modify, or test. Modified files include line numbers. |
| Interfaces | What is received from the previous task and what is passed to the next task — function names, arguments, and return types |
| Steps | Checkbox-style steps: write a failing test, confirm it fails, write the minimum implementation, confirm it passes, commit |
Once the plan is written, the agent asks you to review it, inquires about how you want to proceed with implementation, and then stops.
Implementation never begins without your confirmation.
writing-plans is a skill that converts a spec into a list of decisions that the implementer cannot make on their own.
Through four distinct functions, it reduces the ambiguity that causes rework — all before implementation begins.
The plan is written for an implementer who has not seen the codebase or the spec.
It therefore spells out which files to touch, function names and types, specific values from the spec, and the tests that back each task.
Function bodies are not written.
The exception is algorithms that cannot be determined from types and tests alone.
One task is the smallest unit that has its own test cycle and can be sent back independently during review.
Setup, scaffolding, and documentation work must be included in the task that requires them.
If the spec spans multiple independent subsystems, the agent will propose splitting the plan into separate plans per subsystem.
Once the plan is written, the agent compares it against the spec and verifies five points:
Problems found are corrected on the spot, and tasks are added for any requirements that lack coverage.
Name drift — such as writing clearLayers() in Task 3 and clearFullLayers() in Task 7 — is also caught at this stage.
The Interfaces section of each task records the exact types of what is received and what is passed on.
An implementer can read only their own task and still align their names and types with adjacent tasks.
The location of the original spec is also noted at the top of the plan.
The recipient can read the plan and the spec side by side.
writing-plans is one of the skills included in obra/superpowers; the only accompanying file is SKILL.md.
To install via command line, run the following:
npx skills add https://github.com/obra/superpowers --skill writing-plans
To have the agent install it for you, send the following message as-is.
It asks the agent to inspect the contents before placing the files.
次の Agent Skill をインストールしてください。
https://github.com/obra/superpowers/tree/main/skills/writing-plans
まず SKILL.md と付属ファイルの中身を確認し、不審な処理（外部への送信、認証情報の読み取りなど）がないことを確かめてから、Claude Code なら ~/.claude/skills/writing-plans/、Codex なら ~/.agents/skills/writing-plans/ に配置してください。
Choose the installation location based on whether you want the skill available across all projects or only in a specific project.
| Agent | All projects | Specific project only |
|---|---|---|
| Claude Code | ~/.claude/skills/ | .claude/skills/ in the project |
| Codex | ~/.agents/skills/ | .agents/skills/ in the project |
Including the location of the spec and any preferences for where to save or how to execute the plan in your request helps things move along quickly.
Here are three common ways to ask:
Create an implementation plan from these feature requirements, including which files to change and the test procedures.
Save it to docs/plans/.
The plan is saved to the specified docs/plans/ location.
Your stated preference takes priority over the default location.
Each task comes with a file list and checkbox-style steps that begin with writing tests.
For Task 2 of the plan, tell me which tests to run, what command to use, and what output means success.
The verification steps in the plan include the command to run and the expected output that signals success.
The response will therefore contain exactly the commands and expected results written in the plan — both for the step that confirms failure and the step that confirms success.
Once the plan is ready, I want to have a separate agent implement it task by task.
If you state your preferred execution method upfront, the agent won't ask again and will only ask you to review the plan.
If you don't specify, it will ask you to choose between the two options below and will explain which it recommends and why.
| Method | How it works | Characteristics |
|---|---|---|
| Subagent-driven | A new subagent implements each task, a new reviewer verifies it, and then the process moves to the next task. The entire branch is reviewed at the end. | Most thorough. Uses a fresh context for each task and review. |
| Native | All tasks are implemented in the same session, and a reviewer using the most capable model checks the entire branch at the end. | Fastest and cheapest. No independent reviews along the way. |
writing-plans is a skill for use when a spec or requirements document is already in hand.
The prerequisite spec must be prepared and verified by a human.
If you provide an ambiguous spec, the plan will inherit that ambiguity.
At the implementation stage, the skill is designed to call other skills.
For Subagent-driven you'll need subagent-driven-development; for Native you'll need executing-plans.
Both are included in obra/superpowers, so install them alongside writing-plans.
Do not accept the plan without reading it yourself.
In particular, the Review Focus section lists inputs and failure conditions not yet covered by any test.
It's a good idea to go through them in order of likely impact on real users.
The license is MIT.
Before installing, read the contents of SKILL.md and confirm what the instructions actually do.
Here are three skills from the same obra/superpowers collection that connect to the steps before and after planning.
brainstorming clarifies goals and constraints through dialogue before the planning phase and produces a design scaled to the size of the work.
When the spec is not yet settled, this is your starting point.
subagent-driven-development delegates each task in the plan to a separate agent, verifying spec conformance and code quality as it goes.
executing-plans runs through the tasks sequentially in the same session and reviews the entire branch at the end.
A spec or requirements document is a prerequisite.
If one isn't ready yet, start by using brainstorming to clarify your goals and constraints, then create the plan from there.
The default location is under docs/superpowers/plans/.
It is saved as a Markdown file named with the date and feature name.
If you specify a location in your request, that takes priority.
No.
After saving the plan and running the self-check, it stops and waits for your review.
Implementation is handled by subagent-driven-development or executing-plans.
The example plan format uses Python and pytest, but it assumes that the implementer will write in the project's own language.
Because the plan specifies files, types, tests, and verification commands, the content will naturally fit the language being used.
writing-plans is a skill for developers who find that having AI agents write code immediately leads to excessive rework.
It produces a plan first — one that lists files to change, function types, tests, and verification commands — before any code is written.
It then self-checks for name drift and missing spec coverage.
The finished plan can be handed off to another agent or team member, task by task.
Try it out with the spec for a small feature addition first.
Page on cccskills
This article is a repost of "Claude Codeで実装計画を作る writing-plansスキル" from cccskills.
Details about the skill and installation instructions can be found on the writing-plans page at cccskills.