Skip to content
Skills Library
Programming · Review & audit

duck-split

/duck-split

Hold a branch, PR or document to the one thing it was opened for; nothing rides along, nothing falls off. Use when the user asks what in a branch, PR, document or plan does not belong to the original task, asks to extract, split or move part of it into its own branch, PR or document, or whether it still carries only what it was meant to.

Repository
skills ↗
Licence
MIT
Last repository change
26.10.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
2
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

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

What it does and when to use it

Hold a branch, PR or document to the one thing it was opened for; nothing rides along, nothing falls off. Use when the user asks what in a branch, PR, document or plan does not belong to the original task, asks to extract, split or move part of it into its own branch, PR or document, or whether it still carries only what it was meant to.

Original author description

Hold a branch, PR or document to the one thing it was opened for; nothing rides along, nothing falls off. Use when the user asks what in a branch, PR, document or plan does not belong to the original task, asks to extract, split or move part of it into its own branch, PR or document, or whether it still carries only what it was meant to.

How it works

  1. Name the intent
  2. Judge each part
  3. Extract
  4. On a git branch
Original SKILL.md headings · 77 lines, 817 words
SKILL.md preview
---
name: duck-split
description: Hold a branch, PR or document to the one thing it was opened for; nothing rides along, nothing falls off. Use when the user asks what in a branch, PR, document or plan does not belong to the original task, asks to extract, split or move part of it into its own branch, PR or document, or whether it still carries only what it was meant to.
---

# Duck Split

Expect a unit of work to carry parts that belong elsewhere. Sort it against the unit's intent, part
by part, and show that the pieces sum to the original before anything leaves it.

Follow the user's language unless they ask otherwise. Keep commands, paths, identifiers,
quoted errors and machine-readable verdicts unchanged; the duck asks for evidence in any language.
Before a step that requires a skill's procedure, load that skill and follow the named section
within existing authority; a conditional or routing mention needs no load until it applies.
A question ("what doesn't belong?") gets the classification and no edits. An instruction to
extract authorizes creating the new units only; removing the moved parts from the original needs an
explicit removal instruction ("cut it from here" or any paraphrase). A unit others already hold is
not rewritten even then: report it and leave the choice to the owner. Pushing, force-pushing,
publishing a unit and every forge action each need their own authorization.

## Name the intent

Use the recorded intent: the [`duck-frame`](../duck-frame/SKILL.md) outcome, the work item, or the
unit's own title and description. With none recorded, state the intent its first parts imply as an
assumption and classify against that. A doubt about the intent itself is not a scope finding; leave
it open.

## Judge each part

Read part by part — a hunk, a section, a plan item — not commit by commit or file by file.

- **Belongs**: removing it weakens the intent. A test, fixture or migration the change needs in
  order to work belongs with it.
- **Does not belong**: the intent survives without it. Name where it would go. A good fix found
  on the way still does not belong.
- **Unsure**: it serves both, or a named fact would decide it. Unsure stays.

Answer two questions: does the unit carry only its intent, and does it carry all of it. Stop here
unless extraction was asked for.

## Extract

1. Back up the original in a copy or ref this pass never deletes; confirm it resolves before
   touching anything else.
2. Build one new unit per destination from the original's parts. A part that cannot stand without
   the rest, or collides with a sibling, depends on another new unit; say which and why.
3. Only on a removal instruction, take the moved parts out of the original. Otherwise report that
   those parts now exist in two places.
4. Prove nothing was lost: recombine every resulting unit and compare with the backup, counting
   each source part once (a copy left in the original counts as the original's). Then run each
   unit's checks alone; one that passes only beside its sibling depends on it: return it to step 2
   as a dependency, or fold the two.
5. Report what each unit carries and sits on, the backup, the comparison, the checks, whether the
   original was rewritten, and the publishing steps left unrun. Once the comparison passed and the
   units exist, say the backup has done its job so the next sweep can retire it.

## On a git branch

- Take the base from `git merge-base`, not from a base branch that has moved. Include staged,
  uncommitted and untracked work. For an open PR, compare the local branch with the pushed head
  and report what exists on one side only.
- The backup is a ref at the current tip with staged, uncommitted and untracked work committed
  onto it; a stash will not do, since the comparison reads commits. Those files stay uncommitted
  in the checkout and are the one difference the comparison may show: name each.
- Ignored files stay out of the backup, and a checkout overwrites one whose path the target tracks.
  List `git status --ignored`, and build the new branches in a separate worktree so this checkout
  never switches.
- Split a mixed commit with `git apply --cached <patch>` over a patch holding the selected hunks,
  never `git add -p`.
- Compare against the backup merged with the base the new branches sit on, or a base that moved
  since the fork reads as loss. For a stack, diff that against the top; for separate branches,
  merge them all onto a scratch branch from the base and diff that.
- With the removal instruction, push and forge authority, rebase each stacked layer with
  `git rebase --onto <new-parent> <old-fork-point> <layer>`, the fork point read from the backup
  or the reflog, never guessed from a parent that moved. Where the layers are open PRs, repoint
  each base before any force-push, or the forge marks a child whose commits its base reaches as
  merged and may delete its branch.
- The backup's commits land under new SHAs, so [`duck-sweep`](../duck-sweep/SKILL.md) will find it
  Unproven: name it in the report as the work item its Unmerged path reads, with the comparison
  result as the decision that lets it be deleted.
Files in this package (2)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB

Versions

The database has no other skills named duck-split.

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

  • 100split-branch
    Split a branch with N commits into N branches with 1 commit each. Use when the user asks to split a branch into single-commit branches.
  • 100duck-prebuild
    Pre-build session with the rubber duck — runs BEFORE implementation, covering both a pre-coding design sketch and plan/spec review. Use when the user states implementation intent (\"build this for me\", \"build me X\") with no plan or code yet, when a plan/spec/RFC was just…
  • 90duck-run
    Challenge the goal, shape the plan, build it, and make it prove itself; local means local. Use when the user asks to duck a task, apply selected findings, or carry work through the delivery flow; when a review came back REJECT and the work must be fixed; or when the user says a…
  • 100split-to-prs
    Split current work into small reviewable PRs. Use when the user asks to split a chat, branch, or change set. Whole dirty tree to one merge-ready PR → workflow-release-prep.
  • 100duck-debug
    Socratic debugging: root-cause questioning or read-only evidence tracing. Use when: "debug this", "why is X broken", "trace this failure", "where is this used", "map callers".
  • 100duck-debug
    Socratic debugging: root-cause questioning or read-only evidence tracing. Use when: "debug this", "why is X broken", "trace this failure", "where is this used", "map callers".

Feedback and reports

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