Skip to content
Skills Library
Management & product · Planning

task-decomposition

/task-decomposition

Splits user stories and system design into independent features that can be developed by individual engineers with minimal overlap. Trigger on any "break down / split / decompose <feature> into tasks" request, not only explicit skill invocation. Use after system design / HLD is complete and before Kiro spec generation begins.

Repository
konductor ↗
Licence
Apache-2.0
Last repository change
27.10.2026

Assessment and security

100/ 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.
Content35 / 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 27.10.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

Splits user stories and system design into independent features that can be developed by individual engineers with minimal overlap. Trigger on any "break down / split / decompose <feature> into tasks" request, not only explicit skill invocation. Use after system design / HLD is complete and before Kiro spec generation begins.

Triggers from the description

break down / split / decompose <feature> into tasks
Original author description

Splits user stories and system design into independent features that can be developed by individual engineers with minimal overlap. Trigger on any "break down / split / decompose <feature> into tasks" request, not only explicit skill invocation. Use after system design / HLD is complete and before Kiro spec generation begins.

How it works

  1. Overview
  2. Usage
  3. Splitting Criteria
  4. Output Format
  5. Execution
  6. Quality Gate
Original SKILL.md headings · 89 lines, 561 words
SKILL.md preview
---
name: task-decomposition
description: Splits user stories and system design into independent features that can be developed by individual engineers with minimal overlap. Trigger on any "break down / split / decompose <feature> into tasks" request, not only explicit skill invocation. Use after system design / HLD is complete and before Kiro spec generation begins.
version: 1.0.0
tags: [skill, feature-splitting, task-decomposition, planning, agile]
---

# Task Decomposition (Feature Splitting)

## Overview

Takes user stories and system design / HLD and splits them into independent features scoped for individual engineers. The goal is to minimize overlap and dependency between team members so each engineer can work on their feature track independently.

This skill sits between Design and Kiro Spec Generation in the SDLC — one HLD fans out into multiple independent feature tracks, each going through its own Kiro spec workflow.

## Usage

Use this skill when:

- The request says "break down," "split," or "decompose" a feature/project into (implementation) tasks — this phrasing means produce the Feature Split format below, NOT a generic layer-by-layer technical breakdown (e.g. Data Model → Backend → API Contract → Frontend → Cross-cutting), even when the skill isn't named explicitly
- System design / HLD is approved and ready for implementation planning
- Breaking a project into independent feature tracks for a team
- Scoping work so each engineer can work with minimal coordination

Do NOT use when:

- Generating Kiro IDE tasks.md for a single feature → use `kiro-task-generation`
- Writing requirements.md → use `kiro-requirements-generation`
- Writing design.md → use `kiro-design-generation`

## Splitting Criteria

Each split feature should:

1. **Be independently implementable** — one engineer can complete it without blocking on others
2. **Have clear boundaries** — well-defined inputs, outputs, and interfaces
3. **Map to user stories** — traceable back to one or more user stories
4. **Be testable in isolation** — can be verified without other features being complete
5. **Minimize shared state** — avoid features that read/write the same data concurrently

## Output Format

```markdown
# Feature Split: [Project Name]

## Feature 1: [Feature Name]

- **Scope**: [What this feature covers]
- **User Stories**: [US-1, US-3, US-7]
- **Key Components**: [API endpoints, data models, services involved]
- **Dependencies**: [External dependencies or shared interfaces]
- **Engineer**: [Assigned or TBD]

## Feature 2: [Feature Name]

- **Scope**: [What this feature covers]
- **User Stories**: [US-2, US-4, US-5]
- **Key Components**: [API endpoints, data models, services involved]
- **Dependencies**: [External dependencies or shared interfaces]
- **Engineer**: [Assigned or TBD]

## Shared Interfaces

- [Interface 1]: Used by Feature 1 and Feature 2 — define first
- [Interface 2]: Used by Feature 2 and Feature 3 — define first
```

## Execution

1. Read user stories and system design / HLD from the paths supplied by the caller
2. Identify natural feature boundaries (by domain, by API surface, by data ownership)
3. Check for overlap — if two features touch the same data model or API, consider merging or defining a shared interface
4. Produce the feature split with scope, user story mapping, and dependencies
5. Present to user for approval

## Quality Gate

**CRITICAL (must fix):**

- Features have circular dependencies
- A feature requires another feature to be complete before it can start (tight coupling)
- User stories are missing from the split (every story must map to a feature)

**IMPORTANT (should fix):**

- More than 2 features share the same data model (consider a shared-interfaces feature)
- A feature is too large (>2 weeks of work for one engineer)
- A feature is too small (<2 days of work — consider merging)

**SUGGESTION:**

- Could identify a "foundation" feature that defines shared interfaces first
- Could estimate effort per feature
- Could suggest implementation order based on dependencies

Versions

RepositoryScoreLicence
This page · aws-solutions/konductor100Apache-2.0
sumitaich1998/jarvisvr100MIT
rohitg00/skillkit100Apache-2.0

Database snapshot: 13.11.2026 · package version 41c366dc3699 (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

  • 100decompose
    Decompose specs/plans into atomic, testable tasks — enforces the 15-Minute Rule and populates project/TASKS.md. Use when: decompose, break down tasks, create task list, task decomposition, 15 minute rule.
  • 90kiro-spec-tasks
    Generate implementation tasks from requirements and design. Use when creating actionable task lists.
  • 90kiro-spec-tasks
    Generate implementation tasks from requirements and design. Use when creating actionable task lists.
  • 100worktracker-decomposition
    This skill should be used when the user asks to "decompose task", "break down work", "create subtasks", or mentions task breakdown.
  • 90spec
    Write a detailed spec document for a task before implementation begins. Use when the user wants to define requirements, acceptance criteria, or technical design for a task.
  • 100arn-code-feature-spec
    This skill should be used when the user says "feature spec", "arness code feature spec", "arn-code-feature-spec", "spec this feature", "help me spec", "design this feature", "feature design", "write a spec", "create a specification", "I have an idea for a feature", "let's flesh…

Feedback and reports

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