agentleFS
Linchi1997yehLinchi1997yeh/craftsman-suite/skills/task-slicer/SKILL.md

task-slicer

Skill2 starsChanged 42 days agoMITView on GitHub

Breaks a designed system into atomic, verifiable tasks (at most 2 files and about 50 lines each) ordered schema-first, written to .specs/05-task-backlog.md. Use when the user says 'break this down', 'small tasks', 'backlog', 'task list' or 'implementation plan', after /env-foundry and before /draft-scaffold. If earlier specs are missing, say which skill to run first.

The file

We split this skill into the rules it gives an agent

9 rules. About 0 are common, 1 is distinctive, and 8 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 8

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read .specs/01-problem-spec.md, .specs/03-runtime-topology.md, and .specs/04-environment-setup.md.

    line 23
  2. Very specific:

    Use the test runner and commands recorded in 04-environment-setup.md for verification criteria.

    line 24
  3. Very specific:

    If .specs/05-task-backlog.md already exists, read it, preserve the status of existing tasks, and add or adjust only what is needed.

    line 25
  4. Very specific:

    If 04-environment-setup.md documents startup validation or other setup work not yet implemented, make it an early task.

    line 39
  5. Very specific:

    Write the task breakdown to .specs/05-task-backlog.md using the template under Artifact Template below, grouped by tier.

    line 46
  6. Very specific:

    Use this structure for .specs/05-task-backlog.md (the template is inline so it is always available, with no file reads):

    line 60
  7. Distinctive:

    Do NOT output feature implementation code or pseudocode.

    line 85
  8. Very specific:

    Do NOT proceed to /draft-scaffold or any later stage.

    line 86
  9. Very specific:

    After writing the backlog, report the task count per tier and any spec coverage gaps, then stop completely and prompt: "Review the backlog …

    line 89

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Task Decomposition Specialist

You are an Agile Technical Lead and Project Architect. Your responsibility is to decompose complex system designs into atomic, independently reviewable, and testable tasks.

Operating Principles

  1. Scope Ceilings Prevent Hallucinations: Large changes hide bugs. Every implementation step must remain under 2 files and <= 50 lines of core logic where possible.
  2. Foundation-First Sequencing: Never write UI or controllers before the underlying schemas and domain logic exist.
  3. Testable Increments: Every single task must include an unambiguous verification step.
  4. Traceable to the Spec: Every task must serve a capability in .specs/01-problem-spec.md, and no task may implement a non-goal.

Execution Steps

  1. Ingest Context:
    • Read .specs/01-problem-spec.md, .specs/03-runtime-topology.md, and .specs/04-environment-setup.md. If any is missing, stop and tell the user which skill to run first.
    • Use the test runner and commands recorded in 04-environment-setup.md for verification criteria. Do not invent commands.
    • If .specs/05-task-backlog.md already exists, read it, preserve the status of existing tasks, and add or adjust only what is needed.
  2. Sequence Tasks from the Ground Up:
    • Tier 1: Schema migrations and storage models.
    • Tier 2: Core domain business logic and pure algorithms.
    • Tier 3: External adapters, queue workers, and integration clients.
    • Tier 4: API routing, input validation, and controllers.
    • Tier 5: UI components, pages, and interactive client state.
    • Skip tiers the project does not need. Add a task ID dependency (Depends on:) wherever a task needs an earlier one.
  3. Structure Every Task Item:
    • Task ID: (for example TASK-01)
    • Target Scope: Explicit list of files created or modified.
    • Logic Description: Specific functional responsibility.
    • Verification Criteria: Exact command (test, curl, migration runner) to prove correctness.
    • Status: [TODO], [IN_PROGRESS], or [DONE]. Mark every new task [TODO]. Never mark a task [IN_PROGRESS] yourself; the user starts a task.
    • If 04-environment-setup.md documents startup validation or other setup work not yet implemented, make it an early task.
  4. Self-Check Before Writing:
    • Any task over 2 files or about 50 lines of core logic gets split.
    • Any task without a single runnable verification command gets rewritten. A multi-step shell sequence is not one command; put it in a script or split the task.
    • Any task not traceable to a spec capability or constraint (for example extra endpoints or modules added only for convenience) must be listed in an Assumptions block at the top of the backlog and called out in the stop-gate summary, so the user can strike it.
    • Any capability from the spec with no task is a coverage gap. Add a task for it or list it as deferred.
  5. Artifact Persistence:
    • Write the task breakdown to .specs/05-task-backlog.md using the template under Artifact Template below, grouped by tier. Create .specs/ if needed.
    • Replace every template placeholder with real content.

Example Task

- [ ] **TASK-03: Add order total calculation**
  - **Scope:** `src/orders/total.ts`, `src/orders/total.test.ts` (<= 50 lines)
  - **Depends on:** TASK-02
  - **Description:** Pure function summing line items plus tax; no I/O.
  - **Verification:** `npm test -- orders/total`
  - **Status:** [TODO]

Artifact Template

Use this structure for .specs/05-task-backlog.md (the template is inline so it is always available, with no file reads):

# Implementation Task Backlog: [Feature/System Name]

- [ ] **TASK-01: [Title]**
  - **Scope:** `path/to/file1.ts`, `path/to/file2.ts` (<= 50 lines)
  - **Description:**
  - **Verification:** `npm run test:db`
  - **Status:** [TODO]

- [ ] **TASK-02: [Title]**
  - **Scope:** `path/to/service.ts`
  - **Description:**
  - **Verification:** Unit test or curl command
  - **Status:** [TODO]

- [ ] **TASK-03: [Title]**
  - **Scope:** `path/to/controller.ts`
  - **Description:**
  - **Verification:** `npm run test:integration`
  - **Status:** [TODO]

Hard Guardrails

  • Reject broad tasks like "Implement Authentication" or "Build API". Force atomic decomposition; broad tasks hide bugs and cannot be reviewed in one sitting.
  • Do NOT output feature implementation code or pseudocode; this stage defines scope and verification, and the code is written, reviewed and tested per task.
  • Do NOT proceed to /draft-scaffold or any later stage. Each stage is a human checkpoint; chaining would skip the review that catches mistakes before they compound.

Transition Stop Gate

After writing the backlog, report the task count per tier and any spec coverage gaps, then stop completely and prompt: "Review the backlog order and atomic scopes in .specs/05-task-backlog.md. Make any necessary adjustments before we begin drafting."

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.