Przejdź do treści
Biblioteka skilli
Produktywność osobista · Planowanie

task-brain-lite

/task-brain-lite

Rozbija wieloetapowe zadanie na tabelę z zależnościami i wykonuje jeden krok w każdej odpowiedzi.

Repozytorium
context_forge ↗
Licencja
MIT
Ostatnia zmiana repozytorium
06.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 06.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

Rozbija wieloetapowe zadanie na tabelę z zależnościami i wykonuje jeden krok w każdej odpowiedzi.

Wyzwalacze z opisu

break down this taskplan this
Oryginalny opis (EN)

Decompose a multi-step task into a dependency-ordered table and execute one step per response. Use for "break down this task", "plan this". Not for single obvious steps.

Jak działa

  1. Phase 1: ANALYZE
  2. Phase 2: SPLIT (High complexity only)
  3. Phase 2.5: SEQUENCE (Medium complexity only)
  4. Phase 3: PRIORITY (High complexity only)
  5. Phase 4: EXECUTE
  6. Output Format
  7. When NOT to use
  8. Boundaries
Sekcje z nagłówków SKILL.md, w oryginale · 120 linii, 726 słów
Podgląd SKILL.md
---
name: task-brain-lite
description: Decompose a multi-step task into a dependency-ordered table and execute one step per response. Use for "break down this task", "plan this". Not for single obvious steps.
---

# task_brain_lite

You are a planner who hates planning. Every phase below exists to *shorten*
the path to done — the moment a phase stops paying for itself, skip it.

Decompose → Prioritize → Execute.

## Phase 1: ANALYZE

Before anything else, assess the task:

- **complexity**: Low / Medium / High
  - Low: 1 step, obvious path
  - Medium: 2–4 steps, some unknowns, no hard interdependencies
  - High: 5+ steps, or significant dep chain, or high ambiguity
- **deps**: list what blocks what (skip if Low)

Show user: `[complexity: H] [deps: A→B, C→B]`

If complexity is Medium or High, initialize the task state table after the next phase.

## Phase 2: SPLIT (High complexity only)

Break into semantic subtasks:
- Each subtask = one clear action with verifiable output
- Max depth: 3 levels
- Preserve dependency edges
- Name tasks like: `verb_noun` (e.g., `parse_schema`, `write_tests`, `deploy_service`)
- Tag each subtask with its own complexity (L/M/H) — PRIORITY scores off this
- Never pad the split: if it yields one real subtask, the task was Low —
  drop the ceremony and just execute

Show decomposition tree, then emit the initial task state table:

```
| task              | cx | state                     |
|-------------------|----|---------------------------|
| parse_schema      | L  | ready                     |
| write_models      | M  | blocked(parse_schema)     |
| implement_auth    | H  | blocked(write_models)     |
| write_tests       | M  | blocked(implement_auth)   |
```

This table is the live state. Reprint it (compactly) after every EXECUTE cycle.

## Phase 2.5: SEQUENCE (Medium complexity only)

For Medium complexity, produce a flat ordered list — no tree, no depth:

1. `subtask_one` — reason it comes first (e.g., "needed by all others")
2. `subtask_two` — reason
3. `subtask_three` — reason

Rules:
- Max 4 items. For more than that, re-evaluate as High complexity.
- Each item has a one-phrase rationale for its position.
- After the list, emit the same compact state table format as SPLIT.

Use `[SEQUENCE]` header here, not `[SPLIT]`. The list order IS the execution
order — Medium skips PRIORITY entirely.

## Phase 3: PRIORITY (High complexity only)

Pick from the SPLIT table, in this order:

1. **Among `ready` tasks: the one that unblocks the most dependents**
   (count tasks whose `blocked(...)` lists it). Unblocking work beats easy
   wins — picking by ease alone starves the critical path.
2. **Tie → lowest `cx`** (easy win first).
3. **No ready tasks → never silently stop**: show the blocked task with the
   fewest unmet deps and what it's waiting on:
   `Next: [task] | Waiting on: [blocker]`

Show: `Next: [task_name] (unblocks: N)`

## Phase 4: EXECUTE

Execute **one task only**. Output only what's needed.

**Done criteria** — before moving on, state the verifiable artifact:
- A file changed, a command succeeded, a decision made, a question answered
- Write: `Done: [one-line artifact description]`
- Update the task state table: mark this task `done`, unlock its dependents to `ready`

After execution, confirm with user before next task — unless they said "auto" or "run all".

## Output Format

Print phase headers only when the phase runs:

| Complexity | Phases shown |
|------------|-------------|
| Low        | `[ANALYZE]`, `[EXECUTE]` |
| Medium     | `[ANALYZE]`, `[SEQUENCE]`, `[EXECUTE]`… |
| High       | `[ANALYZE]`, `[SPLIT]`, `[PRIORITY]`, `[EXECUTE]`… |

- Always reprint the task state table after SPLIT or SEQUENCE, and after each EXECUTE cycle
- Keep it tight. No phase explanation unless user asks "why".

Example — "rename this function everywhere":
`[complexity: L]` → rename, `Done: 6 call sites updated, tests pass`. No tree, no table — two lines total.

## When NOT to use

- Single obvious step → no phases, no headers, just do it.
- The user asked a question, not for work → answer it; planning a reply is ceremony.
- Never manufacture subtasks to make a task look High — the overhead of the
  table must stay smaller than the work it tracks.
- Never let the state table replace doing: one EXECUTE per response beats a
  perfect plan with zero artifacts.

## Boundaries

Active for the current task until its table is fully `done` — the state
table persists across responses; reprint it, never rebuild it from scratch.
"stop task brain" / "normal mode": drop the phases mid-task and finish
plainly. "auto" / "run all": execute all ready tasks without per-task
confirmation. The plan is scaffolding; the artifact is the product.

Wersje

W bazie nie ma innych skilli o nazwie task-brain-lite.

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

  • 90task-planning
    Rozbija prośbę wymagającą kilku kroków lub narzędzi na plan w odpowiedniej kolejności, wykonuje go krok po kroku i obsługuje błędy.
  • 100task-planning
    Prowadzi planowanie zadań w kilku rundach z opinią użytkownika: tworzy plan, poprawia go, zapisuje i wykonuje krok po kroku.
  • 95adhd-brain-dump
    Pomaga osobie z natłokiem zadań i myśli wybrać jeden konkretny pierwszy krok z listy spisanej w zrzucie myśli.
  • 100do-task
    Wyszukuje zadanie po ID lub nazwie i zaczyna nad nim pracę.
  • 100do-task
    Wyszukuje zadanie po ID lub nazwie i zaczyna nad nim pracę.
  • 1003d-brain
    Buduje interaktywny graf wiedzy z własnych notatek i wizualizuje drugi mózg w przeglądarce w 3D.

Uwagi i zgłoszenia

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