pattern-task-breakdown

Quick Reference

Process: Scope → Phases → Tasks → Dependencies → Verification

Use when the work touches 4+ files, takes more than 60 minutes, carries sequencing risk, or needs user approval before execution.

Golden Rule: The plan must be smaller than the work it describes. Avoid over-planning.

Workflow

1. Scope

Restate the goal, non-goals, constraints, and known risks. Ask only blocking questions; state assumptions for everything else.

2. Phase

Group related work into phases with a clear outcome each. Keep phases independently reviewable, so work can stop cleanly at a phase boundary.

3. Task

Break each phase into 30 to 120 minute tasks. If a task cannot be described in one sentence, it is still a phase. For each task, name the files or components, the dependencies, and the verification.

4. Sequence

Identify blockers, what can run in parallel, and the critical path. The critical path is what determines the real total, not the sum of estimates.

5. Validate

Include test, build, and docs checks, plus rollback concerns where the work touches production state.

Output Format

Goal: {one sentence}
Assumptions: {short list, or none}
Risks: {top 1-3, with mitigations}

Plan:
1. {Phase or task title}
   - Scope: {files/components}
   - Depends on: {none | task numbers}
   - Verify: {specific runnable check}
2. ...

Open questions: {blocking only}
Estimate: {rough total, or per phase}

Keep estimates realistic: include testing time and add buffer for the parts that are unclear. A verification line that cannot be run is not verification.

Stored or Resumable Plans

Use this section only when the host provides compatible store tools. Without them, keep the complete plan in TODO descriptions or the conversation, and omit storewrite, storeread, and [store:<id>] references rather than substituting repository files.

This skill defines the planning shape; tool-store covers the storage tool itself.

When a stored plan will produce 3 or more TODOs, take more than 60 minutes, or span multiple phases or agents, include data.prompt_drafts in the plan entry:

{
  "prompt_drafts": {
    "handoff_prompt": "Load store: <plan-id>\n\nTask: Continue the stored plan.",
    "todo_items": [
      {
        "title": "Short step title",
        "description": "What to do, required skills, success criteria, [store:<plan-id>]"
      }
    ]
  }
}

Rules:

• Keep prompts plain text so any agent or client can execute them. Do not store client-specific tool-call blocks, which stop working the moment the plan is resumed on a different harness.
• Include the required skills and store references in each item, since a resuming agent inherits neither.
• Replace placeholder plan IDs after the store item is created.

Checklist

Before handing back a plan:

• Goal, non-goals, assumptions, and top risks are stated
• Each task is 30 to 120 minutes with named scope and a runnable verification
• Dependencies, parallel work, and the critical path are explicit
• Each task has an owner agent or can be done directly
• Test, build, docs, and rollback concerns are covered where relevant
• Blocking questions are separated from assumptions
• The plan is shorter than the work it describes

Integration with Other Skills

With pattern-orchestration-complex: supplies the plan its approval and execution phases consume.

With role-orchestrator: the plan output feeds TODOs and delegation prompts.

With tool-store: persists the plan and its prompt_drafts for later resumption.

With role-product-engineer: scope the outcome before decomposing it.