planning-and-task-breakdown

Decompose complex work into a verifiable DAG plan with task blocks and checkpoints.

15|3|Updated Apr 9, 2026
One-click install
npx skills add https://github.com/LazyIsEfficient/agentic-os --skill planning-and-task-breakdown-lazyisefficient
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: planning-and-task-breakdown
Source: https://github.com/LazyIsEfficient/agentic-os/tree/main/.claude/skills/planning-and-task-breakdown
Command: npx skills add https://github.com/LazyIsEfficient/agentic-os --skill planning-and-task-breakdown-lazyisefficient

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

Planning and Task Breakdown provides a structured method to decompose work into small, verifiable tasks with a clear execution DAG, ensuring tasks can be dispatched in parallel and tracked via stable IDs.

Core Features & Use Cases

  • Plan mode and read-only analysis: map dependencies, identify risks, and outline per-task frontmatter.
  • Execution DAG and checkpoints: define edges using DAG syntax and checkpoints to synchronize phases.
  • Task blocks and governance: each task includes id, depends_on, parallel_safe, files_write, files_read, branch_suffix, scope, plus acceptance and verification criteria.
  • Use cases include multi-repo or multi-week projects, cross-team coordination, and avoiding bottlenecks by parallelizing independent work.

Quick Start

Outline a plan by converting your brief into a set of task blocks and a simple DAG you can dispatch to agents.

Frequently Asked Questions about planning-and-task-breakdown

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

FAQPage Schema
How do I break down complex software engineering work into parallelizable tasks?

To break down complex software engineering work, you decompose it into small, verifiable tasks mapped to an execution DAG. This approach outlines per-task frontmatter and identifies dependencies to dispatch independent work in parallel.

What is an execution DAG and how does it manage parallel task scheduling?

An execution DAG is a directed acyclic graph that maps task dependencies and checkpoints to synchronize phases. It manages parallel task scheduling by defining edges that ensure independent work blocks execute concurrently without bottlenecks.

Can I use task breakdown and DAG planning for multi-week or multi-repo projects?

Yes, task breakdown and DAG planning target multi-week or multi-repo initiatives specifically. They handle cross-team coordination by mapping complex project scopes to conflict-aware task blocks with stable IDs for day-zero readiness.

What's the best way to structure task frontmatter for acceptance criteria and verification?

The best way to structure task frontmatter is using a contract-first approach. Each task block includes id, depends_on, parallel_safe, files_write, files_read, and branch_suffix fields alongside explicit acceptance and verification criteria.

How do I prevent file write conflicts when dispatching parallel software engineering tasks?

To prevent file write conflicts during parallel dispatch, you define conflict-aware task blocks using the files_write and files_read frontmatter fields. This ensures parallel_safe tasks do not modify overlapping resources.

Do I need a project brief to start generating a task plan with a DAG?

You need a project brief to start generating a task plan. The planning mode converts your brief into a read-only analysis that maps dependencies, identifies risks, and outlines per-task frontmatter before execution.