writing-plans

Name: writing-plans
Availability: InStock
Author: thisismynewfmail-ui

Generate step-by-step implementation plans with exact file paths and code examples.

Updated Apr 12, 2026

Search Tags:#tdd #documentation #code-examples #task-breakdown #file-paths #subagent-driven-development #implementation-plans

Ready to run

npx skills add https://github.com/thisismynewfmail-ui/Monika-agent --skill writing-plans-thisismynewfmail-ui

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/thisismynewfmail-ui/Monika-agent/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/thisismynewfmail-ui/Monika-agent --skill writing-plans-thisismynewfmail-ui

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Ambiguous or incomplete specifications and feature requests make multi-step implementations error-prone, slow, and hard to delegate; this Skill turns specs into explicit, verifiable plans so implementers never have to guess what to change or how to verify it.

Core Features & Use Cases

Bite-sized tasks: Break features into 2–5 minute actionable steps including exact actions and commit points.
Complete examples & paths: Provide exact file paths and copy-pasteable code snippets for each step, plus test-first instructions.
Verification & delivery: Include precise test commands, expected outputs, and commit guidance so reviewers can validate each task.
Use cases include onboarding a new contributor, delegating work to subagents, implementing complex refactors, and producing reproducible feature rollouts.

Quick Start

Create an implementation plan from a feature spec that lists each 2–5 minute task, exact file paths to create or modify, full test-first code examples, the commands to run for verification, and a commit message for each step.

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 software feature specification into actionable implementation steps?▼

Implementation plans break feature specifications into granular 2-5 minute actionable steps. Each step includes exact file paths to modify, complete copy-pasteable code examples, test-first instructions, and commit points so developers never have to guess what to change.

What is the best way to delegate complex coding tasks to subagents without losing context?▼

Generating comprehensive step-by-step implementation plans provides delegated subagents with exact file paths, full code examples, and verification commands. This explicit, verifiable plan format ensures implementers have little or no context but can still execute tasks accurately.

How do I create test-driven development plans with exact file paths and verification commands?▼

Test-driven development plans provide full test-first code examples for each step, precise test commands to run, and expected outputs. This format ensures reviewers can validate every task by running the specified commands and checking the results against the plan.

Can I use implementation plans for onboarding new contributors to a multi-step codebase refactor?▼

Implementation plans support onboarding new contributors by breaking complex refactors into bite-sized tasks with exact actions and commit points. The plans include complete examples and paths, making multi-step implementations reproducible and easy to follow.

What should an implementation plan include to ensure reproducible feature rollouts?▼

Reproducible feature rollouts require implementation plans to include exact file paths, copy-pasteable code snippets, test-first instructions, verification commands, and commit guidance. This ensures every step is verifiable and the rollout can be tracked progressively.

Why does ambiguous feature request specification make multi-step software implementation error-prone?▼

Ambiguous or incomplete specifications force implementers to guess what to change and how to verify it, slowing down multi-step implementations. Generating explicit, verifiable plans with exact actions and test commands eliminates this guessing and reduces errors.