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
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. Route10 sizing to `task-estimation`, issue-state governance to `triage`, plan review11 to `plannotator`, daily syncs to `standup-meeting`, retros to12 `sprint-retrospective`, and pre-planning concept framing to `bmad`, `bmad-idea`, or13 `bmad-gds`.14allowed-tools: Bash Read Write Edit Glob Grep15compatibility: >16 Best for repositories, issue lists, specs, PRDs, GDDs, launch notes, playtest17 feedback, or chat context that must become a compact execution packet. This is a18 planning and decomposition workflow, not the long-term system of record.19license: MIT20metadata:21 tags: task-planning, backlog-grooming, sprint-planning, milestone-planning, roadmap-slicing, feature-breakdown, launch-planning, game-development22 platforms: Claude, ChatGPT, Gemini, Codex23 version: "2.1.0"24 source: https://skillmd.com/skills/skillmds/task-planning25 upstream: akillness/jeo-skills26 modernization: 2026-04-1227 hardening: 2026-04-1828 ratchet: 2026-04-2029---303132# Task Planning3334Use this skill when the job is **turning messy context into one small planning packet that a team can actually act on**.3536`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.3738Core references:39- [references/intake-packets-and-route-outs.md](references/intake-packets-and-route-outs.md)40- [references/packet-shapes.md](references/packet-shapes.md)41- [references/readiness-checklist.md](references/readiness-checklist.md)42- [references/planning-patterns.md](references/planning-patterns.md)4344## When to use this skill45- The request is too vague, too large, or too mixed to hand straight to implementation.46- A backlog needs to be cleaned into ready vs not-ready work.47- A roadmap item, feature, bug cluster, launch beat, or playtest finding needs execution slices.48- A team needs one compact packet that names dependencies, blockers, and acceptance criteria.49- The packet spans multiple disciplines: frontend/backend, PM/ops, GTM/content, or code/content/build/playtest work.50- The key question is "what should we actually do next?" rather than "how big is it?" or "what board should we use?"5152## When not to use this skill53- **The main job is sizing, forecasting, or story-point language** → `task-estimation`.54- **The work already exists and the real job is issue state transitions** → `triage`.55- **The plan already exists and the real job is review/approval or diff markup** → `plannotator`.56- **The main job is daily status coordination** → `standup-meeting`.57- **The main job is reflection on completed work** → `sprint-retrospective`.58- **The work is still concept framing, scope shaping, or game-production orchestration before decomposition** → `bmad`, `bmad-idea`, or `bmad-gds` first.5960## Instructions6162### Step 1: Choose one intake packet63Use [references/intake-packets-and-route-outs.md](references/intake-packets-and-route-outs.md) and pick exactly one primary packet:6465```yaml66task_planning_packet:67 packet: backlog-cleanup | feature-slice | sprint-candidate | release-packet | milestone-packet | discovery-first68 domain: developer-workflow | web-fullstack | product-ops | marketing-gtm | game-development | mixed69 source_material: repo/issues | prd/spec | gdd/playtest | launch-notes | chat-context | mixed | unknown70 readiness_state: mostly-ready | mixed | mostly-fuzzy71 output_shape: single-packet | slice-table-plus-not-ready | release-packet | milestone-packet | discovery-packet72```7374Packet meanings:75- `backlog-cleanup` — clarify, dedupe, and separate ready from not-ready work.76- `feature-slice` — turn one feature or bug cluster into assignable slices.77- `sprint-candidate` — prepare the next iteration's ready work.78- `release-packet` — shape launch, rollout, campaign, or go-live work.79- `milestone-packet` — coordinate cross-discipline milestone or demo work, especially for games.80- `discovery-first` — expose unknowns before pretending implementation is ready.8182### Step 2: Gather the minimum credible evidence83Do not plan from vibes alone. Pull the smallest packet that supports decomposition:84- goal or problem statement85- user, business, team, or player outcome86- current artifacts: issues, spec/PRD, GDD, launch notes, playtest notes, bug list, or chat context87- timeline or trigger: sprint, release, milestone, event, or dependency window88- obvious constraints: owner, platform, environment, approvals, external dependencies89- missing details that could make the packet fake-ready9091If evidence is thin, say so and choose `discovery-first` instead of inventing certainty.9293### Step 3: Split discovery from delivery early94Before you write slices, separate:951. **Discovery** — unanswered questions, validation, missing decisions962. **Foundation** — setup, architecture, shared assets, tooling, environments973. **Delivery** — user-facing or system-facing implementation slices984. **Verification** — QA, analytics, review, smoke tests, playtests, launch checks995. **Follow-through** — docs, enablement, rollout, reporting, monitoring, distribution100101Do not bury research or unresolved decisions inside build tickets.102103### Step 4: Choose the smallest packet shape104Use [references/packet-shapes.md](references/packet-shapes.md).105106Rules:107- If the user needs one next-action set, prefer a **single packet**.108- If the main need is ready vs not-ready triage, use **slice table plus not-ready list**.109- If the work is tied to a launch window, use a **release packet**.110- If the work is milestone-heavy and cross-discipline, use a **milestone packet**.111- If the packet starts doing decomposition, estimation, board control, review, and ceremony work at once, split responsibilities and route outward.112113### Step 5: Build slices with readiness fields114Every slice should have:115- title116- outcome117- owner role118- dependencies119- inputs required120- acceptance criteria121- risk / uncertainty122- ready? yes / no123- if not ready, what is missing?124125Use short, testable acceptance criteria. Avoid vague statements like "works better" or "launch ready".126127### Step 6: Surface sequence and blockers128Explicitly name:129- what can run in parallel130- what must happen in order131- what is blocked132- what should be deferred133134Use blocker buckets from [references/readiness-checklist.md](references/readiness-checklist.md):135- `missing-scope`136- `missing-design`137- `missing-data`138- `external-dependency`139- `environment-access`140- `approval-needed`141- `cross-team-handoff`142143### Step 7: Run the route-out check144Verify all of these:1451. The chosen packet matches the real planning job.1462. Discovery is separated from implementation when confidence is low.1473. The packet does not silently absorb sizing, board control, plan review, standups, or retros.1484. Cross-domain nuance survives without turning the output into a tutorial.1495. The packet ends with one clear next move.150151Route-outs to keep explicit:152- sizing → `task-estimation`153- issue state transitions → `triage`154- plan review / approval → `plannotator`155- daily coordination → `standup-meeting`156- completed-work reflection → `sprint-retrospective`157- concept framing / strategy shaping → `bmad`, `bmad-idea`, `bmad-gds`158159### Step 8: Return the brief or the final packet160Preferred brief shape before full drafting:161162```markdown163# Task Planning Brief164165## Packet choice166- Packet:167- Domain:168- Why it fits:169- Output shape:170171## Source material used172- Main evidence:173- Constraints / dependencies:174- Assumptions / gaps:175176## Planned slices1771. slice1782. slice1793. slice180181## Route-out notes182- Out of scope:183- Not-ready work kept separate:184- Recommended next move:185```186187If the user already asked for the final artifact, return a compact planning packet directly.188189## Output format190Default packet shape:191192```markdown193# Planning Packet194195## Planning horizon196- Packet:197- Domain:198- Confidence: high | medium | low199200## Goal201- ...202203## Assumptions204- ...205206## Work slices207| Slice | Outcome | Owner role | Dependencies | Ready? |208|------|---------|------------|--------------|--------|209| ... | ... | ... | ... | yes/no |210211## Slice details212### 1. [Slice name]213- Inputs required:214- Acceptance criteria:215 - [ ] ...216- Risks / uncertainty:217- Notes:218219## Sequencing2201. ...2212. ...222223## Blockers / not-ready items224- Bucket:225- Missing:226- Next action:227228## Recommended next move229- start implementation | run discovery first | groom with owners | estimate now | defer until dependency clears230```231232## Examples233234### Example 1: Fullstack feature slicing235**Input**236> Break down a new team-invite flow for our SaaS app. We need email invites, acceptance, and admin visibility before sprint planning.237238**Good output direction**239- packet: `sprint-candidate`240- domain: `web-fullstack`241- split backend/data, invite acceptance flow, admin visibility, verification, and follow-through242- keep story points out of scope243244### Example 2: Backlog cleanup245**Input**246> We have a pile of vague onboarding backlog items. Clean them up so we can see what is actually ready next week.247248**Good output direction**249- packet: `backlog-cleanup`250- output shape: `slice-table-plus-not-ready`251- mark missing scope, ownership, or approvals explicitly252- separate discovery tickets from implementation tickets253254### Example 3: Marketing / launch packet255**Input**256> Plan the next release push for our B2B launch: landing-page updates, email sequence, attribution checks, and launch-day reporting.257258**Good output direction**259- packet: `release-packet`260- domain: `marketing-gtm`261- separate asset creation, review/approval, distribution, measurement, and reporting262- route deep copywriting/campaign execution to `marketing-automation`263264### Example 4: Game milestone packet265**Input**266> Plan the next milestone for our roguelike demo: tutorial polish, controller support, and a streamer-ready build.267268**Good output direction**269- packet: `milestone-packet`270- domain: `game-development`271- separate code/system work, content/polish, build/QA, and playtest/distribution concerns272- keep broader game-production orchestration routed to `bmad-gds` when needed273274## Best practices2751. Choose one primary packet before decomposing the work.2762. Keep discovery separate from delivery whenever requirements are unstable.2773. Prefer small, reviewable slices over broad work categories.2784. Surface blockers and missing inputs explicitly instead of burying them in notes.2795. Preserve domain nuance for developer workflow, web/fullstack, product/ops, marketing/GTM, and game work without bloating the front door.2806. Route sizing, board control, review, daily cadence, and retrospectives out instead of stretching the skill boundary.2817. Keep the packet compact enough that a team can act on it immediately.2828. Update compact and manifest discovery surfaces when the role wording changes materially.283284## References285- [Atlassian — Backlog refinement](https://www.atlassian.com/agile/scrum/backlog-refinement)286- [Atlassian — Sprint planning](https://www.atlassian.com/agile/scrum/sprint-planning)287- [GitHub Docs — About Projects](https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects)288- [GitHub Docs — About milestones](https://docs.github.com/en/issues/using-labels-and-milestones-to-track-work/about-milestones)289- [HacknPlan Docs](https://hacknplan.com/docs/milestones-and-deadlines/)