deep-planning

Decompose complex multi-step tasks into verifiable milestones with risk-first sequencing.

Updated Dec 21, 2018
One-click install
npx skills add https://github.com/dhnt/dhnt --skill deep-planning-dhnt
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-planning
Source: https://github.com/dhnt/dhnt/tree/main/catalog/md/plan/deep-planning
Command: npx skills add https://github.com/dhnt/dhnt --skill deep-planning-dhnt

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Deep-planning helps you slow down before committing to an ambitious, multi-step change by turning vague goals into verifiable milestones and challenging risky assumptions.

Core Features & Use Cases

  • Assumption surfacing and validation: identifies what must be true and what breaks if those beliefs are wrong.
  • Milestone-based decomposition: converts the work into checkpoints with clear “done when” verification gates.
  • Risk-first sequencing via spikes: designs an early exploration of the biggest unknown and schedules uncertain steps before predictable ones.
  • Alignment and definition of done: specifies what success looks like and sets boundaries on what the plan will not do.

Quick Start

Use deep-planning when you’re about to refactor an important subsystem or execute a migration and want a short, verification-oriented plan you can get sign-off on before starting.

Frequently Asked Questions about deep-planning

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

FAQPage Schema
How do I plan a complex software migration to avoid expensive mistakes?

Plan a complex software migration by restating goals, challenging assumptions, and decomposing work into verifiable milestones with explicit verification gates. This risk-first sequencing schedules uncertain steps before predictable ones to minimize surprises.

What is the best way to decompose an architectural refactor into manageable steps?

Decompose an architectural refactor by converting work into ordered milestones with clear 'done when' verification gates. Sequencing milestones risk-first ensures uncertain work is explored early via spikes before predictable steps are scheduled.

Why do I need assumption testing before starting a multi-step project?

Assumption testing identifies what must be true for your project to succeed and what breaks if those beliefs are wrong. Surfacing and validating assumptions before starting prevents costly rework during complex architectural changes or migrations.

Does this risk-first planning approach work for small codebase updates?

This risk-first planning approach is designed for complex multi-step tasks where undoing mistakes would be expensive. Small codebase updates do not require explicit verification gates, milestone decomposition, or spike planning for unknowns.

When should I not use deep-planning for software refactoring?

Avoid deep-planning for software refactoring when the work is predictable, edge cases are unlikely, or undoing mistakes would be inexpensive. It is unnecessary when a simple task list suffices without assumption testing or spike exploration.