planning

Organize confirmed designs into dependency-ordered TDD tasks with failing tests.

4|1|Updated Apr 7, 2026
One-click install
npx skills add https://github.com/NSObjects/specpowers --skill planning-nsobjects
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: planning
Source: https://github.com/NSObjects/specpowers/tree/main/skills/planning
Command: npx skills add https://github.com/NSObjects/specpowers --skill planning-nsobjects

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents premature coding by translating reviewed specs and designs into a disciplined planning sprint that ensures every change ties back to a scenario and includes test-first steps.

Core Features & Use Cases

  • Spec coverage mapping: Every Task must declare which Spec Scenario it addresses, creating a traceable chain from requirements to implementation.
  • TDD-ready decomposition: Plans include failing tests, explicit implementation code, and gated steps that teach the agent to produce concrete deliverables.
  • Dependency-aware ordering: Tasks are ordered by infrastructure, core logic, wiring, and edge cases so each commit compiles independently before execution.

Quick Start

Use the planning skill to convert the reviewed spec and design into sorted TDD tasks for implementation readiness.

Frequently Asked Questions about planning

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

FAQPage Schema
How do I decompose software design into TDD tasks?

Task decomposition for spec-driven development requires translating reviewed designs into bite-sized work items. Each item must declare its corresponding spec scenario, include a failing test, and be ordered by dependencies so every commit compiles independently.

What is spec coverage mapping in a planning sprint?

Spec coverage mapping is the process of linking every development task to a specific spec scenario. It creates a traceable chain from requirements to implementation, preventing premature coding by ensuring no work begins without a corresponding test-first step.

How do I order development tasks by dependencies?

Order development tasks by sequencing infrastructure first, followed by core logic, then wiring, and finally edge cases. This dependency-aware ordering ensures that each task builds on a completed foundation and produces a compilable commit independently before moving forward.

Do I need a reviewed spec before task decomposition?

Yes, task decomposition requires a reviewed spec and confirmed design intent before beginning. The planning stage applies only when design intent is agreed upon, ensuring the generated TDD tasks have concrete deliverables tied to valid requirements rather than placeholders.

Why does my test-first planning include placeholder steps?

Test-first planning includes placeholders when task decomposition lacks failing tests or spec scenario mapping. Replacing them requires mapping each task to specific requirements and generating explicit implementation code with gated steps to produce concrete deliverables.