melodic-software

@melodic-software source repo

270 skills
0 followers
19 hours ago last updated

▌
Audit Skill Visibility · melodic-software bundle
Audit whether each installed skill is actually VISIBLE to the model, and diagnose why most of a fleet never gets used. A skill is invisible when the skill-listing context budget drops its description (Claude Code drops by a decay-weighted usage score, so an unused skill loses its matchable keywords and stays unused), when frontmatter is malformed or a description is missing, when skillOverrides or a disabled plugin hides it, or when disable-model-invocation keeps it out of context by design. Reports reachability, observed usage, and whether it is losing the budget contest, computing overflow from documented settings and withholding any verdict the data cannot support. Read-only; never disables, deletes, or edits a skill. Use when: 'why do I never use most of my skills', 'why does Claude never suggest this skill', 'are my skill descriptions being dropped', 'is my skill listing over budget', 'which skills can the model actually see', 'which skills are starved', 'I have too many skills to know when to use them',

0
installs
▌
Implement Dispatch · melodic-software bundle
Orchestrate worker subagents to execute an approved plan. The main window composes scope-fenced briefs, dispatches workers, verifies their returns against direct evidence, and builds main-side instead of editing inline. Use when: 'dispatch this to workers', 'run this with subagents', 'execute the plan in parallel', 'fan the plan out', or the plan routes phases to worker surfaces or the session runs autonomously; for interactive all-inline execution use /implementation:implement instead.

0
installs
▌
Audit Comment Residue · melodic-software bundle
Classify code comments for four residue shapes. History narration ("used to… now…"), plan/session references ("Task 2 replaces the old…", "in this PR"), conversational antecedents ("per your request", "as you asked"), and ticket/PR/branch back-references a future reader will never see. Emitting Tier 1 (remove) and Tier 2 (review) findings with treatment guidance; read-only, no edits applied. Use when: 'comment residue', 'audit code comments', 'find stale/narrative comments', 'strip conversational comments', or before committing agent-written code, not for removing ALL comments, restating-the-code redundancy (that is /code-tidying:tidy's Beck tidyings), or markdown noise (use /audit-noise).

0
installs
▌
Audit Automation Gaps · melodic-software bundle
Audit a repo's Claude Code automation landscape, covering hooks, MCP servers, skills, subagents and scheduled tasks, against the enforcement hierarchy, producing PASS/REJECT/CONDITIONAL verdicts backed by evidence. The default verdict is REJECT because most gaps are already covered by compiler/analyzer/build-time checks. Use when: 'audit automations', 'what automations should we add', 'are we missing any hooks', 'hook gap analysis', 'should I add an MCP server for X'; pass --implement to apply approved items, or filter by category (hooks|mcp|skills|subagents|scheduled).

0
installs
▌
Draft Auto Mode Rules · melodic-software bundle
Draft an `autoMode` classifier block for Claude Code by interviewing you about what should and should not be auto-approved, then printing a paste-ready JSON block to stdout. Entries follow the shape the classifier actually reads well: a label, bulleted COVERED / NOT COVERED, one line of rationale. Every section keeps `"$defaults"` so customizing does not discard the built-in rules. Use when: 'help me write auto mode rules', 'draft an autoMode block', 'set up auto mode', 'add an auto-mode rule for X', 'my auto mode rules are too vague', 'rewrite this classifier entry', or after an audit shows rules being dropped or ignored. Prints only, never writes any settings file.

0
installs
▌
Recheck Against Upstream · melodic-software bundle
Re-anchor the discipline that existing state, config, code, docs, infra, is not evidence of its own correctness, then audit the surface in flight against CURRENT official upstream docs and classify each divergence. Use when: 'recheck against upstream', 'check this against the docs', 'is our config still current', 'did upstream change', 'are we still doing this right', 'verify against the official docs', 'this may have drifted from upstream', 'audit our setup against the vendor docs', or at conversation start on config, infra, or integration work.

0
installs
▌
Continue In Background · melodic-software bundle
Delegate the task to a fresh background agent that continues it NOW. Produce a save-point, then launch a detached claude --bg session seeded with the resume prompt. Use when: 'continue in the background', 'continue this in the background', 'keep working in the background', 'delegate to a background agent', or the user is going AFK and explicitly wants the work to keep moving. Launches only on the user's explicit request, never self-elected.

0
installs
▌
Audit Permission State · melodic-software bundle
Report the Claude Code permission state actually in effect. Discovers every settings scope (managed policy, user-global, project, local, and the pre-v2.1.211 start-directory copy), merges them into the effective allow/ask/deny set with each rule's source and precedence mechanic named, and classifies which allow rules auto mode drops on entry. Use when: 'what permissions are actually in effect' or 'show me my effective permissions' (including which settings file a rule comes from and what scopes were checked); 'which of my rules survive auto mode' (the entry diff); 'is my managed policy being read'; or before changing a permission rule you cannot locate. An allow rule ignored because of its shape is `audit-permission-grants`. Report-only, never writes any settings file.

0
installs
▌
Curate Language · melodic-software bundle
Actively maintain a consuming project's ubiquitous-language glossary as domain understanding changes: resolve ambiguous or overloaded terms, choose canonical language, record rejected synonyms, sharpen what-it-IS definitions, and route terms to an already-known bounded context. Use when: 'update the domain glossary', 'define this domain term', 'standardize this vocabulary', 'these names conflict', domain modeling resolves vocabulary, or planning resolves domain language worth preserving. Not for passive glossary lookup, general dictionary definitions, or bounded-context discovery.

0
installs
▌
Audit Permission Grants · melodic-software bundle
Audit Claude Code permission GRANTS for portability and auto-mode durability. Scans skill/command/agent frontmatter allowed-tools and settings.json/settings.local.json/user-global permissions.allow for interpreter-wildcard rules dropped in auto mode, hardcoded machine/user paths, and inert plugin self-grants. Use when: 'check permission rules', 'why was my allowed-tools grant ignored', 'audit allow rules', 'is this permission portable', after authoring a code-execution grant, or when a guarded helper is denied despite an allow rule. Report-only.

0
installs
▌
Audit Prompting Postures · melodic-software bundle
Audit locally-owned instruction components (skill bodies, agent definitions, hook instruction text, output styles, CLAUDE.md and rules) for MISSING posture guidance the official prompting guide says their purpose needs: delegation criteria and caps, minimal-scope and anti-test-gaming guardrails, investigate-before-answering and progress-claim grounding, autonomy vs checkpoint posture, destructive-action confirmation, context-budget reassurance, multi-window state guidance, parallel-tool-call steering. The additive complement to audit-instructions (which finds text that is present and wrong; this finds text that is absent and needed). Report-only: proposed additions sourced from a live fetch of the guide, gated to the human, never auto-applied. Use when: 'posture audit', 'audit prompting postures', 'is my skill missing guardrails', 'missing delegation criteria', 'should this component confirm destructive actions', 'align my components with the prompting guide', after authoring a new skill or agent, or as the a

0
installs
▌
Fixtures · melodic-software bundle
Convert a spreadsheet export into the ledger import format, checking the column set and the date parsing before writing anything. Use when: 'import this export', 'convert the ledger file', 'the finance export needs converting'. Not for reconciling balances, which the ledger tool owns.

0
installs
▌
Recheck Against Upstream Deep · melodic-software bundle
Escalate upstream-conformance discipline to a heavy fan-out: dispatch fresh-context subagents doc-by-doc over a whole subsystem, framework, or repo, comparing each surface against its CURRENT official upstream docs, then report an inline divergence ledger. Use when: 'recheck the whole subsystem against upstream', 'audit every surface against the docs', 'deep upstream conformance pass', 'check the entire framework config against upstream', 'we depend on a lot of upstream surfaces and they may have drifted'. For a single inline recheck of the surface in play, use the sibling recheck-against-upstream.

0
installs
▌
Script The Deterministic Work · melodic-software bundle
Re-anchor the discipline that purely deterministic sub-work, counting, diffing, sorting, transforming, matching, arithmetic, gets a script that runs and returns real output, with the model reasoning only afterward over that output; then audit the work in flight for transforms executed by hand. Use when: 'script the deterministic work', 'you should have scripted that', 'don't eyeball that', 'you counted that by hand', 'compute that, don't estimate', 'diff it with a tool', 'stop hand-tallying', 'run it instead of guessing', or at conversation start on count-, diff-, or transform-heavy work. Not for authoring a requested script ('script it' as a work order), and not for a first-turn count/diff/transform work order ('diff these files', 'count the routes', 'convert all of these'). Doing that task with a tool is just doing the task; this corrector fires on drift.

0
installs
▌
Audit Progressive Disclosure · melodic-software bundle
Read-only progressive-disclosure audit for agent-facing instruction markdown. Grades every target against a three-tier load-cost model (always-loaded / invocation-loaded / on-demand) and classifies seven finding shapes in two lanes: split opportunities (oversize vs tier-calibrated Anthropic-prescribed caps, mixed-concerns, tier-mismatch. Procedures, path-local, or sometimes-only content sitting in an always-loaded file) and disclosure-structure defects (blind-pointer lacking a when-to-read clause or read-vs-run intent, orphan-spoke, deep-nesting past one level, missing-toc on long references). Emits Tier 1/2/3 findings with per-shape treatment guidance; read-only, no edits applied. Use when: 'progressive disclosure', 'split this file', 'this file is too long', 'too much context', 'mixed concerns', 'hub and spoke', 'is my CLAUDE.md too big', 'audit context loading', 'what should always be loaded', or before splitting any instruction file, not for prose flavor (/docs-hygiene:compress), in-page noise (/docs-hygi

0
installs
▌
Component Types · melodic-software bundle
Auditing a skill

0
installs
▌
Broken Skill · melodic-software bundle
Generates weekly usage reports.

0
installs
▌
Healthy Skill · melodic-software bundle
Converts contracts to redlined drafts. Use when: 'redline this contract', 'compare contract versions'.

0
installs
▌
Read · melodic-software bundle
Read an X (formerly Twitter) post, note tweet, or X Article as Markdown without an X API key, by routing the URL through third-party converters: xtomd.com for a single post or article, Thread Reader App for an unrolled reply chain. Use when: an x.com or twitter.com status or article URL needs its text read, whether the user pasted it or research turned it up, 'read this X link', 'unroll this thread', 'convert this X article to markdown', or 'WebFetch returned a login wall on x.com'. Skip for non-X URLs (WebFetch suffices) and for private, protected, or deleted posts, which no converter can reach.

0
installs
▌
Scan · melodic-software bundle
Proactively hunt unobserved bugs in resting code: a read-only two-stage scan, recall-biased per-lens hunter subagents, then a separate fresh-context default-refute gate, over a target path/feature/diff or a rotated lane, emitting only verified 5-field findings. Use when: 'find a bug', 'bug hunt', 'scan for bugs', 'hunt for bugs in <X>'. Skip when: reviewing a diff (`review:code-review`); security auditing (`review:security-review`); root-causing an observed failure (`debugging:debug`); doc/config/code/arch claim drift, all dimensions (`codebase-health:audit`); structural tidying (`code-tidying:tidy`); comment markers (`work-items:scan-todos`); coverage gaps (`testing:audit`, `mutation-testing:audit`). Disambiguation: 'scan repo for issues' is the upstream known-issue registry (`claude-ops:known-issues`); 'file a bug' you already observed is `bugs:write`. Bare invocation neither edits nor files; `--track` files verified findings as raw intake (subject to the team's `filing_posture`).

0
installs
▌
Shape · melodic-software bundle
Shape the assistant's output for a reader with ADHD, and anyone who wants action-first, low-friction responses. Lead with the concrete next action, number multi-step work, restate state across turns, cap and rank lists, give concrete time estimates, make wins visible, and cut preamble, recap, and closers. Use when: 'ADHD-friendly', 'action-first', 'give me the structured version', 'lead with what to do', 'cut the preamble', or when the user invokes it to set that output shape for the session. Once invoked, applies to every response for the rest of the session. This is a STANDING posture over future responses; to reshape one dense message already on screen (chunk it one-decision-at-a-time, define its jargon, surface the decisions) without changing the session style, that is the one-shot sibling adhd:clarify. Skip when the user wants a full narrative explanation (it stays long) or a destructive action needs confirmation (safety wins over brevity).

0
installs
▌
Setup · melodic-software bundle
Verify and configure the bugs plugin for this repository. check inspects both surfaces read-only, the rendered output_dir userConfig value, and the tracked .claude/bugs.md lane config across its cascade layers; apply writes or updates that tracked file and nothing else. Use when: 'set up bugs', 'configure bugs', 'bugs setup', 'where do bug reports land', you want --file reports committed alongside code, or '/bugs:scan' needs project lanes and a filing posture. Actions: check (read-only, default) | apply (creates or updates the tracked lane config; output_dir still routes through Claude Code's own configuration prompt).

0
installs
▌
Write · melodic-software bundle
Produce a structured 5-field bug report (title, steps to reproduce, expected vs actual, severity with justification, suggested fix location) from an informal description. Read-only, never modifies code, never opens PRs, never files issues by default. Use when the user names a defect they observed ('there is a bug in <X>', 'expected X got Y', 'I am seeing <error> in <file>') or asks for one written up ('report a bug', 'file a bug', 'write this up as a bug'). Skip when: deep investigation is needed, a fix is already in progress, or the request is a feature request (missing capability) rather than a defect. Emits Markdown to stdout by default; with --file, persists a report file and can hand off to a work-item tracker for filing.

0
installs
▌
Reach · melodic-software bundle
Run a Claude Code agent turn on ANOTHER machine in the fleet, over SSH on the tailnet. Every machine signs into its own Claude account, so the peer tools (`ListAgents`, `SendMessage`) are same-account and never span machines; SSH plus a headless `claude -p` is the path that does. Carries: resolving a target host from `~/.config/fleet/FLEET.md`, the one-shot and multi-turn headless recipes for both SSH ports, the Windows-side relay that reaches a target's own native-Windows sessions, the permission and safety posture, a verification step, and the gotchas. Use when: 'run this on melo-desk-001', 'ask the desktop to', 'spawn claude on the other machine', 'cross-machine', 'remote agent', 'reach the fleet', 'run claude over ssh'. Not for: messaging a session on THIS machine (the built-in peer tools own that), a detached local background session (session-flow:continue-in-background), or repository fleets (repo-fleet-hygiene, where fleet means repos).

0
installs
▌
Clarify · melodic-software bundle
Faithfully clarify a dense, decision-heavy message so you can act on it. Chunk it into one-decision-at-a-time, define the session's own jargon, and surface exactly what you must decide, with operative terms quoted verbatim and no loss of precision. Decision-dense content gets an HTML decision table with numbered rows. Use when: 'make this clear', 'clarify this', 'help me digest this', 'break this down', 'I can't parse this', 'what am I actually deciding here', 'this is a wall of text'. Empty argument targets the previous assistant response. This changes STRUCTURE, not altitude and not medium. A lossy plain-language drop is education:explain (if installed) instead; a picture explainer (a diagram, ELI5) is education:eli5 (if installed). Sibling to adhd:shape, a standing session-wide posture; this is a one-shot reshape of one artifact.

0
installs
▌
Design · melodic-software bundle
Design an evaluation suite for an LLM-based application or a Claude Code skill: interview for measurable success criteria, pick a grading method per criterion, and scaffold a criteria doc plus eval cases into the consumer repo. Use when: 'design evals', 'create an eval suite', 'scaffold evals', 'write evals for my skill', 'define success criteria for this app', 'set up LLM testing', 'build a test set for my prompt' — not for eval-design theory questions (use /evals:methodology), not for statically validating an existing evals.json (use /skill-quality:check validate-evals when installed), and it does not execute evals.

0
installs
▌
Audit · melodic-software bundle
Read-only audit of the GitHub settings/admin plane through the user's own gh CLI: current-state review, drift vs declared conventions, standards conformance, and cost signals over any coverage area (rulesets, billing, security model, Actions policy, webhooks, PATs, apps, and more). Use when: 'audit my GitHub org', 'check billing', 'review repo settings', 'GitHub drift', 'are my rulesets consistent', 'what does our Actions policy allow', 'review org security posture'. NOT for forward-looking design ('how should I configure X', 'walk me through setting up Y'). That is the advise skill. Bare invocation performs zero mutations. Findings only; grounded in live gh state and freshly fetched official GitHub docs, never recall.

0
installs
▌
Prd · melodic-software bundle
Produce a Product Requirements Document that locks product intent. Problem, users, success metrics. Before any engineering plan, with tiers (one-pager / consumer-feature / b2b-internal), a synthesize path, and a review mode. Use when: 'write a PRD', 'spec out a feature', 'product brief', 'product requirements doc', 'define the requirements', 'what are we actually building', 'acceptance criteria', 'how will we know it worked', or any user-facing business-driven change needing written alignment; skip for refactors, infra, bug fixes, and engineering-internal work (route to /planning:interview or /planning:plan).

0
installs
▌
Plan · melodic-software bundle
Analyze code changes and produce a test plan. Classify changed files by required test type, identify coverage gaps, and prioritize by regression risk. Use when: 'test plan', 'what needs testing', 'where are the coverage gaps', 'what should I test here', after /implementation:implement completes, or for PR-prep coverage verification; for writing the tests use /testing:write, for running them /toolchain:check.

0
installs
▌
Advise · melodic-software bundle
Forward-looking guidance and hand-holding over the GitHub settings/admin plane: how to design, configure, and set up any coverage area (rulesets, billing budgets, security model, Actions policy, webhooks, PATs, apps, and more), grounded in live gh state and freshly fetched official GitHub docs. Use when: 'how should I configure X', 'help me set up Y', 'walk me through Z', 'what's the recommended way to', 'design our org's Actions policy'. NOT for current-state review or drift ('what is', 'what drifted', 'are these consistent'). That is the audit skill. Bare invocation performs zero mutations. Guidance and proposals only, never recall presented as grounded.

0
installs
▌
Fanout · melodic-software bundle
Fan out review across many finding-producing surfaces at once, this plugin's reviewer agents, the project's own per-concern review criteria docs, and orchestrator review plugins, then normalize the heterogeneous outputs into one severity-ranked, deduplicated report persisted to disk. Use when asked for a breadth review of a change (every reviewer at once, every angle or side, one combined ranked report), or to 'fix the review findings' (the fix action applies the merged set of persisted findings).

0
installs
▌
Sync · melodic-software bundle
Maintainer-only drift check for the grounding skill's vendored upstream content. Never model-invocable — only a human explicitly running /dometrain:sync. Use when: 'check dometrain sync drift', 'has the dometrain-grounding skill changed upstream', before a version bump, or at a scheduled fleet-conformance recheck.

0
installs
▌
Eli5 · melodic-software bundle
Dead-simple VISUAL explainer. Produces a visual HTML explainer that assumes zero prior knowledge: one idea per diagram, minimal text. Works on a codebase object (a module, a tradeoff, an incident) or a general concept, and grounds in the real artifact before drawing anything. Use when: 'ELI5', 'explain like I'm five', 'picture explainer', 'show me a diagram of this'. Delegates to the community `eli5` skill when that plugin is installed and performs the behavior inline when it is not. This produces a PICTURE. When the ask is a prose drop to plain words at a lower altitude, that is education:explain instead; when it is to restructure a dense message without losing precision, that is adhd:clarify (if installed).

0
installs
▌
Principles · melodic-software bundle
Answers test design questions from authoritative TDD sources (Beck, Khorikov), producing WHY reasoning to improve test design decisions. Use when: 'should I mock this', 'four pillars of a good test', 'red green refactor', 'classical vs london school', 'test doubles', 'testing anti-patterns', 'resistance to refactoring', 'code coverage', 'observable behavior', 'humble object', 'integration test', 'test pyramid', 'output vs state vs communication test' — not for HOW to run tests in your project (use your project's own test tooling and workflow for that).

0
installs
▌
Lint · melodic-software bundle
Run polyglot linters and format checks across all affected ecosystems without a full build cycle. Auto-detects ecosystems from changed files, honors each tool's config-file opt-in, and supports --fix (format-only) plus a gated --code-fix mode for semantic lint autofixes. Use when: 'lint this', 'run the linter', 'format check', 'fix the formatting', 'is this formatted right', 'run prettier/ruff/eslint', or for quick lint/format feedback during development; for build+test use /toolchain:check, for full outcome verification use /verification:confirm.

0
installs
▌
Lookup · melodic-software bundle
Look up current library documentation, API references, and code examples via Context7 (ctx7 CLI or the Context7 MCP server, same backend). Use when: 'look up the docs for X', 'how do I migrate to X v2', or whenever a question names a library, framework, SDK, CLI tool, or cloud service, including API syntax, configuration, setup, and version-migration questions. Actions: lookup <library> <query> (default) | update (CLI upgrade + upstream drift check). For CLI/MCP setup, auth, and Windows gotchas, run /context7:setup.

0
installs
▌
Reduce · melodic-software bundle
Iteratively reduce coupling at any altitude — documents, code modules, applications, or repositories: scan for change-transmitting dependencies typed against a coupling model, verify each finding, apply a budgeted batch of safe behavior-preserving reductions, and ledger structural candidates for design routing so repeated runs continue where the last stopped. Use when: 'reduce coupling', 'decouple', 'loosen coupling', 'too tightly coupled', 'high cohesion low coupling', 'break this dependency', 'dependency injection pass', 'externalize this config', 'connascence', 'coupling scan', 'these files always change together', 'stop copying between repos'. Skip when: reviewing a diff before merge (review tools), deep-designing one already-chosen boundary (/architecture:improve), general structural tidyings with no coupling focus (/code-tidying:tidy), or a docs noise/dedup pass with no cross-artifact coupling angle (docs-hygiene).

0
installs
▌
Debug · melodic-software bundle
Debug and diagnose broken behavior via a disciplined six-phase loop: build feedback loop → reproduce → hypothesise → instrument → fix + regression test → cleanup. Use when: the user reports an OBSERVED FAILURE with no pre-existing reproduction, in any of three shapes: wrong or broken behavior ('diagnose this', 'debug this', 'why is X broken', 'X is throwing'), a performance regression ('this is slow'), or an intermittent or flaky failure, whether seen in the UI, logs, production, or a screenshot. Phase 1 builds the loop; no phase proceeds without a fast, deterministic signal. Skip when: the symptom is already a failing test with no reproduction gap. Cycle it directly. Outputs: reproduction loop, root-cause hypothesis, regression test or documented seam gap, cleaned fix, post-mortem finding.

0
installs
▌
Teach · melodic-software bundle
Interactive multi-session learning coach for general topics or repo-grounded concepts; also a single-session domain primer (primer action). Use when: 'teach me', 'study session', 'help me learn', 'onboard me to', 'learn this codebase'. Coaches through the Knowledge-Skills-Wisdom progression with persistent per-topic learning state. Not for one-off inline questions (answer directly).

0
installs
▌
Boris · melodic-software bundle
Boris Cherny Claude Code workflow tips (howborisusesclaudecode.com). 127 tips across 115 sections on parallel sessions, planning, CLAUDE.md, skills, hooks, permissions, autonomy, orchestration, loops, and context engineering. Use when: 'how does Boris use Claude Code', 'Claude Code workflow tips', 'optimize my CLAUDE.md', 'improve my Claude Code setup', 'parallel Claude sessions', 'hook ideas', or optimizing Claude Code setup, workflows, CLAUDE.md, skills, hooks, or parallel sessions.

0
installs
▌
Use · melodic-software bundle
Reach Anthropic's first-party playground capability in one step: verify the upstream playground plugin is installed, invoke its skill for interactive single-file HTML explorers (controls beside a live preview, output is a prompt you paste back), or emit the exact install commands when it is absent. Use when: 'make me a playground', 'interactive explorer for X', 'install the playground plugin', 'critique this document with approve/reject controls', or any ask to tune a parameter space visually and see the result (sliders, balancing, exploring parameters). Also carries field-tested prompt recipes, delivery guidance for cloud and remote sessions where a local browser cannot open, and known-limitation notes. This wrapper generates nothing itself; the upstream skill owns generation. Not for choosing a visual form for conversation content (a visualization capability owns that) or for throwaway variations of your own project's UI (a prototyping capability owns that).

0
installs
▌
Run E2e · melodic-software bundle
End-to-end live app verification. Check prerequisites, start the app, drive UI/API flows, and capture evidence (screenshots, responses, logs); includes a non-UI smoke-test playbook for libraries, MCP servers, hooks, and scripts. Use when: the user wants the running app verified end to end (e2e, smoke test, 'does it actually work'), the UI clicked through, or UI/API changes need runtime verification; for comprehensive build+test+lint use /verification:confirm.

0
installs
▌
Check · melodic-software bundle
Run build, test, and lint verification for changed files, auto-detecting affected ecosystems (.NET, Python, TypeScript, Go, Bash, PowerShell, Markdown) from git status, with the consuming project's own documented commands overriding portable defaults. Use when: 'does it compile', 'run tests', 'build it', 'run the tests', 'does this still build', 'check it', or after any code edit; for lint-only use /toolchain:lint, for full outcome verification use /verification:confirm.

0
installs
▌
Generate · melodic-software bundle
Generate an interactive bash wizard script that walks a human through the steps only they can perform. The agent authors the script and never runs it; the human runs it in their own terminal. Use when: 'provisioning infrastructure', 'provisioning credentials', 'set up CI secrets', 'walk me through the dashboard', 'guided setup script', 'one-off migration', 'cutover', or a manual dashboard, credential, or third-party-console step is what blocks progress. Don't invoke this for steps the agent can perform itself.

0
installs
▌
Ship · melodic-software bundle
Macro-journey router over one spec container: say where the multi-session effort stands, which execution shape is in effect (per-item PRs vs integration branch → single PR) with that mode's discipline, and route the next step to the machinery that owns it. Use when the user says 'ship' about a spec or container, asks where a spec container stands or what is next in it, wants to drive or resume the multi-session effort, or wants to close out the container. Thin by design, it reads the container, its sub-item rollup, and its scoped frontier through the tracker seam, states the active execution shape's discipline, and ROUTES to /work-items:work (next item), /work-items:decompose (re-slice, container close ritual), planning/review close-out machinery, and session-flow, never duplicating their mechanics. Sibling skills: /work-items:decompose (publishes containers + records the shape), /work-items:work (executes one item), /work-items:track (backlog CRUD), /work-items:triage (raw intake).

0
installs
▌
Work · melodic-software bundle
Auto-select one development work item from the tracker frontier and execute it end-to-end through the project's development workflow. Use when the user asks to pick, grab, or work the next item, ticket, or issue from the backlog, or asks what to work on next. Selects exactly ONE item by priority tiers (due recurring, guardrails, highest-impact, then not-yet-due recurring), claims it race-safe via the seam (assignee + lease), then runs the full workflow. Sibling skills: /work-items:track (backlog CRUD, add, start, done, list, stats, search, due, recheck, audit), /work-items:triage (raw intake), /work-items:decompose (plan → tickets), /work-items:scan-todos (TODO sweep).

0
installs
▌
Lanes · melodic-software bundle
Start, restart, stop, and check loop lanes as named background Claude Code sessions seeded from canonical prompt files, the scripted replacement for the manual morning refresh (cancel loop, clear, re-paste the canonical prompt) across N lanes on a machine. `start`/`restart` first pull the repo and refresh the plugin marketplace, then launch each configured lane with its per-lane model/effort. `consume-restarts` reads each configured lane's telemetry `restart_request` and relaunches the stopped lanes that asked, the scheduled headless reader. Use when: 'launch my lanes', 'restart the loop lanes', 'start the work lanes', 'morning lane refresh', 'stop a lane', 'which lanes are running', 'lane status', 'consume restart requests', 'lane restart consumer', 'relaunch the lanes that asked'. Mutating and operator-initiated; never touches a session whose name is not a configured lane.

0
installs
▌
Update · melodic-software bundle
Maintainer-facing drift-check and upstream sync for the firecrawl plugin's wrapper skill. Tracks the firecrawl-cli npm release and the upstream SKILL.md source. Run only from a working-tree checkout. Actions: --check (read-only drift report) and a bare invocation (the full gated update: npm upgrade plus advisory skill-content integration). Not for consumers. Consumers update via /plugin marketplace update.

0
installs
▌
Find · melodic-software bundle
Evidence-first, cross-dimension improvement finder: scans code/architecture, performance, product-level behavior, config/automation outside the codebase (GitHub labels, Actions), and Claude Code operational setup, then returns a ranked candidate list. Every candidate cites its evidence (telemetry, CI failure rates, churn hotspots, or, weakest, model judgment) and carries an S/M/L size with a value-to-effort rationale; an unmeasured target makes 'instrument this' the top candidate. Interactive by default; caller-declared unattended mode persists the report and files top candidates as work items. Never edits anything itself; execution routes through the discovery/planning/implementation pipeline. Use when: 'what should we improve', 'find improvements', 'improvement sweep', 'improve <X>', 'highest-impact improvement', 'tech debt sweep', 'where is the highest-value work', 'what would move the needle', 'run an improvement scan'. Skip when: single-lens architecture deepening (`architecture:improve`), applying small

0
installs
▌
Goal · melodic-software bundle
Construct a performance goal the data can actually settle: the metric and the exact command that produces it, a REALISTIC target and an IDEAL target held separately, and the irreducible FLOOR computed BEFORE any work. Surfaces 'your target is below the measured floor, no code change can reach it' up front and makes the human decide, instead of silently failing the goal at the end. Human-gated always: this is the one phase that may never run unattended. Use when: setting or sanity-checking a performance target, judging whether a target is reachable at all, or defining done for an optimization: 'set a performance target', 'is this target achievable', 'define done for this optimization', 'what is the floor here'. Runs after /performance:target and before /performance:snapshot. Skip when the work is exploratory with no claim to defend, or when the target is a correctness fix that happens to also be faster.

0
installs
▌
Wayfind · melodic-software bundle
Chart a too-big, still-foggy effort as a shared decision map on the work-item tracker, then work its frontier one decision at a time, routing each resolved decision to the right skill until the map graduates to a Brief / PRD / PLAN. Use when a task is too big to hold at once AND parts are still too fuzzy to phrase as sharp tickets ('this is a huge foggy effort', 'I don't even know the questions yet', 'map this out', 'chart this program', 'plan-the-plan'); skip when the work is already a set of sharp, answerable tickets (use /planning:interview or /work-items) or small enough to just do.

0
installs
▌
Suno · melodic-software bundle
Generate and refine Suno AI music prompts (v5.5). Style prompts, tagged lyrics, genre templates, troubleshooting, tips, features, and genre research via an action router. Use when: 'suno prompt', 'write suno lyrics', 'style prompt for suno', 'BPM prompting', 'vocal tags', 'fix garbled lyrics', 'voice cloning suno', 'suno genre', 'suno studio', or any Suno prompt-craft request.

0
installs
▌
Diagnose · melodic-software bundle
Diagnose and fix failing tests. Failure classification, root-cause analysis (never retry blindly), then the reproduce → isolate → fix → retest → regression loop. Use when: 'why does this fail', 'this test is failing', 'fix the failing tests', 'why is this test flaky', visible test failures, stack traces, or flaky tests; for authoring new tests use /testing:write, for running the suite /toolchain:check.

0
installs
▌
Track · melodic-software bundle
Track development work items through the bound tracker (work-item-tracker seam), the backlog-CRUD multi-verb skill. Actions: stats, list, add, start, done, due, recheck, search, audit (default: stats dashboard). Use when the user wants to add, claim (start), or close a work item, ticket, or issue; list, search, or see a dashboard of open items; check or recheck what is due on the recurring schedule; or audit stale claims and label hygiene. Not for new bug reports, use /bugs:write first (read-only report), then chain to /work-items:track add via --context if filing is needed. Sibling skills own the other verbs: /work-items:work (auto-select + execute one), /work-items:triage (raw intake), /work-items:decompose (plan → tickets), /work-items:scan-todos (TODO/FIXME sweep).

0
installs
▌
Tidy · melodic-software bundle
Proactively hunt a rotated lane of the codebase for safe structural improvements (Beck's 15 tidyings + a Fowler subset + prose tidyings), apply scope-budgeted edits, and ship one tight structure-only PR per invocation. Use when: 'tidy', 'tidy up', 'boy scout', 'polish', 'small refactors', 'improve gradually', 'clean up in passing', 'tidying day', 'tidy lane', 'run tidy'. Actions: [<lane>] targeted lane run; [dry-run [<lane>]] plan-only, no edits; [help] print the lane catalog. Skip when: /simplify refines the current diff; batch-simplify processes a diff window; issue-tracker work drains already-filed items. Tidy proactively hunts unfiled drift across a glob-scoped lane.

0
installs
▌
Explore · melodic-software bundle
Explore the local codebase before making changes. Read code, trace dependencies, scan git history, discover tests, and audit build and tool configuration, persisting an EXPLORE.md index plus sidecars. Dispatches a fresh-context subagent by default so the file reads stay out of the main conversation, with a documented inline escape hatch. Use when: 'explore the codebase', 'what exists for X' investigation, 'how does this work', 'where is X implemented', 'trace the dependencies', 'what tests cover this', or as step 1 before any code change. Skip when: the question is why a thing was built the way it was rather than what it is or how it works. Reconstructing the reasoning behind a past decision from review discussion, tickets, and design documents is '/discovery:trace-intent'; this skill's git mode reports what changed and by whom, not the intent behind it.

0
installs
▌
Explain · melodic-software bundle
One-shot plain-language explainer. Drops any concept, code, error, architecture, or the previous assistant response to genuinely plain words (concrete analogy, zero jargon), then layers altitude up only on request (high-school, then peer level). Use when: 'I don't understand this', 'I don't get it', 'what does this actually do', 'what does this mean', 'explain simply', 'rephrase that'. Empty argument targets the previous assistant response (anaphora), so 'I don't get it' needs no topic named. This changes ALTITUDE, in PROSE. Trades precision for plain words; when the ask is instead to reorganize a dense message faithfully without losing precision, that is a STRUCTURE change, adhd:clarify (if installed), not an altitude drop. When the ask is for a picture (a diagram, a visual explainer, ELI5), that is a MEDIUM change, education:eli5. Sibling to education:teach. Hand off there for multi-session coaching; this is a single-shot check, not ongoing tutoring.

0
installs
▌
Quiz Me · melodic-software bundle
Post-work comprehension check: after a change is complete, generate a self-contained HTML report of what was done (context, intuition, decisions) with a quiz at the bottom that you answer. Verifying the HUMAN absorbed the work, not the artifact. Non-gating by default; the quiz_policy userConfig tunes offer cadence. Also recalls prior work from the retained report library. Use when: 'quiz me', 'quiz me on this change', 'do I understand this change', 'comprehension check', 'a quiz at the bottom that I must pass', 'I want to make sure I understand everything that happened', 'what did we do on <ticket>'. Sibling to education:teach (multi-session coach) and education:explain (one-shot explainer); this verifies comprehension of COMPLETED WORK. Not artifact verification. That is verification:confirm (if installed).

0
installs
▌
Methodology · melodic-software bundle
Answers LLM-evaluation design questions from Anthropic's official evaluation guidance — success criteria, eval-suite design, and grading methods for LLM-based applications and Claude Code skills. Use when: 'define success criteria', 'how do I eval this', 'LLM eval', 'measure prompt quality', 'LLM judge', 'model-graded eval', 'golden answer', 'grading rubric', 'eval grading method', 'exact match vs LLM-graded', 'how many eval cases', 'is my success criteria measurable' — knowledge (WHY/WHAT of eval design), not a runner; for scaffolding a suite use /evals:design, and no marketplace command executes model-graded evals.

0
installs
▌
Fable 5 · melodic-software bundle
Claude Fable 5's operating doctrine — calibration, reasoning moves, problem framing, planning, debugging, execution, orchestration, verification, communication, recovery, context economy, and trust boundaries — authored by Fable 5 as standing instructions that arm the current session immediately, with chapters loading on demand at their trigger moments. Use when: 'fable playbook', 'fable-5-playbook', 'operate like Fable', 'load the playbook', at the start of any substantive engineering session, or proactively before any multi-step task where judgment quality matters. Also hosts the per-model adaptation chapters (Fable 5.1, Opus 5, Opus 4.8, Sonnet 5): use when running on any model other than Fable 5, or when adapting a repo's prompts or instructions to one of them: 'fable 5.1 adaptation', 'opus 5 adaptation', 'model delta', 'model adaptation chapter'.

0
installs
▌
Rhyme · melodic-software bundle
Find and stress-test rhymes with Pat Pattison's discipline. Identity check, stability-tier walk, vowel triangle, song-world vocabulary, mosaic/multi-word rhyme, cliche scan. Internal generation is primary (8-15 labeled candidates, never a single winner); the Datamuse API supplements for breadth/syllables/semantic field. Use when: 'rhyme this', 'find rhymes for X', 'why does this rhyme feel weak', 'mosaic rhyme', 'rhyme this proper noun', 'rhyme like Eminem', 'syllable count of X', 'rhyme worksheet'. For meter/scansion use /songwriting:meter-prosody; for line-volume dumps use /songwriting:co-write line-brainstorm.

0
installs
▌
Triage · melodic-software bundle
Evaluate raw intake, any untriaged item carrying the raw marker, whoever authored it (external bug reports, incoming feature requests, unsolicited PRs, and team-authored self-observation/dogfood issues), through a small state machine: raw → verified → briefed → autonomous-eligible, with side exits to needs-info, human-gated, and close. A PR is an item with attached code and enters the same intake as an issue. Use when: 'triage', 'what needs triage', 'triage this issue', 'triage this PR', 'evaluate this bug report', 'is this bug real', 'should we merge this unsolicited PR', 'attention view', 'what intake needs attention'. No number = attention view (untriaged intake). Sibling skills: /work-items:track (backlog CRUD), /work-items:work (auto-select + execute), /work-items:decompose (plan → tickets), /work-items:scan-todos (TODO sweep).

0
installs
▌
Plugins · melodic-software bundle
Bring a machine's plugin fleet current on demand: marketplace refresh, update the plugins that actually load (including in-repo project/local-scope installs), install new catalog plugins per policy, detect scope divergence, and surface (never silently fix) drift, with a terse actionable report; refuses to downgrade by default. Actions: sync (default, mutating), audit (read-only dry run), converge (explicit scope consolidation). Use when: 'sync plugins', 'update my plugins', 'are my plugins current', 'check plugin drift', 'converge plugin scopes', or before relying on a plugin that might be stale.

0
installs
▌
Research · melodic-software bundle
Multi-source external research in chained phases, corpus enumeration, broad, targeted + falsification, preferred sources, with per-claim source tiers, recency checks, a coverage ledger, and a binary outcome gate before presenting. Dispatches a fresh-context subagent by default so the research transcript stays out of the main conversation, with a documented inline escape hatch. Use when: 'research this', 'verify a technical claim', 'evaluate libraries or approaches', 'compare X vs Y', 'is this still current', 'find the authoritative source', 'what do the official docs say', or grounding any decision in current authoritative sources instead of training data. This is the right skill for a single topic, including a small one. For a multi-topic or workflow-driven pass that fans one question across several dispatches, use research-deep, which layers tiered execution on this same discipline.

0
installs
▌
Clean · melodic-software bundle
Audit an arbitrary directory tree for orphaned, temporary, stale-lock, failed-write, partial-download, and empty leftover artifacts; classify evidence into confidence tiers; and optionally remove exact validated paths after explicit per-tier approval. Read-only by default and manual-only. Use when: 'audit this directory', 'find orphaned files', 'what junk can I clean up', 'reclaim disk space', 'find temp or lock leftovers', 'clean up my home directory'. Skip when: repository cache/build cleanup belongs to repo-hygiene, a product has its own prune/GC command, or the target is an OS-managed root.

0
installs
▌
Target · melodic-software bundle
Identify and rank optimization targets by EVIDENCE QUALITY rather than by suspicion, so an unmeasured system yields 'instrument this first' instead of a guess. Accepts targets from the current session's own pain, a named path or component, a telemetry store, or an open-ended 'what is slow here'. Ranks each candidate by how well its cost is actually attributed, names the drift-immune counter that would settle it, and refuses to rank an unmeasured candidate above a measured one however plausible its mechanism. Use when: choosing what to optimize, locating a bottleneck, or judging whether a suspected target is worth the work: 'what should we optimize', 'find the bottleneck', 'this feels slow', 'is X worth optimizing'. Entry point for the measurement-first optimization workflow; hands off to /performance:goal. Skip when the target is already chosen and measured (go straight to /performance:goal), or when a specific failure needs root-causing rather than a candidate ranking (that is debugging).

0
installs
▌
Verify · melodic-software bundle
Re-derive a performance result in a FRESH CONTEXT that does not inherit the implementer's numbers, then report the target as met or not met without rounding a miss into a win. Dispatches a verifier told to distrust the reported figures and reproduce them from the trees, checks that the change did not alter behavior via a differential covering every MODE the subject runs in, and states any behavior change separately from and above the performance claim. Use when: independently re-deriving a measured performance claim before it is stated, or writing up the result: 'verify this speedup', 'is this result real', 'independent verification', 'write up the performance result'. Final phase; runs after /performance:snapshot post. Skip when no baseline exists (there is nothing to verify), or when reviewing a diff for general quality rather than checking a measured claim.

0
installs
▌
Interview · melodic-software bundle
Interview relentlessly to reach shared understanding on a plan, decision, or idea. Questions arrive in frontier rounds: every question whose prerequisites are settled asked together as one numbered set, each with a recommendation. Routes by context: an engineering task locks a task contract (goal, constraints, acceptance criteria, named assumptions) into a PLAN.md Brief that feeds the planning pipeline; a general decision drives to a shared understanding and stops. Synthesizes directly when intent is clear, runs the rounds loop when gaps remain, or interviews relentlessly on request. Use when: 'interview me', 'lock the brief', 'spec this task', 'grill me', 'this is underspecified', 'ask me questions first', 'what do you need to know', 'acceptance criteria', 'how will we know this is done', or proactively before behavior-changing work when intent is ambiguous or underspecified; skip for mechanical work (typo/lint/whitespace/rename) and casual conversation.

0
installs
▌
Code Review · melodic-software bundle
CI code-review lane for a GitHub pull request. High-signal correctness and maintainability findings only, scoped out of security when a security lane exists. Use when: 'CI code review', 'claude-review lane', '/review:code-review', or a reusable workflow invokes the org code-review plugin command.

0
installs
▌
Retro · melodic-software bundle
Run a structured session retrospective: extract transcript metrics, assess quality across five dimensions, check feedback-memory regressions, and codify learnings durably. Use when: 'retro', 'retrospective', 'what did we learn', 'how did I do', 'codify learnings', 'show trends', or at end of session; modes: session (default), codify, trends, quick.

0
installs

270 published skills · page 3 of 3