writing-plans

Create file-specific implementation plans with validation commands and commit points.

1|Updated Apr 7, 2026
One-click install
npx skills add https://github.com/fartmonarch/RenderMind --skill writing-plans-fartmonarch
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/fartmonarch/RenderMind/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/fartmonarch/RenderMind --skill writing-plans-fartmonarch

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you turn a specification or multi-step request into a concrete implementation plan before writing code, so an engineer can work from clear steps instead of guesswork.

Core Features & Use Cases

  • Scope separation: Splits broad requirements into independent subprojects when a spec spans multiple subsystems.
  • File-level planning: Lists the exact files to create or modify and explains the responsibility of each one.
  • Step-by-step execution: Breaks work into small, testable tasks with commands, expected results, and commit points.
  • Use case: Use it when you need a detailed rollout plan for a new feature, refactor, bugfix, or tooling change in an unfamiliar repository.

Quick Start

Ask me to create a detailed implementation plan for your feature or specification before you start coding.

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 vague software specification into an executable implementation plan?

A vague specification is transformed into an executable implementation plan by splitting requirements into independent subprojects. It then produces file-specific, step-by-step tasks with validation commands and commit points for engineers.

How do I plan multi-step feature work across multiple files in an unfamiliar codebase?

To plan multi-step feature work in an unfamiliar codebase, you separate broad requirements into subprojects and list exact files to modify. The plan then provides step-by-step execution tasks with expected results and commit points.

What is the best way to break down a complex software refactor into testable tasks?

Breaking down a complex software refactor involves generating step-by-step execution instructions. It separates broad requirements into subprojects and breaks work into small, testable tasks with commands and review checkpoints.

Can I use this to plan rollout steps for a new feature before writing code?

Yes, you can plan rollout steps for a new feature before writing code. It creates detailed implementation plans covering tasks that span multiple files, tests, documentation, and rollout steps.

Does this planning approach work for splitting broad requirements into independent subprojects?

Yes, this planning approach handles splitting broad requirements into independent subprojects when a specification spans multiple subsystems. It then generates file-level planning and step-by-step execution instructions.

When should I not use an automated implementation plan for software changes?

You should not use an automated implementation plan for single-file edits or trivial bugfixes. It is designed for multi-step software changes and feature work that span multiple files, tests, and documentation in unfamiliar repositories.