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 Decomposition

by jwynia in jwynia/agent-skills

Transform overwhelming development tasks into manageable units.

MITAuto-check passedAgent Workflows

Install Task Decomposition

skills CLI
$ npx skills add jwynia/agent-skills --skill task-decomposition -a claude-code

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

GitHub CLI
$ gh skill install jwynia/agent-skills task-decomposition --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/jwynia/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/tech/development/quality/task-decomposition .claude/skills/task-decomposition && 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-decomposition
GitHub stars
166
Token cost
~1.5k tokens
SKILL.md length
562 words
Files
1
Skills in repo
112
Repo updated
First seen
Licence
MIT

At a glance

Transform overwhelming development tasks into manageable units.

  • Says task too big
  • SKILL.md covers When to Use This Skill, Core Principle, Quick Reference: Cognitive… and Task Duration Success Rates, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Overwhelmed by scope

What it does

Task Decomposition is an agent skill from jwynia/agent-skills. Transform overwhelming development tasks into manageable units. This skill should be used when the user says 'task too big', 'can't estimate', 'overwhelmed by scope', 'where do I start', 'epic needs breakdown', or has dependency problems. Keywords: decomposition, breakdown, estimate, scope, INVEST, vertical slice, spike, dependencies.

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: Works with any project. Integrates with github-agile for tracking decomposed work.

It sits in Agent Workflows, covering Task breakdown. The licence is MIT.

When your agent uses it

  • Says task too big
  • Overwhelmed by scope
  • Where do I start
  • Epic needs breakdown

Example prompts

  • “task too big”
  • “t estimate”
  • “overwhelmed by scope”
  • “/task-decomposition”

Requirements

  • Compatibility (from SKILL.md): Works with any project. Integrates with github-agile for tracking decomposed work.

What it can do on your machine

Read from SKILL.md and the folder at commit e02ec7e. 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.

  • Compatibility

    Works with any project. Integrates with github-agile for tracking decomposed work.

    From compatibility in the SKILL.md frontmatter.

Context cost

Task Decomposition loads about 1.5k tokens when it runs. Until then it costs about 89 tokens; SKILL.md has 562 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~89
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k

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 jwynia/agent-skills at commit e02ec7e, republished under its MIT licence (© jwynia). 562 words, ~1,511 tokens.

Download SKILL.mdSave it as .claude/skills/task-decomposition/SKILL.md (or your agent's skills folder).
name
task-decomposition
description
Transform overwhelming development tasks into manageable units. This skill should be used when the user says 'task too big', 'can't estimate', 'overwhelmed by scope', 'where do I start', 'epic needs breakdown', or has dependency problems. Keywords: decomposition, breakdown, estimate, scope, INVEST, vertical slice, spike, dependencies.
compatibility
Works with any project. Integrates with github-agile for tracking decomposed work.
license
MIT
metadata.author
jwynia
metadata.version
1.0
metadata.type
utility
metadata.mode
assistive
metadata.domain
development

Task Decomposition Diagnostic

Transform overwhelming development tasks into manageable units by respecting cognitive limits, creating clear boundaries, and enabling parallel work. Tasks properly decomposed achieve 3x higher completion rates and 60% fewer defects.

When to Use This Skill

Use this skill when:

  • A task feels too big to estimate
  • Unsure where to start
  • Blocked by dependencies
  • Task keeps growing (scope creep)
  • Need to break down an epic or feature

Do NOT use this skill when:

  • Task is already small and clear
  • Doing implementation work
  • Architecture decisions needed (use system-design)

Core Principle

The goal isn't more tasks—it's the right tasks. Tasks small enough to understand completely, large enough to deliver value, independent enough to avoid blocking.

Quick Reference: Cognitive Limits

LimitThresholdImplication
Working memory7±2 itemsMax concepts per task
Context switch recovery23 minutesMinimize task switching
Files examined15-20 maxBound task scope
Days before completion drops2-3 daysKeep tasks under this

Task Duration Success Rates

DurationCompletion Rate
< 2 hours95%
2-4 hours90%
4-8 hours (1 day)80%
2-3 days60%
1 week35%
> 2 weeks<10%

Diagnostic States

TD1: Too Big to Understand

Symptoms: Estimates range wildly, can't hold all requirements in mind, more than 7 concepts to track

Interventions:

  • Apply INVEST criteria: Independent, Negotiable, Valuable, Estimable, Small, Testable
  • Use vertical slicing (each slice is independently deployable)
  • Apply walking skeleton (minimal end-to-end first)
TD2: No Clear Entry Point

Symptoms: Multiple valid starting points, paralysis, everything seems connected

Interventions:

  • Front-load risk: start with highest-uncertainty items
  • Tracer bullet: minimal proof of concept
  • Find the walking skeleton: thinnest slice through all layers
TD3: Dependency Problems

Symptoms: "Blocked on X", diamond dependencies, coordination overhead

Interventions:

  • Interface contracts: define API, mock while implementing
  • Feature flags: deploy independently, enable when ready
  • Branch by abstraction: create layer, swap implementations
TD4: No Clear Done Criteria

Symptoms: "Almost done" forever, no way to verify completion

Interventions:

  • Define acceptance criteria (Given/When/Then)
  • Time-box to force prioritization
  • Define explicit out-of-scope items
Show full SKILL.md (237 more words)Show less
TD5: Scope Creep

Symptoms: Task keeps growing, "while we're here" additions

Interventions:

  • Freeze scope, spawn new tasks for additions
  • Define minimum viable version
  • Ship smallest version that solves the problem
TD6: Need Spike First

Symptoms: Estimate variance > 4x, new technology, multiple approaches

Interventions:

  • Time-boxed spike (8 hours max)
  • Deliverables: options, POC, trade-offs, revised estimate
  • Spike then implement pattern

Decomposition Patterns

Vertical Slicing (Preferred for Features)
Feature: User Profile Management

Slice 1: View basic profile (4h)
  - UI: Profile display
  - API: GET /profile
  - DB: Read profile

Slice 2: Edit profile name (6h)
  - UI: Edit dialog
  - API: PATCH /profile/name
  - DB: Update profile

Each slice is independently deployable
Walking Skeleton (For New Systems)
Minimal end-to-end first:
1. Hello World page
2. One GET endpoint
3. Single table
4. Basic deploy

Then flesh out incrementally
Tracer Bullet (Validate Architecture)
Step 1: Minimal Service A (1h) - Hardcoded response
Step 2: Minimal Service B (1h) - Simple transformation
Step 3: Integrate (2h) - Prove they communicate

Total: 4 hours to decision point

Estimation Techniques

Complexity Sizing (Fibonacci)
PointsMeaning
1Trivial, < 1 hour
2Simple, 1-2 hours
3Standard, 2-4 hours
5Moderate, 4-8 hours
8Complex, 1-2 days
13Very complex, 2-3 days
21Too large, must decompose
Three-Point Estimation
O = Optimistic (everything perfect)
L = Likely (normal case)
P = Pessimistic (major issues)

PERT estimate: (O + 4L + P) / 6

Anti-Patterns

Big Bang Delivery

Building complete system before any delivery. Fix: Vertical slices, incremental value.

Technical Tasks Without Value

"Set up database," "Create service layer." Fix: Include in feature tasks: "User can view products (includes DB)."

Research Forever

Unbounded investigation. Fix: Time-boxed spikes with deliverables.

Perfect Decomposition

Over-analyzing before starting. Fix: Decompose next 2 weeks. Details for later work emerge.

Decomposition Checklist

Before starting any task:

  • Can hold all requirements in working memory?
  • Duration under 2-3 days?
  • Clear acceptance criteria exist?
  • Dependencies identified and broken where possible?
  • Can be completed independently?
  • Delivers verifiable value?
  • Estimate confidence is high?

If any "no" → further decomposition needed.

  • github-agile - Track decomposed work as issues
  • system-design - Understand architectural boundaries
  • requirements-analysis - Clarify unclear requirements
  • code-review - Review after implementation

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

Files

Just SKILL.md in skills/tech/development/quality/task-decomposition of jwynia/agent-skills.

Open the folder on GitHubat commit e02ec7e

Compare with similar skills

Task Decomposition 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 Decomposition compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Task Decomposition this skilljwynia/agent-skills166—~1.5kAutomated safety check: PassMIT
MemPalace Task HandoffMemPalace/mempalace59k—~1.9kAutomated safety check: PassMIT
Planning And Task Breakdownabashev/vfs-s31068 repos~1.9kAutomated safety check: PassApache-2.0
Incremental Implementationaddyosmani/agent-skills103k1 repos~2.3kAutomated safety check: PassMIT
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

Similar skills

  • MemPalace Task Handoff

    MemPalace/mempalace

    Creates, hands off, claims, executes and closes agent tasks through the MemPalace logstream, with approval of the exact task before it is recorded.

    59k GitHub stars~1.9k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • 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

  • Incremental Implementation

    addyosmani/agent-skills

    Delivers a change in thin vertical slices, each implemented, tested, verified and committed before the next, using vertical, contract-first or risk-first slicing.

    103k GitHub starsUsed in 1 repo~2.3k 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

  • agtx One-Shot Project Runner

    fynnfluegge/agtx

    Runs a whole project unattended on an agtx kanban board, decomposing the goal, starting tasks, unblocking workers and merging each result.

    1.7k GitHub stars~3.8k tokensUpdated 5 days ago
    Agent WorkflowsAuto-check passed

More from jwynia/agent-skills

All 112 skills in this repo

  • Devcontainer

    jwynia/agent-skills

    Diagnose devcontainer configuration problems and guide development environment setup.

    166 GitHub stars~1.2k tokensUpdated 7 mo ago
    Auto-check: notes

  • Frontend Design

    jwynia/agent-skills

    Create distinctive, production-grade frontend interfaces with high design quality.

    166 GitHub stars~3.2k tokensUpdated 7 mo ago
    Auto-check passed

  • Gitea Workflow

    jwynia/agent-skills

    Orchestrate agile development workflows for Gitea repositories using the tea CLI.

    166 GitHub stars~3.8k tokensUpdated 7 mo ago
    Auto-check passed

  • Godot Asset Generator

    jwynia/agent-skills

    Generate game assets using AI image generation APIs (DALL-E, Replicate, fal.ai) and prepare them for Godot.

    166 GitHub stars~3.8k tokensUpdated 7 mo ago
    Auto-check passed

  • Mastra Hono

    jwynia/agent-skills

    Develop AI agents, tools, and workflows with Mastra v1 Beta and Hono servers.

    166 GitHub stars~2.9k tokensUpdated 7 mo ago
    Auto-check passed

  • PPTX Generator

    jwynia/agent-skills

    Create and manipulate PowerPoint PPTX files programmatically.

    166 GitHub stars~3.1k tokensUpdated 7 mo ago
    Auto-check passed

Categories

Questions about Task Decomposition

What does Task Decomposition do?

Transform overwhelming development tasks into manageable units. Task Decomposition is an agent skill from jwynia/agent-skills. Transform overwhelming development tasks into manageable units.

When should I use Task Decomposition?

Task Decomposition fits situations like: says task too big; overwhelmed by scope; where do I start; epic needs breakdown.

How do I install Task Decomposition in Claude Code?

Run `npx skills add jwynia/agent-skills --skill task-decomposition -a claude-code`. Or copy the skill folder (skills/tech/development/quality/task-decomposition in jwynia/agent-skills) into .claude/skills/task-decomposition in your project. Claude Code loads it when a task matches its description.

How do I install Task Decomposition in Codex?

Run `npx skills add jwynia/agent-skills --skill task-decomposition -a codex`. Or copy the skill folder (skills/tech/development/quality/task-decomposition in jwynia/agent-skills) into .agents/skills/task-decomposition in your project. Codex loads it when a task matches its description.

Can I use Task Decomposition 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 jwynia/agent-skills --skill task-decomposition -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-decomposition, .gemini/skills/task-decomposition, .github/skills/task-decomposition and .opencode/skills/task-decomposition in your project.

What does Task Decomposition need to run?

SKILL.md names no scripts, command-line tools or credentials: Task Decomposition is instructions for the agent only. Compatibility (from SKILL.md): Works with any project. Integrates with github-agile for tracking decomposed work..

Does Task Decomposition 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 Decomposition 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 Decomposition use?

Task Decomposition is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Task Decomposition use?

About 1.5k tokens (SKILL.md is roughly 6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Task Decomposition?

Skills that share tags, products or a category with Task Decomposition: MemPalace Task Handoff (MemPalace/mempalace, 59k stars), Planning And Task Breakdown (abashev/vfs-s3, 106 stars), Incremental Implementation (addyosmani/agent-skills, 103k stars) and ULW Plan Workflow (code-yeongyu/oh-my-openagent, 70k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Task Decomposition?

jwynia (a GitHub user) maintains it in jwynia/agent-skills, which has 166 GitHub stars. The repository holds 112 skills in this directory. The repository was last updated on February 24, 2026.

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