Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Planowanie

work-breakdown

/work-breakdown

Dzieli specyfikację na uporządkowaną listę zadań, każde z jednym weryfikowalnym wynikiem, przypisanym poziomem i briefem delegowania, a efektem jest plik planu.

Repozytorium
agent-dev-team ↗
Licencja
MIT
Ostatnia zmiana repozytorium
26.09.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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.09.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 specyfikację na uporządkowaną listę zadań, każde z jednym weryfikowalnym wynikiem, przypisanym poziomem i briefem delegowania, a efektem jest plik planu.

Oryginalny opis (EN)

Splits a spec into an ordered list of tasks, each with a single verifiable outcome, an assigned tier, and a delegation brief. Use when a spec exists but there is no plan, when work must be divided across agents or people, or when a task is too large to verify in one step. Produces a plan file, not code.

Jak działa

  1. Process
  2. Task format
  3. Sizing heuristics
  4. Ordering
  5. Output
  6. Verification
  7. Red flags
Sekcje z nagłówków SKILL.md, w oryginale · 102 linii, 711 słów
Podgląd SKILL.md
---
name: work-breakdown
description: Splits a spec into an ordered list of tasks, each with a single verifiable outcome, an assigned tier, and a delegation brief. Use when a spec exists but there is no plan, when work must be divided across agents or people, or when a task is too large to verify in one step. Produces a plan file, not code.
license: MIT
metadata:
  phase: plan
  owners: [tech-lead]
  version: "0.1.0"
---

# Work Breakdown

A plan is right when each task has one outcome you can check with one command, and the
order puts the riskiest thing first.

If there is no spec, use `spec-writing` first. Planning against unwritten requirements
produces a plan that changes every day.

## Process

1. **Read the repository before planning.** Existing patterns constrain the plan more than
   preferences do. Note the conventions you found, with paths, and plan inside them or
   state the deliberate deviation.

2. **Cut along seams that already exist.** A task spanning three modules is either three
   tasks or one badly-drawn boundary. Prefer boundaries the code already has.

3. **Order by risk, not by ease.** The task that could invalidate the rest of the plan goes
   first. If an unknown could do that, task one is a spike whose output is an answer, not
   code you keep.

4. **Size to one verifiable outcome.** A task is right-sized when its definition of done is
   a single command whose output you can read. Three commands means three tasks.

5. **Assign the lowest tier that clears the ceiling** (`references/escalation-ladder.md`).
   Over-assignment hides a vague brief.

6. **Write a brief per task.** A task without one comes back wrong, and that is the
   planner's defect.

7. **State dependencies explicitly.** Tasks with no dependency between them can run in
   parallel, but two tasks that edit the same file are one task.

## Task format

```markdown
- [ ] **<id> · <title>** — `<agent>`
  - Goal: <one sentence in observable behavior>
  - Files in scope: <explicit paths>
  - Pattern to follow: <path:line>
  - Definition of done: `<the single command that must pass>`
  - Out of scope: <what to leave alone>
  - Stop condition: <what triggers an escalation>
  - Depends on: <ids, or none>
```

## Sizing heuristics

| Symptom | Fix |
|---------|-----|
| The definition of done needs three commands | Split into three tasks |
| The task title contains "and" | Split at the "and" |
| You cannot name the files in scope | You do not understand it yet. Investigate first, as its own task. |
| The task touches more than one module | Either split, or the boundary is wrong |
| Estimating it feels impossible | It contains an unknown. Make removing that unknown task one. |

## Ordering

- Riskiest first. The purpose of order is to find out early that the plan is wrong.
- A task that unblocks several others outranks a task that unblocks none.
- Group tasks that touch the same file so they do not run in parallel.
- Prefer an order where each step leaves the system working. A plan with a broken middle
  cannot be paused, and plans always get paused.

## Output

```markdown
## Plan: <feature>

### Sequence rationale
<which task removes the most risk, and why this order>

### Parallelisable
<which ids can run at once, and which must not share files>

### Tasks
<the task list>

### Not in this plan
<what was deliberately left out>
```

## Verification

- Every task has a definition of done that is a runnable command.
- Every task is assigned a tier, and the assignment clears that tier's ceiling.
- The dependency graph has no cycle.
- The first task is the riskiest, or the rationale says why not.
- No two parallel tasks edit the same file.

## Red flags

| Thought | Reality |
|---------|---------|
| "I'll do the easy tasks first for momentum" | You will discover the plan is wrong at the end instead of the start. |
| "This task is obvious, no brief needed" | Obvious to you. The brief is for whoever picks it up. |
| "I'll assign it senior to be safe" | Over-assignment is a symptom of a vague brief, not caution. |
| "The order does not matter much" | Order is the plan. If it did not matter you would not need one. |
| "I'll write this task myself, it is small" | Then it is a T0 task with a brief. Your output is the plan. |
| "We can plan the rest as we go" | Plan to the next verifiable milestone at least. Beyond that, say so explicitly. |

Wersje

RepozytoriumWynikLicencja
Ta strona · khuynh22/agent-dev-team100MIT
dnlrsls/gentle-stack95MIT

Migawka bazy z 13.11.2026 · wersja paczki b64e5df23b12 (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

  • 100breakdown
    Rozbija funkcję ze specyfikacją i planem na uporządkowaną listę zadań w pliku tasks.md, także gdy zmiana specyfikacji lub planu unieważniła starą listę.
  • 100planning-and-task-breakdown
    Rozbija specyfikację lub wymagania na uporządkowane zadania do wdrożenia i szacuje zakres pracy.
  • 100planning-and-task-breakdown
    Zamienia specyfikację na zadania do wdrożenia, szacuje zakres i wskazuje część pracy możliwą równolegle.
  • 100planning-and-task-breakdown
    Rozkłada specyfikacje na małe, uporządkowane zadania z kryteriami akceptacji i krokami weryfikacji, tworząc plan implementacji lub listę zadań.
  • 100brief-to-tasks
    Rozbija brief projektowy na uporządkowaną listę niezależnie budowalnych zadań w pionowych plastrach i zapisuje ją jako checklistę w markdown.
  • 90planning
    Dzieli funkcję na uporządkowane, weryfikowalne zadania w pliku planu i przypisuje model do każdego zadania przy zmianach w wielu plikach.

Uwagi i zgłoszenia

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