writing-plans

Generate step-by-step implementation plans for software development tasks with TDD principles.

2|Updated Jun 14, 2026
One-click install
npx skills add https://github.com/eng-vmessiah/project-development-skill --skill writing-plans-eng-vmessiah
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/eng-vmessiah/project-development-skill/tree/main/skills/writing-plans
Command: npx skills add https://github.com/eng-vmessiah/project-development-skill --skill writing-plans-eng-vmessiah

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill eliminates ambiguity in software development by forcing the creation of highly detailed, step-by-step implementation plans that prevent guesswork and reduce implementation errors.

Core Features & Use Cases

  • Bite-Sized Tasking: Breaks complex features into 2-5 minute actionable steps.
  • TDD Integration: Enforces test-driven development by requiring failing tests before implementation.
  • Use Case: Before starting a complex refactor or a new feature, use this skill to generate a structured plan that maps out every file, command, and verification step, ensuring the implementation is predictable and verifiable.

Quick Start

Use the writing-plans skill to generate a detailed implementation plan for the new user authentication module.

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 step-by-step implementation plan for complex software refactoring?▼

To create an implementation plan for complex refactoring, break down the work into 2-5 minute actionable steps that specify exact file paths, commands, and verification criteria. This ensures technical accuracy and predictable execution without guesswork.

How do I write a TDD implementation plan for new feature development?▼

Writing a TDD implementation plan requires mapping out every file and forcing the creation of failing tests before any implementation steps begin. This enforces test-driven development by making verifiable task completion criteria mandatory for each phase.

What is the best way to break down multi-step engineering tasks for team delegation?▼

The best way to break down engineering tasks for team delegation is to generate a structured plan that maps every file modification and verification step into bite-sized 2-5 minute intervals. This prevents ambiguity and reduces implementation errors across the team.

Does generating detailed implementation plans work for multi-step feature development scenarios?▼

Generating detailed implementation plans works effectively for multi-step feature development by producing comprehensive, step-by-step documentation. It forces exact file path specification and verifiable completion criteria to ensure reliable technical execution.

Why does my software implementation plan fail to prevent implementation errors?▼

Software implementation plans fail to prevent errors when they lack sufficient detail and allow guesswork. Forcing highly detailed, bite-sized tasking with exact file paths and strict TDD verification criteria eliminates ambiguity and ensures predictable execution.

When do I need to use a structured implementation plan for software engineering tasks?▼

You need a structured implementation plan when facing complex refactoring, multi-step feature development, or team delegation scenarios. It is required to eliminate ambiguity by mapping out every file, command, and verification step before execution begins.