writing-plans

Generate test-first implementation plans with exact file paths and commands.

Updated Mar 31, 2026
One-click install
npx skills add https://github.com/DFly7/iOS-FastAPI-Supabase-AI --skill writing-plans-dfly7
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/DFly7/iOS-FastAPI-Supabase-AI/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/DFly7/iOS-FastAPI-Supabase-AI --skill writing-plans-dfly7

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns ambiguous specifications and multi-step requirements into precise, test-first implementation plans that an engineer with no prior context can follow end-to-end.

Core Features & Use Cases

  • Exact file mapping: lists exact files to create or modify and describes each file's responsibility.
  • TDD-driven bite-sized tasks: decomposes work into small actions (write failing test, run, implement minimal code, run tests, commit) with explicit commands and expected outputs.
  • Self-review and handoff: includes placeholder scans, type-consistency checks, and explicit save locations plus execution options for subagent-driven or inline execution. Use Case: Given a product spec that spans multiple subsystems, produce one or more standalone plans that result in working, testable software with clear commit history.

Quick Start

Write a complete test-first implementation plan for the described feature, include exact file paths, full test and code snippets, expected test commands and outputs, commit commands, self-review checklist, and save it to .agents/superpowers/plans/YYYY-MM-DD-feature-name.md.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create a test-first implementation plan from a feature spec?

To create a test-first implementation plan, you decompose feature specs into bite-sized TDD tasks: write failing tests, run commands with expected outputs, implement minimal code, and commit. The plan includes exact file paths, full code snippets, and self-review checks for context-free execution.

What is task decomposition for multi-step engineering requirements?

Task decomposition for multi-step requirements breaks ambiguous specs into small, standalone actions mapped to exact files. It ensures an engineer with minimal repository context can implement features across files, tests, and CI by following explicit run commands and commit instructions.

How do I write implementation plans for engineers with no repository context?

Writing implementation plans for context-free engineers requires listing exact file paths, describing each file's responsibility, providing full test and code snippets, and specifying run commands with expected outputs. This ensures end-to-end execution without prior repository knowledge.

Does TDD planning work for features spanning multiple subsystems?

TDD planning works for multi-subsystem features by producing one or more standalone plans from a product spec. Each plan maps exact files, includes type-consistency checks, and results in working, testable software with a clear commit history.

What's the best way to structure engineering docs for subagent-driven execution?

Structuring engineering docs for subagent execution involves saving test-first plans to a specific path like .agents/superpowers/plans/YYYY-MM-DD-feature-name.md. The plan provides explicit execution options, placeholder scans, and self-review checklists for autonomous or inline processing.

Can I include commit instructions and expected test outputs in an implementation plan?

Yes, implementation plans explicitly include commit commands and expected test outputs alongside full code snippets. This ensures precise execution validation, enabling engineers to verify minimal code implementations against failing tests before committing changes.