cut

name: cutdescription: "Proposes cuts and a polish list to finish the game from its brief and what is built; the person picks each cut. A game to sell also gets a release date and a feature freeze. Use when asked what to cut, how to finish or ship it, or for a polish list."argument-hint: "[no arguments]"user-invocable: trueallowed-tools: Read, Glob, Grep, AskUserQuestion, Bash(bash "*/.claude/skills/cut/../../hooks/yaml-helper.sh" resolve_config *), Bash(bash .claude/scripts/cut-read.sh*), Bash(bash .claude/scripts/cut-apply.sh *), Bash(bash .claude/scripts/config-set.sh project.goal *), Bash(bash .claude/scripts/one-shot-check.sh *), Bash(bash .claude/scripts/one-shot-run.sh *), Bash(find prototypes/*), Bash(timeout 900 npm run smoke), Bash(timeout 900 godot --headless *), Bash(git rev-parse *), Bash(git add design/*), Bash(git commit -m *)model: sonnet

!bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys automation

Resolved above — use as-is. No block → defaults in .claude/docs/config-resolution.md.

Cut

Finishing a game is choosing what not to build. /cut reads what exists, proposes cuts with a reason taken from it, and keeps a polish list; the person picks every cut. For sell, early_access and publisher it asks a target date and proposes a freeze date. It writes the brief, the polish list and any cut story's Status line, and makes one commit.

It runs only when asked: /cut, or "what should I cut?", "how do I finish this?". It works on the game design/game-brief.md describes. A project with GDDs and no brief is /scope-check's.

Ask with the question tool. Without one, list the options numbered and end your turn to wait. The question is the last thing in the reply. A skipped or dismissed question is not an answer: ask again in plain text. Every ask follows .claude/docs/automation-modes.md: in collaborative and guided the cuts and the dates are asked, as scope changes are major decisions; in autonomous /cut writes the polish list only and leaves the proposals in its report: cuts and dates wait for the person, and nothing is committed.

Phase 1: Read what exists

Run bash .claude/scripts/cut-read.sh and keep its rows:

Read the brief itself too: its Question, Hooks, First minute, Challenge, Goal & fail state and Build order give the reasons.

• Fresh first: a record ... stale row means the game changed after its check record. A changed game gets the light check, never the small check again: the small check is the build's, and one-shot-check.sh --record records only that, so never run it here. First see whether a light check is newer than every game file. For each marker on disk, evidence/changes.tsv (a change's light check) and evidence/cut-end.png (an earlier /cut's), run find prototypes/<name> -type f -newer prototypes/<name>/evidence/<marker> ! -path '*/evidence/*' ! -path '*/dist/*' ! -name brief.md ! -name feel-log.md ! -name polish-list.md.

  • One prints nothing: that light check is fresh, so run nothing. Errors and a bot stop on changes.tsv's last line that the polish list lacks become rows.
  • Otherwise, run the light check once, as .claude/skills/prototype/references/one-shot-4-change.md section 7 does before accept: its step 1 (keep) and step 2 (play it once), the shot prototypes/<name>/evidence/cut-end.png. A not_assessed row: say "not checked: " in one line. Fix nothing: each error, bot stop and changed or gone keep row becomes a polish row.

  These rows end · from: light check of <date>. The stale record row stays; its open rows still count.

• A project: smoke <command>: run timeout 900 <command> once, as it is: no pipe, redirect or second command (the permission is for that command alone). A failure is a polish row (from: smoke run of <date>); a pass adds none. record none with no smoke command to run: say in one line that the polish rows come from the feel log and the person.

Phase 2: Propose

Cuts, in this order, each with a reason from what exists:

1. A not_yet item that Out of scope or Avoid already rules out.
2. A built item whose check fails (open), offered as cut it or polish it.
3. A not_yet item that no Question, Hook, First minute, Challenge, Goal & fail state or Keep line names.

For a selling goal, every not_yet item left also shows "build it before , or cut it". Never propose an item a Keep line names. The person can still name any item.

Marks brought up to date: a not_yet item whose story row is Complete is shown built and marked [x] with the other writes.

Polish rows come from what exists, never invented: each open row, each smoke failure, and what the person adds. Each row ends · from: <source>: <check> check of <date>, smoke run of <date> or you said. The person's rows and ticks stay; a row whose source now passes is ticked, said in one line. Rows about a cut item go with the cut.

Phase 3: Dates, for sell, early_access and publisher only

Any other goal gets no date, asked or shown.

• Recorded dates are shown, not asked again ("move the dates" changes them). A passed freeze row is said in one line; a passed target row is asked again.
• Target: ask in plain words named for the goal: when to release it (sell), when the Early Access launch is (early_access), when the pitch or demo is (publisher). Turn a month or "next spring" into a date and show it.
• Freeze: run bash .claude/scripts/cut-read.sh --target <date>; its proposed freeze row is 70% of the way from today to the target. Ask "Freeze on ?" Options: Freeze then / Another date. Say what it means: from then on no new features, only the polish list and fixes; recorded, and nothing holds you to it yet. target_past: ask the target again.
• A goal changed on the screen ("I want to sell it") is written at once with bash .claude/scripts/config-set.sh project.goal <value>, and its dates are asked. A guessed goal left as it is is not written. No other project.yaml key is touched.

Phase 4: The screen and the pick

/cut · <title> · Goal: <goal> (set | guessed)
Cut? You pick; nothing is cut without your pick.
  1. [ ] <item>
     · <reason>
Staying: <n> built features · Never offered: your <n> Keep lines
Polish: <n> rows, from <the sources>
Dates: target <date> (<what>) · freeze <date>
Writes: <the briefs>, <the polish list>, <each story> · one commit

Leave out the Dates line for a goal that gets none, and Cut? when there is nothing to propose. Every file is named on the Writes line before writing, and nothing is written before the pick. Then ask with the question tool, multi-select, up to four proposals ("Cut which? Pick none to cut nothing"); more are numbered in text and picked by number. The reason is the person's words if they gave any, else the proposal's. With dates to ask, ask the target in the same call, then the freeze as Phase 3 says.

Phase 5: Write and commit

Run bash .claude/scripts/cut-apply.sh with --brief <path> for each brief row and:

• --cut <n> "<reason>" for each picked item: it leaves Features for the end of Out of scope as - [-] <item> · cut: <reason> (<date>), plus · was built when it was [x]; its story's Status becomes Blocked — BLOCKED: cut by /cut <date>: <reason>, a status /dev-story stops on (a Complete story keeps its status: story moved).
• --mark <n> for each mark brought up to date.
• --dates <target> <freeze> "<what>" when dates were given.
• --polish "<row>", --tick "<row>" and --drop "<row>" for the polish list.

Moving an item renumbers the Features after it, so the stories traced to them are renumbered too (story renumbered); the Writes line names every story a proposed cut can touch. bad rows mean nothing was written: fix the arguments and run it again. A cut built item stays in the game until it is taken out, an ordinary change: say "say 'take out ' to remove it".

Commit when git rev-parse --is-inside-work-tree succeeds, the pick being the commit instruction: git add <each wrote path, design/ ones first>, then git commit -m "docs: cut <items> · dates · polish list (<n> rows)" -m "Brief: design/game-brief.md" -- <the same paths>. Leave out cut <items> · when nothing was cut, and dates · when the Dates line did not change. No git: "Not committed: this project has no git." Say in one line what was written.

Next step: build what is left before the freeze (/create-stories writes a story for each not-yet item in a project), and work down the polish list.

Afterwards

• "Bring back ": cut-apply.sh --back "<item>" built|not_yet moves the line back to Features: built while it is still in the game. Its story goes back to Ready. Commit the wrote paths as docs: bring back <item>.
• "Move the dates": Phase 3 again, with the recorded dates shown, then write and commit as Phase 5 does.
• Nothing blocks or warns on the freeze date in this version: only /cut reads it back.