task-breakdown

Break down large work into session-sized tasks with verification mappings.

Updated Apr 9, 2026
One-click install
npx skills add https://github.com/ldmrepo/agent-harness --skill task-breakdown-ldmrepo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-breakdown
Source: https://github.com/ldmrepo/agent-harness/tree/main/template/.claude/skills/task-breakdown
Command: npx skills add https://github.com/ldmrepo/agent-harness --skill task-breakdown-ldmrepo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Converts large, vague, or tightly coupled backlog items into small, bounded, and verifiable session-sized tasks so planners and coding agents can implement, verify, and hand off work safely and predictably.

Core Features & Use Cases

  • Structured Decomposition: Identify split axes (user flow, API contract, state boundary, verification boundary) and draft candidate subtasks with explicit scope and dependencies.
  • Verification-First Scoping: Require a clear verification path for each task and map tasks to smoke, unit, integration, E2E, or full verification gates.
  • Planning Integration: Update backlog, feature lists, and current-task artifacts and recommend the first selectable task for execution.
  • Use Case: During backlog refinement, convert an overscoped feature into a prioritized set of session-sized tasks with completion criteria and verification commands.

Quick Start

Use the task-breakdown skill to split the selected backlog item into session-sized tasks with clear scope, dependencies, and verification steps.

Frequently Asked Questions about task-breakdown

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

FAQPage Schema
How do I break down large backlog items into verifiable session tasks?

Break down large backlog items by identifying split axes like user flow or API contract, then drafting candidate subtasks with explicit scope, dependencies, and completion criteria. Each session task receives a clear verification path mapped to smoke, unit, or integration gates.

What is the best way to scope ambiguous coding tasks for safe handoff?

Scoping ambiguous coding tasks requires converting them into bounded session-sized chunks with explicit verification mappings. You apply structured decomposition to define priority and dependencies, producing artifacts compatible with repository verification commands for predictable handoff.

How does verification-first task scoping work for backlog refinement?

Verification-first task scoping requires a clear verification path for each decomposed task before execution. It maps backlog items to smoke, unit, integration, E2E, or full verification gates, ensuring every session-sized task has explicit completion criteria and test boundaries.

Do I need a planner to decompose tightly coupled features into subtasks?

You do not need an external planner to decompose coupled features. The skill acts as a planner-led decomposition tool, analyzing state boundaries and verification boundaries to generate structured task artifacts with IDs, priorities, and dependency mappings.

Can I use task-breakdown for recovery from overscoped coding sessions?

You can use it to recover from overscoped coding sessions by splitting oversized work into prioritized, bounded tasks. It updates current-task artifacts and recommends the first selectable task for execution to safely resume implementation.

What limitations exist when splitting work along API contract boundaries?

Splitting work along API contract boundaries depends on identifying clear state and verification boundaries. If the tightly coupled backlog items lack distinct split axes or clear verification paths, generating bounded session-sized tasks with explicit scope becomes difficult.