Skip to content
Skills Library
Management & product · Planning

breaking-down-work

/breaking-down-work

Decomposes a goal, feature, epic, or deliverable into a structured task tree (tasks, subtasks, checklists) with dependencies in Astravue. Use when the user wants to break down, decompose, or plan out work, turn an epic or feature into tasks, "split this into tasks", scope a deliverable, or build a work breakdown structure.

Licence
Apache-2.0
Last repository change
25.08.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Decomposes a goal, feature, epic, or deliverable into a structured task tree (tasks, subtasks, checklists) with dependencies in Astravue. Use when the user wants to break down, decompose, or plan out work, turn an epic or feature into tasks, "split this into tasks", scope a deliverable, or build a work breakdown structure.

Triggers from the description

split this into tasks
Original author description

Decomposes a goal, feature, epic, or deliverable into a structured task tree (tasks, subtasks, checklists) with dependencies in Astravue. Use when the user wants to break down, decompose, or plan out work, turn an epic or feature into tasks, "split this into tasks", scope a deliverable, or build a work breakdown structure.

How it works

  1. Workflow
  2. Important
Original SKILL.md headings · 43 lines, 359 words
SKILL.md preview
---
name: breaking-down-work
description: Decomposes a goal, feature, epic, or deliverable into a structured task tree (tasks, subtasks, checklists) with dependencies in Astravue. Use when the user wants to break down, decompose, or plan out work, turn an epic or feature into tasks, "split this into tasks", scope a deliverable, or build a work breakdown structure.
---

# Breaking Down Work

Turns a high-level goal into a complete, well-scoped task tree. The value is in the decomposition and sequencing — not in the tool calls — so spend effort on coverage and structure, then create in one confirmed pass.

## Workflow

1. **Understand the goal and scope**

   Clarify the deliverable and the target project. Use `astravue_list_projects` if the project is unclear. If the work hangs off an existing task, note its ID — the new tasks become subtasks of it.

2. **Decompose to full coverage**

   Break the goal into tasks, then subtasks, then checklist items where useful. Aim for the 100% rule: the children together fully cover the parent's scope with no overlap. A leaf is small enough when one person can finish it in a sitting and you can tell when it's done.

   - Tasks — the main units of deliverable work
   - Subtasks (`astravue_create_subtask`) — steps within a task
   - Checklist items (`astravue_create_checklist_item`) — acceptance criteria or fine-grained todos

3. **Sequence the work**

   Identify which tasks block others. Capture these as dependencies. Flag anything that can run in parallel so the plan doesn't serialize work that needn't be.

4. **Present the plan and confirm**

   Show the full tree (task → subtasks → checklist), proposed dependencies, and any estimates, as a structured outline. Ask the user to adjust or approve. Do not create anything before approval — decomposition is cheap to revise on paper and expensive to undo in the workspace.

5. **Create after approval**

   - `astravue_bulk_create_tasks` — create the top-level tasks in one call
   - `astravue_create_subtask` — add subtasks under each task
   - `astravue_create_checklist_item` — add checklist items
   - `astravue_add_dependency` — wire up the blocking relationships

   Report back what was created with IDs so the user can navigate to it.

## Important

- Decompose first, create once. The thinking is the deliverable; the writes are mechanical.
- Apply the 100% rule — if the children don't cover the parent, the breakdown is incomplete; if they overlap, it's redundant.
- Never create tasks before the user approves the plan.
- Only set estimates, assignees, or due dates the user actually provides — don't invent them.

Versions

The database has no other skills named breaking-down-work.

Database snapshot: 13.11.2026 · package version 6cecdb67cbb5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90plan
    Break down a goal into actionable tasks with dependencies, priorities, and optional specs. Use when the user wants to plan work, decompose a feature, or create a task breakdown.
  • 100generate-tasks
    Task generation and breakdown workflow. Use when decomposing a PRD or complex feature into implementable subtasks with clear acceptance criteria and dependencies.
  • 100breakdown
    Use when a feature with a spec and a plan needs its ordered task list: \"break this into tasks\", \"make the task list\", \"what are the steps to build this?\", \"generate tasks.md\", a feature folder with plan.md and no tasks.md, or a task list made stale by a spec or plan…
  • 100plan-epic
    Breaks an epic or large feature into tickets, each with its own branch name, from PRDs, TDDs, designs, and other reference material (@ paths), codebase research, or a prompt. The breakdown is checked automatically for gaps and breaking changes before the user reviews it, then…
  • 90mapping-dependencies
    Maps task dependencies in an Astravue project, finds the critical path and blocked work, and detects circular dependencies before any rescheduling. Use when the user asks about dependencies, blockers, what's blocking what, the critical path, or wants to understand or fix the sequencing of a project.
  • 100sub-task-breakdown
    Break one story into the sub-tasks it actually decomposes into — each with a title, checkable acceptance criteria, a grounded effort range, and its dependencies — in Jira's own vocabulary and nobody else's. Produces a proposal to argue with, never sub-tasks written into Jira…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.