planning-and-task-breakdown

Break software requirements into ordered, verifiable tasks with acceptance criteria.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/kamelmh/opencode --skill planning-and-task-breakdown-kamelmh
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: planning-and-task-breakdown
Source: https://github.com/kamelmh/opencode/tree/main/skills/planning-and-task-breakdown
Command: npx skills add https://github.com/kamelmh/opencode --skill planning-and-task-breakdown-kamelmh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents vague work planning by converting requirements into small, verifiable tasks with explicit acceptance criteria, reducing rework and hidden dependencies.

Core Features & Use Cases

  • Structured implementation planning: Builds a step-by-step plan that decomposes work into tasks the team can execute and verify.
  • Dependency graph mapping: Identifies ordering constraints so foundations are built before dependent features.
  • Vertical slicing for end-to-end value: Groups tasks into complete feature paths that are testable and deliver working increments.
  • Operational task format with verification: Produces tasks that include acceptance criteria, verification steps, dependencies, likely files touched, and estimated scope.
  • Checkpointing and risk ordering: Inserts checkpoints after key phases and places higher-risk tasks earlier to fail fast.

Quick Start

Use planning-and-task-breakdown to produce an implementation plan with numbered tasks and acceptance criteria for the feature you want to ship, based on the spec you provide.

Frequently Asked Questions about planning-and-task-breakdown

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

FAQPage Schema
How do I break down software requirements into actionable tasks for implementation?▼

To break down software requirements into actionable tasks, you can decompose specs into verifiable items with explicit acceptance criteria. This structured implementation planning reduces ambiguity and hidden dependencies by ensuring each task includes verification steps and maps to a dependency graph.

What is vertical slicing in project execution and when should I use it?▼

Vertical slicing in project execution groups tasks into complete, end-to-end feature paths that deliver working increments. Use vertical slicing during implementation planning to ensure features are testable early and deliver value independently of the full system dependency graph.

How do I create a dependency graph for software task sequencing?▼

Create a dependency graph for software task sequencing by identifying ordering constraints before execution begins. Mapping dependencies ensures foundational components are built before dependent features, allowing for parallel execution where possible and reducing hidden blockers.

What's the best way to reduce ambiguity and rework in software work planning?▼

The best way to reduce ambiguity and rework in work planning is converting requirements into small, verifiable tasks with explicit acceptance criteria. Adding checkpointing after key phases and placing higher-risk tasks earlier ensures you fail fast and validate scope.

Can I use task breakdown for parallel execution across systems with dependencies?▼

Yes, you can use task breakdown for parallel execution across systems with dependencies. By articulating a dependency graph and ordering constraints, the structured plan allows independent tasks to run in parallel while maintaining explicit verification steps.