eld-sense-task-decomposition

Decompose large tasks into nested parent, child, and grandchild structures with context inheritance maps.

1|Updated Dec 17, 2025
One-click install
npx skills add https://github.com/CAPHTECH/claude-marketplace --skill eld-sense-task-decomposition
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: eld-sense-task-decomposition
Source: https://github.com/CAPHTECH/claude-marketplace/tree/main/caphtech-plugin/skills/eld-sense-task-decomposition
Command: npx skills add https://github.com/CAPHTECH/claude-marketplace --skill eld-sense-task-decomposition

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill decomposes large tasks into a nested parent→child→grandchild structure (root → level 1 → level 2) and designs context inheritance across levels to enable deterministic planning and smooth execution with PCE.

Core Features & Use Cases

  • Three-level decomposition: Up to Level 2 sub-tasks; parent (root), Level 1 major components, and optional Level 2 sub-tasks.
  • Clear boundaries: Each task has explicit boundaries and can be scheduled in parallel where possible.
  • Context inheritance map: Defines what context is inherited and how data flows between levels.
  • Use Case: Start with a large feature, decompose into root task, major components, and sub-tasks to guide implementation and tracking.

Quick Start

Input Task: "Develop a payment processing module" Claude output: A Task Decomposition structure with Level 0 root, Level 1 major components, and Level 2 sub-tasks, plus a Context Inheritance Map.

Frequently Asked Questions about eld-sense-task-decomposition

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

FAQPage Schema
How do I break down a large feature into smaller, manageable tasks?

Task decomposition structures a large feature into a three-level hierarchy: a root task, Level 1 major components, and optional Level 2 sub-tasks. This approach clarifies boundaries, enables parallel scheduling, and maps how context flows between levels so implementation stays coordinated.

What is context inheritance in task planning, and why does it matter?

Context inheritance defines what information, constraints, or dependencies pass from parent tasks to child tasks across decomposition levels. A formal context inheritance map ensures child tasks have the data and constraints they need without duplication, reducing miscommunication and rework.

When should I use three-level task decomposition instead of a flat task list?

Use three-level decomposition for complex features, system design projects, and multi-phase workflows where clear modularization, explicit dependencies, and parallel execution matter. It's essential when you need single-responsibility tasks, deterministic planning, and formal tracking of context flow.

Can I parallelize work after decomposing a task?

Yes. Decomposing tasks into independent Level 1 and Level 2 components with explicit boundaries identifies which work can run in parallel. The context inheritance map shows which tasks depend on shared context, letting you schedule non-blocking work concurrently.

What output do I get from task decomposition?

You receive a nested task structure (root, Level 1 components, Level 2 sub-tasks) plus a context inheritance map showing how data and constraints flow between levels. This output guides implementation, dependency tracking, and execution sequencing for complex projects.

Does task decomposition work for payment processing or other multi-phase implementations?

Yes. Task decomposition applies to any complex feature with distinct phases or components—like payment processing modules. It breaks the feature into major components and sub-tasks, defines clear boundaries, and maps context flow so each phase knows its inputs and constraints.