Skip to content

Latest commit

 

History

History
154 lines (115 loc) · 39.7 KB

catalog.md

File metadata and controls

154 lines (115 loc) · 39.7 KB

Plugin catalog

The generated per-category plugin catalog: the block between the markers below is generated from the plugin manifests and kept in sync by CI. Never hand-edit it; the category vocabulary is owned by docs/catalog-taxonomy.md.

Discovery

  • knowledge: Ingests external knowledge into synthesized artifacts: book-distill (PDF or EPUB into author-attributed reference files), video-digest (one YouTube or X video: transcript, links, repo applicability), course-digest (Dometrain and Teachable courses into recommendations), docpage-digest (one documentation page into a verified knowledge slice), and map-corpus (a multi-resource corpus into a classified link map and an approved docpage-digest queue). setup sets where artifacts land.
  • context7: Looks up current library documentation, API references, and code examples via Context7 (ctx7 CLI or the Context7 MCP server) with a two-step resolve-then-query workflow: a lookup skill (default lookup plus an upstream drift-check action) and a setup skill for CLI install, auth, and MCP configuration.
  • firecrawl: Web scraping, search, crawling, and file parsing through the firecrawl-cli binary with a write-to-disk-then-Read pattern that keeps large results out of context: a user-facing wrapper skill, a lazy-install setup skill, and a separate gated maintainer update skill tracking the upstream CLI and skill source.
  • discovery: Discovery before changes: explore the local codebase, run multi-source external research, and reconstruct why a past decision was made from evidence outside the code. Each dispatches a subagent by default so the reading stays out of the main thread, with source tiers, falsification, recency gates and a coverage ledger, and persists EXPLORE.md / RESEARCH.md / INTENT.md handoff artifacts. A research sweep workflow (/discovery:research-sweep) backs deep research with adversarial claim verification.
  • dometrain: Dometrain course-content grounding skills for a Dometrain MCP server: search lessons, pull curated lesson documents with on-screen code, and cite timestamped deep links. Requires an active Dometrain Pro subscription. Ships no server: configure a user-scope dometrain server. Includes a setup check and a grounding usage skill kept in sync with Dometrain's own official Claude Code plugin.
  • x: Read X (formerly Twitter) posts, note tweets, and X Articles as Markdown without an X API key, via a documented fallback ladder over third-party converters: xtomd.com for single posts and articles, Thread Reader App for unrolled reply chains, plus a dated list of other services for replies and media. A pasted X link becomes readable content instead of a login wall.

Design

  • architecture: improve uses Ousterhout's deep-module lens to find shallow modules, seam leaks, and locality gaps, reports them as HTML, and interviews the chosen one. map-landscape charts a C4 system landscape and portfolio table with drift checks. map-dependencies, map-components, map-containers, map-context, map-flow, map-events, map-data, and map-deployment draw dependency, C4, sequence, event, data, and deployment views from committed files. record-decision writes an ADR in the repo's convention.
  • prototype: Builds throwaway code to answer a design question before committing to architecture: a logic facet (an interactive terminal app over a portable state model) and a UI facet (radically different visual variants on one route).
  • planning: Pre-implementation planning pipeline: chart a too-big, foggy effort as a decision map, diverge on candidate approaches, lock product intent and the engineering contract, route resolved domain language to the domain-driven-design glossary steward, explore the design space, stress-test adversarially, and produce a structured implementation plan with an approval gate, with an opt-in multi-angle plan panel workflow (/planning:plan-panel).
  • domain-driven-design: Domain-driven-design practice skills. Today it actively maintains a consuming project's ubiquitous-language glossary: resolves ambiguous or overloaded terms, records canonical language and rejected synonyms, sharpens what-it-IS definitions, and routes entries to already-known bounded contexts without discovering boundaries.
  • naming: Generates and evaluates fresh name candidates for an identifier, file, module, skill, repo, or domain term (naming:name-it-better). It distills a context brief, runs blind fresh-context generators from distinct lenses (responsibility-literal, moment-of-use, domain-lore), and scores a shortlist against the org's naming criteria. The human always picks; it never locks a name. An optional tournament mode adds elimination rounds with independent judges for high-stakes names.
  • event-storming: EventStorming for domain discovery: a methodology skill (Big Picture / Process Modeling / Design-Level facilitation reference, notation, patterns) and a simulation skill (agentic multi-persona workshops that produce a structured-markdown model by default; a live Miro-board rendering path is available when the first-party miro plugin is enabled).
  • miro: Miro board management over the Model Context Protocol: create and manage boards, sticky notes, shapes, frames, connectors, and tags for EventStorming, brainstorming, and diagramming. Ships a local stdio MCP server that installs its pinned npm dependencies on first launch (needs Node.js 24+ and npm); installs disabled, so opt in. The server starts without a Miro API token; until one is set, each tool call explains how to set it.
  • user-experience: Front door for user experience on the app being built, at any stage from idea to legacy: shape detects the app's stage and the project's own research, personas and analytics, then chains user research planning, synthesis, flows and IA, and evaluation, routing to the tools installed, with every deliverable labeled evidence-based, assumption-based or mixed.

Development

  • markdown-format: Rewrites Markdown with markdownlint-cli2 once per batch of tool calls and at git pre-commit, only in repos that carry their own markdownlint config; findings are reported at commit.
  • bash-format: Auto-format shell scripts with shfmt once per batch of tool calls and again at git pre-commit, and check them with ShellCheck at commit, using the consuming repo's own .editorconfig and .shellcheckrc.
  • biome-format: Rewrites JavaScript, TypeScript, JSX and JSON with Biome once per batch of tool calls and at git pre-commit, only when a biome.json governs the file, using the consuming repo's own Biome config.
  • ruff-format: Rewrites Python with Ruff's safe fixes and formatter once per batch of tool calls and at git pre-commit, only when a Ruff config governs the file, using the consuming repo's own Ruff config; lint findings are reported at commit.
  • typos-format: Spell-check at commit time via typos-cli: a git pre-commit entry that blocks only on typos in the lines a commit adds, with an opt-in end-of-turn check, honoring the consuming repo's own typos configuration.
  • go-format: Auto-format Go and manage imports with goimports once per batch of tool calls and at git pre-commit, skipping generated files, with no consumer-config gate.
  • eol-normalizer: Normalize the line endings of the files a batch of tool calls wrote to their .gitattributes eol value in the working tree, once per batch; silent and never blocking.
  • powershell-format: Format and lint PowerShell at git pre-commit via PSScriptAnalyzer, only when a PSScriptAnalyzerSettings.psd1 governs the repo; optionally check uncommitted changes when a turn ends.
  • actionlint: Lint GitHub Actions workflows with actionlint at git pre-commit, on changed lines, for every author; optionally check uncommitted workflow changes when a turn ends.
  • source-control: Git and GitHub delivery: /commit (convention-checked subject, Co-authored-by trailer, surgical staging), /pull-request (prep, create, CI monitoring, review triage, merge, CI logs), /babysit-prs (safe-by-default PR fleet loop, opt-in worker and autopilot tiers), /babysit-loop (merge lane; merge is human until the repo adopts it), /worktree, /resolve-conflicts (intent-first), /check, and /setup (layered source-control.md convention config; Conventional Commits by default).
  • implementation: Disciplined implementation stage: execute approved plans inline (/implementation:implement) or via orchestrated worker subagents (/implementation:implement-dispatch) with incremental validation, TDD-by-default cadence, green-checkpoint commits, scope-fence drift detection, and divergence detection that routes back to planning. Build/test/lint, testing, and outcome verification live in the companion toolchain, testing, and verification plugins, invoked when installed.
  • toolchain: Repo-agnostic polyglot verification toolchain: build + test + lint for changed files across .NET, Python, TypeScript, Bash, PowerShell, Markdown, Go, YAML, and cross-cutting surfaces (/toolchain:check, /toolchain:lint with format-only --fix and gated --code-fix), plus a re-runnable /toolchain:setup with check (report the configured ecosystems and their command surface) and apply (interview, infer, and write the tracked per-ecosystem command config those skills resolve first).
  • wizard: Scripts that walk a human through manual steps an agent cannot do: provisioning infrastructure or credentials, CI secrets, third-party dashboards, one-off migrations. /wizard:generate scopes stages from the repo (.env key names only), builds an interactive bash wizard on a hardened library (TTY-only prompts, hidden secret entry, 0600 .env writes), and shows the stages for approval first; the human runs it. /wizard:unattended writes a PowerShell script the human launches once.
  • developer-experience: Helps a team build and maintain its own developer tooling: setup records the team's tooling conventions, build-cli builds command-line tools to them, and audit-tools inventories a repository's scripts, CLIs, hooks and skills and reports what to fix.

Testing

  • playwright: Live E2E browser automation via Microsoft's @playwright/cli: named sessions, accessibility-ref snapshots, click/fill by ref, screenshots, console and network capture, mocking, tracing, video, and auth state, with artifacts written to disk so only paths enter context, plus produced pull-request demo videos with frame-measured quality control, a vendored upstream baseline and maintainer drift-check update flow.
  • app-control: Launches and operates the project's app, observes it and records evidence, and never judges: /app-control:drive finds the project's own control skill (or falls back to the bundled run skill or a project-type recipe), reports what is reachable with ready, records one artifact with capture, stops only what it started with cleanup, and writes a fixed report.md and report.json that a verifier, a debugger or a CI job reads.
  • tdd: A TDD knowledge base distilled from cover-to-cover readings of Kent Beck's Test-Driven Development: By Example and Vladimir Khorikov's Unit Testing: Principles, Practices, and Patterns. Fourteen author-attributed reference files behind a routing table, plus a no-load quick decision guide, answer the WHY behind test design decisions.
  • evals: LLM evaluation methodology and eval-suite design, based on Anthropic's evaluation guidance. /evals:methodology answers questions on success criteria, eval design, and grading. /evals:design interviews for measurable success criteria and scaffolds a graded eval suite for an LLM app or Claude Code skill. /evals:plugin-eval preflights the CLI and target, prices a suite before running, and reads the with-versus-without delta. /evals:validate checks case files with no model call.
  • testing: Test-stage discipline: /testing:plan (coverage gaps, test plans), /testing:write (TDD authoring), /testing:run-e2e (live E2E and smoke checks), /testing:diagnose (failing-test root cause, with a fix-until-green workflow across files), /testing:audit (can't-fail test audit with a fail-closed gate), /testing:cleanup (rewrite, quarantine, or delete low-value tests behind a mutation gate), /testing:setup, and an opt-in hook that flags edits that weaken tests.
  • mutation-testing: Measures whether a test suite detects faults, not merely runs code. /mutation-testing:principles answers operator, mutant-state, and metric questions from the literature. /mutation-testing:setup verifies the mutation tool and writes tracked config. /mutation-testing:audit runs mutation analysis on the diff (or, with --exercised, on code the changed tests call), reports surviving mutants and why each lived, verifies source was restored, and can save survivors as findings.

Verification

  • verification: Outcome-verification stage: prove a change achieved its intended outcome (/verification:confirm: a mechanical build/test/lint prerequisite gate, then intent-match + evidence + verdict with the criterion auto-detected by change type), and verify measurable-improvement claims against a planning-time baseline (/verification:measure), never fabricating numbers.
  • performance: Measurement-first optimization that refuses to report what the data does not support. go-faster sweeps the whole process for evidenced ways to go faster. target ranks candidates by evidence quality. goal sets realistic and ideal targets and computes the floor first. snapshot captures interleaved baseline and post runs on a qualified host and refuses wall-clock claims from a noisy one. verify re-derives results in a fresh context. protect locks in a counter win with a CI ceiling.

Quality

  • mcp-tools: Two MCP audits. audit scores the tool definitions of a server you build against MCP-specification, Anthropic tool-design, and Claude-Code client criteria in a per-tool PASS/WARN/FAIL scorecard (Python, TypeScript, .NET). audit-posture inventories the MCP servers your Claude Code configuration runs and flags supply-chain risks such as floating package versions, without running any server.
  • review: Code-review toolkit: nine agents, read-only over the reviewed code, plus orchestration skills for the quality gate, fan-out, and enforceability audit (/review:audit-enforceability), a pull-request change digest with an interactive view (/review:explain-change), a fan-out sweep workflow (/review:fanout-sweep), and CI lane commands (/review:code-review, /review:security-review) for org reusable workflows.
  • codebase-health: Repo-wide drift audit between docs, config, code, and architecture: verifies every factual claim against reality via parallel subagent fan-out, severity-rates findings, and reports read-only, delegating remediation to the implementation/verification lanes. Audit dimensions are configurable through a tracked .claude/codebase-health.md config file written by the setup skill.
  • code-metrics: Read-only code measures for a change, with cited references and no verdict: lines per file (audit-size), cyclomatic, cognitive, and Halstead complexity (audit-complexity), duplication (audit-duplication), per-function coverage and CRAP from existing lcov, Cobertura, coverage.py, or Go artifacts (audit-coverage), TypeScript and Python type debt (audit-type-debt), metric literacy (principles), and setup. Uses only collectors already installed; never installs or runs tests.
  • discipline: Correctors that re-anchor a rule, audit work in flight, and fix drift: do-your-research, follow-our-standards, point-dont-copy, reason-dont-recite, tighten-your-output, recheck-against-upstream, pick-for-the-problem, mind-your-maxims, script-the-deterministic-work, use-your-skills, reuse-or-replace, scrutinize-dont-coast. sweep-all runs them as one batch. wait-what re-pitches a message that did not land. hold-my-hand shows work one phase at a time. be-ambitious raises one request's ambition.
  • ai-slop: Detects and removes AI-writing tells (slop) in tracked markdown prose: em dashes, emoji formatting, AI vocabulary, negative parallelisms, chatbot phrases, filler, stacked hedging, citation artifacts, and model-era phrases, from a catalog based on Wikipedia's Signs of AI writing plus an evidence-graded model-vocabulary inventory. Read-only audit by default (deterministic detector plus judgment rubric); an explicit fix action rewrites findings behind a semantic-diff guard.
  • overengineering: Evidence-earned-keep audit of agent hooks and instructions, git hooks, CI lanes and gate scripts, branch protections, forge apps, and integrations. audit treats each as a retirement candidate until evidence earns its keep, argues in cost of carry, caps security-class retirements at FLAG-FOR-HUMAN, and writes a diffable findings file. realign simplifies behind a per-item human gate. delta reports changes since the last run. justify asks whether one artifact's reason still holds.
  • improvement: Find and make improvements to anything, from one method to a whole feature. find ranks evidence-cited candidates by value-to-effort and hands the pick to planning; improve ships one improvement, measured against the repo's standards and, when the focus asks for it, current upstream guidance, as one small draft PR. Both run unattended on a schedule.
  • attribution: Finds prose in tracked markdown that restates content an external source owns (vendor docs, blogs, articles) without attribution, confirms the source, and converts the copy into a pointer, a citation, or a dated stamped record. Documentation attribution, not software supply chain. Scripts do only mechanical work; judgment is LLM work. Read-only audit by default; explicit fix and sweep actions apply changes behind a semantic-diff guard and live pointer checks.
  • corrections: Turns a recurring correction into an enforced check. /corrections:codify counts how often a described mistake recurs, picks the strongest enforcement-ladder rung that can catch it, and proposes a check proven to fail on the old code and pass on the current code, using scripts/prove-check.sh to run it in temporary worktrees at two refs.

Maintenance

  • bugs: Produces from an informal defect description a structured five-field bug report: title, steps to reproduce, expected vs actual, severity with justification, and suggested fix location. Read-only by default: it emits the report and never edits code, opens a PR, or files an issue on its own.
  • debugging: Debug observed failures via a disciplined six-phase loop: build a fast deterministic reproduction signal, reproduce, rank falsifiable hypotheses, instrument, fix with a regression test, then clean up and post-mortem.
  • docs-hygiene: Documentation-hygiene toolkit: compress (trim markdown with a semantic-diff check), audit-noise (classify markdown noise), extract-ssot (deduplicate into a single source of truth), audit-encapsulation (citations into skill-private files), rename-references (stale references after renames), audit-derivability (does a doc earn its existence), audit-progressive-disclosure (load tiers), write-for-agents and write-for-humans (authoring). Setup checks markdownlint-cli2.
  • docs-naming: File-name toolkit that plans, applies, and enforces a casing rule across a tracked tree: setup (the one configuration surface), audit-file-names (read-only inventory plus the reference sweep, writing the rename plan), realign-file-names (the executor, one human acceptance per file), and generate-file-name-gate (emits the standalone check that keeps the tree from drifting back).
  • code-tidying: Code tidying and comment hygiene. tidy hunts a rotated lane for Beck-style tidyings and ships one PR. batch-simplify sweeps a branch, time window, or repo in dependency-ordered waves. dissolve-comments deletes zero-information comments and moves the rest into names (safe, aggressive, strip modes). audit-comment-residue flags history, plan, conversational, and ticket residue. audit-dead-code finds dead code with knip, vulture, gopls, and grep. setup scaffolds tidy lanes.
  • coupling: Iteratively reduces coupling in documents, code modules, applications, or repositories: scans for change-transmitting dependencies against a coupling model (strength ladder, connascence, volatility), verifies each finding, applies a budgeted batch of safe behavior-preserving reductions, and keeps a ledger so structural candidates route to design and later runs resume. When a value changes, it finds and classifies every site stating it and converts setup sites to references.
  • repo-hygiene: Repo hygiene action-router: /repo-hygiene:clean sweeps reclaimable caches, build artifacts, and stale git metadata, and can realign the working tree to a fresh-pull state, dry-run-first, with destructive tiers gated behind explicit confirmation and a session-scoped destructive-command guard. Ecosystem targets are detected at runtime; secrets, runtime dependencies, and skill data are preserved by default.
  • repo-fleet-hygiene: Cross-repository Git/GitHub fleet discovery, evidence rollup, a gated apply verb, and a sync verb that fast-forwards canonical checkouts onto the remote default branch. Audit stays read-only. apply and sync mutate only with --apply plus interactive confirmation or --yes.
  • disk-hygiene: Context-aware disk hygiene for arbitrary directory trees: inventories orphaned and temporary artifacts, classifies evidence into review tiers, and offers exact-path cleanup only after a fresh safety preview and explicit per-tier approval. The target is read-only by default; OS-managed paths, links and mount points, VCS-tracked content without the complete checkout evidence bundle, changed entries, and live-handle uncertainty fail closed.

Claude Code

  • desktop-notification: Alert you when Claude Code needs input: an audible terminal bell, an OSC 9 terminal notification, and an OS-native toast (macOS/Linux) on permission and idle prompts.
  • playbooks: Doctrine and knowledge playbooks as on-demand skills: boris (Boris Cherny's Claude Code workflow tips, howborisusesclaudecode.com), skill-authoring (Anthropic's internal skill-authoring playbook), fable-5 (Claude Fable 5's operating doctrine, self-authored), and repo-sweep (runs a catalog of hygiene skills through a repository one commit per step). boris and skill-authoring vendor a verbatim upstream baseline; /playbooks:update drift-checks and syncs them (maintainers).
  • harness-config: Configuration health for a repo's Claude Code: audit (settings, .mcp.json, hooks, plugins, permission drift), audit-automation-gaps, audit-permission-grants, audit-permission-state (effective rules with provenance), draft-auto-mode-rules (prints an autoMode block), audit-instructions (instructions the model no longer needs, conflicts), audit-prompting-postures, audit-pass (one ordered, resumable pass), unhobble (strip instructions, re-add what evidence earns), and setup.
  • harness-memory: Keeps a repo's Claude Code memory layer healthy, against criteria from official Claude Code docs. audit checks CLAUDE.md, a root AGENTS.md, CLAUDE.local.md, .claude/rules/, and auto-memory for structure, size, placement, and index integrity, with scripted and judgment checks. stateless inspects, disables, and (after confirmation) purges Claude-written auto memory across settings scopes. Whether instruction text fits the current model belongs to harness-config.
  • harness-ops: Claude Code operations: audit-skill-visibility (skills the listing budget hides), inventory (every invocable surface), audit-install-state, audit-performance (slowness), audit-mod-posture (mods and the guard), audit-native-overlap (skills duplicating built-ins), observability (telemetry), known-issues, changelog, behavior-probes, prerequisites, check, machine-profile, plugins (update the fleet), morning-brief, lanes (background loop sessions), setup. Plus opt-in hook event logs.
  • rate-limit-guard: Shared rate-limit guard for loop lanes and Claude: a hooks module writes the subscription rate-limit windows to a fixed machine-scope file and toasts window changes (telling Claude too only with model_notices on, off by default), a StopFailure hook records rate-limit stops reactively, and a reader contract fixes how consuming sessions pause and resume.
  • context-guard: Per-session context-window observability. A mod writes each session's context-window figures to a snapshot file and shows the person a toast and a transcript line when the context zone (smart, acceptable or dumb, from bands in zones.json) worsens; with model_notices on (off by default) it also tells Claude the zone at each crossing, approach and compaction. /context-guard prints status and toggles an optional band row. It answers a status tool. A PostCompact hook leaves a marker.
  • context-budget: Measures a Claude Code session's fixed startup context payload per item at a pinned binary version, including per-tool attribution of the built-in tool pools that /context reports only as totals, derived by A/B deny differencing. Falls back from an SDK meter to a headless /context parser, then to an error rather than a wrong number. Keeps a before/after ledger per lever. Shows a live context breakdown in a pane or above the prompt. Report-only by default; fix applies one approved project trim.
  • plugin-quality: Post-use behavioral audit (plugin-quality:audit) of any Claude Code plugin skill, agent, hook, command, or config you have used. Six steps: capture evidence; map behavior in a fresh subagent that records errors, improvements, and quality-of-life items against standards; a blindspot pass; an interactive contract lock; review with a research gate on each finding's claims and fixes; and a confirmed work item for the maintainers. Uses context-guard snapshots when present.
  • skill-quality: Skill-authoring QA tooling (skill-quality:check): a static contract checker running thirty deterministic checks over a Claude Code skill (frontmatter, invocation mode, description, listing cap, trigger keywords, line caps, broken refs, markdownlint, gotchas, evals), a shared skill-listing budget reporter, an evals.json schema with an eval-quality lint, and a measure-invocation harness that scores description auto-invocation probes on train and validation splits.
  • computer-use: Operating knowledge for Claude Code's built-in computer-use MCP server (desktop screen control). /computer-use:diagnose resolves a symptom to a cause instead of retrying: the fixed screenshot pixel budget and why zoom recovers detail, how to read capture and input failures, and per-OS quirks that make synthesized keys or menus behave unlike a human's. /computer-use:setup verifies prerequisites and reports environment settings that end a session mid-run.
  • fleet: Agent-to-agent reach across a personal fleet (fleet:reach): from any Claude Code lane (WSL or native Windows, any machine), run a script, prompt, or query and wait, message a session, or start a named session in another lane. Each lane signs into its own Claude account, so built-in peer tools see only their own lane. Carries the route matrix for headless turns in the target lane, target resolution from the fleet manifest, and a posture that keeps agent launches prompting.
  • instruction-placement: Routes agent instructions to the surface that loads them at the right time. audit finds conventions narrower than the always-loaded CLAUDE.md or AGENTS.md, or stranded in docs Claude never loads, and proposes a destination with a validated paths glob; safety content is never demoted. realign applies each move and regenerates an index. check verifies globs and index. migrate moves content to AGENTS.md with a CLAUDE.md shim. setup registers a git pre-commit entry that fails on a stale rules index.
  • display-redaction: A mod that masks email addresses and secret-shaped text in what Claude Code draws, for recordings and screen shares. It changes the screen only; the transcript, the model's context and the files on disk are untouched, so it is not a privacy or data control.

Autonomy

  • autonomy: Contracts for governed autonomous agent operation: role topology, binding seam, telemetry, return accounting, trigger dispatch, a per-work-class guardrail matrix, a standing-routine catalog, and a runner charter. A guided setup skill writes an org's binding, wires OTLP telemetry (file default), human-attested return capture, and signal adapters behind one governed dispatch entrypoint, binds the guardrail matrix to isolation substrates after a live probe, and schedules routines.

Security

  • guardrails: Thirteen toggleable guards. Blocks: secret writes, machine paths, git hook bypass, force-push, reset --hard, merges with open review, drive-root /tmp writes, exported MSYS_NO_PATHCONV, recursive deletes of roots or outside the tree, shell-expanded commit -m, off-convention commit or PR titles; off by default, credential reads. Warns on: Workflow fan-out, direct gh pr create. Git hooks check commit subjects, secrets and paths, CLI flags, skill refs and removed paths.

Workflow

  • session-flow: Session lifecycle: workflow (next stage), handoff (save-point, resume prompt), continue-in-background, keep-going (resume after interruption or stall), find-handoff (recover a lost handoff), clean-stop (durable stopping point), retro and running-retro (retrospectives), audit-sessions, audit-friction, orient (where the session stands), orchestrate (delegation imperatives), reanchor (verify assumptions), reconcile (retire finished work), show-options, tidy-work (.work tiers), check, setup.
  • multi-agent: Workflow and model-routing guidance for multi-agent work: assess (workflow, subagent or single context), route (the role map a workflow script reads from args, keeping fan-out stages off a frontier model), audit-defaults (rechecks bundled defaults against upstream, or sweeps the repo's model and workflow guidance, via a read-only drift-audit workflow), check (whether node resolves and the fetch gate is registered), and setup (writes a user, team or local layer after a preview and a yes).

Presentation

  • playgrounds: One-step access to Anthropic's first-party playground plugin: declares the cross-marketplace dependency, routes playground-shaped requests to the upstream skill when it is installed, emits the install commands when it is not, and carries field-tested prompt recipes, cloud-session delivery guidance, and consumer cautions. Generates nothing itself.
  • visualization: Visualization skills. visualize picks the form (mermaid diagram, markdown table, SVG/CSS chart, ASCII/Unicode art, or a rendered page) and the medium (terminal, local HTML file, or published Artifact) for what is in the conversation, asking only when the target is ambiguous. present builds a slide deck from the account's claude.ai Slides Artifact type behind a publish gate, with a markdown outline as the record. Chart craft and artifact design route to those capabilities when installed.
  • writing: Prose a scanning reader can use. /writing:be-concise puts the bottom line first, cuts words the meaning does not need, and keeps structure scannable and tone factual. Bare, it sets a standing posture; given a target, it reshapes it and reports word counts. For tickets, PR descriptions, changelogs, READMEs, and status updates. Never drops a decision, number, ask, error, or warning. Paraphrases NN/g, GOV.UK, US plain-language guidelines, Google and Microsoft style guides, and BLUF.
  • user-interface: Front door for interface design: terminal and CLI output, TUIs, prompt themes, Claude Code mods, web and app UI. design detects the project's own design system and the design tools installed, routes each concern to the best present source with the project first, and supplies its own guidance where nothing covers the concern. Terminal guidance is its own contribution.

Project Management

  • work-items: Work items through a provider-neutral tracker seam (github, local-markdown, jira, gitea, linear adapters): track (dashboard, creation, race-safe claims, recurring-schedule checks, stale-lease audits), scan-todos, decompose (plans into vertical-slice items), ship (route and run one spec container), triage (raw intake and unsolicited PRs), work, work-loop (autonomous PR-only drain), attend-queue (escalations), onboard-adapter (new tracker adapter), and setup (binds the provider).

Operations

  • machine-health: Workstation health audit: OS-specific checks (disk, OS updates, security posture, CISA KEV correlation) run from a versioned catalog with trend-aware severity, approval-gated remediations, and dated markdown reports. Windows fully implemented; macOS/Linux scaffolded (report UNKNOWN and stop). Machine state persists in the plugin data directory; the report directory and check catalog are configurable.
  • github: GitHub admin-plane audit, advice, and guided setup over the authenticated user's own gh CLI: billing and cost control, security posture, rulesets and settings drift, Actions policy, and every other org/repo/enterprise settings area. Grounded in live state and current official GitHub docs (zero vendored knowledge); read-only by default, every mutation user-in-loop.

Learning

  • education: Learning tools. teach is a multi-session coach for a general subject or a repo-grounded concept through the Knowledge-Skills-Wisdom progression, with persistent per-topic state, and also a single-session domain primer. explain is a one-shot plain-language explainer. illustrate explains a concept or codebase topic as diagrams: a markdown record plus an interactive page. quiz-me checks your comprehension of a completed change. setup validates the plugin's configuration.

Visual Arts

  • pixel-art: Creates pixel art with no external tools: sprites (sprite), animation sprite sheets for RPG Maker MZ, Godot, PICO-8, or plain strips with Aseprite-style frame data and GIF previews (animate), tilesets and parallax (tileset), UI skins and bitmap fonts (ui), effect sheets (vfx), and animated scenes as one HTML file (scene). Specs are palette-locked; a humanoid kit and a Python stdlib renderer write PNG, GIF, and frame data with a render-review loop. Optional Aseprite adapter.
  • animation: Hand-drawn-style 2D animation as code, rendered in headless Chromium by an ink brush engine. rotoscope copies a reference clip drawing by drawing: trace to vector paths, render, measure against the source (XOR, SSIM), and fit per-shot brush overrides. learn-style measures a clip into a style pack (ships woodcut-ink) and checks films against it. produce turns a brief into approved boards, a shot list, frames, and a delivered file. setup checks ffmpeg, Node, Chromium, and Python.
  • explainer-video: Short explainer videos made with ManimCE, narrated when the speech plugin is installed and silent otherwise. The produce skill plans the beats, writes one scene script whose scene changes follow the narration's word timings, renders at low quality first, muxes narration and captions with ffmpeg, and checks every render with ffprobe and a frame read-back. A SessionStart hook installs the hash-locked Python packages; the check skill reports readiness.

Audio

  • songwriting: Songwriting craft companion: nine concern-scoped lyric-craft skills (workflow router, rhyme, object-writing, metaphor, meter-prosody, song-form, co-write, diagnose, practice) applying Pat Pattison's methods, with an object-writing agent that performs the sensory exercise itself and per-skill emission boundaries that route generation to the skill that owns it, plus Suno v5.5 prompt engineering (style prompts, tagged lyrics, genre templates, troubleshooting).
  • retro-audio: Renders retro sound effects and short chiptune loops to WAV with the Python standard library only: an sfxr-style parameter model and an MML subset with Game Boy and NES pulse duties and channel limits for Game Boy, NES, and PICO-8 (four channels, one noise part). Another plugin can play the WAV; this one does not read that plugin's files.
  • speech: Text-to-speech narration. The narrate skill turns a script into narration.wav plus words.json, with a start and end time per word. The default backend runs Kokoro-82M locally. The optional elevenlabs backend sends the text to the third-party ElevenLabs API (ELEVENLABS_API_KEY or vault-exec) after showing the character count against your quota, caching repeats; an organization can forbid it. You install espeak-ng (GPL-3.0); a hook installs Python packages, setup the models, check reports gaps.

Personal

  • kindle-dedrm: Manage the Kindle for PC 2.8.0 + Calibre DeDRM workflow for personal-use ebook DRM removal on books the user owns (Windows only). Action router with setup, sync, update, cleanup, and status, each state mutation paired with a documented compensating reversal.
  • gaming: Apply, track, tune, and remove the community DLSS 5 Neural Rendering mod (OptiScaler forks) in Windows PC games from Steam, Epic, EA app, Battle.net, GOG, Ubisoft Connect, and Xbox (gaming:dlss5). Anti-cheat checks refuse unless you type an at-your-own-risk acknowledgement. Snapshots allow byte-exact removal; a ledger and upstream watch track fork and driver releases. Ships no NVIDIA binary: the DLL comes from a path, an installed DLSS 5 title, or a configured source.
  • ai-briefing: Build source-backed AI-industry briefings from official vendor publications, configured RSS/Atom feeds, GitHub releases, reputable secondary reporting, and user-supplied URLs. Deduplicate, rank, and present results as markdown or optional HTML/PPTX decks, with repository-owned profile, audience, and brand configuration. Automated X/Twitter collection is disabled; Playwright is used only for deterministic local rendering.
  • adhd: Shapes assistant output for a reader with ADHD: action-first and low-friction. adhd:shape is a standing session posture: lead with the next action, number steps, restate state across turns, cap and rank lists, give time estimates, cut preamble. adhd:clarify reshapes one dense, decision-heavy message: one decision at a time, jargon defined, operative terms quoted verbatim, with an HTML decision table for big content. Reauthored in part from ayghri/i-have-adhd (MIT).