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.