writing-plans

Generate risk-tiered implementation plans with file locations and test expectations.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/rahulsc/forge --skill writing-plans-rahulsc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/rahulsc/forge/tree/main/skills/writing-plans
Command: npx skills add https://github.com/rahulsc/forge --skill writing-plans-rahulsc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of translating approved designs into clear, executable implementation plans, ensuring that developers have precise instructions before writing code.

Core Features & Use Cases

  • Detailed Task Decomposition: Breaks down complex features into bite-sized, manageable tasks.
  • Risk-Aware Planning: Classifies plan risk and adjusts required artifacts accordingly.
  • File Structure Guidance: Dictates optimal file organization for clarity and maintainability.
  • Use Case: After a design for a new user authentication module is approved, this Skill generates a detailed plan outlining each step, the files to be created or modified, and the specific test expectations for each task.

Quick Start

Use the writing-plans skill to create an implementation plan for the 'user-profile-update' feature.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create an implementation plan from an approved software design?

To create an implementation plan from an approved design, you need detailed task decomposition that specifies file locations, task granularity, and test expectations. This translates designs into executable steps by focusing on what and where rather than how.

What is risk-aware task decomposition in software development planning?

Risk-aware task decomposition is the process of breaking complex features into manageable tasks while classifying plan risk levels. It adjusts required artifacts accordingly, ensuring developers receive risk-tiered instructions that clarify dependencies and test expectations before coding.

How do I structure implementation tasks for team-based execution workflows?

Structuring implementation tasks for team-based execution involves defining task dependencies and performing wave analysis. This organizes file modifications and development steps into parallel workstreams, ensuring team members can execute tasks without blocking each other.

Does this implementation planning approach dictate exact file structure and locations?

Yes, this implementation planning approach dictates optimal file organization by specifying exact file locations for created or modified components. It provides file structure guidance to ensure maintainability and clarity for developers before they begin writing code.

When do I need to generate a risk-tiered plan for a new software feature?

You need to generate a risk-tiered plan when translating approved designs into executable development steps. It is essential when complex features require precise instructions, specific test expectations, and clear task dependencies to mitigate potential implementation risks.

Can I use this for serial execution workflows or is it limited to team development?

You can use this for both serial and team-based execution workflows. The plan defines task dependencies and wave analysis to support parallel team workstreams, while also providing the sequential task granularity needed for independent serial development.