Claude Skills by aberson

Shared scoring fragment referenced by `/skill-iterate` Phase 2 Step D and any other skill-pipeline tooling that needs a single, reproducible scoring axis for a SKILL.md. Composes two scoring axes — deterministic structural metrics (Step 3 of the hill-climbing plan) and LLM-driven absolute per-assertion grading (SIHC.2 Option A) — into one composite score in `[0.0, 1.0]`. NOTE on history: composite mode previously used the differential pair grader (Step 4 of the SIHC.1 plan) as its second axis...

Orchestrate a multi-step build phase end-to-end. Reads step definitions from a plan doc, runs /build-step for each in order, posts live progress to GitHub issues, verifies quality gates between steps, and reports. Invoke as "/build-phase --plan <path> [--phase N]".

Queue N pending phase plans and run them unattended overnight. For each item invoke /plan-expedite then /build-phase via the Skill tool, isolating each in its own worktree. On any halt, park the phase by filing a GitHub issue with halt context and proceed to the next queue item. Polls a kill-switch file between items. Emits a morning summary. Invoke as "/build-queue --queue <path>".

Execute one build step end-to-end. Developer writes, reviewers gate, changes merge. Configurable isolation (worktree/docker), review style (auto/code/deep/runtime/full), optional UI.

How to authenticate with Claude using a subscription OAuth token instead of an API key. Use when setting up Claude Code sessions, building tools that invoke the claude CLI, or when a user has a Claude subscription but no API key.

Audit all auto-loaded Claude Code context files (CLAUDE.md chain, .claude/rules/*.md, MEMORY.md) for a project and produce a prioritized progressive-disclosure improvement report — what to stub, extract, or prune to reduce per-turn token cost. Run bare for a report only; add --apply to implement high-confidence changes (rules stubbing, stale memory pruning) autonomously.

Read exact lifecycle markers from this disposable plugin's shared reference. Use when a request contains the unique trigger {{TRIGGER_ALPHA}}.

Read exact lifecycle markers from this disposable plugin's shared reference and helper asset. Use when a request contains the unique trigger {{TRIGGER_BETA}}.

The single front door for a chosen goblin atom. Mode-dispatches a resolved suggestion or UAT task — a `small` suggestion or a safe `uat` task is EXECUTED via /build-step (auto-ship a genuinely-clean result, park the rest with a one-line --land to ship later); a `big` suggestion or a not-safe `uat` task is HANDED OFF (prints the /plan-feature seed + the build-rail next step). Collapses /goblin-handoff for the small path.

Produce a grounded, ranked improvement shortlist for a workspace project and persist it to goblin's brain/ atom store. Three mutually-exclusive modes: --small (default — small, purely-additive, non-disruptive quick wins), --big (full-fidelity improvement ideas), and --uat (triage the project's operator-asks for AI takeover). Reads the project's real state, generates anchored candidates, scores/triages them with parallel LLM judges, ranks, and writes mode-discriminated atoms.

Drive a web UI through a defined flow, capture stage screenshots + a structured read-back, and have an independent vision-judge sub-agent render a PASS / FAIL / UNCERTAIN verdict cross-checked against the read-back — turning "look at the screen" UAT from a human task into an agent-judged one, with a mandatory fall-back to human escalation on low confidence. Use when a UAT step needs someone to drive a browser and judge what renders ("does the screen look right?"), or when user-uat's Visual ti...

Scan recent git history + skill-iterate run-logs for UN-codified regressions and DRAFT codification candidates (memory one-liner + rule clause + hook stub), parking them as a draft PR for the operator to judge via /memory-distill. Detects and drafts only — never auto-applies. Run bare to open a draft PR; add --dry-run (default-safe) to print the report + PR body and create nothing.

Post-mortem-style review of recent feedback memories. Pick 3-5, walk through them one at a time asking "did I get this right? what's the next layer?", then surface latent principles that several memories point at but none articulate. Use when memories feel stale, when the same correction keeps recurring, or periodically to consolidate. Works from concrete recent evidence — not vibes. Invoke as "/memory-distill".

Chain plan-review-autofix, plan-wrap-autofix, repo-sync, and task-handoff into one autonomous prep step before /build-phase. Required arg --plan <path>. Default continues in-window — emits a /goal + /build-phase command pair (the /goal arms the Stop hook over the agent-completable build span); auto-compaction handles context (no forced /compact). Use --new-window for a fresh-window handoff (durable current.md write via task-handoff --next-task, then /session-wrap --end renders handoff-prompt....

Plan a new feature, phase, or significant change for an existing project. Reads the codebase and existing docs first, then runs a focused conversation to produce a scoped plan document at documentation/<feature>-plan.md. Use when adding capabilities to a project that already has code and architecture in place.

Guide the creation of a new project plan.md through a structured conversation. Asks the right questions up front — stack, auth, data storage, async patterns, build tooling, UI — before writing anything. Use at the start of any new project to avoid mid-plan discovery of architectural gaps.

Merge two overlapping plan documents into a single coherent plan. Identifies shared goals at different fidelity, resolves sequencing tensions, picks a spine, deletes subsumed phases, and archives originals. Use when two plans target related work and need to be reconciled before execution (e.g., a capability plan plus an infrastructure plan that together deliver the same feature).

Review a project plan.md or feature plan for gaps, missing pieces, unresolved decisions, and risks. Works for both greenfield project plans and scoped feature plans (documentation/*-plan.md). For feature plans, also validates claims against existing code and checks impact completeness. Use when asked to review or audit a plan before building begins.

Investigate a project's current state, propose plan items to cut or fold together, and execute the trim once confirmed. Use when a plan has accumulated cruft, the user asks to "tighten the plan", "what can we cut", "what's still relevant", or after a phase ships and the surrounding plan has drifted. Companion to user-pm (read-only snapshot); plan-trim writes.

Check whether a document (plan, spec, README) is self-contained for a model with no prior conversation history. Finds anything a fresh model would need but can't derive from the document alone. Use after plan-init or plan-review, or any time a document will be handed to a new model or agent.

Use when a local project directory has no GitHub repo and needs to be published — initializing git, creating the remote repo, adding a README, and converting a plan document into GitHub issues.

Sync GitHub issues to match a plan's structure (umbrellas + step issues), with rich bodies optimized for fresh-context LLM work. Detects letter-named phases, sub-phase notation, table-row step formats. Use after plan changes or to bring issue bodies up to current build-doc richness.

End-to-end docs + git update after completing a phase or feature. Updates README, plan doc, runs plan-wrap, fixes gaps, updates memory, commits, creates a closed GitHub issue for posterity, and pushes. Use when asked to "update the docs", "update git", "wrap up this phase", or "push everything".

Scan active projects and surface /deep-research topic strings per project. Reads MEMORY.md to enumerate projects, fans out parallel Explore agents (one per project) to identify 2-3 high-value research topics each, then renders a grouped copy-pasteable menu. Use when you want token-rich research tasks to hand off to separate windows, or when you want to understand what research would most improve each project.

Six-lens code review (correctness, bugs, security, tests, style, plan-conformance) with anti-pattern catalog, severity+evidence, JSON audit trail. Use for high-stakes diffs; use the leaner review-gauntlet profile for routine diffs.

Lean code-review profile over review-deep's engine. Takes a developer prompt and code diff (positional args), runs review-deep's code lenses (correctness, bugs, security, test quality, style) with deterministic aggregation, and emits a terse PASS / NEEDS-WORK verdict — no JSON sidecar. Use after a developer agent produces a diff for a fast multi-lens gate; use review-deep directly when you need the full audit trail, plan-conformance, or runtime lenses.

Enforce evidence-based responses by requiring primary source verification before making claims. Use when accuracy matters and guessing is unacceptable -- audits, debugging, architecture decisions, or any time you need to be sure.

Refine a user-acceptance-test (UAT) script so every step is unambiguous, every prerequisite is explicit, and only the things that genuinely need a human stay on the human's plate. Use when a UAT/manual-test/handoff doc reads like 'wipe → expect setup screen' and the operator has to guess what to do or what counts as pass.

The session-transition front door. Bare invocation TRIAGES the session — context utilization, task-boundary state from current.md, git state, armed /goal — announces one route, then ACTS: continue (checkpoint + one line), clear-next (durable state to disk, git verb, emit /clear), or end-window (full wrap, handoff rendered to handoff-prompt.md, Pick-up-here block). Use at any transition moment: task boundary, heavy context, or end of day. /task-handoff is the checkpoint library this skill calls.

Auto-generate an evaluation framework (evals.json + test_scenarios.json) for any skill by reading its SKILL.md, then output a ready-to-paste self-improvement loop prompt. Use as "/skill-eval-setup <skill-name-or-path>".

A/B-test N variant mutations of a skill in parallel. Takes --skill <name> and either --variants <file> (one strategy per line) or no variants (brainstorm mode — LLM proposes a candidate list and exits for operator curation, no worktrees created). When variants are supplied, creates N worktrees, dispatches N parallel agents that each apply their strategy and run the existing produce-grade loop, then produces a comparison table. The winner's branch is pushed and a `gh pr create` command is prin...

Serial-iterate every scorable skill autonomously overnight via hill-climb. Default invocation drains all .claude/skills/*/evals-bearing skills (minus an embedded skip-list); per-skill budget capped by 1h wall-clock OR 12 iterations, whichever first. Carries autoresearch's NEVER-STOP-mid-loop discipline. Complementary to /skill-evolve (parallel A/B exploration); /skill-iterate is serial exploitation.

Checkpoint library — orchestrators call this (build-phase, build-step, plan-expedite, user-draft); operators usually want /session-wrap. Modes: --loop [--no-commit] (write current.md), --next-task [label] (durable task-boundary save), --resume (read current.md + orient), --end (delegates to /session-wrap).

Audit a project's test suite for redundant, trivial, or mock-theater tests; relocate the ones that are the only coverage for a behavior; delete the rest. Use after a project has accumulated drift from many build phases, or when tests slow down the dev loop with no payoff. Read-only by default until cleanup phase.

Scan your own .claude/skills/ to find which skills contain a single load-bearing seed-artifact phase worth escalating a session to Fable 5, and emit a human-readable Fable escalation map for the operator. Fans out read-only Explore agents to classify each skill's roles (ORCH/AUTHOR/PLAN/JUDGES/GATE/MECH/SOLO), applies the seed-artifact escalation rule (only a solo quality-ceiling phase that a diversity committee cannot substitute for warrants Fable; fan-out arms never do), and writes the map....

Scan your own .claude/skills/ to find which LLM-bearing sub-tasks are safe to offload to a local model, and emit both a human-readable offload inventory and a switchboard config the local_judge client can load. Fans out read-only Explore agents to classify each skill's roles (ORCH/AUTHOR/PLAN/JUDGES/GATE/MECH/SOLO), applies the difficulty-based routing rule (only a cheap fan-out judge/grader slice is local-safe), and writes the inventory + config. Discovery + config only — it never auto-wires...

The milestone workspace-hygiene front door — invoke at a milestone or any time to run the whole cleanup sweep: 'milestone hygiene', 'workspace cleanup', 'run the sweep', 'afterparty', 'tidy up the workspace', 'sprint wrap'. A THIN orchestrator that CHAINS the existing hygiene skills via the Skill tool and owns no hygiene logic of its own: it runs the 2 autonomous ones (lesson-harvest --dry-run, context-slim) plus the tier-drift + meta-tool-prune checks unattended into ONE consolidated report,...

Brainstorm and investigate a topic end-to-end. Seeds 10 starter topics, gap-fills through 2-4 "what's missing?" rounds with the user, tiers by importance, then dispatches one background sub-agent per topic to write a templated reference file. Produces a navigable doc set under `docs/investigations/<topic>/` with a tier-organized README index. Use when the user wants to ideate comprehensively on a subject, build a reference catalog of considerations, or convert an open-ended question into a st...

Diagnose and fix a bug end-to-end with forced primary-source investigation before any code change. Independently reproduces the bug, designs a fix, delegates implementation to build-step, then verifies the original symptom is gone. Built to break the command-paste loop with the user. Invoke as "/user-debug --symptom '...' [flags]".

Refine rough thoughts into a polished, ready-to-use artifact — either an improved prompt or a copy-pasteable /goal \"<condition>\". NL-detects which you want, runs a gaps→questions→polish pass, and checkpoints current state (task-handoff --loop) so a window pivot loses nothing. Invoke as /user-draft <your rough thoughts>.

Pre-work intake gateway — CONVERTS an operator vent into routed, ledger-backed work; it never proposes work of its own. Invoke when the operator dumps everything on their mind about a topic ('here's everything on my mind about X'), says a project 'doesn't feel right', wants rough observations made concrete ('take my rough observations and make them concrete'), or is venting half-formed worries. Runs a listening pass (gaps -> 3-5 targeted questions, ONE round max, never block), lands every voi...

Render the output you JUST sent to the screen as a Lavish annotatable HTML artifact for detailed, element-level review. Chat output stays the default; reach for this on demand when a just-delivered plan / comparison / diagram / table / long fix-list is easier to mark up by clicking elements than by quoting in chat. Invoke as "/user-lavishify [what to render]".

Scaffold a hands-on learning ramp for a topic using the applied-learning method (70% hands-on / 20% mentoring / 10% coursework). Given a topic, creates a self-contained folder with a knowledge base, runnable Jupyter notebooks (graphics included, self-validated by execution), standalone code examples, exercises, project-grounded seed ideas, and a progress tracker. Fans out one sub-agent per file. Use when the user wants to learn a concept by doing, not just reading. Invoke as "/user-learn <top...

Re-orient the user on the session axis — the state of this conversation/thread — via a status snapshot (verified, not-verified, next steps) plus parallel asides; `--quick` skips all lookups and gives a lightweight three-section thread summary (problem, what we tried, what's left). Use when the user asks "where are we", "what's the status", "remind me what we were doing", "what were we doing", or just wants a quick reminder of the working thread. For project-axis state (a project's plan+git-de...

Tight PM-lens overview of a project — what shipped, what's planned, what we could do next, and what could be cut. Default mode emits a four-section snapshot; a topic flag (`--uat` / `--test` / `--build` / `--decide` / `--overnight` / `--goal` / `--other` / `--cut` / `--history` / `--outstanding`) drills into one topic with context + what-it-unblocks + the work. Use when the user asks for a project overview, status snapshot, "where are we / what's next", or wants to challenge plan assumptions.

Autonomous UAT closure of a just-built tool or feature. Same ledger/engine as /user-walkthrough, but the agent drives itself — for each open item it verifies (with evidence), quick-fixes in-tree (narrowest test), or logs it (one-line diagnosis) until the ledger has zero open items. Designed to run armed under a /goal whose zero-open condition is mechanically checkable every turn. STOPS (logs, never guesses) on anything needing operator judgment. Invoke as "/user-shakedown <tool/feature>".

Run an already-clear UAT block FOR the operator — execute each step, capture the real output, and auto-judge only the mechanically-checkable ones (exit code, output match, refusal text, DB/HTTP/file/log); escalate every judgment call with evidence. Removes the run-command → paste-output → relay loop. With --ui, also drives + vision-judges the visual-tier steps via /judge-ui instead of escalating them. Use when the operator has a concrete UAT/manual-smoke block (a plan M-step, a "commands + wh...

Attended, operator-driven acceptance of a just-built tool or feature. Establishes a persistent operating contract on entry, then YIELDS each turn to the operator — you ask questions or point at problems, the agent answers from primary source, fixes small things in-tree on the spot, logs big ones without rabbit-holing, marks UAT coverage as a byproduct, and hands the turn back. Use for post-/build-phase exploration where the operator wants to drive. Invoke as "/user-walkthrough <tool/feature>".

The return-moment front door — invoke when sitting back down at an open window: 'sitting back down', 'should I keep going or wrap up', 'am I safe to close this window', back-from-lunch or next-morning re-entry. Despite the name, the most common verdict is KEEP GOING — this skill serves the whole return moment, not just closing. Orients from current.md + git (task-handoff --resume's shape), delegates the verdict to /session-wrap --advise (the one triage owner), re-presents its verdict banner +...