git-branchless

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 --onto for a one-off, non-interactive upstream sync in a repo where branchless is not initialized (the skill is inert there anyway).
• git checkout -b when 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-commit is the per-commit-grouping concern. Pair this skill with atomic-commit when the task is "commit my changes" — branchless handles workflow, atomic-commit handles per-change boundaries.
• git-guardrails-claude-code is the complementary block-list hook. This skill teaches the branchless idioms; that skill enforces a hard block on git push --force, git reset --hard, and similar. They coexist — the hook surfaces a refusal, this skill surfaces the right alternative.
• fix drives iterative repair via per-iteration commits + revert protocol. fix already uses git revert HEAD --no-edit (event-log-friendly) rather than git 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 split and its modes (--detach, --discard, --before) are documented for [v0.11.0+]. The locally installed version may be older. Recipes include a pre-v0.11.0 workaround.
• git submit --forge github is experimental in v0.9.0. Stack reordering can lose PR ancestry. Default to manual branch + git push for GitHub work; reserve git submit for Phabricator.
• The event log is per-repository and per-clone. git undo cannot reach state from a different clone or a different machine.
• Speculative-merge skips during git sync and git move are 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.