writing-plans

Expand bd tasks into detailed implementation steps with file paths, code, and verification commands.

80|17|Updated Oct 27, 2025
One-click install
npx skills add https://github.com/withzombies/hyperpowers --skill writing-plans-withzombies
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/withzombies/hyperpowers/tree/main/skills/writing-plans
Command: npx skills add https://github.com/withzombies/hyperpowers --skill writing-plans-withzombies

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill transforms high-level bd tasks into detailed, step-by-step implementation instructions, eliminating ambiguity for engineers with zero codebase context. It ensures every task has exact file paths, complete code examples, and verification commands.

Core Features & Use Cases

  • Detailed Step Generation: Expands bd task checklists into bite-sized (2-5 minute) implementation steps, including code and commands.
  • Codebase Verification: Uses the codebase-investigator agent to verify current codebase state against plan assumptions, ensuring accuracy.
  • User Validation Loop: Requires presenting each expanded task to the user for approval before updating bd, preventing off-track work.
  • Use Case: After a feature is brainstormed, use this Skill to take a bd task like "Implement user authentication" and expand it into precise steps, including which files to create, specific code snippets, and how to run tests.

Quick Start

Use the writing-plans skill to expand bd-2 with detailed implementation steps.

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 high-level task into step-by-step implementation instructions?

Turn high-level tasks into step-by-step implementation instructions by expanding them with explicit file paths, complete code samples, and verification commands. This Skill takes vague tasks like 'implement authentication' and breaks them into bite-sized (2-5 minute) steps with exact files to create, code to write, and tests to run.

What's the best way to ensure task checklists include file paths and runnable code?

The best way is to systematically expand each task with concrete artifacts: exact file paths, complete code examples, and measurable verification steps. This eliminates ambiguity and ensures engineers can execute without guessing about which files to modify or what code to write.

How do I verify my implementation plan matches the current codebase state?

Verify your plan by investigating the current codebase state against assumptions before execution. The Skill uses a codebase-investigator workflow to surface mismatches early, ensuring your expanded steps remain accurate and prevent off-track work.

Can I expand existing task checklists into detailed implementation guides?

Yes. You can expand single tasks, task ranges, or entire epics from existing checklists into detailed implementation guides. Each expansion is presented for user approval before updating, ensuring alignment before work begins.

When should I use task-first TDD alongside detailed step generation?

Apply task-first TDD when generating detailed steps to ensure each implementation step includes verification commands and measurable outcomes. This cadence produces concrete, testable artifacts rather than ambiguous instructions.

What happens if my task checklist spans multiple engineering contexts?

The Skill applies across diverse engineering contexts—frontend, backend, infrastructure—by generating context-specific file paths, code samples, and verification commands for each step, maintaining consistency while adapting to the domain.