Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

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.

Repozytorium
agentic-os ↗
Licencja
MIT
Ostatnia zmiana repozytorium
22.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
6
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. When to use
  2. The planning process
  3. Universal rules
  4. References
  5. Verification
Sekcje z nagłówków SKILL.md, w oryginale · 57 linii, 607 słów
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

RepozytoriumWynikLicencja
Ta strona · LazyIsEfficient/agentic-os100MIT
lucasouzadev/agent-kit-skill100MIT
zeative/satgas100AGPL-3.0
FrancoStino/opencode-skills-collection100MIT
usermahiro/opencodee100MIT
rafidone/agent-skills100MIT
georgewangyu/GeorgeCodingAgent100MIT
hamzabellouch/agent-skills100MIT
addyosmani/agent-skills100MIT

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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.