writing-plans

Create structured implementation plans with task decomposition and parallel execution.

4|2|Updated May 4, 2026
One-click install
npx skills add https://github.com/zpyoung/quirk --skill writing-plans-zpyoung
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/zpyoung/quirk/tree/main/skills/writing-plans
Command: npx skills add https://github.com/zpyoung/quirk --skill writing-plans-zpyoung

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires quirk:subagent-driven-development, quirk:executing-plans, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill streamlines the creation and execution of implementation plans, ensuring clarity and efficiency in software development workflows.

Core Features & Use Cases

  • Plan Creation: Transforms specifications into structured task breakdowns.
  • Task Decomposition: Breaks down tasks into actionable steps with behavioral instructions.
  • Parallel Execution: Supports parallel execution for increased throughput.
  • Code Review: Ensures no runnable code is embedded, promoting better developer autonomy.
  • Use Case: Ideal for teams using 'quirk:subagent-driven-development' or 'quirk:executing-plans' to implement complex features, as it provides a framework for clear, executable plans.

Quick Start

/quirk:writing-plans: Create a new implementation plan for the 'Feature X' project.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
What is task decomposition in software development planning?

Task decomposition breaks down software development specifications into actionable steps with behavioral instructions. This process ensures implementation plans are clear, executable, and structured for parallel execution.

How do I create an implementation plan for a complex feature?

To create an implementation plan, provide your project specifications to the Skill. It transforms specifications into structured task breakdowns, ensuring the resulting plan is clear, executable, and contains no runnable code.

Do I need subagent-driven-development to execute parallel implementation plans?

Yes, executing the implementation plans requires dependencies like subagent-driven-development or executing-plans. These prerequisite frameworks handle the actual parallel execution of the structured tasks.

Why do implementation plans exclude runnable code?

Implementation plans exclude runnable code to promote better developer autonomy and ensure clear task boundaries. This approach enforces code review standards by separating planning instructions from actual code execution.

What's the best way to structure plans for parallel execution?

The best way to structure plans for parallel execution is automating task decomposition into actionable steps with behavioral instructions. This ensures clear, executable plans that support increased throughput without embedded code.

Can I use this implementation planning approach without an executing-plans framework?

No, you need an executing-plans framework like subagent-driven-development or executing-plans to run the generated plans. The Skill focuses solely on creating the structured task breakdowns rather than handling the execution itself.