Skip to content
Skills Library
Management & product · Planning

split

/split

Turn a settled layer of a map into its next children: decide whether the layer is child maps or tasks, decide how many, and start each child through the action that writes it. Use when a map's layer is settled and its children do not exist yet.

Licence
Apache-2.0
Last repository change
13.11.2026

Assessment and security

90/ 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.
Content25 / 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 13.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Turn a settled layer of a map into its next children: decide whether the layer is child maps or tasks, decide how many, and start each child through the action that writes it. Use when a map's layer is settled and its children do not exist yet.

Original author description

Turn a settled layer of a map into its next children: decide whether the layer is child maps or tasks, decide how many, and start each child through the action that writes it. Use when a map's layer is settled and its children do not exist yet.

How it works

  1. When it runs
  2. Steps
  3. Hands off
  4. What this skill does not do
Original SKILL.md headings · 37 lines, 522 words
SKILL.md preview
---
name: split
description: "Turn a settled layer of a map into its next children: decide whether the layer is child maps or tasks, decide how many, and start each child through the action that writes it. Use when a map's layer is settled and its children do not exist yet."
family: track
invocation: model
---

# Split

One question decides the whole layer: can one complete action and one auditable standard be written for a part of it? Yes writes tasks, no writes child maps. Nothing else in this skill changes that answer.

## When it runs

A layer is settled — what it holds, which children it needs, and what is still unknown in each — and none of those children exists yet. A map may split while fog remains elsewhere; the part this layer covers has no open fog. The fog of a child is not this layer's: it is written when the child is opened.

The layer goes back to `grill-and-records` when it cannot support a child's `Target`, or the evidence a task's acceptance signal would name.

## Steps

1. **Decide the type.** Ask the question above for the layer as a whole. A layer is all one type; a direction that needs the other type opens a sibling map instead. Parts that read each other's output are not tasks: they are child maps with an edge between them.
2. **Decide the count before writing anything.** A layer is cut by the decisions the map already settled: each child's part comes from a decision in `Decisions so far`, and several decisions may feed one child or one decision may feed several. A part with no decision behind it is not cut; it goes back to `grill-and-records`, or stays in `Not yet specified` until it settles. For tasks, write the count and a one-line plan per task into the discussion's testimony.
3. **Open each child, one at a time, by calling the action that writes that record.** This skill writes no record: the writer hangs the child under the parent it is given.
   - A child map: call `open-map` once per child map, with that child's part of the parent's target and the decision it came from, and `--parent <map>`.
   - A task: call `open-task` once per task, with the action, the acceptance signal, the kind, `reversibility`, `needs_human`, the decision it serves, and `--parent <map>`.

   A layer is all one type, so a run calls one of the two actions for every child, never both.
4. **Start the map on its first split.** `waymark start <map>` and `waymark field update <map> --set split_as=<submap|task>`, once. `waymark/res/fields.md` defines the field and `map/res/body.md` freezes it; later splits change neither.
5. **Read the shape back.** `waymark tree --root <map>`.

A map carries one type for its whole life, so a split that finds a settled layer needing the other type is not this skill's job: it reports the mismatch and stops.

Each child exists, hung under the map, written by the action for its record; `waymark/res/fields.md` says what `split_as` is.

## Hands off

- A task: `advance-task`, when the person asks for it.
- A child map: back into this skill, one level down, when its own layer is settled.
- A layer that cannot be written: `grill-and-records`.

## What this skill does not do

- Change a map that has already split. Its content is `update`'s; recutting a task layer whose tasks wait on each other is `resplit`'s.

Versions

The database has no other skills named split.

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

  • 90open-map
    Write one map: turn the target it is given into a body with its fog and exclusions, and record where the target came from. The same action writes a root map and a child map. Use when a target is settled and has no map yet, or when a split is writing child maps.
  • 90whole-review
    Read the children of one map against themselves, their siblings, and their parent, and report where the set does not hold together: a child that contradicts its own review, two that promise the same result, or one that reaches past the map's acceptance direction. Use when a…
  • 100cl-split
    Split one top-level high-complexity ClosedLoop feature ticket into smaller executable child tickets when safe. Use when $cl-analyze or $cl-sweep determines a top-level ticket is HIGH complexity but potentially splittable, or when asked to decompose a FEA-* ticket before…
  • 100carve-github-issue
    Break one GitHub issue that is too large to work into sub-issues, unattended, and keep the carving honest as the children close. A carver names the pieces along the highest natural seam (domain, tier, route, area, file, unit, material), matches each against the backlog so…
  • 100child
    Runs this session as a child of a ticket's manager, the bottom of three levels. It does one named part, usually in another repo, asks and reports only to its manager, and leaves closing to it. Use when a slot opens with /orchestrator:child.
  • 100working-on-an-epic
    Use when asked to work on, implement, drive, or coordinate a GitHub epic, parent issue, or tracking issue whose work is split into child issues, and separate agent workspaces are available to implement them - you coordinate, the children implement

Feedback and reports

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