Tier 5

Tier 5 — Checkpointing & Hardening: Checkpoint in git and harden the harness, so you can always roll back

Reach for this tier when a long run goes wrong and you've lost good work with nothing to roll back to. With a checkpoint at every green step, a bad run costs minutes to undo, not a rewrite.

These are the triad's constraints, hardened — from a line in the prompt into checkpoints, CI, and rollback the harness enforces for you.

Git isn't bookkeeping here — it's the loop's memory and undo. And the harness around it — hooks that always run your tests, CI, the gh CLI — makes the whole loop deterministic and shareable with the team.

5.1 Commit every working step — checkpoints are what make a loop safe.

Instead of: one giant commit at the end (or none).

Prefer: commit after each green step; each commit is a state the loop (or you) can revert to.

How: "After each task step that passes tests, commit with a descriptive message." Combine with a Stop hook (below) that won't let it stop on red, and you get an agent whose every checkpoint is a working state — it can iterate hard and never lose ground.

Start from a clean tree; back up anything it can't regenerate before granting write access.

5.2 Let Claude drive gh — the collaboration layer is harness too.

Instead of: copy-pasting diffs into the GitHub web UI.

Prefer: have Claude use the gh CLI to open PRs, read issues, check CI, and answer review comments.

How:

gh issue view 123          # pull the task context into the session
gh pr create --fill        # open the PR from the working branch
gh pr checks               # watch CI; feed failures back into the loop
gh pr comment 45 --body "addressed in 3f9a1c2"

Claude has native git (stage/commit/branch/PR) and can run gh. In CI, claude -p + gh closes the loop from issue → branch → PR → review.

5.3 Try risky work in a worktree — a disposable checkpoint you can throw away.

Instead of: a risky refactor or spike directly on your working branch, hoping you can git reset your way out.

Prefer: git worktree add ../spike-x spike-x — experiment there; keep it if it works, delete the directory if it doesn't. Your main working copy never sees the mess.

Worktrees also isolate parallel agents so they don't clobber each other — that's the Tier 7 use — see Tip 7.2.

5.4 Replace "remember to run tests" with a hook.

Instead of: "run the tests after each change" (a request it can forget).

Prefer: a hook that always runs them, and one that won't let it stop on red.

This is where Tier 4 becomes durable: the check you defined there gets wired into the harness, so it runs every time and can't be skipped or forgotten.

How: .claude/settings.json (commit it so the team shares the gate):

{
  "hooks": {
    "PostToolUse": [
      { "matcher": "Edit|Write",
        "hooks": [{ "type": "command",
          "command": "FILE=$(cat | jq -r '.tool_input.file_path // empty'); [ -n \"$FILE\" ] && npm test -- --findRelatedTests \"$FILE\"" }] }
    ],
    "Stop": [
      { "hooks": [{ "type": "command",
        "command": "INPUT=$(cat); [ \"$(echo \"$INPUT\" | jq -r .stop_hook_active)\" = true ] && exit 0; npm test || { echo 'tests still failing' >&2; exit 2; }" }] }
    ]
  }
}

exit 2 on a Stop hook forces the agent to keep working (guard with stop_hook_active so it can't loop forever — Claude overrides a Stop hook after 8 consecutive blocks). PreToolUse exit 2 blocks a tool outright — use it to protect .env, package-lock.json, .git/; a PreToolUse deny fires before the permission check, so it holds even under --dangerously-skip-permissions (hooks can tighten, never loosen). Hooks aren't only shell + exit codes: beyond command, a hook can be a prompt (a quick Haiku yes/no judgment) or an agent (a subagent that verifies before allowing stop) — an agent-based verify hook is a sturdier loop check than a brittle test-runner line.

5.5 Move repetitive engineering into CI / headless — run it without you in the seat.

Instead of: doing PR review, issue triage, and release notes by hand each time.

Prefer: run the agent non-interactively in your pipeline, scoped tightly.

How:

claude -p "Review this PR diff for correctness and security; comment only on real issues." \
  --allowedTools "Bash(git diff:*),Read,Grep"

Or the Claude Code GitHub Action on pull_request. Note: as of mid-2026, programmatic use (claude -p, Agent SDK, Actions) bills from a separate Agent-SDK pool at API rates — budget for it.