writing-plans

Generates step-by-step implementation plans with file modifications, tests, and commit messages for software tasks.

Updated Jan 30, 2026
One-click install
npx skills add https://github.com/andrescardonas7/salchipapa-web --skill writing-plans-andrescardonas7
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/andrescardonas7/salchipapa-web/tree/main/.cursor/skills/writing-plans
Command: npx skills add https://github.com/andrescardonas7/salchipapa-web --skill writing-plans-andrescardonas7

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill generates comprehensive, step-by-step implementation plans for software development tasks, ensuring clarity and reducing the need for prior codebase knowledge.

Core Features & Use Cases

  • Detailed Task Breakdown: Divides complex features into small, manageable, bite-sized tasks.
  • Code & Test Guidance: Specifies exactly which files to modify and provides example code for tests and implementation.
  • Use Case: When a new feature is defined, use this Skill to create a detailed plan that any developer can follow to implement it, including specific commit messages and testing instructions.

Quick Start

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

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a complex software feature into manageable implementation steps?

Implementation plans divide complex software features into small, bite-sized tasks. This approach outlines specific file modifications, test cases, and commit messages for each step, ensuring any developer can follow the progression without prior codebase knowledge.

How does test-driven development planning work for new software features?

Test-driven development planning specifies exact files to modify and provides example code for tests before implementation. It ensures adherence to TDD, DRY, and YAGNI principles by outlining specific test cases and testing instructions for each development step.

What is the best way to document software development tasks for developers unfamiliar with the codebase?

Documenting software development tasks with detailed implementation plans ensures clarity and reduces the need for prior codebase knowledge. Plans outline specific file modifications, example code, and commit messages, allowing any developer to execute the work.

Can I generate implementation plans that include specific commit messages and testing instructions?

Yes, implementation plans can be generated to include specific commit messages and testing instructions. They specify exactly which files to modify and provide example code for both tests and implementation to guide the developer through each step.

Do I need prior context about a codebase to create a detailed task breakdown?

No prior context is needed to create a detailed task breakdown. The planning process assumes minimal prior codebase knowledge and generates comprehensive, step-by-step plans that outline specific modifications and tests.

When should I not use detailed implementation plans for software development?

Detailed implementation plans may be unnecessary for trivial changes or rapid prototyping where strict adherence to TDD, DRY, and YAGNI principles is not required. They are best suited for complex features needing clear, structured task breakdowns.