writing-plans

Create implementation plans for multi-step software tasks with file paths and test commands.

Updated Jun 30, 2026
One-click install
npx skills add https://github.com/JiangAustin/Money_Never_Sleep --skill writing-plans-jiangaustin
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/JiangAustin/Money_Never_Sleep/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/JiangAustin/Money_Never_Sleep --skill writing-plans-jiangaustin

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns a spec or feature request into a concrete implementation plan so engineers can start building without guessing, losing context, or missing required steps.

Core Features & Use Cases

  • Breaks a large requirement into small, testable tasks with clear file-level responsibilities.
  • Captures the files to create or modify, the tests to write, and the commands to run before and after each change.
  • Helps when you need a plan for a new feature, a refactor, or a multi-step change that spans several parts of a repository.

Quick Start

Ask the skill to create an implementation plan for your feature spec, and it will return a step-by-step document you can hand directly to an engineer.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn a feature specification into a build-ready implementation plan?

To turn a feature specification into an implementation plan, provide the spec to generate a task-by-task document with file paths, test commands, and execution order. It breaks large requirements into small, testable tasks with clear file-level responsibilities.

What is the best way to plan a multi-step architecture change across an existing repository?

Planning a multi-step architecture change involves splitting the work across files, tests, and validation steps while respecting existing codebase structure. This approach produces task-by-task guidance that captures required modifications and execution order.

How do I break down a large refactor into testable tasks with clear file-level responsibilities?

Breaking down a large refactor requires splitting the requirement into small, testable tasks. The process captures the files to modify, the tests to write, and the commands to run before and after each change to ensure clear file-level responsibilities.

Can I generate test-driven development plans that include specific test commands?

Yes, generating test-driven development plans includes capturing the specific test commands to run before and after each modification. The resulting plan provides step-by-step guidance for writing tests and executing validation steps.

Does planning a multi-file feature update respect existing codebase structure?

Yes, planning a multi-file feature update respects existing codebase structure and planning boundaries. It evaluates the current repository layout to produce task-by-task guidance that aligns with your current architecture and file paths.