aberson
UserProvider-neutral skill pipeline (Claude, GitHub Copilot/GPT, OpenAI Codex) for autonomous plan -> build -> review -> ship: 57 skills (54 portable with three adapters each, 3 Claude-native), calibrated judges, and install/build/release tooling.
Categories
Indexed Skills (43)
build-phase
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]".
build-queue
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>".
build-step
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.
goblin-do
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.
judge-ui
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 tier delegates here. Project specifics (server bring-up, auth, testids) come from a project adapter. Invoke as "/judge-ui [flow-or-spec] [--adapter <name>] [--dry-run]".
memory-distill
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".
plan-expedite
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.md and prints the Pick-up-here block).
plan-feature
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.
plan-init
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.
plan-merge
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).
plan-review
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.
plan-wrap
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.
repo-sync
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.
repo-update
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".
research-prospect
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.
review-deep
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.
review-gauntlet
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.
review-proof
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.
review-uat
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.
session-wrap
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.
skill-eval-setup
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>".
skill-evolve
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 printed for operator review (no auto-PR). Loser-analysis is written under docs/investigations/skill-evolve/ for the next generation. Invoke as "/skill-evolve --skill <name> [--variants <path-or-inline>]".
skill-iterate
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.
task-handoff
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).
test-prune
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.
tier-escalate
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. Discovery + map only — it never edits a skill or CLAUDE.md; switching a session to Fable stays a per-session operator action. Run bare to scan + report + write the map.
tier-offload
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 a skill to local_judge. Run bare to scan + report + write the artifacts.
user-afterparty
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, then WALKS the operator through the 3 conversational ones (memory-distill, test-prune, plan-trim) one at a time, yielding at each confirmation gate and never force-deciding. Report-first / apply-on-confirm — nothing mutates without a per-skill go-ahead. Promotes the monthly sprint-wrap ritual to an on-demand front door. NOT for wrapping a single session (use /session-wrap) or the sit-back-down verdict (use /user-wrap). Invoke as '/user-afterparty [--only <csv>] [--skip <csv>] [--dry-run] [--all-projects]'.
user-debug
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]".
user-draft
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>.
user-gateway
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 voiced fragment as an intake-ledger row routed by consulting the routing web, emits a ready-to-paste seed per row, and closes with the ledger path + canonical /goal + QUICK COPY. Wanting IDEAS is /goblin-suggest's job; refining ONE prompt/goal is /user-draft's. Invoke as '/user-gateway <topic> <free-text vent>' (the vent may also follow in conversation).
user-lavishify
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]".
user-orient
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-derived shipped / planned / next / cuttable), use user-pm.
user-shakedown
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>".
user-uat
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 + what to look for" table, or ad-hoc "run these, expect these") and wants the mechanical tier done for them. Invoke as "/user-uat [source] [--deep] [--ui] [--dry-run] [--yes-side-effects]".
user-walkthrough
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>".
user-wrap
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 + loss report front and center, then acts per verdict. NOT for mid-task transition moments (use bare /session-wrap) or checkpoint-only writes (use /task-handoff --loop).
claude-oauth-auth
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.
plan-trim
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.
repo-init
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.
user-brainstorm
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 structured doc set. Invoke as "/user-brainstorm <topic>".
user-learn
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 <topic>".
user-pm
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.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.