# Finishing

> Use when an implementation is complete and ready to land — deciding how it integrates and cleaning up. "finish this", "land it", "wrap up", "ship it", "merge", "make a PR", "I'm done — now what"

- Skill: `atgreen/finishing` (Agent Skill)
- Install (CLI): `npx skillmds@latest add atgreen/finishing`
- Raw SKILL.md: https://api.skillmd.com/api/skills/atgreen/finishing/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: atgreen (https://skillmd.com/u/atgreen)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/atgreen/finishing

---


# Finishing

## Overview

**Core principle:** Landing work is a sequence with a human decision in the middle: **prove it's
green → figure out where you are → let the human choose how it integrates → execute that → clean up.**
How work integrates — and especially whether it's ever discarded — is the human's call, not yours.

## Step 1 — Prove It's Green (on the tree you'll integrate)

Run the **full** test/build suite on the actual code about to land, right now. A green run from
before your last change does not count (**evidence-before-claims**). Red suite → stop and fix, or
surface it; don't land red.

**Green includes warning-clean.** A build that passes while emitting compiler warnings is not
green — warnings are the compiler reporting probable bugs at the cheapest possible moment, and a
warning tolerated today is invisible tomorrow (it scrolls by in every future build until nobody
reads any of them). Before landing:

- Read the build output, don't just check the exit code. `unused`, `dead_code`, deprecation, and
  type-lint warnings all get fixed or explicitly gated (`#[cfg(...)]`, `#[allow(...)]` **with a
  comment saying why**), never ignored.
- "It's pre-existing" is not an exemption — file it as a bead if it's out of scope, so it stays
  visible. "It's only in release/debug profile" is not an exemption — check the profile you don't
  normally build.

## Step 2 — Detect Where You Are

You can't present the right options until you know the git situation:

```bash
[ "$(git rev-parse --git-dir)" != "$(git rev-parse --git-common-dir)" ] && echo "linked worktree" || echo "main checkout"
git branch --show-current   # empty output = detached HEAD (needs a branch before it can land)
```

## Step 3 — Confirm the Base Branch

Which branch does this integrate into (`main`, `develop`, …)? Confirm it before offering to merge —
don't assume.

## Step 4 — Present the Menu, Then Wait

Offer exactly these, and **stop for the human to choose** — do not pick for them:

1. **Merge locally** into the base branch.
2. **Push and open a PR.**
3. **Keep the branch as-is** (integrate later).

(Detached HEAD: first create a branch, or offer only "keep" until one exists.)

**Discarding work is not on this menu by default.** Only discard on an explicit request, and only
after the human confirms by typing the literal word **`discard`** — losing work must be deliberate,
never a default or a misread.

## Step 5 — Execute, Then Close the Loop

- Do the chosen action. Pushing or opening a PR is an **external side effect** — a gate; confirm intent first.
- **Close the beads** this work completed (`bd close <id>`), comment any follow-ups discovered, and
  **`bd sync`** so the shared record is current (**using-beads**).
- **Clean up the worktree** if you made one: `git worktree remove <path>` (never a hand `rm -rf`;
  never `--force` past a refusal — if it refuses, show the human the uncommitted files and ask).

## Common Mistakes

- **Landing on a stale green.** Re-run the full suite on the final tree; earlier passes don't certify it.
- **Calling a warning-emitting build "green."** Exit code 0 with warnings scrolling by is not green.
  Fix them, gate them with a commented `allow`/`cfg`, or bead them — never scroll past them.
- **Merging without asking.** Integration is the human's decision. Present the menu; wait.
- **Discarding on a vague "scrap it."** Require the typed `discard`. Work is expensive; deletion is forever.
- **Force-removing a worktree with uncommitted changes.** That's silent data loss. Surface the files and ask.
- **Leaving beads open.** Unclosed beads rot the backlog; unsynced ones don't reach the next session. Close and sync.