writing-plans

Create detailed implementation plans for multi-step software work.

Updated Sep 27, 2024
One-click install
npx skills add https://github.com/sheer-rey/PowerBash --skill writing-plans-sheer-rey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/sheer-rey/PowerBash/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/sheer-rey/PowerBash --skill writing-plans-sheer-rey

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns vague requirements into a clear, execution-ready implementation plan so engineers can build multi-step features without guessing what to do next.

Core Features & Use Cases

  • Scope splitting: Breaks large requests into independently deliverable subprojects when a specification spans multiple subsystems.
  • File-first planning: Lists the exact files to create or modify and assigns each one a single responsibility before any coding starts.
  • Test-driven tasking: Decomposes work into small, concrete steps with tests, commands, and expected outcomes so the plan is directly executable.
  • Use case: A team can hand it a feature spec and get a reviewable plan that covers architecture, implementation order, testing, and commit strategy.

Quick Start

Use the writing-plans skill to turn this specification into a step-by-step implementation plan saved in the default plans directory.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn feature specifications into actionable implementation plans?

Implementation plans are generated by breaking down feature specifications into small, TDD-oriented tasks with exact file paths, testing commands, and expected outcomes. This process creates a review-ready plan covering architecture, implementation order, and commit strategy before coding begins.

What is the best way to break down multi-step software work before coding?

Breaking down multi-step software work involves splitting large feature scopes into independently deliverable subprojects and assigning single responsibilities to exact files. This task breakdown method ensures coordinated subsystem changes are organized into small, concrete steps for direct execution.

Do I need a dedicated worktree to plan coordinated subsystem changes across multiple files?

A dedicated worktree is required for planning coordinated subsystem changes spanning multiple files, tests, and documentation. Planning within a worktree ensures isolated scope checks and review-ready handoff instructions are established before any implementation starts.

How does test-driven tasking work when creating an implementation plan?

Test-driven tasking decomposes work into small, concrete steps that include specific tests, commands, and expected outcomes. This ensures the resulting implementation plan is directly executable and aligns with TDD practices before the actual coding phase begins.

Can I split a large feature request into independently deliverable subprojects?

Large feature requests are split into independently deliverable subprojects when the specification spans multiple subsystems. This scope splitting ensures complex features are organized into manageable, reviewable plans that cover architecture and implementation order.

When should I not use a file-first planning approach for software features?

File-first planning is not suitable for simple features that do not span multiple files, tests, or documentation. It requires exact file paths and multi-step coordinated subsystem changes to effectively utilize its detailed task breakdown and TDD-oriented structure.