finishing-with-review

Finishing With Review

Overview

Review-gated branch completion. Every branch gets reviewed before it merges — no exceptions.

Announce at start: "I'm using the finishing-with-review skill to review and complete this work."

Core principle: Implement → Review → Reflect → Finish. Code review happens while the code is fresh and there's still willingness to change it.

The Process

digraph finishing_with_review {
    rankdir=TB;
    request1 [label="Step 1: Request Code Review" shape=box];
    receive1 [label="Step 2: Receive Code Review\n+ implement fixes" shape=box];
    significant [label="Changes significant?" shape=diamond];
    request2 [label="Step 1 (repeat):\nRequest Code Review" shape=box];
    receive2 [label="Step 2 (repeat):\nReceive Code Review" shape=box];
    reflect [label="Step 4: End-of-Session\nReflection" shape=box];
    finish [label="Step 5: Finish Branch" shape=doublecircle];

    request1 -> receive1;
    receive1 -> significant;
    significant -> request2 [label="yes"];
    significant -> reflect [label="no"];
    request2 -> receive2;
    receive2 -> reflect;
    reflect -> finish;
}

Step 1: Request Code Review

Invoke superpowers:requesting-code-review.

1. Get the git range. Resolve the base branch robustly — this works on a fresh repo with no remote, on master/main/trunk, and warns rather than producing a garbage range if nothing resolves:

# >>> base-branch-detection >>>
set -euo pipefail
resolve_base_ref() {
  # Echo a ref usable DIRECTLY in `git merge-base` — a remote-tracking ref when
  # one exists (so a clone with origin/main but no local main still works), else
  # a local branch. Never strips the remote prefix off a ref that needs it.
  # Tier 1: the remote's declared default branch (remote-tracking ref, e.g. origin/main).
  if git symbolic-ref -q refs/remotes/origin/HEAD >/dev/null 2>&1; then
    git symbolic-ref --short refs/remotes/origin/HEAD
    return 0
  fi
  # Tier 2: the current branch's configured upstream (remote-tracking ref).
  if git rev-parse -q --verify '@{upstream}' >/dev/null 2>&1; then
    git rev-parse --abbrev-ref '@{upstream}'
    return 0
  fi
  # Tier 3: a conventional LOCAL branch, if one exists.
  local b
  for b in main master trunk; do
    if git rev-parse -q --verify "refs/heads/$b" >/dev/null 2>&1; then echo "$b"; return 0; fi
  done
  return 1
}
# Guard every command substitution explicitly — `BASE_SHA=$(failing-cmd)` does NOT
# trip `set -e`, so a bad merge-base would otherwise leave BASE_SHA empty silently.
BASE_REF=""
if BASE_REF=$(resolve_base_ref) && [ -n "$BASE_REF" ] \
   && BASE_SHA=$(git merge-base HEAD "$BASE_REF" 2>/dev/null) && [ -n "$BASE_SHA" ]; then
  : # resolved cleanly; BASE_REF + BASE_SHA are valid
else
  echo "WARNING: could not resolve a base branch (BASE_REF='${BASE_REF:-<none>}'); review the full working tree manually." >&2
  BASE_REF="${BASE_REF:-<none>}"
  BASE_SHA=$(git rev-parse HEAD)   # degrade safely: empty range, reviewer is warned
fi
HEAD_SHA=$(git rev-parse HEAD)
# <<< base-branch-detection <<<