Skip to main content
skill CX Codex

land — Claude Code skill: what it does, how to install

land is a Claude Code skill that finishes a development branch through merge, PR, keep, or discard. It runs after implementation is complete.

MIT 1,000 installs ★ 10 updated 2026-10-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pwguler/skills --skill land -a claude-code
Open on GitHub

What land does

The skill runs verification steps and rubric checks before presenting options for the branch. It extracts durable details from the spec into architectural records and documentation files, then drafts commit messages and pull request bodies.

Requires a completed implementation and existing spec files where applicable. Merges are blocked without passing tests and a verification record.

Install the skill via terminal with npx skills add pwguler/skills --skill land -a claude-code.

What it helps with

  • finish a branch with a merge or pull request
  • update documentation files from specification data
  • verify work before landing changes
  • clean up worktrees and branches safely

Example prompts for the agent

  • Finish this branch with a pull request
  • Merge the current branch locally
  • Keep the current branch and worktree

How to install land

1Skills CLI (Vercel)

npx skills add pwguler/skills --skill land -a claude-code

2Manually: put the files in place

~/.claude/skills/land/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/land/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about land

How to install land in Claude Code?

Run npx skills add pwguler/skills --skill land -a claude-code, then reference ~/.claude/skills/land/SKILL.md.

What does land do?

Finishes a development branch with a merge, PR, keep, or discard option after running verification and updating documentation.

What is needed to use land?

A completed development branch implementation and specification files when available.

Source text

SKILL.md · MIT
---
name: land
description: Finish a development branch with a merge, a PR, a keep, or a discard. Use it when the implementation is complete.
---

Do not land work that is not verified.

Fast path: the diff is small, and the invocation already names the path: merge, PR, keep, or discard. Then skip the options menu and go, unless step 4 removes that path. The spec question is not part of the fast path. When a spec exists and the invocation did not name its fate, ask about it here too. Ask in one line, with keep as the default.

1. Before you run anything, create a task list with these steps as its items. If a task list already exists, add the steps to it. Each step is one item. When the chosen path skips a step, mark it done and add `skip: <reason>` to its text.
2. Read the `verify` skill and follow it. It reuses its evidence record when the tree hash did not change. A record made inside a declared phase covers only its area. So when you land from inside a phase, run the full gate first. Then read the `rubric` skill and follow it. Its defect pass runs when the work has a spec at `docs/specs/<slug>.md`. Its taste pass runs when the diff changes a UI, a public interface, a name, or prose. It runs also when the spec has a criterion that names a quality, not a behavior. Send an act-on finding back to `implement` or `debug`. The fixed tree then passes `verify` again. Failing work does not reach the options menu.
3. Find the environment: a normal checkout, a named-branch worktree, or a detached HEAD. A detached HEAD is a workspace that something outside manages.
4. Show exactly four options, with no explanation. They are: merge locally to the base branch, push and open a PR, keep the branch, or discard. A detached HEAD removes the merge and discard options, also when the invocation names one. Then say that its workspace belongs to what manages it, and show the other options. Discard requires the user to type "discard".
5. On the merge and PR paths, close the spec. First move its lasting content out. A decision worth keeping becomes an ADR, as [decision-record.md](references/decision-record.md) says. A settled term goes to `CONTEXT.md`, as [terms.md](references/terms.md) says. A change to the shape of the system updates `ARCHITECTURE.md`, as [architecture-format.md](references/architecture-format.md) says. Create that file if it does not exist. This move is not optional. Only the fate of the spec file is the decision of the user. Ask about it in one line, and give the default in the same line: **keep, unless the user asks otherwise**. A path named in the invocation already answers it, such as "land: merge, drop the spec". The keep path leaves the spec in place without a question, because the spec still guides the work.
6. Write the PR body and the merge commit message from the spec. Start the body with the demo. The demo is the `verify` evidence: what ran and what it showed. Or it tells how to exercise the change. Then write the goal as the summary line, the acceptance criteria as the change list, and non-goals as scope notes. The reasoning goes into the permanent record where `git blame` points, whether the spec file stays or not.
7. On the merge path, do these actions in this order. From the main checkout, merge the branch. Test the merged result: a matching evidence record counts. Remove the worktree. Then delete the branch. A branch deletion before the worktree removal fails. A worktree removal from inside the worktree fails.
8. The PR and keep paths keep the worktree, because the user needs it for more work. On the discard path, wait until the user typed "discard". In a named-branch worktree, remove the worktree from the main checkout. Use `git worktree remove --force` when the worktree holds uncommitted work. In a normal checkout, switch to the base branch with `git switch --discard-changes <base>`. Untracked files stay, and you name them to the user. In both cases, then delete the branch with `git branch -D`. A copy of the branch on the remote stays there, unless the user asks.

Rules:

- Never force-push, and never amend a published commit. Use no `--no-verify`, and no `reset --hard` on a dirty tree, unless the user asks explicitly.
- Never delete a spec that the user did not ask to delete. Silence is not consent. When the user does not answer, keep the spec.
- Remove only the worktree of the branch that you land. Leave every other worktree alone, also the worktrees that subagent runs keep. The tool that made such a worktree removes it. Run `git worktree prune` after a removal.
- Never merge without a test. The merged result runs the tests, unless its tree hash matches the evidence record. A fast-forward matches the record. A merge after the branches diverged never matches it.
- Resolve merge conflicts by intent, one hunk at a time. Trace each side to its source. `--abort` is not a resolution.

© pwguler · MIT · pwguler/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set15

The whole set →
core-interview core-interview — a skill for Claude Code that runs an interview loop through decision trees until every branch is settled. CX Codex +1 1,000installs research The research Claude Code skill traces library and API behavior to primary sources, or investigates why code took its current shape. It activates for lookups and questions about the history of a setting or constant. CX Codex +1 1,000installs debug debug is a Claude Code and Cursor skill that traces bug root causes step by step and verifies regression tests. CX Codex +1 1,000installs verify verify — a skill for Claude Code checks claims about completed or fixed work against fresh command output. It runs before a commit or PR, after changes, and before reporting that work is done or tested. CX Codex +1 1,000installs drill A skill for Claude Code interviews the user about a plan or design until its decisions are settled. It runs for new features, unresolved designs, or a request to “drill this.” CX Codex +1 1,000installs implement implement — a skill for Claude Code and Codex that executes settled plans in thin test-driven slices. Runs when prompted to build code from a spec or slice plan. CX Codex +1 1,000installs rubric rubric — a skill for Claude Code finds defects in changes and judges design, interface, or writing quality. It sets evaluation criteria before asking an independent subagent to inspect the work. CX Codex +1 980installs prototype This Claude Code skill builds visual UI prototypes before implementation begins. It activates for mockup requests and helps settle a look or flow that text cannot resolve. CX Codex +1 978installs

Project sponsors

Companies that keep this analytics open