planning-decision-tree

Decompose software tasks into stub creation and logic implementation phases.

4|Updated Dec 17, 2025
One-click install
npx skills add https://github.com/MatrixFounder/Agentic-development --skill planning-decision-tree
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: planning-decision-tree
Source: https://github.com/MatrixFounder/Agentic-development/tree/main/.agent/skills/planning-decision-tree
Command: npx skills add https://github.com/MatrixFounder/Agentic-development --skill planning-decision-tree

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured approach to breaking down complex tasks into manageable sub-tasks and prioritizing them effectively, ensuring a clear development path.

Core Features & Use Cases

  • Task Decomposition: Splits functional requirements into "Stub Creation" and "Logic Implementation" phases.
  • Prioritization Framework: Defines a clear order for tackling tasks, from critical architecture to medium-priority edge cases.
  • Use Case: When faced with a large feature request, this Skill helps you first define the structure and stubs, then implement the actual logic, ensuring a robust and testable development process.

Quick Start

Use the planning-decision-tree skill to break down the task of implementing user authentication.

Frequently Asked Questions about planning-decision-tree

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

FAQPage Schema
How do I break down complex software development tasks into manageable sub-tasks?

Task decomposition splits functional requirements into stub creation and logic implementation phases, ensuring a structured development path. This approach helps manage complex software tasks by defining structure first, then implementing actual logic.

What's the best way to prioritize development workflow when facing a large feature request?

Prioritization frameworks define a clear order for tackling tasks based on criticality, dependencies, and complexity. They guide prioritizing work from critical architecture down to medium-priority edge cases when handling large feature requests.

When do I need to use a stub-first development approach for task breakdown?

A stub-first approach is needed when decomposing tasks to ensure a robust and testable development process. It guides the agent to split requirements into stub creation and logic implementation phases for structured project planning.

Can I use this task decomposition method for structuring user authentication implementation?

Yes, task decomposition can break down user authentication implementation by first defining the structure and stubs, then implementing the actual logic. This ensures a clear development path for complex features.

How does prioritization by criticality and dependencies improve project planning?

Prioritization by criticality and dependencies improves project planning by establishing a clear hierarchy from critical architecture to medium-priority edge cases. This ensures a clear development path and structured execution.

Are there limitations to using a decision tree for software task prioritization?

Decision trees for task prioritization focus on splitting requirements into stubs and logic phases based on dependencies and complexity. They are designed for structured project planning but may not cover every dynamic execution scenario.