planning-and-task-breakdown
/planning-and-task-breakdown
Dzieli pracę na uporządkowane zadania do równoległego wykonania z grafem DAG, stabilnymi identyfikatorami, deklarowanymi zapisami plików, konfliktami i sufiksami gałęzi dla macierzy CI i agentów.
- Autor
- LazyIsEfficient ↗
- Repozytorium
- agentic-os ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 22.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 6
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Dzieli pracę na uporządkowane zadania do równoległego wykonania z grafem DAG, stabilnymi identyfikatorami, deklarowanymi zapisami plików, konfliktami i sufiksami gałęzi dla macierzy CI i agentów.
Oryginalny opis (EN)
Breaks work into ordered, parallel-dispatchable tasks with an execution DAG. Output format is consumable by CI matrices and parallel agent runners — each task has a stable ID, declared file writes, conflict edges, and branch suffix. Use when you have a spec, brief, or shaper output and need to decompose it into implementable units. Use when a task feels too large, when scope spans multi-repo or multi-week work, or when parallel execution across multiple agents is on the table.
Jak działa
- When to use
- The planning process
- Universal rules
- References
- Verification
Podgląd SKILL.md
--- name: planning-and-task-breakdown description: Breaks work into ordered, parallel-dispatchable tasks with an execution DAG. Output format is consumable by CI matrices and parallel agent runners — each task has a stable ID, declared file writes, conflict edges, and branch suffix. Use when you have a spec, brief, or shaper output and need to decompose it into implementable units. Use when a task feels too large, when scope spans multi-repo or multi-week work, or when parallel execution across multiple agents is on the table. when_to_use: | Use after a `prompt-shaper` or `marketing-shaper` (marketing pack: `--with-marketing`) brief when the work spans multiple repos, multiple weeks, or needs parallel agent execution — specifically when the implementation order is not obvious or tasks can safely be dispatched concurrently. Use when a spec or task feels too large to start in one session. Not when: the change is single-file with obvious scope — implement it directly. Not when the work has not yet been shaped into a brief — use `prompt-shaper` first. Not when there is no spec yet and requirements are unclear — produce the spec first, then return to decompose it. compatibility: Requires Bash (Python 3 where scripts are invoked). Works in Claude Code and Codex via install.sh. --- # Planning and Task Breakdown Decompose work into small, verifiable tasks with a parallel-dispatchable structure. The output is a plan document — never code — that downstream runners (CI matrices, single-agent execution sessions) consume to do the work. ## When to use - After a `/shape` brief covering multi-repo, multi-week, or multi-slice work - When a spec or task feels too large to start in one session - When work needs to parallelize across agents or sessions - When implementation order isn't obvious **When not to use.** Single-file changes with obvious scope, or specs that already contain well-defined tasks. ## The planning process 1. **Plan mode.** Read in read-only mode. Map dependencies, note risks. *Do not write code during planning.* 2. **Identify the dependency graph.** Bottom-up — foundations first. 3. **Slice vertically.** Each task is a feature path through every layer it needs (schema + API + UI), not a horizontal layer of the system. Horizontal slicing produces half-finished branches. 4. **Write task blocks.** Each task is YAML frontmatter (id, depends_on, parallel_safe, conflicts_with, files_write, files_read, branch_suffix, scope) plus prose (description, acceptance, verification). Format and field semantics: [`references/task-block-format.md`](references/task-block-format.md). 5. **Order and checkpoint.** Phases are *presentational*; the DAG is the execution order. Checkpoints are synchronization barriers — dispatch pauses until they clear. 6. **Declare the Execution DAG.** Top-of-document summary of edges using `→` and `||`. Format and dispatcher contract: [`references/execution-dag.md`](references/execution-dag.md). ## Universal rules - **Stable IDs, never renumbered.** Use content-based slugs (`T-auth-schema`). Renumbering breaks every reference. Retire dropped IDs rather than reusing them. - **`files_write` is authoritative, not advisory.** The dispatcher uses it for conflict detection. Under-declare → parallel collisions; over-declare → false serialization. - **The DAG is a summary, not the source of truth.** Per-task `depends_on` is authoritative. The verification checklist enforces that they agree. - **Day-zero ready set must be non-empty.** At least one task has `depends_on: []`. If none do, the plan is malformed. - **`scope: L` must be split before dispatch.** Agents perform best on XS / S / M. - **Plan, do not implement.** This skill never writes code. The output is a plan document; execution is a separate step. - **Every plan carries a `**Status:**` line.** Lifecycle `proposed` → `in-progress` → `shipped` | `superseded`. A fresh plan starts at `proposed`; keep it current as the work moves. It is the signal for retiring completed plans (prune `shipped`/`superseded` plans manually), so an unmarked plan never gets recognized as done. See [`assets/plan-document-template.md`](assets/plan-document-template.md). ## References - [`references/task-block-format.md`](references/task-block-format.md) — per-task YAML frontmatter and prose structure, field-by-field semantics - [`references/execution-dag.md`](references/execution-dag.md) — DAG syntax, dispatcher contract, checkpoints, worked example - [`assets/plan-document-template.md`](assets/plan-document-template.md) — full document template - [`references/parallelization-decisions.md`](references/parallelization-decisions.md) — when to set each YAML field; contract-first, barrel-file, migration patterns - [`references/task-sizing-and-redflags.md`](references/task-sizing-and-redflags.md) — sizing table, when to split, common rationalizations, red flags ## Verification Before starting implementation, confirm: - [ ] The plan has a `**Status:**` line (a fresh plan starts at `proposed`) - [ ] Every task has a stable `id` (content-based slug, not a number) - [ ] Every task has acceptance criteria and a verification step - [ ] Every task declares `depends_on`, `parallel_safe`, `files_write` - [ ] Every pair of tasks whose `files_write` overlap is in each other's `conflicts_with` - [ ] At least one task has `depends_on: []` (a non-empty day-zero ready set) - [ ] No task is `scope: L` (split it before dispatch) - [ ] No task touches more than ~5 files - [ ] The Execution DAG matches the per-task `depends_on` (no orphan IDs, no missing edges) - [ ] Checkpoints exist between major phases and are referenced in the DAG - [ ] The human has reviewed and approved the plan
Pliki w paczce (6)
- SKILL.md 6 KB
- assets/plan-document-template.md 3 KB
- references/execution-dag.md 3 KB
- references/parallelization-decisions.md 3 KB
- references/task-block-format.md 3 KB
- references/task-sizing-and-redflags.md 3 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · LazyIsEfficient/agentic-os | 100 | MIT |
| lucasouzadev/agent-kit-skill | 100 | MIT |
| zeative/satgas | 100 | AGPL-3.0 |
| FrancoStino/opencode-skills-collection | 100 | MIT |
| usermahiro/opencodee | 100 | MIT |
| rafidone/agent-skills | 100 | MIT |
| georgewangyu/GeorgeCodingAgent | 100 | MIT |
| hamzabellouch/agent-skills | 100 | MIT |
| addyosmani/agent-skills | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki e561c73ab7c4 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100task-breakdown-engineering
Opisuje praktykę podziału specyfikacji na małe, uporządkowane zadania z kryteriami akceptacji i sprawdzeniem ich wykonania. - 100wave-execution-planner
Grupuje fazy i zadania planu w fale uporządkowane według zależności do równoległego wykonania przez subagentów w git worktrees, z grafem DAG, sortowaniem topologicznym i żywym dokumentem statusu. - 90planning
Dzieli funkcję na uporządkowane, weryfikowalne zadania w pliku planu i przypisuje model do każdego zadania przy zmianach w wielu plikach. - 100plan-execution
Dzieli zatwierdzony plan implementacji na zadania właściwej wielkości i wykonuje je, każde w osobnym kontekście, z kontrolą kompletności. - 100planning-parallel-work
Dzieli dużą pracę programistyczną na niezależnie sprawdzalne elementy i grupy wykonywane równolegle. - 100vibe-parallel-task-decomposition
Analizuje duże zadanie pod kątem niezależnych podzadań i układa plan równoległego wykonania z kolejnością zależności.