home / skills / steveclarke / dotfiles / finalize

finalize skill

/ai/skills/finalize

This skill performs a post-implementation finalize checklist, auto-verifying lint, tests, docs, UI quality, and hygiene to prep for merge.

npx playbooks add skill steveclarke/dotfiles --skill finalize

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.5 KB
---
name: finalize
description: Post-implementation checklist for documentation, code quality, convention alignment, visual verification, and issue hygiene. Run after core work is done, before committing or merging. Use when user says "finalize", "ready to merge", "preflight check", "wrap this up", "did we miss anything", or "final review".
---

# Finalize

## How it works

This skill runs a universal checklist, then checks the project's CLAUDE.md
for any project-specific finalization requirements (look for a "Finalize
Checklist" section or similar). The project knows what it needs — this skill
just makes sure nothing gets skipped.

## Universal Checklist

Work through each section. Report what passes and what needs fixing.
Fix issues directly rather than just listing them — the user wants the
work done, not a report.

### 1. Lint & Format

Run whatever lint/format tools the project uses. Check CLAUDE.md or
package.json/Gemfile for the commands. Common ones:

- Ruby: `standardrb`, `rubocop`
- JS/TS: `eslint`, `oxlint`, `prettier`, `oxfmt`
- CSS: `stylelint`
- Python: `ruff`, `black`

### 2. Tests

Run the project's test suite. Check for:
- All tests pass
- No skipped tests that shouldn't be skipped
- New code has test coverage (or note if it doesn't)

### 3. Code Quality Sweep

Scan changed files for common issues:
- Raw/hardcoded values that should use project utilities or constants
- Inconsistent patterns with existing code (naming, structure, style)
- Dead code, redundant logic, TODO/FIXME comments left behind
- Debug statements (console.log, binding.pry, debugger, puts)
- Security: hardcoded secrets, unsafe patterns

### 4. Documentation

Check that new/changed code has corresponding documentation:
- README or docs pages updated if user-facing behavior changed
- Inline docs (JSDoc, YARD, docstrings) on public APIs
- Any project-specific docs (check CLAUDE.md for the list)

### 5. UI & Design Quality

Skip this section if the changeset has no view/template/component files.

**Run Impeccable skills on changed view files:**
- `/polish` — spacing, interaction states, typography, transitions, details
- `/audit` — accessibility, performance, responsive, theming
- `/normalize` — component library usage, design system compliance, tokens

Report which skills were run and what they found. Fix issues directly.

**Consistency with existing pages** (not covered by Impeccable):
- New pages match the structure of similar existing pages
- Headers, content wrappers, and action placement follow established patterns
- If the page deviates from the dominant pattern, the deviation is intentional
  and justified

**Visual verification:**
- Changes render correctly in dev server, Storybook, or Lookbook
- Light mode and dark mode if applicable
- Mobile/responsive if applicable

### 6. Git & Issue Hygiene

- PR description reflects the actual scope of changes
- `Closes #N` or equivalent issue linking in PR body
- Parent issues/epics updated if this is part of a larger effort
- Follow-on issues created for deferred or discovered work
- Issues added to project board with correct status

### 7. Project-Specific Checks

Read the project's CLAUDE.md for a "Finalize Checklist" section (or similar).
If it exists, work through those items too. These are project-specific
requirements that the universal checklist can't know about.

### 8. Memory

If this is a Claude Code session with persistent memory:
- Update memory files with key learnings, decisions, or patterns discovered
- Update status tracking (component counts, phase progress, etc.)

Overview

This skill runs a post-implementation finalization checklist to ensure code, docs, visuals, and issue hygiene are ready before committing or merging. It is designed for shell-based projects and projects that include a project-specific CLAUDE.md with finalization requirements.

How this skill works

The skill executes a universal checklist: lint/format, tests, code-quality sweep, documentation, UI/design verification, git/issue hygiene, and memory updates when applicable. After the universal pass it reads the project's CLAUDE.md for a "Finalize Checklist" section and runs any project-specific items found. Wherever possible the skill fixes issues directly instead of only reporting them, and it reports remaining items that require manual attention.

When to use it

  • When you say: "finalize" or "final review"
  • Before creating a pull request or merging: "ready to merge"
  • Before pushing changes from a local machine: "preflight check"
  • When wrapping up a feature or bugfix: "wrap this up"
  • If you suspect something was missed: "did we miss anything"

Best practices

  • Run lint/format tools listed in project files (package.json, Gemfile, CLAUDE.md) and apply fixes automatically when safe
  • Run full test suite and ensure no unexpected skips; add tests for new behavior or note why tests are omitted
  • Remove debug statements, TODO/FIXME markers, and hardcoded secrets; replace with constants or utilities
  • Align new UI code with the project component library and spacing/typography tokens; verify responsive and accessibility basics
  • Update PR description, link issues (Closes #N), and create follow-on issues for deferred work

Example use cases

  • Finish a set of shell scripts and ensure formatting and tests pass before merging
  • Finalize a UI tweak: verify component usage, spacing scale, color tokens, and run visual checks in dev server
  • Wrap up a refactor by scanning for dead code, updating docs, and ensuring tests cover changed behavior
  • Prepare a cross-machine sync toolset: run shell lint, confirm docs reflect install steps, and add memory notes about chosen defaults
  • Close out a bugfix: run tests, confirm PR links the issue, and create follow-ups for related edge cases

FAQ

Will the skill automatically modify files?

Yes — where safe (formatting, lint fixes, removing obvious debug lines) the skill applies fixes. It reports any risky changes for manual review.

How does it find project-specific finalization steps?

It scans CLAUDE.md for a "Finalize Checklist" or similar section and executes each listed item after completing the universal checklist.