Abhillashjadhav
UserInstallable Claude Code plugins for AI product evaluation, model routing, guarded loops, and MCP migration decisions.
Categories
Indexed Skills (58)
concise-rewriter
Use this skill when a user wants to compress verbose model output, shorten a draft, reduce token usage, or improve the signal-to-noise ratio of any text. Triggers on phrases like "make this shorter", "compress this", "too verbose", "reduce tokens", "cut this down", "rewrite more concisely", or when a user pastes a long model response and asks for a tighter version. Rewrites the input at the same information density, shorter — then reports the exact before/after token count and percentage reduction. Not a summary. A rewrite. Every piece of meaning is preserved.
context-auditor
Use this skill when a user wants to audit a CLAUDE.md, system prompt, agent context file, or any assembled context before running it in production. Triggers on phrases like "audit my context", "check my CLAUDE.md", "review my system prompt", "why is my agent behaving badly", "context issues", or when a user pastes a context file and wants it reviewed. Scans for the four known context failure modes — poisoning, distraction, confusion, and clash — and returns a severity-rated diagnostic. This is the pre-flight check for agent reliability that Anthropic does not ship a tool for.
eval-rubric-generator
Use this skill when a product spec, feature requirement, PRD, or user story needs to be converted into a concrete evaluation rubric. Triggers on phrases like "write an eval for this", "create a rubric", "how do I test this AI feature", "define good output", "what should I measure", or when a user pastes a spec and asks what success looks like. Produces a binary pass/fail checklist — not vague metrics, not suggestions — a rubric you can run against model outputs today. This is the skill AI PMs need before anything ships to production.
token-cost-estimator
Use this skill before running any prompt in production or sharing a workflow with stakeholders. Triggers on phrases like "how much will this cost", "compare model costs", "which model should I use", "estimate tokens", "pre-flight check", or when a user pastes a prompt and asks about inference economics. Takes a prompt and a list of candidate models, then returns a projected cost and latency comparison across all models before a single token runs. Essential for any AI PM who owns inference budgets.
ai-feature-go-no-go
Strategy-stage skill: turns an AI-feature idea plus context into a build/kill decision that names the single criterion it turns on. Use when the user asks for a go/no-go, build-or-kill, or ship-worthiness call on an AI or LLM-powered feature — 'should we build AI auto-replies', 'build or kill: LLM search', 'make the call on this AI feature' — or when /pm routes such a request here. Do NOT use for non-AI feature prioritization, for mapping assumptions without deciding (assumption-mapper), for model/vendor selection, or for launch-timing decisions.
announcement-drafter
Launch-stage skill: turns a shipped spec into an internal/external announcement pair with zero capability claims beyond what actually shipped — every claim mapped to its spec line. Use when a launch needs its announcements — 'draft the launch announcement', 'internal and external announcement for the release', 'changelog + customer email', 'blog post for the feature we shipped' — or when /pm routes such a request here. Do NOT use for internal status updates (stakeholder-update), GTM one-pagers (gtm-brief), announce-now-or-wait timing decisions, or general marketing-site copy.
assumption-mapper
Discovery-stage skill: breaks a product idea into its load-bearing assumptions, ranked riskiest-first, each tagged testable/untestable with a proposed test. Use when the user pitches an idea and asks what it depends on — 'map the assumptions', 'what are we betting on', 'what could kill this', 'what needs to be true', 'riskiest assumption first' — or when /pm routes such a request here. Do NOT use to write the PRD or spec (Build stage), to size the market (opportunity-sizer's job), for knowledge questions about assumption-testing methods, or for analyzing non-product documents.
build-buy-partner
Strategy-stage skill: turns a needed capability into a build/buy/partner recommendation — all three options scored on the same axes before any verdict. Use when the user must decide how to acquire a capability — 'build or buy X', 'build vs buy vs partner for Y', 'should we build our own Z or use a vendor' — or when /pm routes such a request here. Do NOT use for vendor selection after a buy decision is made, for AI-feature ship decisions (ai-feature-go-no-go), for contract negotiation, or for definitions of the framework.
builder-validator
Build-stage skill: freeze requirements into binary criteria, generate the artifact, then self-audit against the frozen criteria verbatim before delivery. Use when the user asks for an artifact WITH requirements attached — 'draft X and check it against these requirements', 'build Y to this spec', 'generate and self-QA before showing me' — or when /pm routes a spec-bearing generation request here. Do NOT use when no requirements exist to freeze, for reviewing work the user wrote themselves, for building eval harnesses from specs (prd-to-eval), or for knowledge questions about QA.
competitor-teardown
Discovery-stage skill: turns material about a competitor's product — pricing pages, docs, changelogs, screenshots, customer reports — into a structured teardown where every claim is marked observed or inferred. Use when the user names a competitor product and asks for a teardown, competitive analysis, or comparison — 'tear down X', 'how does our Y compare to theirs', 'what is X doing with their pricing' — or when /pm routes such a request here. Do NOT use to write positioning or battlecards (Strategy stage), to scrape or collect the competitor data itself, for company-culture questions, or when no competitor material or product is identified — with nothing to observe it asks for material rather than inventing findings.
context-auditor
Use this skill when a user wants to audit a CLAUDE.md, system prompt, agent context file, or any assembled context before running it in production. Triggers on phrases like "audit my context", "check my CLAUDE.md", "review my system prompt", "why is my agent behaving badly", "context issues", or when a user pastes a context file and wants it reviewed. Scans for the four known context failure modes — poisoning, distraction, confusion, and clash — and returns a severity-rated diagnostic. This is the pre-flight check for agent reliability that Anthropic does not ship a tool for. Do NOT use to author or rewrite context files; it only diagnoses supplied context.
drift-monitor-designer
Iterate-stage skill: designs production drift monitoring for a shipped AI feature — every monitored signal carrying a threshold and a named response action. Use when a live feature needs watching — 'design drift monitoring for the summarizer', 'how do we know when it degrades in production', 'what do we watch now that it shipped' — or when /pm routes such a request here. Do NOT use for per-request guardrails (guardrail-designer), for pre-ship change gating (regression-gatekeeper), for building the dashboards themselves, or for drift definitions.
eval-engine
Iterate-stage skill: turns a spec into the complete runnable verification layer — binary gates, anchored rubric, paste-ready judge prompt, and harness instructions — in one pass. Use when a feature needs its full eval built — 'create an eval for this spec', 'build the verification layer', 'spec to eval harness', 'turn this PRD into something we can run outputs through' — or when /pm routes such a request here. Do NOT use for the gates+rubric design artifact alone (prd-to-eval), for judge prompts over existing criteria (llm-as-judge-designer), for executing an eval over outputs, or for eval definitions.
eval-vs-abtest-router
Iterate-stage skill: routes a product question to offline eval or A/B test — by first classifying it as output-quality (a property of the artifact, judgeable against criteria) or user-behavior (a property of humans, observable only in the field). Use when the measurement tool is in question — 'eval this or A/B test it?', 'how do we know the new prompt is better', 'is an A/B test the right tool here', 'how do we measure if it worked' — or when /pm routes such a request here. Do NOT use to build the eval (eval-engine), to design the experiment itself, for build/kill decisions (ai-feature-go-no-go), or for eval-vs-experiment definitions.
failure-to-eval-capture
Iterate-stage skill: converts a production failure into a scrubbed, permanent eval case — PII removed with the failure's trigger structure demonstrably preserved, wired into regression testing. Use when a bad output escaped to production — 'capture this failure as an eval case', 'turn this incident into a permanent regression test', 'encode this so it never ships again' — or when /pm routes such a request here. Do NOT use for batch curation of reviewed outputs (golden-dataset-builder), for root-causing why the model failed, for PII scrubbing with no eval encoding, or for regression-testing definitions.
feedback-pattern-miner
Discovery-stage skill: turns a raw feedback dump — support tickets, app-store reviews, NPS verbatims, survey answers — into ranked themes whose counts reconcile exactly to the input total. Use when the user provides a list of discrete feedback items and asks what the patterns, top complaints, or priorities are — 'rank these tickets by theme', 'what are people complaining about most', 'mine this review export' — or when /pm routes such a request here. Do NOT use for interview transcripts (interview-synthesizer's job), for replying to a single feedback item, or for process questions about how to collect feedback.
golden-dataset-builder
Iterate-stage skill: curates real outputs plus human judgments into golden eval cases — every case carrying the human verdict and the human's reason, no unlabeled cases, ever. Use when reviewed outputs need structuring into a reusable test set — 'build a golden dataset from these outputs', 'turn these human-graded examples into golden cases', 'we need a regression set, here are outputs and verdicts' — or when /pm routes such a request here. Do NOT use to grade the outputs (human judgment is input), to capture a single production failure (failure-to-eval-capture), to generate synthetic cases, or for golden-dataset definitions.
gtm-brief
Launch-stage skill: turns a feature plus its evidence into a GTM one-pager where every audience claim is tied to a stated source or labeled assumption. Use when a launch needs its go-to-market summarized on one page — 'draft the GTM one-pager', 'GTM brief for the launch', 'who are we selling this to and how', 'GTM summary for sales kickoff' — or when /pm routes such a request here. Do NOT use for full GTM strategy authoring, launch checklists (launch-checklist), announcements (announcement-drafter), or GTM definitions.
guardrail-designer
Iterate-stage skill: designs error, hallucination, and edge-case guardrails for a workflow — every guardrail naming the specific failure it prevents and the trigger condition that fires it. Use when a workflow needs hardening — 'design guardrails for this workflow', 'what can go wrong here and what stops it', 'harden this before we scale', 'where are we exposed' — or when /pm routes such a request here. Do NOT use for autonomous-loop design (loop-designer), for offline eval construction (eval-engine), for production drift monitoring (drift-monitor-designer), or for guardrail definitions.
interview-synthesizer
Discovery-stage skill: turns user-interview transcripts into evidence-cited patterns. Use when the user provides one or more interview transcripts, discovery-call notes, or user-research conversations and asks what patterns, themes, or learnings they contain — 'synthesize these interviews', 'what patterns are in these transcripts', 'what did we learn from these calls' — or when /pm routes a Discovery request here. Do NOT use for lists of feedback items or support tickets (feedback-pattern-miner's job), for summarizing a single meeting, or to invent personas or findings when no transcript data is provided — with no data it refuses.
jtbd-framer
Discovery-stage skill: reframes a feature idea or feature request into jobs-to-be-done statements containing zero solution language. Use when the user wants the underlying job behind a feature — 'frame this as JTBD', 'what job is this feature hired for', 'what are users really trying to get done', 'rewrite these requests as jobs' — or when /pm routes such a request here. Do NOT use for explaining JTBD theory, writing PRDs (Build stage), synthesizing interviews (interview-synthesizer — its patterns can feed this skill), or prioritizing feature lists.
judge-calibration-auditor
Iterate-stage skill: analyzes human labels vs LLM-judge verdicts and turns every disagreement into a classified calibration signal with a stated correction — never auto-resolved toward the judge. Use when a judge and humans diverge — 'our judge disagrees with human reviewers', 'human labels vs judge verdicts, what's drifting', 'the judge scores everything 4', 'disagreement analysis' — or when /pm routes such a request here. Do NOT use to design the judge (llm-as-judge-designer), to build the eval (eval-engine), to produce the human labels themselves, or for judge-bias knowledge questions.
latency-ux-tradeoff
Build-stage skill: designs the waiting experience for an AI flow — every recommendation tied to a stated user-tolerance threshold, measured or labeled heuristic, never vibes. Use when latency is shaping UX decisions — 'the summary takes 12 seconds, how should the UX handle it', 'stream or spinner', 'sync or async for a 45-second generation', 'users bail during generation' — or when /pm routes such a request here. Do NOT use to make the model faster (engineering), for model-cost selection (model-complexity-router), for threshold knowledge questions with no flow attached, or for visual spinner styling with no latency tradeoff.
launch-checklist
Launch-stage skill: turns a feature plus team context into a tailored launch checklist where every item has a named owner role and a verifiable done condition. Use when a ship date is approaching and the work needs enumerating — 'build the launch checklist', 'what do we need before we ship', 'launch readiness list', 'we ship in 3 weeks, what has to happen' — or when /pm routes such a request here. Do NOT use to write announcements (announcement-drafter), GTM one-pagers (gtm-brief), ship/no-ship decisions (ai-feature-go-no-go), or for definitions of launch process.
launch-retro
Launch-stage skill: turns launch data into a structured retro where every lesson cites an observed event and decisions are judged separately from outcomes. Use when a launch has run and the learning needs extracting — 'run the retro on the launch', 'what did we learn from the March launch', 'post-launch review with these numbers', 'turn these launch notes into a retro' — or when /pm routes such a request here. Do NOT use for mid-launch status updates (stakeholder-update), for designing the investigation into a metric drop (research-brief), for team-process retros with no launch data, or for retro-facilitation knowledge questions.
llm-as-judge-designer
Iterate-stage skill: turns existing eval criteria into an LLM judge prompt with anchors and few-shot calibration cases — every rubric point carrying both a pass and a fail exemplar. Use when criteria exist and the judge needs building — 'write the judge prompt for these criteria', 'turn this rubric into an LLM judge', 'judge prompt plus calibration cases' — or when /pm routes such a request here. Do NOT use to build the whole eval from a spec (eval-engine), to audit an existing judge against human labels (judge-calibration-auditor), to execute scoring over outputs, or for judge-reliability knowledge questions.
loop-designer
Iterate-stage skill: turns a recurring chore into a guarded autonomous loop — five-part anatomy (Discover/Plan/Execute/Verify/Stop), five non-negotiable guardrails, and a verifier that is never the executor. Use when a repeated manual task should run on a schedule — 'turn this weekly chore into an autonomous loop', 'design a guarded loop for the digest', 'automate this triage safely' — or when /pm routes such a request here. Do NOT use for one-shot workflow hardening (guardrail-designer), for plain cron scheduling of a script, for executing the loop, or for definitions of autonomous loops.
mcp-migration-auditor
Iterate-stage skill: scans an MCP configuration against the 2026 spec revision and returns per-server BREAKS/DEGRADED/SAFE verdicts — every finding citing both the config line and the spec clause. Use when spec readiness is the question — 'audit our MCP config for the 2026 spec', 'will our connectors break when the spec lands', 'spec-readiness scan on this .mcp.json' — or when /pm routes such a request here. Do NOT use for MCP context-cost audits, for debugging broken connections, for server installation, or for what-changed-in-the-spec questions with no config to audit.
model-complexity-router
Build-stage skill: scores a concrete task on a four-axis complexity rubric and recommends the right Claude tier (Haiku/Sonnet/Opus). Use when the user asks which model a task needs — 'which model should I use', 'is this an Opus task', 'am I overpaying for this', 'route this to the right model' — giving the full scored breakdown; also use proactively on any substantial task handoff, emitting one compact line without delaying the task. Fires once per distinct task. Do NOT use for vendor comparisons, knowledge questions, pricing lookups with no task, or repeatedly on follow-up messages about an already-scored task.
model-upgrade-evaluator
Iterate-stage skill: turns a new model release into a re-test plan for current prompts and shelved ideas — every verdict cites a run result, no capability assumed from release notes. Use when a new model version lands — 'new model dropped, what should we re-test', 'worth migrating our prompts?', 'build the upgrade evaluation plan', 're-test our shelved ideas' — or when /pm routes such a request here. Do NOT use to gate an already-decided migration's ship (regression-gatekeeper), for per-task tier routing (model-complexity-router), for release-notes summaries, or for academic benchmarking.
north-star-designer
Strategy-stage skill: designs a north star metric and its input-metric tree for a product — the NSM must be leading, not lagging, and the output states the causality check it passed. Use when the user wants to choose or fix their top metric — 'design a north star metric', 'what should our NSM be', 'is MRR a good north star', 'build the metric tree' — or when /pm routes such a request here. Do NOT use for definitions of metric concepts, for analytics instrumentation setup, for diagnosing why a metric moved (research-brief), or for setting OKR targets on existing metrics.
opportunity-sizer
Discovery-stage skill: builds a TAM/SAM/SOM opportunity size where every number carries a stated source or an explicit estimate label — no naked figures. Use when the user asks how big a market or opportunity is — 'size the market for X', 'TAM/SAM/SOM for Y', 'is this niche big enough', 'market-size inputs for the deck' — or when /pm routes such a request here. Do NOT use for definitions of sizing terms, for single-fact lookups like a company's market cap, for internal revenue forecasting, or for mapping idea risks (assumption-mapper's job).
pm-context-system
Build-stage skill: watches a working session and proposes one-line memory captures — never an interview — building a four-file project context (INDEX, STAKEHOLDERS, DECISIONS, STATE) that compounds across sessions. Use when the user asks for persistent project memory — 'set up project memory', 'make Claude remember my stakeholders', 'you keep forgetting my project' — and proactively whenever a decision, stakeholder fact, or state change worth keeping surfaces in conversation. Do NOT use for one-off summaries, for auditing an existing context file (context-auditor), or for questions about whether Claude remembers past chats.
pm
The pm-agent-os orchestrator. Use when the user invokes /pm or hands over any product-management request — synthesizing interviews, mining feedback, mapping assumptions, tearing down a competitor, sizing an opportunity, framing jobs-to-be-done, planning research, or any multi-step product task spanning discovery, strategy, build, launch, or iterate. Classifies the request into lifecycle stage(s), invokes the matching stage skills in sequence, and blocks every output whose verification gate has not passed. Also use when the user asks to run any output past a reviewer persona — 'review as engineer/designer/executive/skeptic/customer/data-analyst/legal' — routing to the persona agents in .claude/agents/. Do NOT use for coding tasks, repo maintenance, PR reviews (/pr-review's job), or knowledge questions about PM concepts with no work item attached.
prd-to-eval
Build-stage skill: turns a PRD or feature spec into a verification layer — binary quality gates for disqualifiers plus an anchored 1-5 rubric for tradeable qualities, with the two never mixed. Use when the user needs to define and test 'good' for a feature — 'turn this PRD into an eval', 'define good for our AI summarizer', 'build quality gates and a judge rubric', 'how do we test whether this works' — or when /pm routes a spec-bearing eval-design request here. Do NOT use to generate artifacts against frozen criteria (builder-validator), to execute an eval over outputs, for gate-vs-rubric knowledge questions, or for build/kill decisions (ai-feature-go-no-go).
pricing-tradeoff
Strategy-stage skill: turns a pricing question into structured options — every option carries a stated margin mechanism, never a naked price point. Use when the user is weighing pricing structures — 'per seat or usage-based', 'freemium vs free trial', 'structure the pricing options', 'bundle or unbundle the add-on', 'how should we price X' — or when /pm routes such a request here. Do NOT use to conjure a single price with no cost/margin context, to size markets (opportunity-sizer), to audit a roadmap's economics (roadmap-reality-check), or for definitions of pricing terms.
prompt-optimizer-loop
Build-stage skill: improves an existing prompt one mutation per round against a scoring checklist, logging every round and reverting anything that doesn't score better. Use when the user has a prompt that underperforms — 'improve this prompt', 'tune my extraction prompt', 'this prompt works 60% of the time, make it reliable', 'optimize it one change at a time' — or when /pm routes a prompt-repair request here. Do NOT use to author prompts from scratch (no baseline to mutate), for knowledge questions about prompting, for artifact generation with frozen criteria (builder-validator), or for model selection (model-complexity-router).
prototype-first-workflow
Build-stage skill: turns a feature idea into the smallest testable prototype plan — built around what the prototype must disprove, not what it should demonstrate. Use when the user wants to test before building — 'plan the smallest prototype', 'how do we prototype this before committing', 'design the spike', 'fastest way to test if this works' — or when /pm routes such a request here. Do NOT use to execute the build, to make the build/kill call itself (ai-feature-go-no-go), to map assumptions without a test plan (assumption-mapper — its riskiest assumption is this skill's input), or for definitions of prototyping methods.
rag-vs-agent-architect
Build-stage skill: matches a problem to an AI architecture — RAG, tool-calling, agent, or hybrid — and states the failure mode of every rejected option, not just the benefits of the chosen one. Use when the user is choosing an AI architecture — 'RAG or agent for this', 'do we need an agent or is retrieval enough', 'design the AI architecture for X' — or when /pm routes such a request here. Do NOT use for component selection inside a chosen architecture (vector DBs, frameworks), for feature go/no-go calls (ai-feature-go-no-go), for build/buy decisions (build-buy-partner), or for definitions of RAG or agents.
regression-gatekeeper
Iterate-stage skill: gates any prompt or model change behind a golden-set regression run — the run happens and its results are shown before any ship verdict exists. Use when a change wants to ship — 'we tweaked the prompt, safe to ship?', 'regression plan before the model swap', 'gate this change', 'what has to run before this goes out' — or when /pm routes such a request here. Do NOT use to decide whether an upgrade is worth pursuing (model-upgrade-evaluator), to build the golden set (golden-dataset-builder), for post-incident capture (failure-to-eval-capture), or for regression-testing definitions.
research-brief
Discovery-stage skill: turns an open product question into a structured research plan where every method is mapped to the decision it informs. Use when the user needs to plan research before acting — 'write a research plan for X', 'how should we figure out why Y happened', 'what research do we need before betting on Z', 'draft the research brief' — or when /pm routes such a request here. Do NOT use to synthesize research already run (interview-synthesizer / feedback-pattern-miner), to execute surveys or studies, for qual-vs-quant knowledge questions, or for web/market deep-research tasks.
roadmap-reality-check
Strategy-stage skill: audits a roadmap against unit economics — every item tagged supported or unsupported with the economic mechanism stated. Use when the user provides a roadmap plus business numbers and asks what's economically justified — 'reality-check this roadmap', 'which items pay for themselves', 'what survives contact with the P&L', 'does this lineup make economic sense' — or when /pm routes such a request here. Do NOT use to author a roadmap, to prioritize purely by customer impact without economics, to size markets (opportunity-sizer's job), or for definitions of unit-economics terms.
stakeholder-update
Launch-stage skill: turns raw project state into audience-calibrated status updates whose numbers reconcile exactly to the input — emphasis varies by audience, facts never do. Use when project state needs communicating — 'write the launch status update for the exec team', 'weekly stakeholder update from these notes', 'update sales on where the launch stands' — or when /pm routes such a request here. Do NOT use for public launch announcements (announcement-drafter), for logging decisions to memory (pm-context-system), for one-off meeting summaries, or for cadence-process questions.
strategy-review
Strategy-stage skill: pressure-tests a strategy document — every weakness it raises must cite the specific line it attacks. Use when the user provides their own strategy doc, positioning memo, or plan and asks for it to be stress-tested — 'pressure-test this strategy', 'tear it apart before the board does', 'red-team this memo', 'what's weak in this one-pager' — or when /pm routes such a request here. Do NOT use to author a strategy from scratch (there must be a doc to attack), to review PRs (/pr-review), to analyze a competitor's strategy (competitor-teardown), or for knowledge questions about strategy frameworks.
unit-economics-stress-test
Build-stage skill: models a feature's per-user token cost at three scale points — every number derived from stated assumptions, arithmetic fully reproducible. Use when inference cost needs stress-testing before commitment — 'what does this cost per user at 1k/50k/1M users', 'will inference eat our margin at scale', 'run the unit economics on this feature' — or when /pm routes such a request here. If token counts or prices are missing it asks for them or proposes labeled assumptions — it never silently invents them. Do NOT use for portfolio-level roadmap economics (roadmap-reality-check), pricing-structure design (pricing-tradeoff), bare per-MTok price lookups, or general infra cost reduction.
concise-rewriter
Use this skill when a user wants to compress verbose model output, shorten a draft, reduce token usage, or improve the signal-to-noise ratio of any text. Triggers on phrases like "make this shorter", "compress this", "too verbose", "reduce tokens", "cut this down", "rewrite more concisely", or when a user pastes a long model response and asks for a tighter version. Rewrites the input at the same information density, shorter — then reports the exact before/after token count and percentage reduction. Not a summary. A rewrite. Every piece of meaning is preserved. Do NOT use when a summary, factual correction, or a change in the author's position is requested.
eval-rubric-generator
Use this skill when a product spec, feature requirement, PRD, or user story needs to be converted into a concrete evaluation rubric. Triggers on phrases like "write an eval for this", "create a rubric", "how do I test this AI feature", "define good output", "what should I measure", or when a user pastes a spec and asks what success looks like. Produces a binary pass/fail checklist — not vague metrics, not suggestions — a rubric you can run against model outputs today. This is the skill AI PMs need before anything ships to production. Do NOT use to execute an evaluation or invent requirements absent from the supplied specification.
token-cost-estimator
Use this skill before running any prompt in production or sharing a workflow with stakeholders. Triggers on phrases like "how much will this cost", "compare model costs", "which model should I use", "estimate tokens", "pre-flight check", or when a user pastes a prompt and asks about inference economics. Takes a prompt and a list of candidate models, then returns a projected cost and latency comparison across all models before a single token runs. Essential for any AI PM who owns inference budgets. Do NOT use as a substitute for current provider pricing or measured production latency.
cli-over-mcp-auditor
Use this skill proactively on the first substantial prompt of a session — silently inspect the session's own available tools/MCP servers (never ask the user to paste anything for this check) and, if any connectors look irrelevant to the task at hand, surface one compact line offering to free up context. Use this skill when the user makes explicit requests too — to audit MCP connectors, reduce context window usage, or explain why sessions run out of context fast — phrasings like "audit my MCPs for context cost", "why is my context filling up", "should I use CLI instead of MCP", "reduce my context overhead", "my sessions compact too early" — which get the full deep-audit flow instead of the one-liner. Do NOT use for debugging a broken MCP connection, for installing new connectors, for general questions about what MCP is, or for MCP spec-compatibility and migration audits (mcp-migration-auditor's job).
prd-first
Forces a written PRD before any code generation. Use this skill the moment the user says "build", "create app", "make me a", "vibe code", "let's build", "I want an app that", "spin up a", "prototype a", "ship a", or any phrasing that signals they want code generated from a high-level idea. Also use when the user references an existing project but the conversation has no PRD context (no /prds/ file referenced, no clear success metric). The skill blocks code generation until a 5-field PRD exists as a markdown file in the repo. Do NOT use when the user is asking factual questions, debugging existing code, editing a specific file they've named, or working in a repo where a PRD for this feature already exists at /prds/. Skip when user explicitly says "skip the PRD" or "just code it" — but flag the risk once before proceeding.
loop-designer
Use this skill when the user says turn this into a loop, run this on a schedule, automate this daily, build me a loop, make this recurring, design a loop for a task, or loop this task — any request to make a one-off task a recurring autonomous job. Interviews minimally (goal, sources/inputs, output destination, schedule), then generates a five-part loop spec (Discover, Plan, Execute, Verify with a separate verifier checklist, Stop-or-Repeat), a non-negotiable guardrails block (max-iterations cap, cost ceiling, seen-log cross-run dedup, no-destructive-actions allowlist, completion/trip notification), and two ready-to-paste runners — a Claude Code Routine prompt and a local cron/launchd variant. Do NOT use for improving an existing prompt ("improve this prompt" is prompt-optimizer-loop's job), for one-off tasks, for debugging an already-built loop, or to run something on an interval in the current session — the built-in /loop command does that; this skill designs durable guarded loops, it doesn't run them.
mcp-migration-auditor
Use this skill when the user wants to audit my MCP setup, check MCP compatibility, asks will my MCP servers break, mentions MCP spec migration, wants an MCP 2026 spec check, or says scan mcp config — also on any readiness question about the MCP 2026-07-28 specification (stateless transport, removed Mcp-Session-Id, deprecated roots/sampling/logging, experimental Tasks migration, OAuth hardening). Locates MCP configs (.mcp.json, claude_desktop_config.json, mcp.json, settings files) or accepts a pasted one, checks each server against rules verified from the official MCP blog and spec changelog, and outputs a per-server BREAKS/DEGRADED/SAFE table naming the triggering rule and specific fix, plus a prioritized migration checklist against the 2026-07-28 final date. Stdio-only local setups get an honest all-clear. Do NOT use for context-window cost audits of MCP connectors (cli-over-mcp-auditor's job), for debugging a broken MCP connection, or for installing new servers.
builder-validator
Use this skill when the user asks to generate an artifact (document, code, post, analysis, design spec) and wants it validated, self-checked, or quality-assured before seeing it — or whenever they say "make sure it meets the requirements", "validate against the spec", "self-QA this", "check your own work", or after repeated correction rounds on the same artifact. Freezes the requirements into binary pass/fail criteria BEFORE generating, generates, then audits the output against the frozen criteria in a separate pass and reports a scorecard. Do NOT use for pure questions, brainstorming, or when the user explicitly wants a fast rough draft with no checks.
model-complexity-router
Use this skill proactively whenever the user hands over any substantial task to execute — not just when they ask about models. Use this skill when a concrete work item is handed over by silently scoring it and emitting one compact line noting the current model, the score, the recommended tier, and the potential savings, without blocking or delaying the task itself. Also fires on direct questions like "which model should I use", "is this an Opus task", "route this to the right model", "am I overpaying for this", "should I use Haiku or Sonnet for this" — those get the full scored breakdown instead of the compact line. Fires once per distinct task, not on every follow-up message within that same task. Do NOT fire on pure knowledge questions, vendor comparisons, hypotheticals with no concrete work item, or repeatedly while a task is still in progress.
pm-context-system
Use this skill proactively during any session — observe the conversation, and the moment a decision is made or context worth keeping surfaces, propose a one-line log entry rather than interviewing the user up front. Use this skill when the user makes an explicit request too — wanting Claude to remember their work across sessions, set up persistent project context, or complaining that Claude starts from zero every time — phrasings like "set up my context system", "make Claude remember my stakeholders", "you keep forgetting my project", "set up project memory", "initialize my PM workspace". Scaffolds a four-file context structure (INDEX, STAKEHOLDERS, DECISIONS, STATE) silently on first approved log entry, with a session-start read order and maintenance rules for merging, pruning, and flagging stale entries. Do NOT use for one-off summaries, for auditing an existing CLAUDE.md (context-auditor's job), or for conversation-level memory questions.
prompt-optimizer-loop
Use this skill when the user wants to improve, tune, or optimize an existing prompt or system instruction — phrasings like "improve this prompt", "my prompt works 80% of the time", "optimize my system prompt", "make this prompt more reliable", "tune this instruction". Runs an interactive optimization loop, one mutation per round, scored against a locked binary checklist, keeping only changes that improve the score. Requires three inputs from the user — the target prompt, 2-3 realistic test inputs, and 3-6 binary quality checks (offer to help draft checks if missing). Do NOT use for writing a brand-new prompt from scratch, or for one-off output fixes where the prompt itself isn't the problem.
eval-engine
Use this skill when the user pastes a feature spec, PRD, or task description and wants to create an eval, write an eval, build an eval rubric, define good, test this AI feature, generate a verification layer, set up an LLM judge, grade outputs, add quality gates, or asks "how do I measure" whether the feature works. Produces three artifacts from the spec — 3-6 binary disqualifying gates each marked with WHY it is a gate and not a score, a calibrated 4-7 criterion LLM-judge rubric on a 1-5 scale with anchors, worked examples, and a paste-ready judge prompt, and a runnable pure-Python-stdlib harness (prepare.py, run.py, report.py) that applies gates first so any gate failure is an automatic fail, then rubric scoring wired to the user's own Claude session with no API keys. Supersedes the standalone eval-rubric-generator skill when both are installed. Do NOT use for running or debugging an existing eval suite, for QA of non-AI features, or for one-off review of a single output with no spec attached.
prd-first
Forces a written PRD before any code generation. Use this skill when the user says "build", "create app", "make me a", "vibe code", "let's build", "I want an app that", "spin up a", "prototype a", "ship a", or any phrasing that signals they want code generated from a high-level idea. Also use when the user references an existing project but the conversation has no PRD context (no /prds/ file referenced, no clear success metric). The skill blocks code generation until a 5-field PRD exists as a markdown file in the repo. Do NOT use when the user is asking factual questions, debugging existing code, editing a specific file they've named, or working in a repo where a PRD for this feature already exists at /prds/. Skip when user explicitly says "skip the PRD" or "just code it" — but flag the risk once before proceeding.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.