New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Task Decomposer

by Mathews-Tom in Mathews-Tom/armory

Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices.

MITAuto-check passedAgent Workflows

Install Task Decomposer

skills CLI
$ npx skills add Mathews-Tom/armory --skill task-decomposer -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Mathews-Tom/armory task-decomposer --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Mathews-Tom/armory.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/task-decomposer .claude/skills/task-decomposer && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
task-decomposer
GitHub stars
328
Token cost
~2.8k tokens
SKILL.md length
1,000 words
Files
6 (incl. references)
Skills in repo
80
Repo updated
First seen
Licence
MIT

At a glance

Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices.

  • Works in 6 steps: Understand the Feature → Decompose into Vertical Slices → Identify Edge Cases → …
  • : decompose this feature
  • SKILL.md covers Reference Files, Prerequisites, Project Context and Workflow, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Task Decomposer is an agent skill from Mathews-Tom/armory. Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices. Triggers on: "decompose this feature", "task breakdown with dependencies", "phased implementation plan", "work breakdown structure". NOT for discovering which decisions are still open, use decision-map. NOT for effort estimates, use estimate-calibrator.

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including reference files (for example `evals/cases.yaml`, `references/decomposition-patterns.md` and `references/dependency-mapping.md`).

It sits in Agent Workflows, covering Task breakdown, Planning and Project management. The repository describes itself as: Curated, production-grade skills for AI coding agents. Battle-tested workflows for developers who use AI seriously. The licence is MIT.

When your agent uses it

  • : decompose this feature
  • Task breakdown with dependencies
  • Phased implementation plan
  • Work breakdown structure

Example prompts

  • “decompose this feature”
  • “task breakdown with dependencies”
  • “phased implementation plan”
  • “/task-decomposer”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Understand the Feature
  2. Decompose into Vertical Slices
  3. Identify Edge Cases
  4. Plan Testing
  5. Map Dependencies
  6. Flag Risks

What it can do on your machine

Read from SKILL.md and the folder at commit 4594fb7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Task Decomposer loads about 2.8k tokens when it runs, and up to ~7.9k if it reads all its reference files. Until then it costs about 103 tokens; SKILL.md has 1,000 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~103
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Mathews-Tom/armory at commit 4594fb7, republished under its MIT licence (© Mathews-Tom). 1,000 words, ~2,808 tokens.

Download SKILL.mdSave it as .claude/skills/task-decomposer/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
task-decomposer
description
Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices. Triggers on: "decompose this feature", "task breakdown with dependencies", "phased implementation plan", "work breakdown structure". NOT for discovering which decisions are still open, use decision-map. NOT for effort estimates, use estimate-calibrator.
metadata.version
1.1.2
metadata.category
development
metadata.tags
task-breakdown, dependencies, planning, phased
metadata.difficulty
intermediate
metadata.phase
plan
metadata.complements
decision-map

Task Decomposer

Transforms ambiguous feature requests into concrete, implementable task sequences: identifies acceptance criteria, decomposes into tracer-bullet vertical slices with effort sizing, maps dependencies and parallelization, enumerates edge cases, plans testing, labels HITL/AFK readiness, and flags risks — producing a ready-to-execute task board.

When to use this skill vs native decomposition: The base model decomposes features well in an ad-hoc format. Use this skill specifically when you need the structured output: phased task tables with dependency mapping, parallelization flags, risk flags, and integrated test strategy. If you just need a quick list of steps, ask directly without invoking this skill.

Reference Files

FileContentsLoad When
references/decomposition-patterns.mdFeature → task decomposition strategies, granularity guidelinesAlways
references/edge-case-checklist.mdCommon edge case categories by domain (web, API, data, CLI)Edge case identification needed
references/dependency-mapping.mdDependency graph construction, critical path identificationMulti-task breakdown
references/sizing-guide.mdEffort estimation guidance (S/M/L), complexity indicatorsEffort sizing needed

Prerequisites

  • Feature description or requirements (can be vague — the skill handles ambiguity)
  • Project context (tech stack, existing architecture, team size)

Project Context

Before decomposing, check for repo-local agent context:

  • docs/agents/domain.md for CONTEXT.md, CONTEXT-MAP.md, and ADR lookup rules
  • docs/agents/triage-labels.md for readiness labels when tasks become issues
  • CONTEXT.md or relevant context-local glossary for task titles and acceptance criteria
  • .out-of-scope/ for durable rejections that may affect scope

Continue if these files are absent, but state that the plan is using inferred vocabulary.

Workflow

Phase 1: Understand the Feature
  1. Extract the user-facing goal — What does this feature enable the user to do? If unclear, state assumptions explicitly.
  2. Define acceptance criteria — What must be true for this feature to be "done"? Express as testable statements: "User can X", "System does Y when Z."
  3. Identify non-functional requirements — Performance, security, accessibility, backwards compatibility constraints.
  4. Clarify scope boundaries — What is explicitly out of scope? State this to prevent scope creep during implementation.
Phase 2: Decompose into Vertical Slices

Break the feature into tracer-bullet slices first, then split oversized slices into tasks. Each slice should deliver a narrow but complete path through the affected layers. Avoid horizontal breakdowns where one issue only creates schema, another only creates API, and another only creates UI unless the work is pure infrastructure.

GranularitySizeExample
Too coarse"Build the search feature"Not actionable
Right level"Exact-match product search returns results end-to-end"Single PR, testable
Too fine"Import the search library"Not independently meaningful

Right granularity test: Each task should be completable in a single PR, testable in isolation, and deliverable independently. A completed vertical slice should be demoable or verifiable without waiting for unrelated slices.

Group tasks into phases:

PhasePurposeContains
SetupShared contracts or migrations that unblock slicesTypes, schemas, fixtures
Slice 1First end-to-end behaviorMinimal data, logic, API, UI/CLI path
Slice NIncremental capabilityOne user-visible behavior or operational capability
HardeningCross-slice edge cases and quality gatesPerformance, security, docs, cleanup

Label each slice:

  • AFK — an agent can implement it from the issue brief with no further human context.
  • HITL — requires human judgment, external access, product approval, design review, or release authority.
Phase 3: Identify Edge Cases

For each task, enumerate edge cases:

  1. Input boundaries — Empty, null, maximum size, special characters
  2. State transitions — Concurrent modification, interrupted operations
  3. Error conditions — Network failures, invalid data, permission denied
  4. Backwards compatibility — Existing data, existing API consumers
Phase 4: Plan Testing

For each task, identify what to test:

Test LevelWhat to TestWho Writes
UnitIndividual functions, pure logicDuring implementation
IntegrationComponent interactions, API endpointsAfter integration phase
ManualUser flows, visual correctnessAfter polish phase
Show full SKILL.md (410 more words)Show less
Phase 5: Map Dependencies

Identify which tasks depend on others:

  1. Hard dependencies — Task B requires Task A's output (database table must exist before writing queries)
  2. Soft dependencies — Task B benefits from Task A but could use a stub
  3. No dependency — Tasks can be done in parallel
Phase 6: Flag Risks

For each risk, identify mitigation:

Risk TypeExampleMitigation
Technical unknown"Never used WebSockets before"Spike/prototype first
External dependency"Requires API access we don't have"Request early, use mocks
Scope uncertainty"Requirements may change"Implement core first, defer edge cases
Performance risk"May be slow with 1M rows"Add benchmark task, define acceptable threshold

Output Format

text
## Task Decomposition: {Feature Name}

### Feature Summary
{One paragraph describing what this feature does and why}

### Acceptance Criteria
- [ ] {Testable statement 1}
- [ ] {Testable statement 2}
- [ ] {Testable statement 3}

### Scope
- **In scope:** {what's included}
- **Out of scope:** {what's excluded}

### Task Breakdown

#### Phase 1: Foundation
| # | Slice / Task | Type | Effort | Dependencies | Parallel |
|---|--------------|------|--------|--------------|----------|
| 1.1 | {task description} | {AFK/HITL} | {S/M/L} | None | Yes |
| 1.2 | {task description} | {AFK/HITL} | {S/M/L} | 1.1 | No |

#### Phase 2: Vertical Slices
| # | Slice / Task | Type | Effort | Dependencies | Parallel |
|---|--------------|------|--------|--------------|----------|
| 2.1 | {end-to-end behavior} | {AFK/HITL} | {S/M/L} | 1.x | Yes |
| 2.2 | {end-to-end behavior} | {AFK/HITL} | {S/M/L} | 1.x | Yes |

#### Phase 3: Hardening
| # | Task | Type | Effort | Dependencies | Parallel |
|---|------|------|--------|--------------|----------|
| 3.1 | {cross-slice quality gate} | {AFK/HITL} | {S/M/L} | 2.x | No |

### Edge Cases

| # | Edge Case | Handling | Phase |
|---|-----------|----------|-------|
| 1 | {edge case} | {how to handle} | {which phase} |

### Test Strategy

#### Unit Tests
- {Component}: {what to test}

#### Integration Tests
- {Flow}: {what to test}

#### Manual Verification
- {Scenario}: {what to check}

### Risk Flags
- {Risk}: {mitigation strategy}

### Agent Brief Notes
- {Any interface contracts, acceptance criteria, or out-of-scope boundaries that should be copied into ready-for-agent issues}

Calibration Rules

  1. Right granularity. Each slice should be 1-3 days of work and each implementation task should fit in one PR. Larger → decompose further. Smaller → merge into a parent slice.
  2. Testable acceptance criteria. "Make search work" is not testable. "Search returns relevant results within 200ms for queries up to 100 characters" is testable.
  3. Dependencies are sacred. If Task B truly depends on Task A, mark it. False dependencies slow teams down; missing dependencies cause integration failures.
  4. Edge cases are not optional. Every feature has edge cases. If the edge case list is empty, the analysis is incomplete.
  5. Parallel = velocity. Maximize parallel tasks. If 4 tasks can be done simultaneously, the phase takes the duration of the longest, not the sum.
  6. Vertical first. Prefer end-to-end slices over layer-only tasks. Use horizontal tasks only for shared contracts, migrations, or infrastructure that genuinely unblocks slices.
  7. Ready-for-agent requires a brief. AFK slices need desired behavior, key interfaces, acceptance criteria, and out-of-scope boundaries clear enough for a fresh agent.

Error Handling

ProblemResolution
Feature description is vagueState assumptions, decompose what's known, mark uncertain tasks with "pending clarification."
Feature is too large (20+ tasks)Split into multiple features. A feature that takes months is a project, not a feature.
No clear acceptance criteriaHelp the user define them: "What does done look like? What would you demo?"
Technical stack unknownDecompose at the logical level (data model, business logic, API, UI) without implementation specifics.

When NOT to Decompose

Push back if:

  • The task is already atomic (single function, single file change) — just do it
  • The user wants time estimates, not task breakdown — use estimate-calibrator instead
  • The feature is exploratory (research, prototype) — decomposition assumes known scope
  • The destination or the decisions needed to define it are still unknown — use decision-map

© Mathews-Tom, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (references) in skills/task-decomposer of Mathews-Tom/armory.

  • SKILL.md
  • evals/cases.yaml
  • references/decomposition-patterns.md
  • references/dependency-mapping.md
  • references/edge-case-checklist.md
  • references/sizing-guide.md

Open the folder on GitHubat commit 4594fb7

Compare with similar skills

Task Decomposer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Task Decomposer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Task Decomposer this skillMathews-Tom/armory328—~2.8kAutomated safety check: PassMIT
Planning And Task Breakdownabashev/vfs-s31068 repos~1.9kAutomated safety check: PassApache-2.0
ULW Plan Workflowcode-yeongyu/oh-my-openagent70k—~3.9kAutomated safety check: PassCustom licence
Implementation Plan Creatortailcallhq/forgecode7.6k1 repos~1.1kAutomated safety check: PassApache-2.0
Ask NavigatorYeachan-Heo/oh-my-claudecode40k—~4.1kAutomated safety check: PassMIT
Manual Planningfjrevoredo/mini-diarium308—~3.7kAutomated safety check: PassMIT

Similar skills

  • Planning And Task Breakdown

    abashev/vfs-s3

    Breaks work into ordered tasks. An agent skill from abashev/vfs-s3.

    106 GitHub starsUsed in 8 repos~1.9k tokens
    Agent WorkflowsAuto-check passed

  • ULW Plan Workflow

    code-yeongyu/oh-my-openagent

    Explore-first planning that turns a vague or large request into one decision-complete work plan, written only after your approval and executed by a separate worker.

    70k GitHub stars~3.9k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Implementation Plan Creator

    tailcallhq/forgecode

    Writes a structured Markdown implementation plan with checkbox tasks, verification criteria and risks, then checks it with a validation script; no code changes.

    7.6k GitHub starsUsed in 1 repo~1.1k tokens
    Agent WorkflowsAuto-check passed

  • Ask Navigator

    Yeachan-Heo/oh-my-claudecode

    Charts a foggy effort into a map of decision tickets on the repo's issue tracker and works through them one per session, producing decisions rather than deliverables.

    40k GitHub stars~4.1k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Manual Planning

    fjrevoredo/mini-diarium

    Create, update, review, and execute manual Markdown implementation plans when harness planning mode is not being used.

    308 GitHub stars~3.7k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Harness Plan

    Chachamaru127/claude-code-harness

    Creates and maintains Plans.md task plans with a spec delta, updates task markers and syncs plan progress with the implementation.

    3.2k GitHub stars~3.7k tokensUpdated 3 days ago
    Agent WorkflowsAuto-check: notes

More from Mathews-Tom/armory

All 80 skills in this repo

  • Architecture Reviewer

    Mathews-Tom/armory

    Architecture reviews across 7 dimensions (structural, scalability, enterprise readiness, performance, security, ops, data) with scored reports.

    328 GitHub stars~4.6k tokensUpdated 2 days ago
    Auto-check passed

  • Concept To Image

    Mathews-Tom/armory

    Turn concepts into static HTML visuals exported as PNG or SVG files via HTML/CSS/SVG.

    328 GitHub stars~2.6k tokensUpdated 2 days ago
    Auto-check passed

  • Watch

    Mathews-Tom/armory

    A skill your agent uses when analyzing an existing video URL or local recording: "watch this video", "analyze youtube video", "summarize this video", "youtube transcript", "find this moment", "what…

    328 GitHub stars~2.8k tokensUpdated 2 days ago
    Auto-check passed

  • Code Refiner

    Mathews-Tom/armory

    Deep code simplification and refactoring preserving behavior across Python, Go, TypeScript, Rust.

    328 GitHub stars~3.1k tokensUpdated 2 days ago
    Auto-check passed

  • Concept To Video

    Mathews-Tom/armory

    Turn concepts into animated explainer videos using Manim (Python) with MP4/GIF output, audio overlay, multi-scene composition.

    328 GitHub stars~4.9k tokensUpdated 2 days ago
    Auto-check passed

  • Decision Map

    Mathews-Tom/armory

    Maps the unresolved architecture, policy, and scope decisions that must be answered before planning can start: one durable decision ticket per question on the issue tracker, typed and blocker-linked…

    328 GitHub stars~2.7k tokensUpdated 2 days ago
    Auto-check passed

Categories

Questions about Task Decomposer

What does Task Decomposer do?

Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices. Task Decomposer is an agent skill from Mathews-Tom/armory. Produces phased task boards from feature requests: dependency-mapped work items, parallelization flags, risk flags, edge cases, test matrices.

When should I use Task Decomposer?

Task Decomposer fits situations like: : decompose this feature; task breakdown with dependencies; phased implementation plan; work breakdown structure.

How do I install Task Decomposer in Claude Code?

Run `npx skills add Mathews-Tom/armory --skill task-decomposer -a claude-code`. Or copy the skill folder (skills/task-decomposer in Mathews-Tom/armory) into .claude/skills/task-decomposer in your project. Claude Code loads it when a task matches its description.

How do I install Task Decomposer in Codex?

Run `npx skills add Mathews-Tom/armory --skill task-decomposer -a codex`. Or copy the skill folder (skills/task-decomposer in Mathews-Tom/armory) into .agents/skills/task-decomposer in your project. Codex loads it when a task matches its description.

Can I use Task Decomposer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Mathews-Tom/armory --skill task-decomposer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/task-decomposer, .gemini/skills/task-decomposer, .github/skills/task-decomposer and .opencode/skills/task-decomposer in your project.

What does Task Decomposer need to run?

SKILL.md names no scripts, command-line tools or credentials: Task Decomposer is instructions for the agent only.

Does Task Decomposer access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Task Decomposer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Task Decomposer use?

Task Decomposer is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Task Decomposer use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.1k tokens, read only when the agent opens those files.

What are the alternatives to Task Decomposer?

Skills that share tags, products or a category with Task Decomposer: Planning And Task Breakdown (abashev/vfs-s3, 106 stars), ULW Plan Workflow (code-yeongyu/oh-my-openagent, 70k stars), Implementation Plan Creator (tailcallhq/forgecode, 7.6k stars) and Ask Navigator (Yeachan-Heo/oh-my-claudecode, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Task Decomposer?

Mathews-Tom (a GitHub user) maintains it in Mathews-Tom/armory, which has 328 GitHub stars. The repository holds 80 skills in this directory. The repository was last updated on October 6, 2026.

Source: Mathews-Tom/armory on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.