decompose-task

Decompose approved build requests into named subcomponents and orchestrate parallel implementation.

Updated May 21, 2026
One-click install
npx skills add https://github.com/mica-agent/mica-solar-system --skill decompose-task-mica-agent
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: decompose-task
Source: https://github.com/mica-agent/mica-solar-system/tree/main/.qwen/skills/decompose-task
Command: npx skills add https://github.com/mica-agent/mica-solar-system --skill decompose-task-mica-agent

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It turns build/create/implement-style requests into an organized execution plan that splits work into clear subcomponents, reducing confusion and missed integration seams.

Core Features & Use Cases

  • Orchestrates decomposed execution: delegates planning to a task-decomposer and implementation to component-coder subagents, then dispatches in a controlled queue.
  • Uses decomposition gates + approval gates: only decomposes when architectural seams and working-set needs justify the overhead, and when the user explicitly approves implementation.
  • Contract verification workflow: validates that outputs match interfaces/dom contracts and performs stage 2 integration checks to ensure the artifact actually works.

(Optional) When to use

  • Use when the user says build verbs for a non-trivial artifact and gives explicit approval like "let's build" or "ship it".
  • Skip when it’s a bug fix, pure Q&A, doc-only edits, or the user opts out by saying to do it directly.

Quick Start

When you reply with an explicit approval to build an artifact (e.g., “ship it”), invoke decompose-task and let it coordinate planning and subagent implementation.

Frequently Asked Questions about decompose-task

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I decompose a complex software build into parallel steps?

Parallel task decomposition splits approved build requests into named subcomponents and orchestrates parallel implementation execution. It delegates planning to a task-decomposer and dispatches component-coder work per plan item to reduce missed integration seams.

When do I need task decomposition for build requests?

You need task decomposition for build requests when working on non-trivial artifacts that have clear architectural seams and working-set needs justifying the overhead. It requires explicit user approval like "let's build" or "ship it" to trigger the orchestrated execution workflow.

How do I verify interface contracts after parallel implementation?

To verify interface contracts after parallel implementation, validate that outputs match interface and domain contracts, then perform stage 2 integration checks. This contract verification workflow ensures the decomposed subcomponents function correctly as a unified artifact.

Should I use task decomposition for bug fixes and documentation edits?

Do not use task decomposition for bug fixes, doc-only edits, pure Q&A, or explicit user opt-outs. It applies strictly to create, implement, and build workflows for non-trivial artifacts that require parallel dispatch and integration verification.

What's the best way to orchestrate parallel implementation across subcomponents?

The best way to orchestrate parallel implementation is delegating planning to a task-decomposer, dispatching component-coder subagents per plan item, updating plan.todo lifecycle states, and enforcing approval gates to ensure controlled execution and contract verification.