Build a Claude Code skill that reviews, triages, and commits

There is a specific kind of developer guilt that hits around 6pm. You've been heads-down all day, things mostly work, but the Git history is a graveyard of half-finished commits. There's a TODO three files deep that you mentally flagged at 10am and forgot entirely. The README still describes the architecture from three weeks ago.

We wanted to fix this without adding another tool, another process, or another thing to remember. Type one command at the end of the day, let the AI coding partner handle the rest.

This is how we built /wrapup — a Claude Code skill that does exactly that.

What a proper end-of-day handoff looks like

A good wrapup does five things:

1. Reviews what actually changed — not just a git diff, but a human-readable summary of what moved and why.
2. Runs quality checks — lint, types, tests, a quick build. Catches the embarrassing stuff before it lands on GitHub.
3. Keeps documentation honest — updates CLAUDE.md, the README, a changelog if one exists. The things that always slip.
4. Triages open issues — scans for TODOs and open GitHub issues, runs a quick Q&A on anything important, writes a prioritised agenda for the next morning.
5. Commits and pushes — automatically for clean or low-risk changes, with a pause for human review only when something critical is unresolved.

The result is a Git history that tells a coherent story, a CLAUDE.md that stays current, and a ## Next Session block that means tomorrow morning you open the project and already know where to start.

How the skill works

The skill is a Markdown file. That's genuinely all it is. Claude Code reads it, loads the instructions into context, and follows them when you invoke the command.

Here's the full sequence:

Phase 1 — Review changes. Runs git status, git diff HEAD, and git log --oneline -10. Produces a plain-language summary of what changed today.

Phase 2 — Quality checks. Detects the project's toolchain from package.json or CLAUDE.md and runs whatever fits: ESLint or Ruff for linting, tsc --noEmit or Mypy for types, the test suite, a build check. Minor issues like stray console.log statements get fixed automatically. Larger issues get flagged and documented as TODOs rather than attempted mid-wrapup.

Phase 3 — Update memory and docs. Checks whether anything new needs to go into CLAUDE.md — new commands, conventions, environment variables. Updates the README if any user-facing behaviour changed. Appends to a changelog if one exists.

Phase 4 — Triage issues and TODOs. This is the part we find most valuable. It greps across the codebase for TODO, FIXME, HACK, and XXX, and pulls open GitHub issues via the gh CLI. For each important item it runs a short Q&A: what's the problem, is there a clear solution, what's the effort estimate, are there blockers? Everything gets sorted into three buckets — critical, important, backlog — and a ## Next Session block gets written into CLAUDE.md with tomorrow's priorities in order.

Phase 5 — Prepare the commit. Stages changes and composes a conventional commit message. If unresolved critical issues exist, it pauses and shows the staged diff for review. Otherwise it proceeds automatically.

Phase 6 — Commit and push. Commits, pushes to the current tracking branch, and prints a one-screen summary: what shipped, what's critical for tomorrow, what docs were updated, and the commit hash.

What is a Claude Code skill, exactly?

Claude Code has persistent, reusable instructions that extend what it can do. CLAUDE.md handles always-on project context. Skills handle specific repeatable workflows you invoke on demand.

A skill is a directory containing a SKILL.md file. That file has two parts:

---
name: wrapup
description: End-of-day review, triage, and commit. Run before closing the project.
allowed-tools: Read, Write, Bash(git:*), Bash(gh:*), Bash(grep:*), Bash(npm:*), Bash(ruff:*), Bash(tsc:*)
---

# End-of-Day Wrapup

## Phase 1 — Review changes
Run `git status`, `git diff HEAD`, and `git log --oneline -10`.
Summarise what changed today in plain language.

## Phase 2 — Quality checks
Detect the toolchain from package.json or CLAUDE.md.
Run lint, type checks, tests, and build. Fix minor issues automatically.
Flag larger issues as TODOs rather than attempting repairs mid-wrapup.

## Phase 3 — Update memory and docs
...

The YAML frontmatter tells Claude Code the skill's name (which becomes the /slash-command), a description used to decide when to load it automatically, and which tools it may use. The Markdown body is the prompt — plain language, structured however makes sense for the task.

When you type /wrapup, Claude Code loads the skill into context and follows the instructions. It can run bash commands, read and write files, call the gh CLI, commit to Git — anything the allowed-tools list permits.

Skills are part of the Agent Skills open standard, so they work across Claude Code, Claude on the web, and Claude Desktop. Define once, use everywhere.

Three ways to install a skill

Global (available in every project)

Best when the skill is general-purpose and you want it regardless of which repo you're in. /wrapup fits here.

mkdir -p ~/.claude/skills/wrapup
nano ~/.claude/skills/wrapup/SKILL.md

Paste in the skill content, save. No restart required — Claude Code detects skill changes live.

Project-scoped (committed to the repo)

Best when the skill is project-specific, or when the whole team should have it.

mkdir -p .claude/skills/wrapup
nano .claude/skills/wrapup/SKILL.md

Then commit it:

git add .claude/skills/wrapup/SKILL.md
git commit -m "chore: add /wrapup end-of-day skill"
git push

Anyone who clones the repo gets the skill automatically.

Personal project override (not committed)

For project-specific skills that don't belong in the shared codebase — opinionated commit message styles, personal triage criteria, stack-specific shortcuts your team doesn't use.

mkdir -p .claude/commands
echo ".claude/commands/" >> .gitignore
nano .claude/commands/wrapup.md

Invoking the skill

Type / in Claude Code and wrapup appears in the autocomplete list:

/wrapup

Or with the project namespace prefix if there's a naming conflict:

/project:wrapup

You can verify it registered by running /help — all available skills show up with their descriptions. If wrapup is missing, check the SKILL.md path and validate the frontmatter YAML.

Why the commit pauses on critical issues

One design decision worth explaining: the skill commits and pushes automatically for normal work, but pauses if unresolved critical issues exist.

The logic in the skill instructions:

## Phase 5 — Prepare the commit

Stage all changes with `git add -A`.
Compose a conventional commit message summarising today's work.

If any CRITICAL issues remain unresolved:
  - Print the staged diff
  - Print the proposed commit message
  - Wait for explicit confirmation before proceeding

Otherwise:
  - Commit and push without interruption

The pause isn't to block you from shipping. It's to make sure you're consciously deciding to push in a state where something important is broken. Often you'll still push anyway — the work is unrelated to the critical issue — but you'll do it intentionally rather than accidentally.

An automated tool that silently ships broken state is worse than no automation at all. The pause is the skill acknowledging it doesn't have full context, and handing that specific decision back to you.

CLAUDE.md as working memory

The ## Next Session block written at the end of Phase 3b deserves its own section.

Because Claude Code loads CLAUDE.md automatically at the start of every session, tomorrow morning Claude already knows the three things that need to happen, in priority order. You don't need to re-explain context, re-read your own notes, or spend fifteen minutes remembering where you left off.

The block looks like this after a typical wrapup:

## Next Session

**Last updated:** 2025-01-14 18:03

### Critical
- [ ] Fix auth token expiry not being caught in `api/middleware.ts` — users hitting 401s silently
- [ ] The `/export` endpoint times out for datasets > 10k rows — needs investigation

### Important
- [ ] Migrate remaining fetch calls in `dashboard/` to the new API client
- [ ] Write tests for the CSV parser edge cases (empty rows, quoted commas)

### Backlog
- [ ] Update the deployment docs — still references the old Docker setup
- [ ] TODO in `utils/date.ts:47` — handle timezone offsets properly

Each session ends by handing off to the next one. Over time, CLAUDE.md becomes a living document that reflects the current state of the project — not just the architecture, but the work in progress. When you onboard a new collaborator, or return to a project after two weeks, that file tells the full story.

What the output looks like

After /wrapup runs, the final summary prints to the terminal:

── Wrapup complete ──────────────────────────────────────

Commit: a3f91c2
Branch: main → origin/main

Changed
  Modified  src/api/middleware.ts
  Modified  src/dashboard/index.tsx
  Added     src/utils/csv-parser.ts
  Modified  README.md

Quality checks
  ESLint      passed
  TypeScript  passed
  Tests       47 passed, 0 failed
  Build       passed
  Fixed       2 stray console.log statements

Docs updated
  CLAUDE.md   Next Session block updated
  README.md   Updated /export endpoint docs

Critical for tomorrow
  1. Auth token expiry silent failure — api/middleware.ts
  2. /export timeout on large datasets

─────────────────────────────────────────────────────────

One screen. Everything you need to close the laptop.

Make it yours

The wrapup skill took about an hour to write and has been part of our daily routine since. The Git history is cleaner. The docs are more accurate. Each morning starts with a clear list already loaded into context.

It's also a decent example of what skills are good for in general: taking a multi-step, context-dependent workflow you'd otherwise do manually — or skip — and encoding it once in a Markdown file. Claude Code handles the execution. You type one word.

The cost of a good end-of-day routine isn't the work itself. It's the friction of remembering to do it and knowing where to start. A skill eliminates both. Copy the file, swap npm test for pytest, swap ESLint for Ruff, add whatever project-specific checks matter — and run /wrapup tonight.

If you hit a snag adapting the skill to your stack, paste this post's URL into Claude Code or your AI assistant of choice. It'll have the full context to help you debug.

Download the proven SKILL.md here:

Important: always review a skill before trusing it blindly. Fortunately, skills don't contain complicated code and are easy to understand in plain English.

Where to run this

You need a machine where Claude Code and Git are available — which is any Linux box with a terminal. If you're running dev environments on a VPS, Hetzner gets you a CX22 at €4.85/month with €10 free credit. It's what this blog runs on.

If you'd rather skip the server management and want a hosted environment for AI workflows, xCloud handles the infrastructure so you can focus on the skills themselves.

For teams that want monitoring on the services Claude is committing to, UptimeRobot covers 50 monitors on its free tier at 5-minute intervals — useful for catching those /export timeout issues before your users do.

(Affiliate links — we get a small cut if you sign up, at no cost to you.)