Skills

Personal skills for agentic coding with Claude Code.

Checks

Run the lint gate before committing (also enforced in CI by .github/workflows/lint.yml):

pre-commit run --all-files

It covers ruff (Python), shfmt + shellcheck (shell), markdownlint-cli2 (Markdown), actionlint + zizmor (workflows), and the SKILL.md frontmatter validator. Install the git hook once with pre-commit install.

Pull requests

The PR title must be a Conventional Commit, enforced by .github/workflows/lint-pr-title.yml. This is a separate check from the commit-message hook, and it reads the PR title only — a valid commit message does not imply a valid PR title, so a title typed by hand at gh pr create time is the usual thing that fails.

A skill name is a scope, not a type. The type prefix is mandatory:

feat(pm-deepen): adopt the branch the caller prepared     # correct
pm-deepen: adopt the branch the caller prepared           # fails: no type

Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert. Fix a rejected title in place with gh pr edit <n> --title "..." — the check re-runs on edit, no push needed.

cp

Slash command /cp that commits and pushes changes to the current branch, running only the pre-commit checks described in the project's CLAUDE.md (or AGENTS.md) — nothing more, nothing less.

codex-2nd-opinion

Slash command /codex-2nd-opinion that invokes OpenAI Codex CLI (GPT-5.4) to get an independent second opinion on any discussion, plan, or code. Presents both Claude's and Codex's perspectives with a structured, fair comparison.

auto-merge-dependabot

Slash command /auto-merge-dependabot that reviews all open Dependabot PRs in the current repository, assesses each for risk (version bump type, CI status, file scope), and automatically merges safe ones while flagging those that need manual review.

brainstorming

Skill that guides collaborative design before implementation. Explores user intent through one-at-a-time questions, proposes 2-3 approaches with trade-offs, presents the design incrementally for approval, then writes and commits a spec document. Stops at the approved spec — does not auto-trigger implementation. Forked from obra/superpowers brainstorming skill with all references to other superpowers skills removed.

wigo

Slash command /wigo (What Is Going On?) that gives a comprehensive situational briefing on the current git tree: branch state, dirty files, recent session history, associated PR status (CI, reviews, mergeability), and suggests actionable next steps.

pm-autofix-pr

Slash command /pm-autofix-pr that iteratively fixes CI failures and addresses reviewer feedback on a GitHub PR from the local CLI. Fetches CI and review state, evaluates each feedback item on its merits, fixes valid issues, replies with no-change rationale for invalid or out-of-scope feedback, auto-resolves merge conflicts with the base branch, runs local pre-commit checks, commits, pushes, and loops until CI is green, the PR has no merge conflicts, and all feedback has an outcome reply.

rebase-pr

Slash command /rebase-pr that rebases a PR branch onto its base branch, resolves conflicts file by file, re-runs the project's detected quality gate, and force-pushes through a --force-with-lease armed with an anchor captured before the rebase — so a concurrent writer is protected instead of clobbered. gh CLI only. Bundles scripts/capture-lease.sh (anchor capture plus ahead/behind/diverged classification) and scripts/safe-force-push.sh (re-inspect, stand down, or push).

pm-plan

Skill /pm-plan that performs deep, multi-phase implementation planning before writing any code. Dispatches parallel Explore subagents (via the native Agent/Task tool) for codebase exploration, plus a one-shot Haiku call for plan-name generation. Small tasks (which include trivial ones) skip subagents and adversarial review; Medium and Large tasks get an adversarial review from the advisor, else a read-only Plan subagent. Safe to run headlessly: it never blocks on a question, recording guesses under ## Assumptions. Produces a structured plan at .ultraplan/<plan-name>.md.

pm-cr

Slash command /pm-cr that reviews the current diff, or a PR/branch/path target, for correctness bugs and reuse/simplification/efficiency/altitude/conventions cleanups. It takes no level argument: the sibling pm-risk skill rates the change's merge risk, which sets the depth (low/medium/high, with critical mapped to xhigh); without pm-risk it reviews at high. Medium and above fan out across up to 11 parallel finder angles and verify each candidate (3-state at medium, recall-biased above it), and xhigh adds a gap-sweep pass. Runs on the latest Opus at high reasoning effort via frontmatter. From medium up, every finder gets a reviewer brief (the author's stated intent plus CLAUDE.md/AGENTS.md/REVIEW.md rules, read from the base when the diff edits them). Findings are ranked security > correctness > performance > cleanup and filtered through a shared never-report list. A review can add one scope finding that suggests a split, and it ends with a short assessment. --fix applies the findings directly, --comment posts them as inline PR comments plus the assessment as one general comment. scripts/scope.py resolves the base and the scope. Mechanics live in references/angles.md, references/review-depth.md, and references/flags.md (read only when a flag is passed). Run the scope script's tests with uv run --with pytest pytest pm-cr/tests.

pm-risk

Slash command /pm-risk that rates how risky a PR, branch or working tree is to merge (low/medium/high/critical) and explains why. Built on the merge-risk skill (Matt Pocock, via warpdotdev/common-skills, MIT): the model reads the diff and surrounding code and rates five weighted categories (alignment, impact, verification, rollback cost, error detection); critical means Impact and Rollback cost are both at their worst. scripts/score_risk.py first gathers deterministic facts (size, test changes, high-stakes paths including globs under a High-stakes paths heading in the base's REVIEW.md, instruction-file edits), and two of them set a floor the judgment cannot go below: a high-stakes path means at least high, an instruction-file edit at least medium. A PR is rated without checking it out, and --comment posts the report on the PR. pm-cr calls it to choose its review depth. Facts and floor live in references/rules.md. Run its tests with uv run --with pytest pytest pm-risk/tests.

pm-simplify

Slash command /pm-simplify that cleans up the changed code without changing behavior. Reviews the diff for reuse, simplification, efficiency, and altitude issues via four parallel review agents (falling back to a single inline pass when no native subagent tool is available), then fixes what it finds directly. Quality only — does not hunt for correctness bugs.

best-of

Slash command /best-of that compares code across two git worktrees against 15 software engineering best practices (correctness, security, SOLID, DRY, testing, etc.) and project contribution guidelines (CLAUDE.md, CONTRIBUTING.md, linter configs). Dispatches parallel analysis agents, scores each solution on a weighted rubric, and presents a structured verdict with specific file:line evidence.

is-skill

Slash command /is-skill that analyzes the current session's conversation, context, and work patterns to determine whether the knowledge or workflow used could be extracted into a reusable Claude Code skill. Classifies proposals as user-level (cross-project, issue filed in pmatos/skills) or project-specific (issue filed in the current project's repo), then creates a GitHub issue with a structured skill proposal after user approval.

upscale

Skill that upscales raster images with a local OpenCV EDSR super-resolution model, writes an exact requested pixel size, and verifies the final dimensions.

codestory

Slash command /codestory that turns a PR, branch, working-tree diff, file, path or whole project into a flow-ordered story told beat by beat, pausing after each beat so the reader can ask for more detail or move on. Built for code review: it explains so the human can judge and never issues verdicts itself. Lens subagents (interfaces, control flow, dependencies, IO, error handling, situating context, tests-as-spec) gather leads only — the narrator re-reads the source before every beat, and every excerpt carries a path:line anchor. Fan-out shape follows a size tier computed by scripts/resolve-target.sh. The story accumulates at .stories/<slug>.md and is resumable.

pm-deepen

Slash command /pm-deepen that runs an architecture review end to end with no questions, so it is safe for cron jobs, routines and headless firings. Scans for deepening opportunities (shallow modules whose interface is nearly as complex as their implementation), scores each on leverage (doubled), locality, heat and inverted blast radius, auto-picks the top one, explores interfaces via codebase-design's design-it-twice sub-agents, adjudicates the winner — via the advisor when one is available, falling back to self-adjudication against the written designs otherwise — instead of the interactive grilling loop, implements it test-first, and opens a PR. It adopts the branch it was started on when that branch is provably its own to take (non-default, no unique history, no upstream, unpublished) — the state a headless harness leaves a prepared workspace in, and what keeps the PR discoverable by its head branch — otherwise cutting its own from origin/<default-branch>. It writes nothing to the repo but the refactor itself: the PR body is the deliverable (problem, before/after Mermaid, scores, both runner-ups, any proposed ADR), and memory lives in GitHub — every PR is labelled pm-deepen, so gh pr list --label pm-deepen --state all tells the next run what was landed, declined, or bailed on. A bail-out that produced work opens a draft PR rather than vanishing. Forked from Matt Pocock's improve-codebase-architecture, which is interactive by design; the exploration heuristics, candidate-card fields and vocabulary discipline are his.

pm-triage

Slash command /pm-triage that runs a per-project decision session over open GitHub issues labeled needs-triage, human-needed, or sym:human-needed. Parallel read-only sub-agents analyze each issue first — resolved by a merged PR, superseded, or still genuinely needing a call — and only genuine calls reach the user, one at a time via AskUserQuestion, with an explicit stop-for-today option on every question. Each decision is written straight back to GitHub as an issue comment plus a label removal, so the label itself is the queue and a later run naturally resumes wherever the last one stopped — no local state file.

review-offline

Slash command /review-offline that turns a changeset (PR, branch, range, HEAD, path or working tree) into a local webpage where the user and an agent review the code together. The page opens on an animated architecture and data-flow picture (rebuilt from show-me and pr-lens, with no dependency on either), arrives pre-loaded with correctness and cleanup suggestions (embedded angles derived from pm-cr and pm-simplify), and lets the user accept, edit and add comments or ask the agent. Finish review writes .reviews/<slug>.md and the background server's exit tells the invoking agent. The agent features run headless through the invoking harness (claude, codex or omp), read-only and config-isolated. It never posts, comments, pushes or edits. Python stdlib only; Preact + htm are vendored with no build step. Run its tests with uv run --with pytest pytest review-offline/tests.

vibe

Slash command /vibe that drives an issue marked epic to closure under ultracode: read-only triage of every child against the current default branch, fix PRs (each agent runs /investigate, then /code-review high --fix --comment and /simplify, then waits for CI), orchestrator-owned merges that rebase only on conflict and keep the default branch green, a report-only schedule, and decision memos for the rulings only a human can make. Ends with a read-only close-out audit; children may be closed-as-measured under a rule the user stated, and an epic that is not fully met gets a gap list, not a closure.