planning-and-task-breakdown
Systematically decompose large tasks into manageable vertical slices.
Install
mkdir -p .claude/skills/planning-and-task-breakdown-hayderncenterpoint && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/16297" && unzip -o skill.zip -d .claude/skills/planning-and-task-breakdown-hayderncenterpoint && rm skill.zipInstalls to .claude/skills/planning-and-task-breakdown-hayderncenterpoint
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Break work into small, verifiable vertical slices with acceptance criteria and verification steps. Use when you have a spec or large task that needs decomposition. Trigger phrases: "break down", "create plan", "task breakdown", "implementation plan", "plan the work".Key capabilities
- →Decompose large tasks into small, verifiable vertical slices
- →Define specific and testable acceptance criteria for each task
- →Specify verification steps and commands for tasks
- →Identify and order task dependencies
- →Create implementation plans with phases and checkpoints
- →Assess risks and define mitigations for the plan
How it works
This skill provides templates and guidance for breaking down work into vertical slices, defining acceptance criteria, verification steps, and creating structured implementation plans with checkpoints and risk assessments.
Inputs & outputs
When to use planning-and-task-breakdown
- →Break down large feature
- →Create implementation plan
- →Decompose vague task
About this skill
Planning and Task Breakdown
Decompose work into small, verifiable tasks with explicit acceptance criteria. Good task breakdown is the difference between reliable completion and a tangled mess.
When to Use
- Have a spec and need to break into implementable units
- Task feels too large or vague to start
- Work needs parallelization
- Need to communicate scope
Vertical Slicing
Good (vertical):
Task 1: User can create account (schema + API + UI)
Task 2: User can log in (auth + API + UI)
Task 3: User can view profile (query + API + UI)
Bad (horizontal):
Task 1: Build entire database schema
Task 2: Build all API endpoints
Task 3: Build all UI components
Task Template
## Task [N]: [Title]
**Description:** One paragraph on what this accomplishes.
**Acceptance criteria:**
- [ ] Specific, testable condition 1
- [ ] Specific, testable condition 2
**Verification:**
- [ ] Tests pass: [command]
- [ ] Build succeeds: [command]
**Dependencies:** Task numbers or "None"
**Files likely touched:** [list]
**Estimated scope:** S/M/L (1-2 / 3-5 / 5+ files)
Task Sizing
| Size | Files | Scope | Example |
|---|---|---|---|
| S | 1-2 | One component | Add validation rule |
| M | 3-5 | One feature slice | User registration |
| L | 5+ | Too large — break down | — |
Plan Template
# Implementation Plan: [Feature]
## Overview
One paragraph summary.
## Task List
### Phase 1: Foundation
- [ ] Task 1: ...
- [ ] Task 2: ...
### Checkpoint: Foundation
- [ ] Tests pass, builds clean
### Phase 2: Core Features
- [ ] Task 3: ...
- [ ] Task 4: ...
### Checkpoint: Core Features
- [ ] End-to-end flow works
## Risks and Mitigations
| Risk | Impact | Mitigation |
|------|--------|-----------|
| [risk] | [H/M/L] | [strategy] |
## Open Questions
- [question needing input]
Dependency Graph
Map what depends on what:
Database schema
│
├── API models
│ │
│ ├── API endpoints
│ │ │
│ │ └── Frontend API client
│ │
│ └── Validation logic
│
└── Seed data
Build bottom-up: foundations first.
Checkpoints
Add explicit checkpoints between phases:
### Checkpoint: After Tasks 1-3
- [ ] All tests pass
- [ ] Application builds
- [ ] Review with human before proceeding
Parallelization
| Safe to Parallelize | Must Be Sequential |
|---|---|
| Independent slices | Database migrations |
| Tests for existing code | Shared state changes |
| Documentation | Dependency chains |
Verification Checklist
- Every task has acceptance criteria
- Every task has verification step
- Dependencies identified and ordered
- No task > ~5 files
- Checkpoints exist between phases
- Human reviewed and approved plan
Grok-Specific Guidance
- Always use the
todo_writetool (withmerge: truefor updates) to surface the task list visibly to the user. Use stable IDs liketask-1,phase-foundation. - After breaking down, immediately call
todo_writeto initialize the list with statuses. - For large plans, also write a markdown plan file using the template above.
When not to use it
- →When the task is already small and well-defined
- →When the user does not need a detailed breakdown
- →When horizontal slicing is preferred over vertical slicing
Limitations
- →Tasks should not exceed ~5 files in scope
- →Requires explicit checkpoints between phases
- →Requires human review and approval of the plan
How it compares
This skill enforces a vertical slicing approach and provides detailed templates for task and plan creation, ensuring work is broken down into testable units with clear verification, unlike ad-hoc task decomposition.
Compared to similar skills
planning-and-task-breakdown side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| planning-and-task-breakdown (this skill) | 0 | 2mo | No flags | Intermediate |
| pmbok-project-management | 38 | 9mo | No flags | Intermediate |
| project-planner | 32 | 10mo | Review | Intermediate |
| spec-kit-workflow | 11 | 8mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
pmbok-project-management
jgtolentino
Comprehensive PMP/PMBOK project management methodologies and best practices. Use this skill when users need guidance on project management processes, templates, knowledge areas, process groups, tools, techniques, or certification preparation. Covers all 10 PMBOK Knowledge Areas and 5 Process Groups with practical templates, frameworks, and industry-standard approaches. Includes risk management, stakeholder engagement, schedule management, cost control, quality assurance, and resource planning.
project-planner
adrianpuiu
Comprehensive project planning and documentation generator for software projects. Creates structured requirements documents, system design documents, and task breakdown plans with implementation tracking. Use when starting a new project, defining specifications, creating technical designs, or breaking down complex systems into implementable tasks. Supports user story format, acceptance criteria, component design, API specifications, and hierarchical task decomposition with requirement traceability.
spec-kit-workflow
jmanhype
Guides specification-driven development workflow. Automatically invoked when discussing new features, specifications, technical planning, or implementation tasks. Ensures proper workflow phases (specify → clarify → plan → checklist → tasks → analyze → implement).
product-manager-toolkit
davila7
Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development.
planning-agent
parcadei
Planning agent that creates implementation plans and handoffs from conversation context
pdd
mikeyobrien
Transforms a rough idea into a detailed design document with implementation plan. Follows Prompt-Driven Development — iterative requirements clarification, research, design, and planning.