Every skill, listed by job.

Honest about its limits: it labels automated vs manual findings and won't claim WCAG compliance from a script — but it catches the real blockers.

Stops a batch of ad variants from being ten takes on one weak angle — scores each on proof and risk, then pushes distinct next angles.

Sets the bar at replaying a real failure from the trace without leaking secrets — and catches teams logging cost but not per-step cause.

Reviews the tool permissions, not just the prompt — where most agent security actually fails. Pairs with prompt-injection-shield for the fixes.

Ties every event to a decision question and flags PII in payloads — so your analytics answers funnel questions instead of just piling up.

The honest AEO audit: no citation-lift claim without before/after proof, and it won't pretend an llms.txt file is a ranking guarantee.

Catches the frontend/backend drift that bites in production — it diffs the OpenAPI contract on every PR so a breaking route fails CI, not your users.

Fixes voice without flattening you into generic SaaS copy — it preserves the specifics and flags the claims that still need proof.

Gives your agent a browser without brittle selectors — the self-healing locator survives the DOM changes that break every hand-written scraper.

Turns git log into a changelog a human would actually read, grouped by feature, fix, and breaking change — the release chore most teams skip until launch day.

Every churn theme carries a real quote or gets marked a hypothesis — so one offhand comment never becomes a roadmap decision.

Points at the first failing command, not the loudest warning — and stops the agent from editing before it has even read the error.

Separates a competitor's marketing claim from hands-on proof and keeps the unknowns honest — instead of overrating a slick landing page.

Storybook stories are the docs nobody writes. This reads your component types and generates the stories and prop tables so the chore stops being optional.

Ranks decaying pages by real evidence and tells you refresh vs rewrite vs delete — not just bumping the date and calling it updated.

The fix for the wall every long-running agent hits — it summarizes old turns before the context window blows, instead of crashing mid-task.

Surfaces the commercial terms that bite — payment, renewal, liability — and flags what needs counsel, without pretending to be your lawyer.

Catches the business-critical nulls and duplicate keys before a report depends on them — concrete column-level issues, no hand-wavy causal claims.

Reads a migration the way production will: full tables, real locks, and a rollback you actually have — catches data-loss before you apply.

For UIs that fragmented during fast AI changes — it finds the repeated drift and gives a convergence plan, not a redesign.

Most teams ship prompt changes on vibes. This makes model quality a CI gate with golden sets and rubrics, so a regression fails the build like any bug.

Separates a significant result from a directional signal from noise — and surfaces the sample-size and seasonality caveats before you ship a win.

Solves flag debt: it tracks every flag and tells you which are safe to delete, then strips the dead branches — so old flags stop rotting in your codebase.

Reads the target version's actual changelog instead of trusting training-data memory — the difference between a clean upgrade and a broken build.

Replaces hiring-on-vibes with a scorecard tied to observable evidence and clear pass bars — and steers clear of irrelevant criteria.

Blameless by design, and every corrective action gets an owner, a date, and a way to verify it — so the postmortem actually changes something.

Returns exact paths for every stale or duplicate doc and names the source of truth before any rewrite — so the KB stays retrievable.

Turns a pretty-but-flat page into a punch list — each fix maps to a visible change or a measurement, and it checks mobile first.

Writing an MCP server by hand means hours of boilerplate before the first tool runs. This validates against the spec so you skip the silent-failure stage.

More than a schema check: it gates every MCP tool on inputs, failure behavior, and auth — and catches injection riding in through tool descriptions.

Audits where you overpay and where a cheap model is risking quality — treating latency, cost, and quality as separate per-task requirements.

A pre-wired supervisor for routing work to specialist agents, with the retry and observability hooks you'd otherwise rebuild by hand for every project.

Finds the no-code automations failing silently or leaking data — it maps triggers, retries, and owners instead of trusting the UI labels.

Maps the path to the first real result and fixes what stalls users there — tied to time-to-first-value, not to a prettier screen.

Stops paying GPT-tier prices for tasks a cheap model can do — it classifies each request and routes to the cheapest model that clears the bar, logging the savings.

Gets a critical procedure out of one person's head: numbered steps a new operator can run, with the rollback and escalation included.

It posts inline fixes on the PR, not generic warnings you'll ignore — the difference between a review bot people read and one they mute.

Runs in Codex on a raw diff and orders findings by severity with verify commands — built for plausible-looking AI PRs that hide a regression.

Catches the gap between what the pricing page promises and what the code enforces — before a wrong plan limit turns into a refund.

Maps policy changes to real data flows and produces review-ready questions — explicitly not legal advice, which is exactly why it's safe to use.

A lightweight first filter for obvious injection attempts. Honest caveat: detection alone is unreliable — pair it with prompt-injection-shield for real defense.

For the prompt you keep re-pasting: it rewrites it as a triggerable skill and scrubs the private paths most people forget to remove.

Skips the where-do-I-start of RAG: ingestion, chunking, and upsert in one config, plus a relevance check so junk chunks never reach the prompt.

Stops you blaming the model for a retrieval bug — it classifies each miss as source, chunking, embedding, ranking, prompt, or synthesis.

Keeps launch proof honest: a passing build, a working checkout, and a live smoke test are tracked as separate lanes — not one green check.

Turns a research folder into a decision pack with a graded source matrix and an action backlog — not a vague strategy summary.

Turns a plain-English schema change into a reviewed migration with rollback steps — and flags the breaking changes before you apply them, not after.

Systematic visual QA across viewports — it catches the text overflow and clipping a quick glance misses, and won't guess at behavior from a still.

A brief a writer can execute: intent, outline, internal links, and a source behind every non-obvious claim instead of invented stats.

Complements the eval-harness runner: this one writes the cases, including the anti-triggers and failure paths most authors never test.

Built for the moment before you publish a skill: it separates a polished README from a runnable one and names the exact missing pieces.

Honest fix for skills that assert facts without backing them — every claim either gets a graded source or gets downgraded.

Demands a real proof point behind every claim and rejects fake metrics — a launch thread that connects problem to proof, not hype.

Drafts on-policy replies but refuses to auto-answer billing, legal, security, or angry tickets — the cases that need a human.

Does the tedious least-privilege pass teams skip — strips scopes a task doesn't need without breaking reads, and gates write and delete.

Ties every finding to a real user task, not taste — and checks keyboard and mobile, so it catches interfaces that look fine but slow work down.

Separates a vendor's marketing claims from audited proof and surfaces the lock-in and data-export risks before you commit, not after.

For builders who can ship logic but freeze on design — the critique loop scores the UI before commit, so taste isn't left to luck.

Will tell you to keep a workflow manual when risk is high — it scopes the automation before you build something brittle around an unmapped process.

Aimed at the one bill teams forget to read — it profiles your Actions YAML against real billing data and estimates the savings before touching anything.

Debugging an ETL means hunting which transform broke the data. This snapshots each step and walks the diff back to the first failing one for you.

Real-time voice is brutal to wire — VAD, barge-in, and silence timeouts all have to feel instant. This handles the latency-sensitive plumbing so you don't.

The honest take on prompt injection: don't try to detect it, defuse it. It enforces the lethal-trifecta budget and gates risky actions — defense that actually holds.