Skip to content
Skills Library
Personal productivity · Planning

task-brain-lite

/task-brain-lite

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.

Licence
MIT
Last repository change
06.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 06.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Triggers from the description

break down this taskplan this
Original author 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.

How it works

  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
Original SKILL.md headings · 120 lines, 726 words
SKILL.md preview
---
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.

Versions

The database has no other skills named task-brain-lite.

Database snapshot: 13.11.2026 · package version 3839a9fe53c8 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90task-planning
    Use when a request needs several steps or tools: break it into a dependency-ordered plan, run it step by step, handle failures, and keep agents and skills safe.
  • 100task-planning
    Structured task planning workflow with user feedback loops. Use when the user explicitly requests planning (e.g., "make a plan", "plan first", "create a plan"). Covers creating plans with actionable steps, iterating based on feedback, saving confirmed plans, and executing…
  • 95adhd-brain-dump
    Help someone with a full, scattered head get to one concrete next step. Use when a person brain dumps a pile of tasks, thoughts and worries, says they are overwhelmed or have too much on their plate, cannot start or does not know where to begin, wants to work through a list one…
  • 100do-task
    Look up a task by ID or name and start working on it. Use when the user wants to pick up and execute a task.
  • 100do-task
    Look up a task by ID or name and start working on it. Use when the user wants to pick up and execute a task.
  • 1003d-brain
    Use when someone asks to build a 3D brain, visualize their AIOS or second brain, turn their knowledge into an interactive graph, or run /3d-brain or /3D brain.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.