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.
- Author
- kyuna0312 ↗
- Repository
- context_forge ↗
- Licence
- MIT
- Last repository change
- 06.09.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 06.09.2026, without references to retired models or APIs.
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
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
- Phase 1: ANALYZE
- Phase 2: SPLIT (High complexity only)
- Phase 2.5: SEQUENCE (Medium complexity only)
- Phase 3: PRIORITY (High complexity only)
- Phase 4: EXECUTE
- Output Format
- When NOT to use
- Boundaries
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.