melodic-software

@melodic-software source repo

270 skills
0 followers
1 day ago last updated

▌
Changelog · melodic-software bundle
Ingest Claude Code changelog entries and integrate them into the current repo. Fetch (read-only display), diff (impact analysis, no edits), status (applied versions), and apply (full integrate pipeline, explicit user intent only). Use when: 'new cc version', 'what changed in claude code', 'apply changelog', a new CC release is mentioned, or the user pastes changelog text.

0
installs
▌
Inventory · melodic-software bundle
Enumerate the complete Claude Code ECOSYSTEM this machine can invoke. Every built-in CLI command with its aliases and hidden/gated status, every bundled skill, and every component of every installed plugin (skills, agents, commands, hooks, MCP servers, LSP servers, workflows, output styles, themes, monitors, bin) across all marketplaces. Reads the shipped binary because the official docs publish no built-in command list. Reports; never changes anything. Use when: 'what slash commands do I have', 'list all my skills', 'what agents are available', 'show me every plugin component', 'what does Claude Code ship built-in', 'is /foo a real command', 'what changed after the update', 'show me only the plugin ones', 'what does marketplace X give me'. Not for: auditing the install DIRECTORY on disk (use /claude-ops:audit-install-state), updating or converging the plugin fleet (use /claude-ops:plugins), or checking settings and permission drift (use /claude-config:audit).

0
installs
▌
Sweep All · melodic-software bundle
Compose this plugin's discipline correctors into ONE batched pass. Requires conversation-inheriting fork subagents (`subagent_type: fork`); without fork mode it degrades to the posture digest and audits nothing. At conversation start it instead reports a cheap posture digest (which disciplines are in scope) with no audit. Use when: 'sweep all disciplines', 'ground ourselves', 're-anchor everything', 'run the whole re-anchor bundle', 'posture batch', 'set our posture before we start', 'batch the correctors', or at conversation start to set posture across every standing discipline at once. Membership is each corrector's own tier metadata; for a single discipline, invoke that corrector directly.

0
installs
▌
Wait What · melodic-software bundle
Stop. That last message did not land. Re-pitch it: back up as far as needed, add the context that was missing, write in ASD-STE100 Simplified Technical English, and use the project's own ubiquitous language. Type /discipline:wait-what the moment you notice you are skimming; only you know when you stopped following.

0
installs
▌
Map Corpus · melodic-software bundle
Map a multi-resource documentation corpus into a verified, classified, triaged slice BEFORE any digesting: bounded discovery (llms.txt + sitemap), a user-approved link map classifying every discovered URL, deterministic node manifests over immutable snapshots, and a per-node relevance inventory whose evidence a script gate verifies. Handing an approved queue to N runs of /knowledge:docpage-digest. Use when: 'map this corpus', 'map this docs site', 'digest this whole site', 'ingest these docs and the spec repo', 'multiple pages/URLs to digest', 'corpus mapper', or the user supplies a topic plus seed URLs covering more than one page. One single page routes straight to /knowledge:docpage-digest; books to /knowledge:book-distill, courses to /knowledge:course-digest, single videos to /knowledge:video-digest. Not ad-hoc summarization, the output is a corpus slice (link map, node manifests, inventory, approved queue) that proves its coverage instead of asserting it.

0
installs
▌
Snapshot · melodic-software bundle
Capture a baseline or post-change performance snapshot with the HOST QUALIFIED FIRST: repeated no-op spawns characterize the machine's own noise, and a wall-clock claim is REFUSED outright from a host carrying the bimodal contention signature, naming the drift-immune counter it can still report instead. Interleaves before/after arms within one run rather than comparing two passes, since a host that drifts 6x in an hour attributes its own drift to the change. Reports a counter alongside and ranked above any duration. Use when: capturing a before or after snapshot, running the comparison between them, or asking whether this machine can support a timing claim at all: 'capture a baseline', 'take a post snapshot', 'run the A/B', 'can I even measure here'. Runs after /performance:goal; hands off to /performance:verify. Skip when no goal with a computed floor exists yet (run /performance:goal), or when the claim is about code shape rather than runtime (that is /verification:measure metrics).

0
installs
▌
Handoff · melodic-software bundle
Write a mid-session save-point for /clear-and-resume, a durable handoff file (default) or a copy-paste resume prompt when follow-ups are small. Use when: 'handoff', 'save state', 'checkpoint this', 'pause', 'come back later', the user reports the session is heavy, a context-measuring mechanism says to fork, or your own responses are visibly drifting, repeating, or looping. Never on your own estimate of the remaining window, a budget reading is not a decay signal. For delegating the continuation to a background agent, use the sibling continue-in-background skill.

0
installs
▌
Co Write · melodic-software bundle
Run a co-writing session and generate titles and high-volume options with Pat Pattison's methods, the No-Free-Zone co-write protocol and feedback discipline, the Title Game (chained vowel-cascade title generation), title generation from an idea, and high-volume brainstorm dumps for ONE line or ONE section. Use when: 'co-write tonight', 'co-write rules', 'no-free-zone', 'Title Game', '10 titles fast', 'title candidates for X', 'give me 30 options for this line', 'brainstorm the whole chorus'. For blank-page/idea/fragment starts use /songwriting:workflow; for rhyme dumps use /songwriting:rhyme.

0
installs
▌
Metaphor · melodic-software bundle
Generate and diagnose metaphor with Pat Pattison's methods, the three types (expressed identity, qualifying, verbal), the three expressed-identity forms, collision drills (noun×verb, noun×noun, adjective×noun), playing in keys (fundamental → diatonic family → collisions), the two metaphor-finder questions, participles, transitive vs intransitive, simile as focus control, and grounded-metaphor diagnosis. Use when: 'I need a metaphor for X', 'generate metaphor options', 'metaphor or simile here', 'this metaphor feels dead', 'my song has no metaphor', 'sustain this image across the song', 'collide these words', 'what else has these characteristics'. For sensory raw material use /songwriting:object-writing; for cliche repair use /songwriting:object-writing cliche.

0
installs
▌
Practice · melodic-software bundle
Build a songwriting practice habit with Pat Pattison's curriculum, the daily object-writing/craft routine and numbered exercises drawn from all four books (Essential Guide to Lyric Form and Structure structural exercises, Songwriting Without Boundaries 56-day curriculum, Essential Guide to Rhyming worksheets). Use when: 'daily practice plan', 'build a writing habit', 'give me a 90-second writing prompt', 'run me a numbered exercise', 'exercise 4.6', 'daily craft prompt'. For a one-off object-writing prompt use /songwriting:object-writing.

0
installs
▌
Workflow · melodic-software bundle
Start-here situation router for songwriting with Pat Pattison's methods. Picks the scenario for a blank page, an idea/seed, a stuck fragment, a co-write, a diagnose-only pass, or a daily habit, and runs step-by-step coaching dialog. Also applies Pat's response filter to AI-generated material and points to going-deeper resources (Coursera / Berklee / columns / podcasts). Use when: 'I want to write a new song', 'I have nothing — just want to write', 'I have an image but no title', 'this fragment is stuck', 'walk me through writing this', 'guide me', 'where do I start', 'review the rhyme list this AI gave me', 'how do I go deeper'. Craft-specific requests route to the concern skills below.

0
installs
▌
Confirm · melodic-software bundle
Prove a change achieved its intended outcome: a mechanical build+test+lint prerequisite (delegated to /toolchain:check and /toolchain:lint, STOPs if broken), then outcome verification. Does the change match the plan/intent and function correctly, with the criterion auto-detected by change-type (feature, fix, refactor). Use when: 'verify changes', 'prove this works', 'did we build the right thing', 'is this done', 'check my work', 'did the fix actually work'; for quick mechanical-only checks use /toolchain:check, for measurable-improvement claims use /verification:measure.

0
installs
▌
Measure · melodic-software bundle
Verify a measurable-improvement claim against a baseline captured BEFORE the change. Two metric families (`performance`: wall time, memory, allocations, throughput, latency; `metrics`: complexity, coverage, coupling), each with a `baseline` phase at planning time and a `compare` phase after the change. Never claims improvement without a baseline (no baseline → honest 'cannot quantify'). Use when: 'is it faster', 'before/after', 'prove the improvement', 'did that actually speed it up', 'how much faster is it', 'measure this', 'capture a baseline', 'benchmark before and after', 'did complexity go down'; intent/outcome confirmation stays with /verification:confirm.

0
installs
▌
Decompose · melodic-software bundle
Break a plan, spec, or PRD into independently-grabbable work items using vertical-slice (tracer-bullet) decomposition, with HITL/AFK classification and dependency ordering. Use when the user wants a plan, PRD, or brief broken (decomposed, split, vertical-sliced) into tickets or work items; wants the spec published to the tracker as a container; or wants an existing decomposition re-sliced or rerouted because the spec changed. Reads a PLAN.md, PRD.md, item body, or the conversation; drafts thin end-to-end slices, classifies each AFK (agent-ready) vs HITL (needs-human), gets approval, then publishes blockers-first via the seam with native dependency edges, optionally (opt-in at approval) under a spec container carrying the Brief with slices as native sub-items. Also owns re-decompose (rerouting) when mid-flight review shows the spec is wrong: close obsolete unimplemented slices, keep implemented ones, edit the spec, regenerate the rest. Sibling skills: /work-items:track (backlog CRUD), /work-items:work (auto-se

0
installs
▌
Work Loop · melodic-software bundle
Run the work-item backlog as a self-paced autonomous drain loop: each cycle sweeps raw intake through mechanical triage, admits items through the work-class gate (fail-closed), executes admitted items via /work-items:work under an adaptive item cap, and evaluates the drain exit condition. Worker lane of the loop-lane three-session topology. Authors PRs, NEVER merges. Use when: 'work loop', 'run the work loop', 'start the worker loop', 'drain the backlog', 'autonomous drain', 'loop the backlog', 'drain the issue backlog to done'. Launch via /loop (self-paced). Sibling skills: /work-items:attend-queue (attended escalation lane), /work-items:work (single-item pick + execute), /work-items:triage (raw intake), /work-items:track (backlog CRUD).

0
installs
▌
Compress · melodic-software bundle
Compress (tighten, shorten, trim) markdown files by dropping flavor, filler, hedging, articles, while preserving all content (directives, qualifiers, thresholds, examples), with a mandatory semantic-diff subagent that reverts any SEMANTIC LOSS or AMBIGUITY. Use when: 'compress this doc', 'tighten markdown', 'cut prose', 'shorten without losing meaning', 'trim onboarding doc', or verbose prose in docs/, READMEs, rule bodies, skill bodies, or third-party pasted text. Actions: default (snapshot → backend → semantic-diff subagent → revert-pass → markdownlint) and audit (read-only dry-run classifying SKIP/COMPRESS/UNCERTAIN per file); empty target + clean tree in an interactive session offers a confirmation-gated repo-wide run (audit-first interview with prescribed defaults) instead of the no-op; flags: --force (bypass <3% revert rule), --keep-snapshot; not for: session compaction (/compact), markdown noise classification (/audit-noise), code-comment trimming, or content relocation/SSOT consolidation (/extract-sso

0
installs
▌
Name It Better · melodic-software bundle
Generate and evaluate fresh name candidates for anything: a variable, function, file, module, skill, repo, or domain term. Then let the human pick. Use when the target name is still UNDECIDED, whether the ask is a fresh name ('suggest names', 'what should I call this') or a retry on one just rejected ('name it better', 'that name is wrong', 'help me rename this to something better'). Not for an already-decided rename ('rename X to Y', 'I renamed X'). That routes to the rename-references sweep. Spawns blind fresh-context generators from distinct lenses; never auto-locks a name. Optional 'tournament' arg for high-stakes, hard-to-refactor names.

0
installs
▌
Delta · melodic-software bundle
Report only what changed in the enforcement surface since the last audit. Re-runs `overengineering:audit`, compares this run's findings spine against the one the previous cycle left behind, and captures a fresh baseline for the next run. The report covers new clutter, verdict moves, closures, and status changes, filtered through a configurable noise budget, so a recurring run is a short delta instead of the whole surface again. Read-only always: it never invokes or enters `overengineering:realign`, never writes a Status, and never touches the surface it reads; verdict changes queue for the human. A first run establishes a baseline and reports no deltas. Use when the ask is for what moved since the last enforcement audit ('what changed since the last audit', 'did any verdict move') or for a recurring, scheduled enforcement check ('run the enforcement audit on a schedule'). Pass layers to scope the pass and `unattended` for a scheduled or dispatched run; both pass straight through to the audit.

0
installs
▌
Playwright · melodic-software bundle
Live E2E browser automation via Microsoft's @playwright/cli: named sessions, accessibility-ref snapshots, click/fill by ref, screenshots, console and network capture, network mocking, tracing, video, and auth state, with artifacts written to disk so only paths enter context (far fewer tokens than Playwright MCP). Use when: 'playwright', 'E2E test', or any task that needs a real browser driven against a running app: testing a UI flow end to end, capturing a screenshot or video as evidence, reading console errors or network traffic, or mocking a response.

0
installs
▌
Reanchor · melodic-software bundle
Verify a session's working assumptions are still true before building on them. Referenced PRs/issues/branches still in the state a handoff or plan claims, base-branch drift, cited skills/plugins that were renamed or version-drifted, and memory-tier files whose subjects have since landed. Reports what drifted and re-anchors; does not resume the work. Use when: 'reanchor', 're-anchor', 'is this still current', 'verify my assumptions', 'has main moved since', 'are these premises still valid', 'is the handoff stale', 'resuming an old plan', 'check freshness'. Not for resuming work (use /session-flow:keep-going), the cross-worktree staleness inventory, PR feedback triage, or re-anchoring a standing behavioral rule (this re-anchors factual premises, not rules).

0
installs
▌
Song Form · melodic-software bundle
Build and balance song structure with Pat Pattison's methods. Section identification (verse/chorus/bridge/refrain), forms (AABA, verse/chorus, verse/refrain), the candy-bar rewrite, hook placement and hot spots, repetition/repainting (You-I-We, Past-Present-Future, hidden questions/commands), verse development and the box model, bridge writing, and Essential Guide to Lyric Form and Structure worked examples. Use when: 'is this verse/chorus or AABA', 'where should the title go', 'my chorus does not land', 'my second verse repeats the first', 'what goes in verse 2/3', 'write me a bridge', 'do I need a bridge'. For stability/scansion use /songwriting:meter-prosody.

0
installs
▌
Commit · melodic-software bundle
Create a git commit with a subject matching the resolved convention (layered `source-control.md` config → project convention → Conventional Commits default), a Claude Co-authored-by trailer, and surgical staging (never `git add -A`), feeding the message to git via Bash heredoc. Use when: 'commit this', 'make a commit', 'commit with message <hint>', not for push, branch creation, or PR creation (use /pull-request).

0
installs
▌
Scan Todos · melodic-software bundle
Sweep the codebase's source comments, not tracker items, for actionable markers (TODO/FIXME/HACK/XXX) and resolve or file each one. Use when: 'scan TODOs', 'scan for FIXME', 'sweep the codebase for markers', 'find TODO comments', 'resolve TODO/FIXME/HACK', 'scan for tech-debt comments', 'clean up markers'. NOT the encouraged workflow for new work. Durable work belongs in the tracker at authoring time; prefer a commit-time hygiene gate. Sibling skills: /work-items:track (backlog CRUD), /work-items:work (auto-select + execute), /work-items:triage (raw intake), /work-items:decompose (plan → tickets).

0
installs
▌
Unhobble · melodic-software bundle
Empirical bare-baseline experiment on a repo's standing instructions: reversibly strip project CLAUDE.md/rules/behavioral hooks/skills on a dedicated branch, work normally against the bare model logging observed stumbles to a ledger, then re-add ONLY instructions with repeated same-cause evidence, each restore citing its ledger rows. Measures the model where sibling audit-instructions judges the text. Use when: 'unhobble', 'run the bare experiment', 'delete my CLAUDE.md and see', 'does the model still need these instructions', 'new model dropped, re-baseline', 'instruction ablation experiment'. Human-gated mutations; resumable state.

0
installs
▌
Trace Intent · melodic-software bundle
Reconstruct WHY something was built the way it was, from evidence outside the code, review discussion, tickets, design docs, incident records, and report what could not be found as a first-class result. Grades every claim on an intent-evidence tier (Direct / Supported / Inferred / Speculative / Unknown) and cites each one. Use when: 'why was this built this way', 'why did we pick X over Y', 'what were they thinking', 'design rationale', 'what problem was this solving', 'why does this still exist', 'archaeology on this decision'. Skip when: you want what the code DOES or where it lives (that is '/discovery:explore', whose git mode owns repo-local history); when the question is whether a convention should STILL hold rather than why it was adopted (that is '/discipline:reason-dont-recite'); or when the answer is a current external fact rather than a past decision (that is '/discovery:research').

0
installs
▌
Book Distill · melodic-software bundle
Distill a technical book (PDF or EPUB) into concept-organized skill reference files via a structured multi-session pipeline. Use when: 'distill this book', 'book to skill', 'PDF to skill', 'EPUB to skill', 'read this book for me', 'extract knowledge from this book', 'book distillation', 'turn this book into a skill', 'extract from PDF'; or when user provides a PDF/EPUB path and asks to create or extend a skill from it. Produces author-attributed reference files (60-160 lines each), named by concept not chapter, with routing table updates to the target skill's SKILL.md. Handles multi-author merges and Phase 3 shared-file consolidation. Not for ad-hoc book summaries. Output is structured developer-facing context files the target skill routes at query time.

0
installs
▌
Video Digest · melodic-software bundle
Watches a single public video from YouTube or X (Twitter). Extracts the transcript, harvests links, researches claims, and synthesizes prioritized repo-applicability recommendations. Use when: 'youtube', '/youtube-digest', 'watch this YouTube video', 'transcript for YouTube', 'watch this video', 'digest this video', 'digest this post', 'summarize this talk', or the user shares a youtube.com, youtu.be, x.com, or twitter.com URL for a single public video or video post. Actions: watch <url> (full pipeline), watch (dequeue epic queue), watch <n> (queue row), queue <url> (batch enqueue), transcript <url> (captions only), resume <slice-slug>. Do NOT use for auth-walled course platforms. Dometrain, Pluralsight, and Udemy courses go to /knowledge:course-digest.

0
installs
▌
Audit Answers · melodic-software bundle
Adversarially validate a completed /planning:interview's answers with independent fresh-context agents. Runs over any filled decision ledger, hand-answered or auto-accepted. Validators re-examine each answer with its rationale withheld and return a per-answer verdict (confirmed / challenged / reclassified-to-human), so only doubtful answers come back as real questions; open branches are filled with the recommended answers first, holding the never-auto floor. Use when: 'audit my interview answers', 'validate the interview answers', 'have agents check the answers', 'accept all and have agents check them', 'agent-validated interview', 'have subagents second-guess the recommendations', 'auto-answer then verify the ledger'. Not for stress-testing a plan artifact (that is '/planning:devils-advocate') or asking the human the first time ('/planning:interview'); needs a filled interview ledger.

0
installs
▌
Questionnaire · melodic-software bundle
Turn a decision another person holds into a Markdown questionnaire handed off async. Interviews the user only about the send (who it goes to, what they need back), never about the subject the recipient holds, then writes a discovery questionnaire aimed at the gap. Use when: 'make a questionnaire for X', 'I need to ask my DBA/the client/legal about this', 'turn this into a doc someone else fills in', 'I don't know, that's the client's call', 'send this to someone else to answer', 'write up questions for our security team', or when an interview branch defers to a person-arbiter; skip when the user can answer themselves (run /planning:interview) or when the answer is agent-lookupable.

0
installs
▌
Security Review · melodic-software bundle
CI security-review lane for a GitHub pull request. Logic, trust-boundary, and Actions security findings static analysis misses. Use when: 'CI security review', 'claude-security-review lane', '/review:security-review', or a reusable workflow invokes the org security-review plugin command.

0
installs
▌
Reconcile · melodic-software bundle
Retire finished off-thread work and reconcile this session's task ledger with reality, the prune-and-reconcile counterpart to keep-going's resume. Inventory the off-thread work this session spawned, inspect each item's REAL state, retire the genuinely finished, close the ledger items proven done, and report sibling-session liveness read-only. Auto-settles the provably-finished; GATES any kill of still-running work. Use when: 'reconcile the session', 'retire finished work', 'square up the task ledger', 'is anything still running that should be retired', 'close out finished tasks', 'prune done work', 'reconcile the ledger'. Boundary: 'is it stuck / pick it back up' is /session-flow:keep-going; a read-only 'where do we stand' glance is /session-flow:orient; making git/PR work durable before shutdown is /session-flow:clean-stop.

0
installs
▌
Stateless · melodic-software bundle
Inspect and turn off Claude Code's auto memory, the notes Claude writes itself per repo under ~/.claude/projects/<project>/memory/. Use when: 'make Claude stateless', 'stop Claude remembering', 'disable auto memory', 'turn off auto-memory', 'purge/clear/delete auto memory', 'wipe what Claude saved about this repo', 'does Claude have saved memories'. Actions: status (default, memory + settings across all scopes), disable (autoMemoryEnabled:false + CLAUDE_CODE_DISABLE_AUTO_MEMORY), purge (destructive delete, confirm-gated). Auto-memory only, not CLAUDE.md/rules (use /claude-memory:audit) and not transcripts/history.

0
installs
▌
Known Issues · melodic-software bundle
Looks up and tracks known Claude product issues. Searches known GitHub bugs, checks service health and model quality, and maintains a persistent registry of tracked issues. Use when: 'is this broken', 'known CC bugs', 'troubleshoot Claude Code', 'any workarounds', 'feature behaves unexpectedly', 'scan repo for issues', 'file a bug'. Actions: status (default), search <feature>, check-all, scan, list, quality, create.

0
installs
▌
Audit Size · melodic-software bundle
Measure lines per file for the changed files, a path, or the whole tree: total, blank, comment, and code lines when `scc` resolves, total and non-blank lines from a bundled counter otherwise, per lane (TypeScript/JavaScript, Python, Bash, Go; C# files are counted too). Each file is reported beside a configurable reference with its provenance (default 1000 non-blank lines, the plugin's own number and not ISO-backed; 500 selectable; an ISO/IEC 5055 §8.2.115 function-percentage mode selectable), and the report never emits a finding, a severity, or an exit-code gate. Use when: 'how long are these files', 'lines per file', 'file size audit', 'which files are too big', 'LOC per file', 'is this file over 1000 lines', 'count lines in the change'; for cyclomatic or cognitive complexity use /code-metrics:audit-complexity, and for a repo-wide dashboard this is the wrong tool (it measures a change).

0
installs
▌
Hold My Hand · melodic-software bundle
Hold the user's hand through a long multi-step job. Partition the remaining work into phases and present ONLY the current one, never the phases after it beyond a one-line 'Phase 1 of 8' count. Each phase names where to be, numbered steps with exact commands, the expected output, the common failure, who performs each step, and the exact reply that advances. Once invoked, this holds for the rest of the session. Use when: 'hold my hand', 'walk me through this', 'one step at a time', 'one phase at a time', 'don't show me the next step yet', 'guide me through all of this', 'exact steps', 'hand-hold'. This is a STANDING posture that withholds later steps: adhd:shape sets action-first formatting for every response and shows the whole list, adhd:clarify reshapes one dense message already on screen, wizard:generate writes a bash script the human runs with no assistant in the loop, and session-flow:workflow routes to the next stage without scripting its steps.

0
installs
▌
Research Deep · melodic-software bundle
Dispatch deep external research to the heaviest isolated execution tier available, a workflow engine, an isolated subagent, or inline as last resort, keeping the main conversation clean while the full research discipline runs. Itself runs in main context, the only place both the Workflow tool (absent from every non-fork subagent) and a dependable Agent spawn are guaranteed. Use when: 'deep research', 'research these N topics', 'broad multi-source research', 'compare these tools thoroughly', 'migration research', 'exhaustive research on X'; for a single small lookup use the research skill directly, which already dispatches its own subagent.

0
installs
▌
Course Digest · melodic-software bundle
Extract and synthesize online video courses into repo-applicable recommendations via browser automation (Playwright + claude-in-chrome), transcript extraction, frame analysis, and LLM synthesis. Use when: 'course digest', 'digest this course', 'analyze course', 'Dometrain', 'watch this course for me', 'course takeaways', 'extract from course', 'summarize course', user shares a Dometrain/Pluralsight/Udemy course URL, or wants course patterns applied to their codebase. Single public YouTube videos → use /knowledge:video-digest. Actions: full pipeline (default), extract (phases 1-2 only), analyze (phases 3-5 only), status (list all digested courses), resume <slug> (continue extraction), continue <slug> (resume from saved session state).

0
installs
▌
Justify · melodic-software bundle
Justify the existence of any artifact you point at: was there a reason for this when it was built, and does that reason still hold today. Walks one target you name (a path, a `path#heading`, or a kind-prefixed identifier) and reports a verdict on the evidence-earned-keep ladder, each row carrying how much evidence supports it. Read-only: it reports and then discusses, never applies a remedy, and writes its findings to the memory tier; the one tracked write, persisting the resolved home to the concern file, needs explicit confirmation. Use when: 'justify this', 'does this need to exist', 'why is this here', 'is this still valid', 'earn its keep', 'justify the existence of'. With no target it never sweeps; it uses what the session has been discussing, else offers to rank candidates by age, else asks. Not for the enforcement surface (hooks, CI lanes, gate scripts, branch protections), which routes to the sibling `audit` skill, and not for applying a fix, which routes to the owner named in the finding.

0
installs
▌
Realign · melodic-software bundle
Execute an enforcement-surface audit's findings behind an explicit per-item human gate. Consumes the findings artifact either producer wrote. It never scans or re-judges the surface itself. For each finding the operator accepts, it drives interview → explore and research → plan → implement through presence-gated skill composition, executing every removal down the rollback ladder: config-disable first, observe for a window with a stated end date, delete last with a recorded rationale. Unproven items route to a time-boxed ablation batch; security-class items surface the capped verdict's evidence and wait for the human's own call; remediation owned by an upstream or a forge control plane becomes a delegation rather than a local patch. Use when the ask is to act on an enforcement-surface audit's findings ('realign our enforcement surface', 'the audit says retire it, do it'), to retire or peel back automation already judged, or to start or advance an ablation window ('disable this gate and observe it'). This is th

0
installs
▌
Design Handoff · melodic-software bundle
Gate and package a finished design for /planning:plan: binary check that every thread in design-threads.md is RESOLVED, directional, or TAGGED-DEFERRED, then an advisory six-dimension coverage table, then emit the plan-ready summary and resume prompt. Use when: 'design handoff', 'hand off the design', 'is the design ready', 'plan-ready summary', 'design gate', /planning:design discussion rounds stop surfacing gaps, or entering /planning:plan from a completed design session. FAILs on any thread that is unresolved AND untagged. Names it and routes back to /planning:design. Skip when: still exploring the design space. Use /planning:design; mid-session save-point to clear and resume later. Use a session-handoff capability.

0
installs
▌
Pressure Test · melodic-software bundle
Builds a throwaway interactive terminal app to pressure-test business logic, a state machine, a data model, or an API surface before committing to it. Use when the question is whether a state model, reducer, or data shape holds up under real cases: 'does this state machine handle X then Y', 'sanity-check this data model', 'feel out the API'. Any question answered by driving state by hand and watching it change. Produces a portable pure logic module (liftable into production) behind a disposable shell, a terminal app by default, or a self-contained HTML demo a non-developer can drive by clicking buttons when no terminal fits. Captures the validated answer in a durable note. Not for visual or design questions. Use /prototype:explore-directions for those.

0
installs
▌
Clean Stop · melodic-software bundle
Get a session to a clean stopping point before the machine may go away. Everything durable, everything linked, nothing stranded on local disk. Sweep every repo and worktree touched for uncommitted, unpushed, or PR-less work, push it durable, put follow-ups and context in PR/issue bodies a cold agent could resume from, prune only what is provably safe, then give a free-and-clear verdict. Use when: 'clean stop', 'get to a clean stopping point', 'safe to shut down', 'wrap up before I lose this machine', 'make everything durable', 'stopping for the day', 'is anything stranded', 'leave it clean'. Makes durable freely; gates destructive cleanup.

0
installs
▌
Keep Going · melodic-software bundle
Recover and continue after an interruption, rate limit, crash, disconnect, or gap, or when live off-thread work looks stalled and you are asked to check on it. Inventory off-thread work, inspect its REAL output, act only on evidence (resume / rerun / kill-and-restart), then continue the main task where it stood. Use when: asked to keep going, continue, resume, or pick up where you left off; after being cut off or interrupted ('what were you doing'); or asked to check on, poke, or judge whether off-thread work is stuck ('check the monitor', 'is it stuck', 'stop staring at it'). Infers intent from the conversation; arguments optional. After a usage limit lifts it continues rather than summarizing-and-stalling; it gates killing or re-firing side-effectful work. To retire finished off-thread work and reconcile the task ledger rather than resume, use /session-flow:reconcile.

0
installs
▌
Worktree · melodic-software bundle
Manage git worktree lifecycle for parallel-session isolation: create (guided naming via EnterWorktree), status (PR + staleness inventory), cleanup (file-lock-aware removal), audit (infrastructure health). Use when: 'create worktree', 'worktree status', 'clean up worktrees', 'orphaned worktrees', or proactively when on main before writing code, not for PR lifecycle (use /pull-request).

0
installs
▌
Visualize · melodic-software bundle
Decide the best visual form and medium for what is in the conversation right now, then render it. Use when asked to visualize, diagram, chart, draw, sketch, or render something, or which visual form fits it best. Infers the target from the conversation, picks a form (a mermaid diagram, a markdown table, a hand-authored SVG/CSS chart, ASCII/Unicode art, code-shape sketches, a rich rendered page, or, where the bundled design skill is available, a hand-editable design canvas) and a medium (inline terminal, a local HTML file, or a published Artifact), renders good defaults, and asks only when the target is genuinely ambiguous and no form was named. It routes chart craft and artifact-design fundamentals to those capabilities when installed. It does not teach them. Not for polishing a specific chart's colors/axes (a chart-craft/dataviz capability owns that) or restating dense text in plainer words (a comprehension/digest concern).

0
installs
▌
Attend Queue · melodic-software bundle
Attend the human-in-the-loop queue for loop-lane operation: ONE attention view merging worker-escalated items (human-gated role label + machine-marked escalation comment) with untriaged raw intake, then drive each row to resolution, answer escalated questions via interview, write answers back as issue comments, ratify first-drain C3 admissions, and flip unblocked items to the autonomous-eligible role label. Use when: 'attend the queue', 'attend queue', 'answer escalations', 'work the escalation queue', 'what needs my attention across the lanes', 'HITL queue', 'ratify admissions', 'clear the human queue'. Attended lane of the loop-lane three-session topology, judgment only; never executes work items, never merges. Composes /work-items:triage (attention view + machinery) and /planning:interview. Sibling skills: /work-items:work-loop (autonomous drain), /work-items:triage (raw intake), /work-items:track (backlog CRUD).

0
installs
▌
Audit Pass · melodic-software bundle
Run ONE coordinated, ordered, resumable pass over a named target repository: a three-scope inventory first (managed policy read-only, user scope routed as recommendations, project scope), then delegated checks lane by lane, findings persisted per lane so an interrupted run resumes instead of restarting, and one human gate for the whole pass instead of one per skill. Adds run semantics, not checks: every check belongs to the plugin that owns it and is invoked presence-gated. Read-only on bare invocation; edits only behind an explicit --fix override, and never to managed policy or user-scope files. Use when: 'audit pass', 'run one pass over this repo', 'coordinate the audit skills', 'audit this repo end to end', 'resume the audit', 'one reconciled findings report', 'sweep all three scopes', or before a release that needs a single diffable findings artifact.

0
installs
▌
Morning Brief · melodic-software bundle
Prints the operator's read-only morning view for the current GitHub repo in one pass. Open counts per queue label (needs-triage / ready / needs-decision / needs-human), the gh-native merge-ready PR list, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness (last-cycle age + flags). Use when: 'morning brief', 'morning view', 'ops dashboard', 'what needs attention', 'daily standup view', 'operator morning pass', 'queues and merge-ready'. Read-only and gh-based, never mutates issues, PRs, labels, or comments.

0
installs
▌
Observability · melodic-software bundle
Read and report on locally captured Claude Code telemetry, OTEL DuckDB store, collector, optional Aspire dashboard, the per-session hook event log and hook-event JSONL, ccusage, with cross-session trend reports, a per-session report, and store pruning. Use when: 'claude observability', 'OTEL', 'collector', 'token burn rate', 'hook latency', 'cost breakdown', 'how am I doing', 'what did this session do', 'hook event log', 'which hooks fired'; read-only except the explicit clean action.

0
installs
▌
Audit Noise · melodic-software bundle
Classify tracked markdown for nine noise shapes — historical citations, ghost refs to ephemeral paths, "Why this file exists" preambles, hard-coupled consumer lists, scope/loading meta-commentary, plan/changeset references, conversational antecedents ("as you asked"), tracker/PR back-references, and prohibitions with no positive alternative — emitting Tier 1 (remove/relocate), Tier 2 (review needed), and Tier 3 (likely legitimate) findings with per-shape treatment guidance; read-only on audited files. Use when: 'audit markdown noise', 'declutter', 'check for stale citations', 'find ghost refs', 'classify preamble', 'strip conversational residue from a doc', 'find negations without a positive', 'sweep a rule/skill/convention doc for noise', or before editing any tracked .md — not for prose flavor/compression (use /compress), structural markdown lint (your repo's markdown linter), or the same residue shapes inside code comments (use /code-tidying:audit-comment-residue, which owns non-markdown files).

0
installs
▌
Implement · melodic-software bundle
Execute approved plans, fix bugs, and make code changes inline with incremental validation. TDD by default, build+test after each logical block, commit at green checkpoints, and divergence detection that routes back to planning instead of pushing through a broken approach. Use when: 'implement this', 'execute the plan', 'fix this bug', 'refactor', 'build this', 'write the code', 'make this change', 'apply the plan', or whenever code is about to be written; modes: feature, fix, refactor, config.

0
installs
▌
Docpage Digest · melodic-software bundle
Ingest a single online documentation page (a docs-site URL) into a verified knowledge slice. Fetch the original, inventory it into a SOURCES.md, fan out per-section digest agents, run dual verification (one cross-vendor verifier), and hand off an interview-ready decision artifact. Use when: 'digest this doc', 'ingest this documentation page', 'run the doc pipeline on <url>', 'docpage digest', 'pull this vendor doc into the knowledge base', 'distill this docs page', or the user supplies a documentation URL to turn into durable corpus artifacts. Remote documentation PDFs (model cards, system cards) DO belong here; book files (PDF/EPUB books) route to /knowledge:book-distill, video courses to /knowledge:course-digest, single YouTube videos to /knowledge:video-digest; not ad-hoc summarization, the output is a durable verified corpus slice plus an interview handoff, not a chat summary. Publisher profiles live under context/ (first: Anthropic docs).

0
installs
▌
Devils Advocate · melodic-software bundle
Stress-test plans and proposals via systematic adversarial review. Assumption extraction, evidence check, failure scenarios, operational gotchas. Before implementation begins. Use when: asked to attack a plan or proposal ('devil's advocate', 'stress test', 'poke holes', 'what could go wrong'), or before implementation on new dependencies, infrastructure/CI/build changes, or any architecture decision with cross-module blast radius. An `incumbent` mode turns the same adversarial lens on the status quo ('is there a better way now', 'should we still use X'), surveying alternatives before a plan commits to keeping an existing tool or approach. Not for code correctness bugs or pre-PR verification.

0
installs
▌
Apply · melodic-software bundle
Apply a prior /repo-fleet-hygiene:audit action-plan JSON behind one fleet confirmation: default dry-run re-derives branch/worktree tips and prints the ordered batch; --apply mutates only after interactive confirmation or --yes. Owns batched merged-local-branch deletion with fail-closed OID refresh; cleans merged/prunable/missing worktrees in plan order (branches before worktrees). Use when: 'apply fleet plan', 'execute fleet cleanup', 'batch delete merged branches', 'one confirmation for fleet cleanup'.

0
installs
▌
Orchestrate · melodic-software bundle
Arm the CURRENT session for an orchestration-heavy task by loading seven proactive-orchestration imperatives (delegate/fan-out, spec-every-spawn, fresh-context verify, run-workers-well, nested subagents, surface drift, calibrate-to-conditions) as active standing instructions; optionally export them as a paste-ready brief for a spawned worker or fresh session. Use when: 'orchestrate', 'orchestration brief', 'prime this session', 'arm for orchestration', 'about to do heavy delegation', 'worker spawn prompt', 'delegation preamble'.

0
installs
▌
Extract Ssot · melodic-software bundle
Deduplicate repeated markdown content, rule files, skill bodies, ADRs, docs, into a single named source of truth and migrate every call site to cite it by exact heading. Use when the same prose, literal, or concept appears (or is reworded) across files: 'DRY this prose', 'extract a shared rule', 'single source of truth for X', a value-bump diff touching several files. Reports duplication at every multiplicity in rule-of-one / rule-of-two / rule-of-three buckets, offering only non-abstracting remedies below three. Creating a NEW SSOT artifact still refuses below the Rule of Three.

0
installs
▌
Simulation · melodic-software bundle
Agentic AI-driven multi-persona EventStorming simulation on Miro. Use when: 'simulate a workshop', 'run an EventStorming simulation', 'agentic EventStorming', 'multi-persona domain modeling on Miro'. Actions: --simulate [domain] (full multi-persona agentic workshop), --process-model / --design-level [board] (deep-dive against an existing board), --evaluate, --retrospective, --induction, --value, --crc, --ux, --discover-bcs (BC heuristics vs Miro board). Needs a Miro MCP server; degrades to structured-markdown output when Miro is absent. For methodology / facilitation reference use /event-storming:methodology.

0
installs
▌
Skill Authoring · melodic-software bundle
Anthropic's internal skill-authoring playbook. 9 skill categories, gotchas-section pattern, progressive disclosure (SKILL.md hub + spoke files), description-as-trigger discipline, config.json first-run setup, persistent CLAUDE_PLUGIN_DATA storage, CLAUDE_EFFORT effort-aware behavior, helper scripts, on-demand session-scoped hooks, distribution, and composition. Use when: creating or reviewing a SKILL.md, choosing a skill's category or structure, writing its description or gotchas section, or asking for skill-authoring best practices: 'create a skill', 'how to write SKILL.md', 'skill best practices'.

0
installs
▌
Find Handoff · melodic-software bundle
Recover a lost handoff after `/clear`. Find the save-point file or resume prompt when the resume prompt was written but never copied and the fresh session has zero context. Read-only detection ladder: known-location glob of `<memory_dir>/handoffs/`, then a bounded, recency-ranked scan of transcripts (excluding the current session's own file) for the handoff directive and dashed-rail markers, then a confirm-before-resume gate. Use when: 'find my handoff', 'recover the handoff', 'I lost the resume prompt', 'forgot to copy the resume prompt', 'I cleared without saving the prompt', 'where's my handoff', 'recover after /clear', 'get back the handoff'. Surfaces only the resume prompt + handoff metadata, never raw transcript content; hands to `/session-flow:keep-going` when the recovered session ended mid-work rather than at a clean save-point.

0
installs
▌
Show Options · melodic-software bundle
Lay out which skills fit this moment as a decidable menu, a ranked shortlist per bucket plus the complete remainder by name, so nothing is hidden and the human chooses. Buckets: Now, Next, Skipped upstream (artifact-grounded), Later (the in-domain remainder, named-only), and a rotating Spotlight of three. Never omits an option because it judges the step already done or unnecessary; that judgment becomes an annotation and may affect rank, never presence. Resolves candidates from the full installed catalog rather than the in-context skill listing, which omits every manual-only skill and truncates most descriptions. Use when: 'what should I run next', 'what are my options', 'what am I forgetting', 'which skill fits here', 'what else could I run', 'show me my options', 'what skills apply now'. Writes one small rotation ledger per invocation so the Spotlight advances; otherwise read-only. Not the staged-workflow navigator that routes to exactly one next stage (/session-flow:workflow), not a situation report (/sess

0
installs
▌
Meter Prosody · melodic-software bundle
Scan lines and make structure serve meaning with Pat Pattison's methods. Meter (scansion, Paradigms I/II/III, Pentad, Goldilocks, the 'into' rule, In Memoriam quatrain, pitch-stress), prosody (motion-emotion, greedy spots, tone-of-voice, three phrasing types), section stability (stable/unstable scan), and lyric-melody alignment. Use when: 'scan this line', 'can this be common meter', 'is this verse stable or unstable', 'my words don't fit the music', 'greedy spot in line 2', 'set lyrics to this tune', 'does my song feel right'. For song sections/form use /songwriting:song-form; for rhyme use /songwriting:rhyme.

0
installs
▌
Map Landscape · melodic-software bundle
Chart a set of repositories as a C4 System Landscape plus an application-portfolio table: discover the repositories, collect owner/runtime/framework/dependency/last-touched facts from a tested script, draw only relationships a cited fact supports, and write both artifacts into the consumer's declared architecture home. Use when: 'map our landscape', 'system landscape', 'what systems do we have', 'application portfolio', 'who owns which repo', 'what runtimes are we on', 'chart our repositories', 'C4 context across repos', 'inventory our systems'. Skip when: the question is inside ONE codebase (module friction, shallow modules, seam placement) which is /architecture:improve, or the goal is fleet cleanup (stale branches, orphaned worktrees, moved remotes) which is /repo-fleet-hygiene:audit.

0
installs
▌
Point Dont Copy · melodic-software bundle
Re-anchor pointer-over-copy discipline, then audit the work in flight for copied content, internal-name coupling, and closed capability lists, and correct by pointing at the living source. Use when: 'point don't copy', 'you copied that', 'don't duplicate the docs', 'cite instead of paste', 'link don't restate', 'you enumerated the tools', 'that couples to internal names', 'this will drift', or at conversation start on documentation work.

0
installs
▌
Use Your Skills · melodic-software bundle
Re-anchor the discipline of actually using the skills available to you. Scan the in-context skill listing, map the conversation and the task to the skills that fit, and invoke them instead of reinventing their procedure from scratch. Then audit the work in flight for a skill that should have fired and did not, and route forward. Invoke it now, and name the relevant skills when delegating to a subagent. Use when: 'use your skills', 'you have a skill for that', 'did you check your skills', 'there's a skill for this', 'you reinvented that', 'you skipped the skill', 'invoke your skills', or at conversation start to set the posture that available skills get used.

0
installs
▌
Running Retro · melodic-software bundle
Take an in-flight retrospective checkpoint mid-session: a subagent analyzes the transcript so far, classifies each finding by category and resolution route, and appends to a cumulative running ledger. Capture and route only, never auto-applied. Live counterpart to /session-flow:retro (the end-of-session scoring + codification pass). An `arm` action instead launches a detached observer that runs the checkpoint autonomously after the session ends. Use when: 'running retro', 'live retro', 'in-flight retro', 'checkpoint this session', 'how is this session going', 'observe the session so far', 'arm the observer', 'watch this session in the background', 'observe this session after it ends', partway through a long skill loop, or on a /loop interval. Does NOT score the session, codify learnings (/session-flow:retro codify), auto-file issues, or /clear the session.

0
installs
▌
Object Writing · melodic-software bundle
Generate raw sensory material with Pat Pattison's methods. Object writing (sense-bound, timed dives, the pivot chain, the seven-channel sense inventory, Rusty's-collar/Kami-kazi), an agent that performs the write itself, cliche taxonomy + redemption, and point of view (camera distance, pronoun consistency). Use when: 'object writing', 'you do the object writing', 'make this less abstract', 'show don't tell', '90-second writing prompt', 'this line sounds cliched', 'who is speaking in this lyric'. For metaphor use /songwriting:metaphor; for rhyme use /songwriting:rhyme; for daily curriculum use /songwriting:practice.

0
installs
▌
Babysit Prs · melodic-software bundle
Babysit your own open GitHub pull requests as a tiered fleet loop. The safe default discovers YOUR PRs under the current repo's owner, checks readiness, fixes clear branch-owned issues, and reports, it never resolves threads or merges. Explicit 'worker' tier adds auto-resolving outdated bot threads and gate-proven merges; explicit 'autopilot' adds all authors under the watched owners. Use when asked to babysit, watch, or advance open pull requests as a fleet (the safe tier), to run the worker or autopilot tier by name, or when pairing with /loop for continuous coverage; not for the single-PR lifecycle: prep, create, monitor one PR, or merge (use /pull-request).

0
installs
▌
Onboard Adapter · melodic-software bundle
Onboard a work-item tracker this plugin does not bundle, by generating a consumer-owned adapter for the tracker seam: interview to lock the provider's shape, explore the consumer's real instance for the per-instance facts only it can settle, generate the adapter (hardened security skeleton, honest capability manifest, contract-fixed verb scaffolds, conformance binding) into the consuming repo, then verify. Use when: 'add support for <tracker>', 'onboard a tracker', 'write a work-item adapter', 'generate a tracker adapter', 'my tracker is not supported', 'use Gitea/Redmine/YouTrack/Azure DevOps/Phabricator with work-items', 'bring my own tracker', 'the seam has no adapter for my provider'. Skip when the provider is already bundled (github, local-markdown, jira, gitea, linear). Bind it with '/work-items:setup' instead; skip for changing which provider a repo uses (also setup), and for fixing a bug in an existing adapter (ordinary implementation work).

0
installs
▌
Audit Coverage · melodic-software bundle
Read coverage artifacts a build already wrote (lcov `.info` including the 2.2 `FNL`/`FNA` records, Cobertura XML, coverage.py JSON, a Go cover profile) and report line coverage per file and function for a change, a path, or the tree, plus CRAP per function (`comp^2 * (1 - cov/100)^3 + comp`, Savoia and Evans 2007) from the sibling complexity numbers. It runs no tests and installs nothing. A missing artifact warns, naming the paths searched, never a silent skip; a function with no executable lines reports null, not 0. Coverage and CRAP default to a null reference (no bar) with its provenance, and no finding, severity, or exit-code gate is emitted. Use when: 'coverage of this change', 'coverage per function', 'CRAP score', 'which functions are complex and untested', 'read the lcov report', 'coverage.xml', 'how covered is this file'; for complexity alone use /code-metrics:audit-complexity; for what these numbers can and cannot say, /code-metrics:principles.

0
installs
▌
Batch Simplify · melodic-software bundle
Batch-run simplification across changed files, or across an entire repository, grouped by ecosystem and dependency order. Use when: 'batch simplify', 'simplify recent changes', 'forgot to run simplify', 'catch up on simplify', sweeping a named scope such as a branch, a whole repository, or one directory, or after a multi-session sprint. Accepts a time window (`24h`, `7d`), `branch` to diff the current branch vs the default branch, or `repo` for a confirmed whole-repository sweep; any scope narrows to one or more trailing paths; optional `docs` flag includes .md files for post-migration or post-refactor doc sweeps. Skip for single-file cleanup. Use /simplify instead.

0
installs
▌
Do Your Research · melodic-software bundle
Re-anchor research and no-assumptions discipline mid-session, then self-audit and correct the current work. Use when: 'do your research', 'you're guessing', 'cite that', 'stop assuming', 'evidence, not vibes', 'you skipped verification', 'that's training-data recall', 'research this properly', 'fact-check that', 'make sure that's right', or at conversation start to set the posture. For a heavy verification fan-out, a typed full inventory of the session's claims verified at a configurable depth, use the sibling do-your-research-deep.

0
installs
▌
Mind Your Maxims · melodic-software bundle
Re-anchor cooperative-communication discipline, Grice's conversational maxims plus the AI-augmented transparency maxim, then audit recent responses and agent-authored artifacts for what the reader actually needed: completeness in both directions, relevance, clarity, and disclosed boundaries. Use when: 'mind your maxims', 'communication quality', 'answer what I asked', 'you buried the answer', 'you didn't answer the question', 'too vague', 'stay on topic', 'is this clear', 'grice', 'maxims', or at conversation start to set the communication posture.

0
installs
▌
Reuse Or Replace · melodic-software bundle
Re-anchor the anti-fragmentation discipline that when an established way of doing something already exists, an idiom, structure, naming shape, doc format, or process, new work REUSES it or openly REPLACES it (migrate the old uses, record the decision); never a silent second, parallel way alongside. Then audit the work in flight for unexplained divergence from an established way. Replacing is first-class when evidence backs it, the sin is the SILENT second way, not divergence itself. Use when: 'reuse or replace', 'we already have a way of doing this', 'don't invent a second way', 'keep it one way', 'follow the existing pattern or replace it', 'be consistent', 'you added a parallel way', 'this diverges from how we do it elsewhere', or at conversation start on work that extends an established codebase, structure, or process.

0
installs
▌
Audit Enforceability · melodic-software bundle
Audit which review findings a deterministic check could catch instead of a model re-deriving them every run: read ONE operator-named findings file, derive a finding class per row, map it through the crosswalk to the cheapest enforcement rung (editorconfig severity, analyzer-pack rule, custom analyzer, Semgrep rule, architecture test, hook, or llm-only), and write one proposal stub per finding naming that rung and its owner. Use when: 'which of these findings could a linter or analyzer catch', 'audit enforceability', 'promote findings to a deterministic check', 'what rung catches this', 'can we stop re-finding this'. 'Enforceability' here means whether ONE finding can be caught deterministically; it is not the question of whether a convention is machine-checkable, and not the C1-C5 promotion the autonomy work classes use. Read-only on the reviewed code and on the findings file it reads; the memory-tier stubs it writes are its report. It proposes a rung and never implements one.

0
installs
▌
Babysit Loop · melodic-software bundle
Run one repository's pull-request queue as the merge lane of the loop-lane topology: a self-paced standing or drain loop invoking /source-control:babysit-prs each cycle at the resolved autonomy tier, with grace windows, do-not-merge respect, escalation, and lane telemetry. Merge authority is human-only until the target repo's tracked config adopts the lane; the body owns the rung rules and the single paired-argument exception. Use when asked to run or stand up the babysit loop or merge lane for a repository, or to drain its PR queue. Required argument: <owner/repo>. Launch via /loop. Sibling skills: /source-control:babysit-prs (single-pass mechanic), /source-control:pull-request (single-PR lifecycle).

0
installs
▌
Pull Request · melodic-software bundle
Orchestrate the full PR lifecycle: prep (review + verify), create, monitor CI + review comments, merge, and fetch CI logs. Use when: 'create pr', 'ship it', 'pr prep', 'fix CI', 'address comments', 'monitor PR', 'merge this', 'check pr status', not for the all-PR babysit loop (use /babysit-prs), branch/worktree lifecycle (use /worktree), or committing without a PR (use /commit).

0
installs
▌
Record Decision · melodic-software bundle
Record an architecture decision into the repository's existing ADR convention: discovers the ADR directory, numbering scheme, and record shape in use and writes one record that follows them; when no convention exists it names what it searched, offers common shapes, and writes nothing until the human chooses. Use when: 'record this decision', 'write an ADR', 'architecture decision record', 'capture this decision', 'document why we chose X', or after a design handoff or interview resolves a decision worth keeping. Skip when: the decision is easily reversed and unsurprising (no ADR earned), or the ask is supersession, an index, or status lifecycle beyond what the convention already defines.

0
installs
▌
Audit Performance · melodic-software bundle
Read-only slowness-diagnostic capture for a Claude Code installation. Run it AT THE MOMENT the machine or a session feels slow, before restarting or deleting anything. One timed engine pass captures the four suspects: CLI version (regression), retention-sweep health including the silent unparsable-settings pause (accumulated state), a timed stat-walk of the install tree plus session and plugin-fleet counts (component bloat), and the fan-out layer (per spawn): a load-labelled no-op spawn baseline, every hook that will fire bucketed per-tool-call versus per-turn, the statusline, subagent concurrency ceilings, sessions that predate the settings file, and orphan attribution by parent liveness not age. On Windows, a kernel-object census (Token objects against uptime, paged pool) names the host-level leak beneath all four suspects. Plus a process census, Defender guidance, and a bundled known-performance-issues reference. Reports and routes; never mutates, never deletes, never 'fixes', never executes a discovered h

0
installs
▌
Audit Type Debt · melodic-software bundle
Measure how much of the code is typed for the changed files, a path, or the whole tree, as a percentage per lane: `type-coverage`'s ratio of identifiers whose type is not `any` for TypeScript, and mypy's `--any-exprs-report` coverage over expressions for Python. Because no standard or CWE anchors this measure, the reference is `null` by design and the number is a trend to watch rather than a bar; the report emits no finding, severity, or exit-code gate. Bash and Go have no comparable collector, and C# is not applicable, because an occurrence count is not comparable to a ratio. A lane whose tool is absent says so with an install hint and the run continues. Use when: 'how much of this is typed', 'type coverage', 'how many anys are in this', 'any usage in the change', 'type debt', 'measure our typing', 'mypy any expressions report'; for cyclomatic or cognitive complexity use /code-metrics:audit-complexity, and for what a measure can and cannot tell you use /code-metrics:principles.

0
installs
▌
Audit Dead Code · melodic-software bundle
Hunt dead code across a whole repository through four labelled lanes of unequal confidence. Knip (TS/JS unused files, exports, types, enum members), vulture (Python symbols), gopls (Go unexported symbols), and a portable grep lane (shell and other symbol languages), then adjudicate every candidate against the dynamic-usage evidence static analyzers are blind to, emitting Tier 1 (dead) and Tier 2 (uncertain) findings plus paste-ready native suppressions; read-only, no edits applied. Use when: 'find dead code', 'audit dead code', 'what is unused in this repo', 'unused exports', 'unreferenced functions', 'orphaned files', 'is anything here still called', 'dead code sweep', or when long-untouched code needs a deliberate hunt a rotated tidying lane never reaches, not for applying the deletion or Beck's Dead Code tidying (use /code-tidying:tidy), diff-scoped simplification of recently changed files (use /code-tidying:batch-simplify), comment residue (use /code-tidying:audit-comment-residue), or unused dependencies,

0
installs
▌
Explore Directions · melodic-software bundle
Builds throwaway UI variations, several radically different visual layouts on one route, switchable from a floating control bar, to answer 'what should this look like' before committing to a design. Use when the question is what a page, screen, or dashboard should look like, or for design options to compare: 'mock up a UI', 'what should this page look like', 'try a different layout'. Runs on your real stack by default (real header, real data, real density) or as a self-contained HTML mockup (or, where the bundled design skill is available, an editable design-canvas Artifact); you flip between variants, pick one (or steal bits from each), and throw the rest away. Not for logic or state questions. Use /prototype:pressure-test for those. Not for an interactive parameter explorer whose output returns as a prompt: that is the first-party playground skill, routed via /playgrounds:use where the upstream playground plugin is installed from its marketplace.

0
installs
▌
Audit Complexity · melodic-software bundle
Measure per-function cyclomatic and cognitive complexity and Halstead difficulty for a change, a path, or the tree, per lane (TypeScript/JavaScript, Python, Bash, Go; C# deferred), from whichever external collector already resolves (lizard, radon, ESLint, sonarjs, gocyclo, gocognit, shellmetrics, multimetric); it installs none. Each number cites its reference: cyclomatic 20 from ISO/IEC 5055:2021 §8.2.117, with 10 (McCabe 1976) and 15 (NIST SP 500-235) selectable; cognitive (Campbell, SonarSource) and Halstead (Halstead 1977) carry none, no standard setting one. A lane with no collector says so and the run continues, an unmeasured value is null not zero, and no finding, severity, or exit-code gate is emitted. Use when: 'how complex is this code', 'cyclomatic complexity', 'cognitive complexity', 'complexity audit', 'is this function too complex', 'Halstead difficulty', 'measure complexity of a change'; for lines per file use /code-metrics:audit-size.

0
installs
▌
Reason Dont Recite · melodic-software bundle
Re-anchor the discipline that inherited content is evidence of what is, never self-justifying authority, then audit the work in flight for decisions coasting on precedent and re-derive them from first principles. Use when: 'reason don't recite', 'why is it this way', 'challenge that convention', 'you're deferring to precedent', "that's just how it's done", 'question the inherited design', 'stop reciting the docs', 'is this actually right', or at conversation start on legacy or inherited code. Note the shared phrasing: this skill challenges whether a convention should STILL hold and re-derives it from first principles; when the ask is instead to RECOVER the original reasoning from the historical record, review discussion, tickets, design documents, that is '/discovery:trace-intent' if the discovery plugin is installed, and otherwise read that record directly before challenging what it says.

0
installs
▌
Write For Agents · melodic-software bundle
Write agent-consumed markdown well at the moment of writing. CLAUDE.md or AGENTS.md content, .claude/rules files, agent-loaded reference/context docs, navigation-pointer lines, and doc-plus-pointer extractions. Use when: 'add this to CLAUDE.md', 'write a rule for X', 'write this up for the agent', 'add a pointer to the docs', 'move this section into its own doc', 'draft an AGENTS.md section', or any drafting or editing of a markdown file an agent will load. NOT for: creating or editing a SKILL.md (playbooks:skill-authoring and skill-quality:check own that), auditing existing docs (the docs-hygiene audit skills own that), or human-facing docs such as end-user READMEs, RFCs, release notes and changelogs. Those route to docs-hygiene:write-for-humans, the sibling that fires at the same moment for the other reader.

0
installs
▌
Write For Humans · melodic-software bundle
Write human-facing prose well at the moment of writing. End-user READMEs, RFCs, design docs, release notes, changelog entries, tutorials, how-to guides, reference pages, and explanations. Resolves the consuming project's own style guide first and applies a named default set only as the fallback (Diátaxis document modes, Google developer style, ASD-STE100 instruction rules, Global English disambiguation). Use when: 'write the README', 'draft an RFC', 'write the release notes', 'write a how-to for X', 'document this for users', 'write this up for humans', 'what kind of doc is this', 'is this the right kind of doc', 'make this doc readable', 'this doc reads like a machine wrote it'. NOT for: markdown an agent will load, CLAUDE.md or AGENTS.md content, rules files, agent-loaded reference docs, which is docs-hygiene:write-for-agents; auditing prose that already exists (the docs-hygiene audit skills own structure and derivability, ai-slop:audit owns AI-writing tells); commit-message or PR-body shape, owned by sourc

0
installs
▌
Draft Goal Condition · melodic-software bundle
Routes the repetition-lever choice across /goal, /loop, routines and /schedule, a dynamic workflow, a Stop hook, and a one-shot prompt, then crafts a paste-ready /goal completion condition when /goal is the fit. The autonomous-goal / keep-working-toward-a-goal field Claude Code evaluates after every turn. Reads the current official docs live for the condition shape and character limit (never hardcodes either), drafts a transcript-demonstrable condition, and proves it fits the limit with a deterministic character counter instead of model guesswork, including a branch for goals no metric can measure. Use when: choosing between /goal, /loop, routines, a workflow, a Stop hook, or a one-shot prompt ('which loop should I use', 'pick the right autonomy lever'); writing or tightening a /goal condition ('craft a /goal', 'make Claude keep working until X'); or a goal has no honest metric or runs over the character limit ('my goal is not measurable', 'my /goal is too long').

0
installs
▌
Audit Install State · melodic-software bundle
Read-only audit of a Claude Code INSTALLATION directory, the machine-scope `~/.claude` tree plus `~/.claude.json`. Inventorying every file, separating what the product's own retention sweep already manages from what nothing manages, resolving what each number in a filename actually means before any process-liveness check, and detecting a deliberate or mid-experiment state before classifying anything as stale. Reports; never deletes. When the bundled doctor skill resolves in your session, prefer it for the quick native health-and-fix pass; this skill for the deep read-only inventory. Use when: 'audit my .claude folder', 'what is in my ~/.claude', 'why is my Claude Code install so big', 'is anything stale in my Claude directory', 'does Claude Code clean up after itself', 'check cleanupPeriodDays', 'is this lock file dead', 'tidy my Claude Code install'. Not for: a repo's project-scope .claude config (use /claude-config:audit), or deleting anything (use /disk-hygiene:clean).

0
installs
▌
Audit Duplication · melodic-software bundle
Measure duplicated code as clone groups over the changed files, a path, or the whole tree: each group's duplicated lines and tokens with every instance's file and line range, per lane (TypeScript/JavaScript, Python, Bash, Go, C#) from whichever clone detector already resolves. Replication the target repository declares about itself, a file vendored into several plugins and listed by path-within-plugin in a sanctioned-replication registry, is subtracted from the total and reported as an exclusion naming the registry line rather than as debt, and the report emits no finding, no severity, and no exit-code gate. Use when: 'is this duplicated', 'find copy-paste code', 'clone detection', 'duplication report', 'how much of this change is copied', 'DRY check', 'redundant code', 'duplicated lines in the diff'; for lines per file use /code-metrics:audit-size, and for what a duplication number can and cannot support use /code-metrics:principles.

0
installs
▌
Dissolve Comments · melodic-software bundle
Enforce self-describing code over a diff, branch, or ranked repository: a three-way comment triage that deletes zero-information comments, dissolves code-expressible ones into names and structure by behavior-preserving refactoring, and keeps only terse, load-bearing comments code cannot express. Deletions and local renames apply behind a token-level proof, other refactors behind a test net, else proposed; 'safe' mode restricts applied edits to removals. Use when: 'dissolve comments', 'remove comments', 'strip agent comments', 'too many comments', 'make it self-documenting', 'make the code expressive', 'comments must earn their keep', after an agent wrote over-commented code. Skip when: read-only residue classification (audit-comment-residue), structural tidyings (tidy), simplification waves (batch-simplify), markdown noise (docs-hygiene audit-noise), adding why-comments (tidy #14). Never touches public-API doc comments, license headers, or machine-read directives.

0
installs
▌
Tighten Your Output · melodic-software bundle
Re-anchor terseness discipline, say markdown in fewer words without semantic loss, write code in fewer lines when readability holds, then audit the work in flight for avoidable verbosity and tighten it. Use when: 'tighten your output', 'tighten this', 'too verbose', 'say it in fewer words', 'this is bloated', 'trim the code', 'simpler form', 'cut the wordiness', 'be more concise', or at conversation start on prose- or code-heavy work.

0
installs
▌
Rename References · melodic-software bundle
Sweep stale references after renames, the syntactic forms token-only grep misses (slash-tokens, paths, chain prose, numbered table rows, frontmatter chains and globs). Use when: 'rename X to Y', 'I renamed X', 'audit rename', 'find stale refs', 'check for stragglers', 'after git mv', 'sweep references', 'rename impact preview', 'find half-renamed state', 'broken refs after rename', 'pre-PR rename check'. Actions: audit, audit blast, audit half-rename, audit orphans, apply, preview, blocklist; not for framework migrations or repo-wide dead-reference audits.

0
installs
▌
Audit Native Overlap · melodic-software bundle
Map native Claude Code surfaces (built-in CLI commands, bundled skills, plugin-backed built-ins, session-provided skills) against the current repo's plugin skills and agents, so a custom component never silently duplicates what Claude Code itself now ships. Bare invocation is a READ-ONLY report: overlap candidates with evidence, detection integrity floors, and a listing-budget exposure section. Verdicts are human-gated and recorded in a committed store rendered into a generated registry; only an explicit `apply` argument edits a component, baking presence-gated native references into descriptions and Boundary sections. Use when: 'does this skill duplicate a built-in', 'what does Claude Code already ship for this', 'audit native overlap', 'is our install-state audit the same as /doctor', 'refresh the native-surfaces registry', 'bake the native reference into this skill', 'which of our skills overlap bundled skills'. Not for: enumerating what this machine can invoke (use /claude-ops:inventory), MCP tool overlap

0
installs
▌
Follow Our Standards · melodic-software bundle
Re-anchor to your organization's engineering standards, then audit the work in flight against them and correct violations with doc citations. Use when: 'follow our standards', 'follow the standards', 're-anchor to standards', 'does this match our conventions', 'audit against standards', 'you're drifting from our conventions', or at conversation start on a repo governed by shared conventions.

0
installs
▌
Pick For The Problem · melodic-software bundle
Re-anchor the discipline that a tool, library, framework, language, or approach is chosen to fit the actual problem, not reached for out of habit, availability, incumbency, or preconception, then audit the selection in flight and re-derive it from the problem. Use when: 'pick for the problem', 'right tool for the job', 'which library should we use', 'what framework', 'should we build this or use X', 'is this the right approach', 'you defaulted to X', 'we always reach for X', 'evaluate the options', 'choose a dependency', or at conversation start on a build-vs-buy or technology-selection decision.

0
installs
▌
Audit Derivability · melodic-software bundle
Audit whether a documentation file earns its existence. Could a fresh agent re-derive its conclusions by exploring the code, config, and structure itself? Read-only classifier: weighs derivability x re-derivation cost x drift risk x fact ownership into a verdict. Delete, convert-to-pointer, keep-as-derivation-cache, or keep-owns-facts. Audience-aware: agent-facing surfaces get the full axe; human-facing docs clear a higher deletion bar. Use when: 'is this doc worth keeping', 'audit doc value', 'derivability', 'could an agent figure this out itself', 'should this doc exist', 'this doc just restates the code', 'prune redundant docs', 'does this doc earn its maintenance', or before deleting a doc, not line-level noise (/docs-hygiene:audit-noise), cross-file duplication (/docs-hygiene:extract-ssot), prose flavor (/docs-hygiene:compress), or code-mismatch staleness.

0
installs
▌
Audit Instructions · melodic-software bundle
Audit locally-owned Claude Code instruction surfaces, including CLAUDE.md, .claude/rules, skill bodies, agent definitions, hook instruction text and output styles, for instructions current models no longer need (prior-model workarounds, over-prescriptive scaffolding, stale examples), instructions that misstate Claude Code's own behavior or cite files in forms that never load, and cross-surface conflicts where two surfaces contradict each other. Report-only: proposed diffs gated to the human, never auto-applied. Use when: 'audit instructions' or 'instruction audit', including after a model upgrade ('are my instructions holding the model back', 'too prescriptive'); a harness claim looks stale ('stale Claude Code behavior', 'my @path import is not loading', 'instruction re-reads CLAUDE.md'); or two surfaces disagree ('conflicting instructions', 'which instruction wins'). Not a brevity pass and not memory-layer hygiene.

0
installs
▌
Do Your Research Deep · melodic-software bundle
Escalate research discipline to a heavy verification fan-out over a TYPED FULL INVENTORY of the session's claims, assumptions, asserted facts, concrete specifics (paths, defaults, flags, signatures), and load-bearing premises, verifying each against a primary source at a configurable depth (tiered by default, or full), then report a per-item ledger with verdict, source, source tier, consensus count, and recency. Use when: 'deep research pass', 'verify every claim', 'audit all our claims', 'fact-check everything', 'go make sure those are all right', 'we've made a lot of load-bearing claims', or when your own judgement is the suspected bias across many claims. For a single or small inline fact-check ('fact-check that'), use the sibling do-your-research.

0
installs
▌
Scrutinize Dont Coast · melodic-software bundle
Re-anchor adversarial self-scrutiny. Stop coasting on your own recent output, re-examine whether it is actually sound (not merely confidently produced) through a fresh-context pass blind to the reasoning that made it, and remediate with the user. Use when: 'scrutinize don't coast', 'wait, stop', 'are you sure about this', 'second-guess this', 'poke holes in what you just did', "you're steamrolling", 'push back on yourself', with an optional focus to scope the re-examination, or at conversation start to set the posture.

0
installs
▌
Audit Encapsulation · melodic-software bundle
Audit and remediate skill-encapsulation violations. External citations reaching into private surfaces inside `.claude/skills/<X>/` or `plugins/<plugin>/skills/<X>/` (marketplace monorepos) beyond the slash invocation. Use when: 'audit encapsulation', 'find skill leaks', 'skill boundary violation', 'who is reaching into <skill>', 'check skill boundaries', 'public API drift', or before refactoring a skill.

0
installs
▌
Resolve Conflicts · melodic-software bundle
Resolve an in-progress merge/rebase/cherry-pick conflict by recovering both sides' intent from history before touching any hunk, composing both changes wherever possible, then sweeping for semantic conflicts the markers don't show. Use when: 'resolve conflicts', 'merge conflict', 'rebase stopped', 'CONFLICT (content)', git status shows unmerged paths, not for choosing merge vs rebase or PR lifecycle (use /pull-request), and not for ordinary commits (use /commit).

0
installs

270 published skills · page 2 of 3