writing-plans

Generate implementation plans with tasks, file paths, tests, and commits from specs.

2|Updated Apr 3, 2026
One-click install
npx skills add https://github.com/kscius/KS-Cursor-Orchestrator --skill writing-plans-kscius
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/kscius/KS-Cursor-Orchestrator/tree/main/skills/writing-plans
Command: npx skills add https://github.com/kscius/KS-Cursor-Orchestrator --skill writing-plans-kscius

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams generate concrete, implementation-ready plans from a spec or requirements before writing code, reducing ambiguity and rework.

Core Features & Use Cases

  • Generate task-by-task implementation plans with explicit files, steps, tests, and commits.
  • Support DRY, YAGNI-driven planning and separation of concerns.
  • Save plan documents to docs/plans in a consistent naming convention.
  • On-demand loading: Load this plan only when a task matches the spec, to avoid overhead.

Quick Start

Create a plan by following the Plan Document Header and Task Structure sections, then save it to docs/plans.

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 software spec before coding?

To generate an implementation plan from a spec, you create a structured plan artifact with a mandatory frontmatter header, detailing tasks, precise file paths, tests, and commit steps. This reduces ambiguity and rework by turning specs into bite-sized, actionable steps.

What is task decomposition in software implementation planning?

Task decomposition in implementation planning involves breaking down multi-step software requirements into explicit, bite-sized tasks. Each task defines specific files, steps, tests, and commit guidelines to ensure traceable progress and enforce separation of concerns before coding begins.

How do I structure multi-step software tasks with explicit files and tests?

You structure multi-step software tasks by following a strict plan document format that includes a frontmatter header and detailed task sections. Each section specifies precise file paths, required tests, and commit steps to guide development and ensure traceability across projects.

Does writing-plans support DRY and YAGNI principles for documentation?

Writing-plans supports DRY and YAGNI principles by guiding task decomposition to enforce separation of concerns and avoid overhead. It saves these structured plan documents to a consistent docs/plans directory using a standardized naming convention for on-demand loading.

When should I not use a structured implementation plan for coding?

You should avoid using a structured implementation plan for highly simple, single-step modifications that do not require task decomposition or risk awareness. Generating a formal plan artifact with frontmatter and commit steps introduces unnecessary overhead for trivial code updates.