writing-plans

Generate structured, test-driven implementation plans for software development tasks.

Updated Nov 22, 2025
One-click install
npx skills add https://github.com/tom-xs/nixos-dotfiles --skill writing-plans-tom-xs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/tom-xs/nixos-dotfiles/tree/main/ai/kimi-skills/skills/writing-plans
Command: npx skills add https://github.com/tom-xs/nixos-dotfiles --skill writing-plans-tom-xs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of disorganized, vague, or incomplete development tasks by enforcing a rigorous, plan-first approach that ensures every step is actionable, testable, and aligned with project requirements.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into bite-sized, reviewer-ready tasks with clear boundaries.
  • TDD Enforcement: Mandates a test-first workflow, ensuring every code change is verified by a failing-then-passing test cycle.
  • Use Case: When starting a new feature, use this skill to generate a comprehensive implementation plan that maps out file changes, interface definitions, and specific test cases before writing a single line of production code.

Quick Start

Use the writing-plans skill to generate an implementation plan for the new user authentication module based on the provided requirements document.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create a test-driven implementation plan for complex software features?

To create a test-driven implementation plan, decompose complex features into bite-sized, reviewer-ready tasks with clear boundaries, explicit interface definitions, and specific test cases mapped to file changes before writing production code.

What is the best way to enforce TDD and DRY principles in a multi-step development workflow?

Enforcing TDD and DRY principles in a multi-step workflow requires a plan-first approach that mandates a failing-then-passing test cycle for every code change, ensuring steps are actionable, testable, and aligned with architectural boundaries.

How does task decomposition work for multi-step engineering workflows?

Task decomposition for multi-step engineering workflows works by breaking complex features into granular, reviewer-ready tasks with clear architectural boundaries, ensuring each step satisfies explicit interface definitions and project requirements.

When do I need a plan-first approach for software development tasks?

You need a plan-first approach for software development tasks when facing disorganized or vague requirements, requiring rigorous task decomposition and explicit interface definitions to ensure every step is actionable and testable.

Can I use this planning approach for new feature development requiring clear architectural boundaries?

Yes, this planning approach is designed for complex feature development requiring clear architectural boundaries, generating a comprehensive implementation plan that maps out file changes and interface definitions based on your requirements.

Why does my development workflow lack actionable and testable task steps?

Your development workflow lacks actionable steps when tasks are incomplete or vague; applying a rigorous, plan-first approach ensures every step is verified by a failing-then-passing test cycle and aligned with project requirements.