Git-branchless
Branchless treats commits as checkpoints, detached HEAD as the default work mode, and branches as publishing artifacts. This skill enforces that mental model and routes every common git workflow to its branchless equivalent. Reference docs:
references/commands.md— every command, flag, revset, config key.references/recipes.md— concrete sequences + decision rubric.references/recovery.md— undo, restack, hide, snapshot, GC semantics.
Pre-flight gate [LOAD-BEARING]
Before applying any rule below, confirm branchless is initialized for the current repository. Run:
test -d "$(git rev-parse --git-common-dir)/branchless" && git config --get branchless.core.mainBranch
(Resolving the git-common-dir handles linked worktrees, where .git is a
file rather than a directory and branchless state lives in the main repo's
git dir.)
| Result | Skill behavior |
|---|---|
| Both succeed | Skill is active. Apply the rules below. Acknowledge with one line: git-branchless active — main=<value>. |
| Either fails | Skill is silently inert. Emit one line: git-branchless not initialized; skill inactive. Yield to plain git. Do not suggest git branchless init unless the user explicitly asks how to enable. |
The inert path is intentional. This skill does not nag and does not refuse legitimate work in repos where branchless was never adopted.
Always / Never (operation-class framing)
Each rule names an operation class, not a command. Plain-git commands are fine when they fall outside the class.
| Class | Always | Never |
|---|---|---|
| Stack edits (reorder, fixup, squash, split) | git move, git move -F, git reword, and git split where available [v0.11.0+] (use the Recipe 4 workaround on older versions). | git rebase -i to drive stack edits. |
| Base updates (rebase a stack onto fresh main) | git sync --pull (or git move -b 'stack()' -d origin/main). Read the skip summary. | git pull --rebase against a stack. |
| Undoing committed history | git undo -i. | git reset --hard <SHA> against any commit you have already made. |
| Discarding local work in progress | git hide -r <tip> (recoverable). | git branch -D or git reset --hard purely to wipe. |
| Branch creation for ephemeral work | Detached HEAD until publish; commit immediately, branch later. | git checkout -b feature/X before the first commit exists. |
| Publishing | Branch the tip then git push -u, or git submit -c on supported forges. | Force-push as a way to "fix" your local history. |
Edge cases that are still legitimate (do not block these):
git reset --soft HEAD~against staging when nothing has been committed yet.git rebase --ontofor a one-off, non-interactive upstream sync in a repo where branchless is not initialized (the skill is inert there anyway).git checkout -bwhen the work is genuinely about to be pushed.
Workflow phases
Init → git branchless init (one-time per repo)
Work → git switch --detach origin/main → edit → git commit (or git record)
Refine → git move | git move --fixup | git amend | git reword | git split [v0.11.0+]
Sync → git sync --pull (re-base onto fresh main; read skip summary)
Verify → git test run --exec '<cmd>' 'stack()' (revset is positional)
Publish→ git branch <name> <tip> && git push -u origin <name>
(or git submit -c on Phabricator; treat GitHub forge as experimental)
Recover→ git undo -i (event-log walk replaces reflog spelunking)
Restack is mostly automatic. After git amend, git reword, git move,
or git split, descendants are auto-restacked in-memory. Run
git restack manually only when the smartlog warns about abandoned
subtrees (✕ ancestors).
Decision rubric (quick lookup)
| Goal | Command sequence |
|---|---|
| Insert a fixup mid-stack | git commit --fixup <target> then git move -s HEAD -d <target> --fixup |
| Reorder commits | git move -s <src> -d <dest> |
| Squash two commits | git move -s <child> -d <parent> --fixup |
| Split a commit | git split <commit> [v0.11.0+] (or workaround in recipes.md Recipe 4) |
| Rebase stack onto main | git sync --pull |
| Find first failing commit | git test run --search binary --exec '<cmd>' 'stack()' |
| Recover lost work | git undo -i |
| Discard a local experiment | git hide -r <tip> |
| Publish | git branch <name> <tip> then git push -u, or git submit -c |
Full recipes with rationale: references/recipes.md.
Hand-off
atomic-commitis the per-commit-grouping concern. Pair this skill withatomic-commitwhen the task is "commit my changes" — branchless handles workflow, atomic-commit handles per-change boundaries.git-guardrails-claude-codeis the complementary block-list hook. This skill teaches the branchless idioms; that skill enforces a hard block ongit push --force,git reset --hard, and similar. They coexist — the hook surfaces a refusal, this skill surfaces the right alternative.fixdrives iterative repair via per-iteration commits + revert protocol.fixalready usesgit revert HEAD --no-edit(event-log-friendly) rather thangit reset --hard; this skill is consistent with that.
ODIN-baseline agents already have an abridged branchless cheat-sheet in their style block. This skill is the canonical, deeper reference for both ODIN and non-ODIN agents — it does not depend on the baseline being loaded.
Self-skepticism notes
Things this skill is uncertain about and treats accordingly:
git splitand its modes (--detach,--discard,--before) are documented for[v0.11.0+]. The locally installed version may be older. Recipes include a pre-v0.11.0workaround.git submit --forge githubis experimental in v0.9.0. Stack reordering can lose PR ancestry. Default to manual branch +git pushfor GitHub work; reservegit submitfor Phabricator.- The event log is per-repository and per-clone.
git undocannot reach state from a different clone or a different machine. - Speculative-merge skips during
git syncandgit moveare silent unless you read the summary line. The skill reminds you to read it, but cannot enforce it without running the command.
When the skill recommends a flag and the local version rejects it, fall
back to the closest documented alternative in references/commands.md
and tell the user which version-gated feature was unavailable.