skills.rest
1J6K21
1J6K21COMMUNITY
Explore all skills by this author →
GitHub

planning-and-task-breakdown

Decompose large specifications into ordered tasks with acceptance criteria and dependency mapping.

Updated Mar 28, 2026
Search Tags:#planning#checkpoints#estimation#acceptance-criteria#task-breakdown#dependency-graph#vertical-slicing
One-click install
npx skills add https://github.com/1J6K21/build4good --skill planning-and-task-breakdown-1j6k21
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: planning-and-task-breakdown
Source: https://github.com/1J6K21/build4good/tree/main/.gemini/skills/planning-and-task-breakdown
Command: npx skills add https://github.com/1J6K21/build4good --skill planning-and-task-breakdown-1j6k21

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Large, vague, or multi-component work items are hard to start, estimate, and coordinate, which leads to rework, missed dependencies, and unpredictable delivery. This Skill provides a structured planning approach that prevents tangled implementations by decomposing work into small, testable tasks with clear acceptance criteria and verification steps. It helps teams and agents make progress incrementally and in parallel without breaking shared contracts.

Core Features & Use Cases

  • Dependency mapping: Identify and order component dependencies so implementation proceeds bottom-up.
  • Vertical slicing: Create end-to-end feature slices that deliver working functionality incrementally.
  • Task templates: Produce tasks with description, acceptance criteria, verification steps, estimated scope, and likely files touched.
  • Checkpoints & sizing: Insert verification checkpoints and size tasks (XS–XL) to keep work achievable and reviewable.
  • Use Case: Given a new user registration feature, produce a phased plan that includes schema changes, API endpoints, UI components, tests, and checkpoints to enable parallel work by backend and frontend engineers.

Quick Start

Break the feature into a short plan by listing dependency-first tasks with acceptance criteria and a verification step for each one.

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 a large software specification into implementable tasks?▼

You can break down large specs by decomposing them into small, verifiable units with acceptance criteria, verification steps, and dependency mapping. This structured planning approach prevents tangled implementations and enables incremental delivery.

What is vertical slicing in task breakdown and when should I use it?▼

Vertical slicing creates end-to-end feature slices that deliver working functionality incrementally. Use it when decomposing vague requirements into testable steps to ensure progress is achievable, reviewable, and coordinated across parallel developers or agents.

How do I map dependencies and estimate scope for parallel software development?▼

Map dependencies by ordering component relationships bottom-up, then size tasks from XS to XL with checkpoints. This sizing guidance keeps work achievable while dependency mapping enables parallel implementation without breaking shared contracts.

Can I use this task breakdown approach for coordinating work across multiple agents?▼

Yes, this approach supports parallelizing work across agents or developers by producing ordered task lists with clear acceptance criteria and dependency mapping. It ensures agents make progress incrementally without breaking shared contracts.

What should a task template include to convert ambiguous requirements into testable steps?▼

A task template should include a description, acceptance criteria, verification steps, estimated scope, and likely files touched. Adding checkpoints enforces incremental delivery and ensures each task is verifiable.

Why does my multi-component feature plan have missed dependencies and rework?▼

Missing dependency mapping in feature plans causes missed dependencies and rework. Decomposing work into ordered, testable tasks with bottom-up component ordering and verification checkpoints prevents tangled implementations and unpredictable delivery.

Related Skills

Explore More Software Engineering Skills→
appautomatonappautomaton
37

auto-plan

Convert project specifications into ordered, verifiable execution slices.

Official
Advanced
tomguntomgun

planning-features

Create implementation plans for software features with scope, files, acceptance criteria, and risks.

Community
Intermediate
MasterCodeYodaMasterCodeYoda
3

workflow-guide

Guide software development workflows across planning, execution, and review phases.

Community
Advanced
jmanuelrosajmanuelrosa
2

planning-and-task-breakdown

Decompose specifications into verifiable tasks with acceptance criteria and dependency graphs.

Community
Advanced