planning

Decompose specs into actionable implementation plans with traceability.

Updated Mar 18, 2026
One-click install
npx skills add https://github.com/djwmobley/pipeline --skill planning-djwmobley
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: planning
Source: https://github.com/djwmobley/pipeline/tree/main/skills/planning
Command: npx skills add https://github.com/djwmobley/pipeline --skill planning-djwmobley

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Planning complex engineering work by turning specs into actionable, auditable steps that engineers can follow.

Core Features & Use Cases

  • Generate implementation plans with task granularity, required files, tests, and commit guidance.
  • Enforce architectural constraints and traceability to the original spec.
  • Create separate plan documents for subsystems when needed to keep scope clear.

Quick Start

Provide a feature spec and request a complete, task-by-task implementation plan.

Frequently Asked Questions about planning

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

FAQPage Schema
How do I turn feature specs into actionable implementation plans for engineers?

To turn feature specs into actionable implementation plans, decompose specifications into task-by-task steps that include required files, tests, and commit guidance. This enforces architectural constraints and maintains traceability to the original spec for build-ready sequencing.

What is task decomposition for engineering build sequence planning?

Task decomposition for engineering build sequence planning breaks end-to-end specifications into granular, actionable implementation tasks. It ensures each task includes required files and tests while maintaining strict traceability to the original architectural documentation.

How do I generate build-ready task sequencing from architectural documentation?

Generate build-ready task sequencing by analyzing architectural documentation and mapping dependencies into an ordered implementation plan. This creates separate plan documents for subsystems to keep scope clear and guide engineers through sequential commits.

Does this implementation planning approach work for complex subsystems?

Yes, implementation planning handles complex subsystems by creating separate plan documents for each subsystem. This keeps scope clear while enforcing architectural constraints and traceability across the entire end-to-end engineering project.

When do I need to create separate plan documents for subsystems?

Create separate plan documents for subsystems when a single feature spec covers multiple complex architectural components. This keeps scope clear, enforces traceability to the original spec, and provides engineers with focused, build-ready task sequencing.

What is the best way to enforce traceability to the original spec during implementation?

The best way to enforce traceability to the original spec is generating implementation plans that map every granular task back to the feature requirements. This ensures architectural constraints are met and build sequences remain auditable.