writing-plans

Create detailed implementation plans from specs with file-level guidance.

Updated Jun 1, 2026
One-click install
npx skills add https://github.com/atro2829-hub/APPLE-NET-NEW --skill writing-plans-atro2829-hub
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/atro2829-hub/APPLE-NET-NEW/tree/main/skills/writing-plans
Command: npx skills add https://github.com/atro2829-hub/APPLE-NET-NEW --skill writing-plans-atro2829-hub

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you turn a spec or set of requirements into a concrete implementation plan before any code changes begin. It is designed for situations where the engineer needs clear direction, exact file targets, and a disciplined task sequence.

Core Features & Use Cases

  • Implementation Planning: Breaks a feature into small, actionable steps that can be executed and reviewed one by one.
  • File-Level Guidance: Specifies exactly which files to create, modify, and test so the work stays scoped and traceable.
  • Test-Driven Workflow: Organizes each task around failing tests, minimal implementation, verification, and commit steps.
  • Use Case: A developer receives a multi-step feature request and uses this Skill to produce a detailed plan in docs/plans/ that another engineer can follow without prior context.

Quick Start

Use the writing-plans skill to create a detailed implementation plan for my feature request and save it in the required docs/plans format.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn software requirements into an implementation plan before coding?

To turn software requirements into an implementation plan, you need a structured approach that breaks features into actionable, file-level steps. This Skill generates execution plans with exact path targeting and saves them under docs/plans for disciplined development.

What is the best way to break down a multi-step feature request for another engineer?

The best way to break down a multi-step feature request is creating a commit-ready task breakdown with file-by-file guidance. This ensures another engineer can execute the work sequentially without prior context using explicit verification commands.

How does test-driven development fit into creating an implementation plan?

Test-driven development fits into implementation planning by organizing each task around failing tests, minimal implementation, verification, and commit steps. This enforces a disciplined task sequence where file modifications are validated before proceeding.

Can I use this planning approach for single-file code changes?

This planning approach is not designed for single-file code changes. It applies specifically to multi-step software tasks requiring file-by-file guidance and a disciplined task sequence to maintain scope and traceability across multiple modifications.

Do I need to specify exact file paths when generating a task breakdown?

Yes, you need to specify exact file paths because this planning process requires exact path targeting. It designates exactly which files to create, modify, and test so the implementation work stays scoped, traceable, and commit-ready.