claude

scott-skills

Scott's end-to-end workflow for Claude Code: set an effort's destination, principles, and high-level design once with /wayfinder, then let agents build it on their own — a plan of pieces on your tracker, only the risks that could sink it proved first, every ready piece built in parallel and verified on two axes, every decision citing its grounds and cross-read each round so bad calls are corrected before they compound — or spec a feature yourself and run it through /specify, /spec-review, /tickets and /ship with /next, or grow a feature a slice at a time with /iterate, decisions made just in time against an effort log in the repo and the next effort's idea parked as a ticket by /seed, client feedback turned into an effort by /triage — every review gate on the finding-pipeline contract, every spawned agent on a policy-resolved model tier, every test run scoped to the change by the repo's TESTING.md — plus standalone skills for grilling, design, domain modeling, prototyping, research, TDD, wizards, verification skills that drive each app the way a user does, writing for agents, Herdr and Rex hand-offs and side panes, cold-reading the docs agents have worn, /tend to keep the repo's CONVENTIONS, TESTING, PRINCIPLES, CONTEXT and ADR docs on purpose as each change lands, a /snag → /autopsy loop that traces friction in past sessions back to the skill text that caused it and replays it as an eval, /rsi, which grades recent sessions from every local coding agent and files the failures these skills caused as snags for that loop, /evals to A/B any skill edit against the text before it, and /maintain-iterate, which tunes the /iterate loop from its own runs.

1 on GitHubby Scott Livingstonv0.73.0updated 5 days ago
/

Plugin scott-skills from marketplace claude-skills in scottlivingston/claude-skills. Commands read from the repo's manifest — 4 days ago.

This plugin runs code on your machine — its hooks fire automatically on events like tool use. The exact commands are listed below; read them before installing.

What it installs

Skills (40)

  • release

    Bump the plugin version, commit the working tree as coherent changes, and push to origin.

  • autopsy

    Trace where skills went wrong in past sessions — open snags from `/snag`, or a sweep of a skill's recent transcripts — back to the skill text that caused it, reproduce each cause as an eval, and fix that text with the human's sign-off and a before/after run. `/autopsy [skill]`.

  • codebase-design

    Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable, or when another skill needs the deep-module vocabulary.

  • cold-read

    Repair a document that many agent sessions have edited so it reads to a cold reader — one holding only the doc and what it points at. Hunts ghosts of things the repo no longer has, pointers that don't resolve, changelog prose written as a change instead of a state, one thing under two names, undefin

  • conventions

    Where a repo's reviewable coding standards live — CONVENTIONS.md at root, per-directory deltas in monorepos, nearest scope wins — and how reviewers find them. Consult when reviewing code against standards, documenting a new standards rule, or setting up a repo's CONVENTIONS.md.

  • create-verification-skill

    Generate a project-local skill per app that drives the real app the way a user does — web, CLI/TUI, desktop, service, any stack — and proves behavior with captured evidence. `/create-verification-skill [app...]` in a repo or monorepo with no scripted way to exercise its apps.

  • deciding

    The contract for an agent making a decision on the human's behalf — the grounds it must cite, the decision record it posts, the three cases that escalate to the human, friction notes when an earlier decision strains, and agent-answered review gates. Consult before any agent makes a call in a wayfind

  • design

    Decide the shape of code before it's built — modules, interfaces, function signatures, data shapes, and the seams tests will live at. Use when the user wants to be intentional about structure, or as the method an agent follows when a wayfinder piece sets a structure other pieces build on.

  • diff-review

    Review the changes since a fixed point (commit, branch, tag, or merge-base) on two axes — Standards (documented coding standards plus the Fowler smell baseline) and Spec (what the originating issue or spec asked for) — through the finding pipeline, validated fixes auto-applied or auto-ticketed and o

  • domain-modeling

    Build and sharpen a project's domain model. Use when the user wants to pin down domain terminology or a ubiquitous language, record an architectural decision, or when another skill needs to maintain the domain model.

  • evals

    Test whether a plugin's skill text changes what an agent does — eval cases under evals/, their graders, running them, and A/B-comparing a skill edit against the text before it. Consult before writing or running an eval, before claiming a skill edit fixes a behaviour, or before deleting a skill sente

  • finding-pipeline

    The find → validate → propose → validate → route contract every review gate runs — adversarial validation in chunked chains, schema-typed verdicts, edge-field routing, durable gate markers, question mechanics, the code-gate specifics. Consult when running a review stage (/diff-review, /ship, /spec-r

  • grilling

    Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any phrasing built on the word "grill".

  • hitl-questions

    The presentation contract for every question put to the human — the opening, facts vs decisions, cold-reader blocks, domain language, recommendations, prose over dialogs, the shape of a turn, escape hatches. Consult when putting any question to the human from a workflow skill, or when authoring a sk

  • implement

    Implement a piece of work based on a spec or set of tickets. Invoke only when the user explicitly asks for it or when /next routes to this stage — never spontaneously.

  • issue-tracker

    The issue-tracker contract every workflow skill speaks — vocabulary, ticket/structure/workflow operations — with GitHub and local-markdown implementations and a per-repo override. Consult before creating, reading, labeling, linking, or querying tickets on the tracker.

  • iterate

    Grow a feature slice by slice — settle only what the next slice needs, hand its build to a background agent, look at what landed, and let that pick the next slice. One slice per invocation, resumable from an effort log in the repo. `/iterate <idea>` starts an effort.

  • maintain-iterate

    Tune the /iterate loop from its own runs — a reader per session since the last pass, the build and review workflows timed, recurring friction traced to the skill text behind it, and the fixes you approve applied. `/maintain-iterate [since]` whenever a batch of slices has gone by.

  • maintain-verification-skill

    Keep a project's verification skill and feature map honest — a source reader per feature, one live pass driving every feature, at most one PR of proven corrections. `/maintain-verification-skill [app]` periodically, or after an app's user-facing surface changes.

  • model-policy

    Which model every spawned agent runs on — three tiers (executor, decider, auditor), resolved from a policy file (repo, then home, then defaults) so the session's model never leaks into a workflow by accident. Consult before spawning any agent or filling any workflow template.

  • multiplexer

    Open new Claude Code sessions and side panes in whichever agent multiplexer this session runs inside — Herdr or Rex — through one script, or carry on without one. Consult before a workflow skill hands work to a session of its own or shows the human something running beside the conversation.

  • next

    Advance an effort by exactly one unit of work — read the tracker, announce the stage, run that stage's skill. `/next auto <spec> [merge]` conducts every remaining stage end to end, to a merged PR, pausing only for escalations.

  • principles

    Where a repo's core principles live — PRINCIPLES.md at root, per-directory deltas in monorepos, nearest scope wins — the rules an agent decides product and architecture questions against. Consult when an agent decides on the human's behalf, when setting up a wayfinder plan, or when setting up or ame

  • prototype

    Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

  • research

    Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

  • rsi

    Grade recent sessions against four rubrics — efficiency, code quality, procedure compliance, verbosity — track the grades run over run, and file every failure a skill caused as a snag for `/autopsy`. `/rsi [since]` weekly, from the repo that holds the skills.

  • seed

    Park an idea for a future `/iterate` effort as a seed ticket on the tracker, where it outlives the session and every worktree — `/seed <idea>` plants one, `/seed <ticket>` preps it further. `/iterate <ticket>` kicks off from it.

  • ship

    Implement a spec's ticket DAG wave by wave — parallel agents in isolated worktrees, serial merges, each wave's merged diff verified on the Spec and Standards axes through the finding pipeline, only intent questions escalated at a durable gate. Re-entrant from the spec issue's ledger; ends by offerin

  • snag

    Flag something a skill just did that bothered you — `/snag <what went wrong>`. Files it with this session's context for `/autopsy`, then carries on.

  • spec-review

    Read a published spec in full — kernel, every decision, seams — and ground it against the codebase before /tickets breaks it down. Hunts decisions that don't decide, stale claims about the code, seam gaps, unfalsifiable acceptance, contradictions and scope leaks through the finding pipeline — deriva

  • specify

    Turn the current conversation into a spec and publish it to the project issue tracker. No interview, just synthesis of what was already discussed or decided. Invoke only when the user explicitly asks for it or when /next routes to this stage — never spontaneously.

  • tdd

    Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

  • tend

    Keep the repo's defined docs — CONVENTIONS.md, TESTING.md, PRINCIPLES.md, CONTEXT.md, CONTEXT-MAP.md, ADRs — clean and on purpose, as a document gate on /finding-pipeline. `/tend --since <ref>` tends the docs a change bears on; run it that way when a workflow finishes a change, or whole-repo when th

  • testing

    Where a repo's test recipes live — TESTING.md at root, per-directory deltas in monorepos, nearest scope wins — and how implementing and shipping skills scope their test runs to a change. Consult before running tests as a spawned agent, filling a workflow's test-notes slot, or setting up a repo's TES

  • tickets

    Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker. Invoke only when the user explicitly asks for it or

  • triage

    Turn a batch of feedback from a client, a tester or your own playtest into work — split into items, each checked against the code, sorted, the vague ones given a reproduce-or-instrument goal — then kick off an `/iterate` effort from it or add it to the one running. `/triage <feedback>`.

  • wait-what

    Stop. That last message did not land — re-pitch it.

  • wayfinder

    Build something too big for one agent session, on its own, from the destination, principles, and design the human sets at the start — agents plan it as a graph of pieces, prove only the risks that could sink it, build every ready piece in parallel, make the detailed calls as they go, and review thei

  • wizard

    Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for steps the agent can pe

  • writing-for-agents

    Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

Hooks (1)

  • SessionStart

    python3 -I "${CLAUDE_PLUGIN_ROOT}/hooks/rsi-nudge.py"

View source on GitHub

Maintain scott-skills?

This page updates itself from your repo. Add the badge to your README, or get it Featured to pin it above the organic results with a followed link to your site.

claude & codex pluginslisted