writing-plans

Generate a structured implementation plan from a project spec.

Updated Apr 9, 2026
One-click install
npx skills add https://github.com/cookeyholder/django-devcontainer-template --skill writing-plans-cookeyholder
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/cookeyholder/django-devcontainer-template/tree/main/.agent/skills/writing-plans
Command: npx skills add https://github.com/cookeyholder/django-devcontainer-template --skill writing-plans-cookeyholder

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Translates ambiguous project specs into clear, executable implementation plans that reduce risk and miscommunication.

Core Features & Use Cases

  • Generates a structured task breakdown mapping tasks to files, tests, and commits
  • Defines a readable project structure and workflow guidance for teams
  • Use Case: starting a new feature from a spec, produce a plan that guides design, coding, testing, and documentation

Quick Start

Generate a complete implementation plan from the spec and save it to docs/superpowers/plans/YYYY-MM-DD-writing-plans.md.

Frequently Asked Questions about writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a project spec into an actionable implementation plan?

To turn a project spec into an implementation plan, you need structured task decomposition that maps tasks to files, tests, and commits. This process generates a reproducible plan artifact with clear acceptance criteria to guide engineering teams.

What is task decomposition in software engineering planning?

Task decomposition in software engineering planning is breaking down a project spec into structured, executable tasks. It maps each task to specific files, tests, and commits, ensuring clear acceptance criteria and commit-level traceability for the engineering team.

How do I map engineering tasks to files and tests from a spec?

Mapping engineering tasks to files and tests requires automating the creation of a detailed implementation plan from the spec. This structured plan defines a readable project structure and workflow guidance, ensuring each task has explicit file and test mapping.

Does generating an implementation plan require structured acceptance criteria?

Generating an implementation plan requires structured acceptance criteria to satisfy requirements for reproducible plan artifacts. Defining these criteria within the task breakdown ensures commit-level traceability and reduces the risk of miscommunication during coding.

Why use an automated tool to generate implementation plans from specs?

Using automated planning translates ambiguous project specs into clear, executable implementation plans that reduce risk and miscommunication. It provides a reproducible plan artifact and structured workflow guidance, which is superior to informal planning for complex features.

When do I need to generate a structured plan artifact for a new feature?

You need a structured plan artifact for a new feature when starting from a spec and requiring explicit task decomposition. It is essential for projects that need commit-level traceability, clear acceptance criteria, and a defined workflow to guide design, coding, testing, and documentation.