writing-plans

Generate executable implementation plans with files, tasks, tests, and commit strategy.

3|Updated Apr 20, 2026
One-click install
npx skills add https://github.com/mor-duongmh/morkit-plugin --skill writing-plans-mor-duongmh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/mor-duongmh/morkit-plugin/tree/main/plugins/morkit/skills/writing-plans
Command: npx skills add https://github.com/mor-duongmh/morkit-plugin --skill writing-plans-mor-duongmh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps engineers turn vague specifications into detailed, executable implementation plans that outline the required files, testing strategy, and commit sequence.

Core Features & Use Cases

  • Plan generation: Create structured, step-by-step tasks from a project brief.
  • File and task decomposition: Map the work into specific files and clear responsibilities.
  • TDD-aligned planning: Emphasize tests, documentation, and frequent commits to drive quality.
  • Use Case: Given a feature description, generate a plan that lists the touched files, code changes, tests, and verification steps.

Quick Start

Provide a feature description and request a full implementation plan.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate an implementation plan from a feature specification?

To generate an implementation plan from a feature specification, provide the feature description to receive a structured breakdown detailing required files, specific tasks, testing strategy, and commit sequence. This decomposes vague project briefs into explicit, executable steps for developers.

What is test-driven development planning for software projects?

Test-driven development planning is structuring implementation steps to emphasize tests, documentation, and frequent commits before writing code. It maps feature specifications into clear file responsibilities and verification steps to drive code quality throughout the project lifecycle.

Can I use task decomposition planning for both new features and subsystem improvements?

Yes, you can use task decomposition planning for both new features and subsystem improvements across software projects of varying sizes. It maps work into specific files and clear responsibilities, generating explicit steps and file paths suitable for any project scale.

How do I map required files and code changes for a new project brief?

You map required files and code changes by transforming a project brief into an actionable implementation plan. The plan lists touched files, specific code modifications, required tests, and verification steps, providing a clear commit sequence to follow.

What is the best way to structure an executable implementation plan?

The best way to structure an executable implementation plan is to break down specifications into explicit step-by-step tasks, file paths, and a clear testing and commit strategy. This ensures the generated plan can be directly followed by a developer.