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.