writing-plans

Generate step-by-step implementation plans with file paths, code snippets, and testing strategies.

6|1|Updated Feb 24, 2026
One-click install
npx skills add https://github.com/Sentry01/copilot-cli-skills --skill writing-plans-sentry01
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Sentry01/copilot-cli-skills/tree/main/writing-plans
Command: npx skills add https://github.com/Sentry01/copilot-cli-skills --skill writing-plans-sentry01

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of creating clear, actionable, and detailed implementation plans for software development tasks, ensuring engineers have all necessary information to proceed efficiently.

Core Features & Use Cases

  • Bite-sized Task Granularity: Breaks down complex tasks into small, manageable steps (e.g., writing a test, implementing code, committing).
  • Detailed Instructions: Provides exact file paths, code snippets, testing commands, and commit messages.
  • Use Case: When starting a new feature, use this skill to generate a step-by-step plan that includes creating new files, modifying existing ones, writing tests, and committing changes with appropriate messages.

Quick Start

Use the writing-plans skill to create an implementation plan for adding user authentication.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate a step-by-step implementation plan for a complex software feature?

Implementation plans break down complex software tasks into bite-sized steps. They provide exact file paths, code snippets, testing commands, and commit messages, ensuring engineers can execute multi-step development tasks efficiently without prior codebase context.

What is task breakdown in software development planning?

Task breakdown in development planning divides complex features into small, manageable actions like writing a test, implementing code, and committing. This granularity ensures every step includes exact file paths and instructions, allowing engineers to execute without prior domain knowledge.

How do I write a development plan that ensures engineers have zero codebase context?

To write a development plan for engineers with zero codebase context, include exact file paths, specific code snippets, testing commands, and commit messages for every granular action. This detailed instruction set provides all necessary information to proceed efficiently.

Does this implementation planning approach work for multi-step development tasks?

Yes, this approach is designed specifically for multi-step development tasks. It generates detailed step-by-step instructions encompassing file modifications, code generation, testing strategies, and commit strategies to guide engineers through complex software workflows.

What is the best way to structure commit messages and testing strategies in a development plan?

The best way to structure commit messages and testing strategies in a development plan is to integrate them directly into bite-sized task steps. Each granular action includes specific testing commands and appropriate commit instructions to maintain code quality throughout the workflow.

When do I need to use a detailed implementation plan for code generation?

You need a detailed implementation plan for code generation when starting new features that require modifying existing files, creating new ones, and writing tests. It ensures every granular action has exact file paths and instructions for engineers lacking codebase context.