Task Planning
Use this skill when the job is turning messy context into one small planning packet that a team can actually act on.
task-planning is the PM front door for backlog cleanup, feature decomposition, sprint-candidate prep, release slicing, milestone packets, and roadmap-to-delivery translation before estimation, boards, review, or execution.
Core references:
- references/intake-packets-and-route-outs.md
- references/packet-shapes.md
- references/readiness-checklist.md
- references/planning-patterns.md
- references/sprint-planning-recipe.md — when the packet is a sprint candidate and the team has velocity history
When to use this skill
- The request is too vague, too large, or too mixed to hand straight to implementation.
- A backlog needs to be cleaned into ready vs not-ready work.
- A roadmap item, feature, bug cluster, launch beat, or playtest finding needs execution slices.
- A team needs one compact packet that names dependencies, blockers, and acceptance criteria.
- The packet spans multiple disciplines: frontend/backend, PM/ops, GTM/content, or code/content/build/playtest work.
- The key question is "what should we actually do next?" rather than "how big is it?" or "what board should we use?"
When not to use this skill
- The main job is sizing, forecasting, or story-point language →
task-estimation.
- The work already exists and the real job is issue state transitions →
triage.
- The plan already exists and the real job is review/approval or diff markup →
plannotator.
- The main job is daily status coordination →
standup-meeting.
- The main job is reflection on completed work →
sprint-retrospective.
- The work is still concept framing, scope shaping, or game-production orchestration before decomposition →
bmad, bmad-idea, or bmad-gds first.
Instructions
Step 1: Choose one intake packet
Use references/intake-packets-and-route-outs.md and pick exactly one primary packet:
task_planning_packet:
packet: backlog-cleanup | feature-slice | sprint-candidate | release-packet | milestone-packet | discovery-first
domain: developer-workflow | web-fullstack | product-ops | marketing-gtm | game-development | mixed
source_material: repo/issues | prd/spec | gdd/playtest | launch-notes | chat-context | mixed | unknown
readiness_state: mostly-ready | mixed | mostly-fuzzy
output_shape: single-packet | slice-table-plus-not-ready | release-packet | milestone-packet | discovery-packet
Packet meanings:
backlog-cleanup — clarify, dedupe, and separate ready from not-ready work.
feature-slice — turn one feature or bug cluster into assignable slices.
sprint-candidate — prepare the next iteration's ready work.
release-packet — shape launch, rollout, campaign, or go-live work.
milestone-packet — coordinate cross-discipline milestone or demo work, especially for games.
discovery-first — expose unknowns before pretending implementation is ready.
Step 2: Gather the minimum credible evidence
Do not plan from vibes alone. Pull the smallest packet that supports decomposition:
- goal or problem statement
- user, business, team, or player outcome
- current artifacts: issues, spec/PRD, GDD, launch notes, playtest notes, bug list, or chat context
- timeline or trigger: sprint, release, milestone, event, or dependency window
- obvious constraints: owner, platform, environment, approvals, external dependencies
- missing details that could make the packet fake-ready
If evidence is thin, say so and choose discovery-first instead of inventing certainty.
Step 3: Split discovery from delivery early
Before you write slices, separate:
- Discovery — unanswered questions, validation, missing decisions
- Foundation — setup, architecture, shared assets, tooling, environments
- Delivery — user-facing or system-facing implementation slices
- Verification — QA, analytics, review, smoke tests, playtests, launch checks
- Follow-through — docs, enablement, rollout, reporting, monitoring, distribution
Do not bury research or unresolved decisions inside build tickets.
Step 4: Choose the smallest packet shape
Use references/packet-shapes.md.
Rules:
- If the user needs one next-action set, prefer a single packet.
- If the main need is ready vs not-ready triage, use slice table plus not-ready list.
- If the work is tied to a launch window, use a release packet.
- If the work is milestone-heavy and cross-discipline, use a milestone packet.
- If the packet starts doing decomposition, estimation, board control, review, and ceremony work at once, split responsibilities and route outward.
Step 5: Build slices with readiness fields
Every slice should have:
- title
- outcome
- owner role
- dependencies
- inputs required
- acceptance criteria
- risk / uncertainty
- ready? yes / no
- if not ready, what is missing?
Use short, testable acceptance criteria. Avoid vague statements like "works better" or "launch ready".
Step 6: Surface sequence and blockers
Explicitly name:
- what can run in parallel
- what must happen in order
- what is blocked
- what should be deferred
Use blocker buckets from references/readiness-checklist.md:
missing-scope
missing-design
missing-data
external-dependency
environment-access
approval-needed
cross-team-handoff
Step 7: Run the route-out check
Verify all of these:
- The chosen packet matches the real planning job.
- Discovery is separated from implementation when confidence is low.
- The packet does not silently absorb sizing, board control, plan review, standups, or retros.
- Cross-domain nuance survives without turning the output into a tutorial.
- The packet ends with one clear next move.
Route-outs to keep explicit:
- sizing →
task-estimation
- issue state transitions →
triage
- plan review / approval →
plannotator
- daily coordination →
standup-meeting
- completed-work reflection →
sprint-retrospective
- concept framing / strategy shaping →
bmad, bmad-idea, bmad-gds
Step 8: Return the brief or the final packet
Preferred brief shape before full drafting:
# Task Planning Brief
## Packet choice
- Packet:
- Domain:
- Why it fits:
- Output shape:
## Source material used
- Main evidence:
- Constraints / dependencies:
- Assumptions / gaps:
## Planned slices
1. slice
2. slice
3. slice
## Route-out notes
- Out of scope:
- Not-ready work kept separate:
- Recommended next move:
If the user already asked for the final artifact, return a compact planning packet directly.
Output format
Default packet shape:
# Planning Packet
## Planning horizon
- Packet:
- Domain:
- Confidence: high | medium | low
## Goal
- ...
## Assumptions
- ...
## Work slices
| Slice | Outcome | Owner role | Dependencies | Ready? |
|------|---------|------------|--------------|--------|
| ... | ... | ... | ... | yes/no |
## Slice details
### 1. [Slice name]
- Inputs required:
- Acceptance criteria:
- [ ] ...
- Risks / uncertainty:
- Notes:
## Sequencing
1. ...
2. ...
## Blockers / not-ready items
- Bucket:
- Missing:
- Next action:
## Recommended next move
- start implementation | run discovery first | groom with owners | estimate now | defer until dependency clears
Examples
Example 1: Fullstack feature slicing
Input
Break down a new team-invite flow for our SaaS app. We need email invites, acceptance, and admin visibility before sprint planning.
Good output direction
- packet:
sprint-candidate
- domain:
web-fullstack
- split backend/data, invite acceptance flow, admin visibility, verification, and follow-through
- keep story points out of scope
Example 2: Backlog cleanup
Input
We have a pile of vague onboarding backlog items. Clean them up so we can see what is actually ready next week.
Good output direction
- packet:
backlog-cleanup
- output shape:
slice-table-plus-not-ready
- mark missing scope, ownership, or approvals explicitly
- separate discovery tickets from implementation tickets
Example 3: Marketing / launch packet
Input
Plan the next release push for our B2B launch: landing-page updates, email sequence, attribution checks, and launch-day reporting.
Good output direction
- packet:
release-packet
- domain:
marketing-gtm
- separate asset creation, review/approval, distribution, measurement, and reporting
- route deep copywriting/campaign execution to
marketing-automation
Example 4: Game milestone packet
Input
Plan the next milestone for our roguelike demo: tutorial polish, controller support, and a streamer-ready build.
Good output direction
- packet:
milestone-packet
- domain:
game-development
- separate code/system work, content/polish, build/QA, and playtest/distribution concerns
- keep broader game-production orchestration routed to
bmad-gds when needed
Best practices
- Choose one primary packet before decomposing the work.
- Keep discovery separate from delivery whenever requirements are unstable.
- Prefer small, reviewable slices over broad work categories.
- Surface blockers and missing inputs explicitly instead of burying them in notes.
- Preserve domain nuance for developer workflow, web/fullstack, product/ops, marketing/GTM, and game work without bloating the front door.
- Route sizing, board control, review, daily cadence, and retrospectives out instead of stretching the skill boundary.
- Keep the packet compact enough that a team can act on it immediately.
- Update compact and manifest discovery surfaces when the role wording changes materially.
References
1---2name: task-planning3description: >4 Turn vague features, bug clusters, roadmap items, launch work, or playtest findings5 into one execution-ready planning packet by choosing the right packet type,6 separating discovery from delivery, and making blockers, dependencies, and the next7 move explicit. Use when the user needs backlog cleanup, feature slicing, sprint or8 milestone prep, release planning, or roadmap-to-delivery translation across9 developer workflow, web/fullstack, product/ops, marketing/GTM, or game work. Also10 owns the retired `sprint-plan` name: sprint capacity from velocity and11 availability, Definition-of-Ready story selection, dependency and critical-path12 mapping, sprint goal, sprint plan summary. Route sizing to `task-estimation`,13 issue-state governance to `triage`, plan review to `plannotator`, daily syncs to14 `standup-meeting`, retros to `sprint-retrospective`, and pre-planning concept15 framing to `bmad`, `bmad-idea`, or `bmad-gds`.16allowed-tools: Bash Read Write Edit Glob Grep17compatibility: >18 Best for repositories, issue lists, specs, PRDs, GDDs, launch notes, playtest19 feedback, or chat context that must become a compact execution packet. This is a20 planning and decomposition workflow, not the long-term system of record.21license: MIT22metadata:23 tags: task-planning, backlog-grooming, sprint-planning, milestone-planning, roadmap-slicing, feature-breakdown, launch-planning, game-development24 platforms: Claude, ChatGPT, Gemini, Codex25 version: "2.1.0"26 source: https://skillmd.com/skills/akillness/task-planning27 upstream: akillness/jeo-skills28 modernization: 2026-04-1229 hardening: 2026-04-1830 ratchet: 2026-04-2031---3233# Task Planning3435Use this skill when the job is **turning messy context into one small planning packet that a team can actually act on**.3637`task-planning` is the PM front door for backlog cleanup, feature decomposition, sprint-candidate prep, release slicing, milestone packets, and roadmap-to-delivery translation before estimation, boards, review, or execution.3839Core references:40- [references/intake-packets-and-route-outs.md](references/intake-packets-and-route-outs.md)41- [references/packet-shapes.md](references/packet-shapes.md)42- [references/readiness-checklist.md](references/readiness-checklist.md)43- [references/planning-patterns.md](references/planning-patterns.md)44- [references/sprint-planning-recipe.md](references/sprint-planning-recipe.md) — when the packet is a sprint candidate and the team has velocity history4546## When to use this skill47- The request is too vague, too large, or too mixed to hand straight to implementation.48- A backlog needs to be cleaned into ready vs not-ready work.49- A roadmap item, feature, bug cluster, launch beat, or playtest finding needs execution slices.50- A team needs one compact packet that names dependencies, blockers, and acceptance criteria.51- The packet spans multiple disciplines: frontend/backend, PM/ops, GTM/content, or code/content/build/playtest work.52- The key question is "what should we actually do next?" rather than "how big is it?" or "what board should we use?"5354## When not to use this skill55- **The main job is sizing, forecasting, or story-point language** → `task-estimation`.56- **The work already exists and the real job is issue state transitions** → `triage`.57- **The plan already exists and the real job is review/approval or diff markup** → `plannotator`.58- **The main job is daily status coordination** → `standup-meeting`.59- **The main job is reflection on completed work** → `sprint-retrospective`.60- **The work is still concept framing, scope shaping, or game-production orchestration before decomposition** → `bmad`, `bmad-idea`, or `bmad-gds` first.6162## Instructions6364### Step 1: Choose one intake packet65Use [references/intake-packets-and-route-outs.md](references/intake-packets-and-route-outs.md) and pick exactly one primary packet:6667```yaml68task_planning_packet:69 packet: backlog-cleanup | feature-slice | sprint-candidate | release-packet | milestone-packet | discovery-first70 domain: developer-workflow | web-fullstack | product-ops | marketing-gtm | game-development | mixed71 source_material: repo/issues | prd/spec | gdd/playtest | launch-notes | chat-context | mixed | unknown72 readiness_state: mostly-ready | mixed | mostly-fuzzy73 output_shape: single-packet | slice-table-plus-not-ready | release-packet | milestone-packet | discovery-packet74```7576Packet meanings:77- `backlog-cleanup` — clarify, dedupe, and separate ready from not-ready work.78- `feature-slice` — turn one feature or bug cluster into assignable slices.79- `sprint-candidate` — prepare the next iteration's ready work.80- `release-packet` — shape launch, rollout, campaign, or go-live work.81- `milestone-packet` — coordinate cross-discipline milestone or demo work, especially for games.82- `discovery-first` — expose unknowns before pretending implementation is ready.8384### Step 2: Gather the minimum credible evidence85Do not plan from vibes alone. Pull the smallest packet that supports decomposition:86- goal or problem statement87- user, business, team, or player outcome88- current artifacts: issues, spec/PRD, GDD, launch notes, playtest notes, bug list, or chat context89- timeline or trigger: sprint, release, milestone, event, or dependency window90- obvious constraints: owner, platform, environment, approvals, external dependencies91- missing details that could make the packet fake-ready9293If evidence is thin, say so and choose `discovery-first` instead of inventing certainty.9495### Step 3: Split discovery from delivery early96Before you write slices, separate:971. **Discovery** — unanswered questions, validation, missing decisions982. **Foundation** — setup, architecture, shared assets, tooling, environments993. **Delivery** — user-facing or system-facing implementation slices1004. **Verification** — QA, analytics, review, smoke tests, playtests, launch checks1015. **Follow-through** — docs, enablement, rollout, reporting, monitoring, distribution102103Do not bury research or unresolved decisions inside build tickets.104105### Step 4: Choose the smallest packet shape106Use [references/packet-shapes.md](references/packet-shapes.md).107108Rules:109- If the user needs one next-action set, prefer a **single packet**.110- If the main need is ready vs not-ready triage, use **slice table plus not-ready list**.111- If the work is tied to a launch window, use a **release packet**.112- If the work is milestone-heavy and cross-discipline, use a **milestone packet**.113- If the packet starts doing decomposition, estimation, board control, review, and ceremony work at once, split responsibilities and route outward.114115### Step 5: Build slices with readiness fields116Every slice should have:117- title118- outcome119- owner role120- dependencies121- inputs required122- acceptance criteria123- risk / uncertainty124- ready? yes / no125- if not ready, what is missing?126127Use short, testable acceptance criteria. Avoid vague statements like "works better" or "launch ready".128129### Step 6: Surface sequence and blockers130Explicitly name:131- what can run in parallel132- what must happen in order133- what is blocked134- what should be deferred135136Use blocker buckets from [references/readiness-checklist.md](references/readiness-checklist.md):137- `missing-scope`138- `missing-design`139- `missing-data`140- `external-dependency`141- `environment-access`142- `approval-needed`143- `cross-team-handoff`144145### Step 7: Run the route-out check146Verify all of these:1471. The chosen packet matches the real planning job.1482. Discovery is separated from implementation when confidence is low.1493. The packet does not silently absorb sizing, board control, plan review, standups, or retros.1504. Cross-domain nuance survives without turning the output into a tutorial.1515. The packet ends with one clear next move.152153Route-outs to keep explicit:154- sizing → `task-estimation`155- issue state transitions → `triage`156- plan review / approval → `plannotator`157- daily coordination → `standup-meeting`158- completed-work reflection → `sprint-retrospective`159- concept framing / strategy shaping → `bmad`, `bmad-idea`, `bmad-gds`160161### Step 8: Return the brief or the final packet162Preferred brief shape before full drafting:163164```markdown165# Task Planning Brief166167## Packet choice168- Packet:169- Domain:170- Why it fits:171- Output shape:172173## Source material used174- Main evidence:175- Constraints / dependencies:176- Assumptions / gaps:177178## Planned slices1791. slice1802. slice1813. slice182183## Route-out notes184- Out of scope:185- Not-ready work kept separate:186- Recommended next move:187```188189If the user already asked for the final artifact, return a compact planning packet directly.190191## Output format192Default packet shape:193194```markdown195# Planning Packet196197## Planning horizon198- Packet:199- Domain:200- Confidence: high | medium | low201202## Goal203- ...204205## Assumptions206- ...207208## Work slices209| Slice | Outcome | Owner role | Dependencies | Ready? |210|------|---------|------------|--------------|--------|211| ... | ... | ... | ... | yes/no |212213## Slice details214### 1. [Slice name]215- Inputs required:216- Acceptance criteria:217 - [ ] ...218- Risks / uncertainty:219- Notes:220221## Sequencing2221. ...2232. ...224225## Blockers / not-ready items226- Bucket:227- Missing:228- Next action:229230## Recommended next move231- start implementation | run discovery first | groom with owners | estimate now | defer until dependency clears232```233234## Examples235236### Example 1: Fullstack feature slicing237**Input**238> Break down a new team-invite flow for our SaaS app. We need email invites, acceptance, and admin visibility before sprint planning.239240**Good output direction**241- packet: `sprint-candidate`242- domain: `web-fullstack`243- split backend/data, invite acceptance flow, admin visibility, verification, and follow-through244- keep story points out of scope245246### Example 2: Backlog cleanup247**Input**248> We have a pile of vague onboarding backlog items. Clean them up so we can see what is actually ready next week.249250**Good output direction**251- packet: `backlog-cleanup`252- output shape: `slice-table-plus-not-ready`253- mark missing scope, ownership, or approvals explicitly254- separate discovery tickets from implementation tickets255256### Example 3: Marketing / launch packet257**Input**258> Plan the next release push for our B2B launch: landing-page updates, email sequence, attribution checks, and launch-day reporting.259260**Good output direction**261- packet: `release-packet`262- domain: `marketing-gtm`263- separate asset creation, review/approval, distribution, measurement, and reporting264- route deep copywriting/campaign execution to `marketing-automation`265266### Example 4: Game milestone packet267**Input**268> Plan the next milestone for our roguelike demo: tutorial polish, controller support, and a streamer-ready build.269270**Good output direction**271- packet: `milestone-packet`272- domain: `game-development`273- separate code/system work, content/polish, build/QA, and playtest/distribution concerns274- keep broader game-production orchestration routed to `bmad-gds` when needed275276## Best practices2771. Choose one primary packet before decomposing the work.2782. Keep discovery separate from delivery whenever requirements are unstable.2793. Prefer small, reviewable slices over broad work categories.2804. Surface blockers and missing inputs explicitly instead of burying them in notes.2815. Preserve domain nuance for developer workflow, web/fullstack, product/ops, marketing/GTM, and game work without bloating the front door.2826. Route sizing, board control, review, daily cadence, and retrospectives out instead of stretching the skill boundary.2837. Keep the packet compact enough that a team can act on it immediately.2848. Update compact and manifest discovery surfaces when the role wording changes materially.285286## References287- [Atlassian — Backlog refinement](https://www.atlassian.com/agile/scrum/backlog-refinement)288- [Atlassian — Sprint planning](https://www.atlassian.com/agile/scrum/sprint-planning)289- [GitHub Docs — About Projects](https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects)290- [GitHub Docs — About milestones](https://docs.github.com/en/issues/using-labels-and-milestones-to-track-work/about-milestones)291- [HacknPlan Docs](https://hacknplan.com/docs/milestones-and-deadlines/)