Skip to content
Skills Library
Management & product · Planning

task-planner

/task-planner

Decompose complex requests into ordered steps, dependencies, risks, and deliverables. Use when the user asks to plan a project, break down a feature, migrate systems, or tackle multi-step work before coding.

Repository
navin ↗
Licence
AGPL-3.0
Last repository change
26.10.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 26.10.2026, without references to retired models or APIs.

Licence

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

What it does and when to use it

Decompose complex requests into ordered steps, dependencies, risks, and deliverables. Use when the user asks to plan a project, break down a feature, migrate systems, or tackle multi-step work before coding.

Original author description

Decompose complex requests into ordered steps, dependencies, risks, and deliverables. Use when the user asks to plan a project, break down a feature, migrate systems, or tackle multi-step work before coding.

How it works

  1. Overview
  2. When to use
  3. When NOT to use
  4. Workflow
  5. Output format
  6. Rules
Original SKILL.md headings · 74 lines, 424 words
SKILL.md preview
---
name: task-planner
description: Decompose complex requests into ordered steps, dependencies, risks, and deliverables. Use when the user asks to plan a project, break down a feature, migrate systems, or tackle multi-step work before coding.
metadata: {"navin":{"emoji":"🧭","category":"intelligence"}}
---

# Task Planner

## Overview

Turn ambiguous or large requests into an executable plan the agent (and user) can follow. Prefer clarity over length.

## When to use

- Multi-step projects, migrations, refactors, or "build X end-to-end"
- Unclear scope - plan first, then ask only the blockers
- Handoffs to `spawn` subagents or parallel workstreams

## When NOT to use

One-shot work is not a plan: one deck, one memo, one file, one script, a typo, a rename, a selected template. Do that now. Do not file a two-step board and wait for Build. HTML or JSON in the pipeline is an intermediate, not a deliverable and not a reason to stop.

## Workflow

1. **Restate the goal** in one sentence (success criteria).
2. **List constraints** (deadline, stack, security, “do not touch X”).
3. **Break into steps** (5-12 max for the first pass). Each step must be:
   - actionable
   - independently verifiable
   - ordered by dependency
4. **Mark dependencies** (`blocked by step N`).
5. **Identify risks / unknowns** and the cheapest probe to resolve each.
6. **Define deliverables** (files, PRs, reports, commands to run).
7. **Propose execution mode**:
   - sequential in this chat, or
   - `spawn` for independent tracks (architect / implementer / reviewer)

## Output format

Prefer recording the plan on the board + mission ledger. When writing in chat, still include:

```markdown
## Goal
...

## Constraints
- ...

## Facts
- ...

## Missing info
- ...

## Acceptance criteria
- ...

## Plan
1. ... (validation=verify|test|lint|manual|none; depends on …)
2. ...

## Risks
- ...

## Next action
Start with step 1: ...
```

Each board step should set `acceptance` and `validation`. After filing steps, call `board` `ledger_init` only for multi-file / architecture work. A plan that describes a system includes an `archify` diagram (HTML path + caption).

## Rules

- Do not invent requirements - call out assumptions as missing_info or facts.
- Prefer the smallest plan that unblocks progress.
- If the request is a greeting or a vague one-liner with no goal, ask what to plan - do not invent a project name from the word.
- After the user confirms (or in /forge|/cruise with a clear target), execute step 1 unless they ask to wait.
- Wait for Build only after /blueprint on a multi-file or architecture job, or when the user asked only for a plan. A short mechanical plan (1-3 steps) on a simple deliverable starts step 1 in this turn.
- When plans change mid-flight, `ledger_replan` locally and state why before continuing.

Versions

RepositoryScoreLicence
This page · Navinspire-ia/navin100AGPL-3.0
aimi-so/aimi-engineering-plugin100MIT
craftos-dev/craftbot100MIT

Database snapshot: 13.11.2026 · package version af6fdf412e4f (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

  • 100planning-and-task-breakdown
    Decompose specs into small, ordered tasks with acceptance criteria and verification steps. Use when you have requirements and need an implementable plan or task list. Triggers: "break down tasks", "implementation plan", "task breakdown", "plan mode".
  • 100plan
    Use this skill when decomposing complex work into verifiable tasks and dependencies before or during implementation. Activates on mentions of write a plan, create a plan, break this down, task decomposition, implementation plan, what are the steps, plan the work, spec this out,…
  • 100task-decomposition
    Breaks down complex software, writing, or research tasks into small, atomic, independently completable units with dependency graphs and milestone breakdowns. Use when the user asks to plan a project, decompose a feature, create subtasks, split up work, or needs help organizing a…
  • 85planner-feature
    Create a plan for a feature, and the files required to continue working on it. Use when the user asks for research for a feature or a plan to run it.
  • 100planner
    Use when the user asks to create a new implementation plan, break down a task, plan a bug fix, plan a feature, or write a phased execution plan. Do not use when a plan already exists and the user wants implementation, review, or sprint scoping.
  • 100sugar-task-planner
    Guides an agent to turn a high-level task into a detailed execution plan with a task breakdown, dependencies, time estimates, risks, and measurable success criteria. Use when planning or decomposing a complex feature, bug fix, or refactor into subtasks; defining success…

Feedback and reports

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