task-decomposition

Decompose blueprints into validated build plans with TDD task structure and dependency mapping.

Updated Nov 8, 2025
One-click install
npx skills add https://github.com/elevanaltd/eav-cep-assist --skill task-decomposition-elevanaltd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-decomposition
Source: https://github.com/elevanaltd/eav-cep-assist/tree/main/.claude/skills/task-decomposition
Command: npx skills add https://github.com/elevanaltd/eav-cep-assist --skill task-decomposition-elevanaltd

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill streamlines the creation and validation of detailed build plans, ensuring tasks are atomic, dependencies are correctly mapped, and critical paths are accurate, preventing costly rework.

Core Features & Use Cases

  • Task Decomposition: Breaks down large blueprints into granular, actionable tasks.
  • Integrated Validation: Uses an external validator (Codex) to enforce strict Definition of Done (DOD) criteria.
  • TDD Enforcement: Ensures tasks follow a Test-First, then Feature implementation structure.
  • Use Case: When initiating a new software feature, use this Skill to decompose the high-level requirements into a precise, validated list of tasks ready for development.

Quick Start

Use the task-decomposition skill to decompose the blueprint for the 'user-authentication' feature into a validated build plan.

Frequently Asked Questions about task-decomposition

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

FAQPage Schema
How do I decompose a software blueprint into actionable development tasks?

Decomposing a software blueprint into actionable development tasks involves breaking down large requirements into granular tasks with calibrated granularity, integrated Test-Driven Development (TDD) structuring, and explicit dependency mapping to create a validated build plan.

How does Test-Driven Development task structuring work when creating a build plan?

Test-Driven Development task structuring in a build plan enforces a strict Test-First, then Feature implementation sequence for each decomposed task, ensuring validation gates are met before feature development proceeds.

Can I use an external validator to enforce Definition of Done criteria for my build plan?

Yes, you can use an external validator like Codex to enforce mandatory validation gates and strict Definition of Done (DOD) criteria, ensuring your build plan tasks are atomic and dependencies are correctly mapped.

What is the best way to map dependencies and identify critical paths for software features?

Mapping dependencies and identifying critical paths is best achieved by decomposing blueprints into atomic tasks with explicit file path specificity, preventing costly rework by ensuring accurate task sequencing before development begins.

Do I need explicit file path specificity when planning task decomposition?

Yes, explicit file path specificity is required during task decomposition to ensure atomic tasks are accurately mapped, dependencies are correctly identified, and critical paths are validated without ambiguity.

Why does my software build plan fail validation without atomic tasks?

A software build plan fails validation without atomic tasks because the external validator enforces strict Definition of Done criteria, requiring granular task decomposition and correct dependency mapping to prevent costly rework.