skills-hub-registry

Assess a codebase's architecture with hard evidence — module map, dependency direction, layering breaks, coupling and cohesion hotspots weighted by git churn — then rank 3-5 improvement moves by risk-adjusted value and actually execute the lowest-risk move end to end with tests green before and after, finishing with a dated architecture doc containing before/after mermaid diagrams. Use when someone says "improve the architecture", "this codebase is a mess", "reduce coupling", "untangle dependencies", "refactor safely", "layering is broken", "circular imports", "tech debt assessment", "where should we refactor first", or "clean up module boundaries" and wants executed change, not just a slideware review.

Extracts a complete design system from a screenshot, live URL, or existing app codebase: palette, type scale, spacing rhythm, radii, shadows, and a component inventory, then normalizes everything into deduplicated tokens, emits them in the target stack's format (CSS custom properties, Tailwind config, Flutter ThemeData, or SCSS variables), and generates a living styleguide page rendering every token and component state. Use when: 'extract the design system', 'pull the colors from this screenshot', 'copy this site's design', 'turn this UI into tokens', 'reverse-engineer this design', 'build a design system from our app', 'make a styleguide', 'tokenize our styles', 'what fonts and colors does this site use'.

Run multi-source web research with adversarial verification and produce a cited report: decomposes the question into 3-6 distinct queries (broad, specific, comparative, recency-anchored), searches and ranks sources by authority, recency, and specificity, fetches the top 5-10 and extracts facts with per-fact source IDs, then runs an adversarial pass that actively searches for evidence CONTRADICTING each key claim, and synthesizes a themed report with a TL;DR, inline [n] citations, an explicit conflicts section, and coverage caveats, saved to ~/research-reports/ and printed inline. Use when the user says: research this topic, deep dive on X, what's the current state of X, compare X vs Y with sources, find evidence for/against, fact-checked report, is it true that X, literature scan, market scan, due diligence on X, cited summary of X.

Build a complete indie launch package for an app, tool, or library — product audit, positioning (one-liner, value props, objection answers), finished launch assets written to a launch/ directory (landing copy, App Store or Play Store or npm/directory listing text, Product Hunt draft, Show HN draft, a 2-week social calendar with 14 fully written posts), an SEO baseline audit with fixes applied when the repo is present, and an hour-by-hour launch-day runbook. Use when someone says "help me launch", "launch plan", "Product Hunt draft", "Show HN post", "write my landing copy", "app store listing", "marketing for my app", "go to market", "launch checklist", "how do I announce this", or when a product is built and needs distribution artifacts, not more code.

One-command PR gate that runs four passes over exactly the changed surface — code review (correctness then simplification), security (injection, authz, secrets, dependency diff), tests (run the suite and flag untested changed lines), and accessibility when UI files changed — and emits a single machine-parseable verdict: MERGE, MERGE-WITH-NITS, or BLOCK with numbered findings, each carrying file:line and a concrete fix. Use when someone says "is this PR ready to merge", "pre-merge check", "gate this branch", "review before I merge", "run the full check on my diff", "can I ship this", "final check", "PR gate", or in CI-like flows where one verdict must summarize review, security, tests, and a11y in a single run.

Conduct a complete feature workflow in one skill — brainstorm, plan, TDD implementation, self-review, delivery summary — with hard gates between stages: no stage starts until the prior stage's artifact exists on disk (brainstorm note, plan doc, green tests per step). Use when someone says "build this feature properly", "take this from idea to done", "brainstorm then implement", "run the full workflow", "plan and build X", "do this the right way", "TDD this feature", "structured feature development", or when a feature request arrives raw and needs the whole arc — options weighed, plan written, red-green-refactor execution, and a reviewed diff — without plugin sprawl or human babysitting between stages.

Convert any pile of documents (PDF, Word, HTML pages, wiki exports, PowerPoint slides) into clean, LLM-ready markdown context: inventories the sources, picks the right extractor per file type (pdftotext or PyMuPDF for PDF, pandoc or mammoth for docx, readability extraction for HTML, python-pptx for slides), preserves structure (headings, real markdown tables, code blocks), strips boilerplate and navigation, chunks by heading hierarchy into 2-4k token files under context/<source>/ with an INDEX.md, and spot-checks three random chunks against the originals for fidelity. Use when the user says: convert these docs to markdown, prep these PDFs for Claude, turn this documentation into context, markitdown these files, extract text from these documents, make this wiki LLM-readable, ingest these docs, build a context folder.

Build an investor or product pitch deck as a real PPTX file from a written brief: extracts the fundamentals (problem, solution, market, traction, business model, ask) and flags anything missing as explicit TODO placeholders instead of inventing numbers, chooses a narrative arc (problem-first for investors, demo-first for product, before/after for sales), drafts 10-12 slides each with speaker notes, renders with python-pptx using a clean typographic template (one idea per slide, big numbers, no clip art), then re-opens the file to assert slide count and non-empty notes. Use when the user says: make a pitch deck, investor deck, seed deck, fundraising slides, product pitch presentation, sales deck, turn this brief into slides, deck for the demo day, YC application deck, build me a PPTX pitch.

Generate a new-developer onboarding guide for any repository: detects the stack, entry points, and run/test/deploy commands from package scripts and CI config, maps the architecture of top-level modules, extracts conventions from linter configs and CLAUDE.md, then VERIFIES every documented command by actually running it (unverifiable ones are marked, never presented as working), and writes docs/ONBOARDING.md with a 15-minute quickstart, an architecture tour with a mermaid diagram, a where-things-live table, three real first-task suggestions mined from TODOs and small bugs, a project jargon glossary, and a freshness header pinned to the verified commit SHA. Use when the user says: onboard a new developer, write an onboarding guide, quickstart for this repo, help a new hire ramp up, explain this codebase to a newcomer, getting-started doc, ramp-up guide, first-day docs.

Convert a plan, PRD, spec, or roadmap document into tracked GitHub issues with a dependency graph: parses the plan into atomic work items (each independently shippable, one day or less, with acceptance criteria), detects dependency cycles before creating anything, then uses the gh CLI to create a milestone, type and priority labels, and issues whose bodies carry context, acceptance criteria, likely-touched files, and depends-on links created in topological order so references resolve. Verifies the created set and emits a plan-item to issue-URL mapping table. Use when the user says: turn this plan into issues, create GitHub issues from this PRD, break this spec into tickets, file issues for this roadmap, to-issues, convert plan to tasks, issue-ify this, populate the milestone.

Compress the current working session into a handoff document that a fresh session (or another person) can resume from without re-discovery. Inventories the session (task, decisions made and why, files touched with one-line diff summaries, commands that worked, dead ends to avoid, current blockers), writes it to .claude/handoff/<date>-<topic>.md with a paste-ready RESUME PROMPT section at the top, runs a stranger-test completeness check (no unexplained jargon, absolute file paths, next three actions explicit), and lists stale handoffs older than 30 days for pruning. Use when you say "hand off this session", "write a handoff", "save context before I close this", "I'm out of context, summarize for the next session", "pick this up tomorrow", "create a resume doc", or before compaction on a long task.

Install a token-efficiency output contract for the current session and project: writes strict brevity rules into CLAUDE.md (answer-first structure, no tool-call narration, no restated questions, no preamble filler, code without prose bookends), defines exceptions where brevity is banned (error reports, destructive-action confirmations, multi-step summaries), measures the token savings on a real sample, and installs a 'verbosity check' self-audit trigger. Use when the user says: be more concise, stop being verbose, save tokens, terse mode, shorter answers, cut the fluff, too wordy, reduce token usage, stop narrating, answer-first, brevity mode, caveman mode, or complains that replies are long.

Turn a pile of bugs, issues, and error reports into a ranked, actionable plan with reproduction evidence. Ingests GitHub issues via gh, TODO/FIXME scans, error logs, or a pasted list; attempts to reproduce or classify every item (confirmed, unconfirmed, cannot-repro, each with evidence); scores each by user impact times frequency times fix cost times regression risk; clusters duplicates and shared root causes; and emits a ranked table with a per-bug next action plus a suggested first-sprint slice of quick wins totaling at most one day. Use when you say "triage these bugs", "prioritize the backlog", "which bugs should we fix first", "make sense of these error reports", "rank the open issues", or "clean up the issue tracker".

Hypothesis-driven debugging that ends at a proven root cause, not a symptom patch. Captures the failure verbatim by running the reproduction yourself, forms two to four ranked hypotheses each paired with a discriminating test ("if H1 is true, then X will show Y"), runs the cheapest discriminating test first and eliminates hypotheses iteratively, confirms the root cause by toggling it (break it again on purpose, then unbreak), then fixes, adds a regression test, verifies the original repro passes, and writes a five-line postmortem. Use when you say "debug this", "find the root cause", "why is this failing", "this bug keeps coming back", "the fix didn't stick", "intermittent failure", or when a previous quick fix only moved the error.

Deterministic browser automation for testing and scripted web flows using Playwright with accessibility-snapshot navigation. Runs a pre-flight (Playwright installed, app reachable, dev server started if needed), then drives the requested flow snapshot-first: takes an accessibility tree snapshot, addresses every element by role and accessible name instead of brittle CSS selectors, re-snapshots after every mutation, asserts per step, and captures an evidence bundle (screenshot per key state, console errors, failed network calls). Delivers a step-by-step flow transcript with pass/fail. Use when you say "test this flow in the browser", "automate the signup flow", "click through the app", "drive the browser", "verify the checkout works", "browser automation", or "E2E this page without writing a spec file".

Enforce strict red-green-refactor test-driven development for a feature. Decomposes the feature into testable behaviors, then for each behavior writes a failing test, runs it and verifies it fails for the RIGHT reason by asserting on the failure message, writes the minimal implementation, runs green, refactors under green tests, and commits one cycle at a time. Detects violations where implementation code appeared before its test and halts. Ends with a coverage delta report and a commit-per-cycle audit trail. Use when you want to "do TDD", "build this feature test-first", "enforce red-green-refactor", "write the test first", "strict TDD", or "make sure every line was driven by a test".

Take an untested or under-tested repository to a real, running test suite in one pass. Detects the language and picks the native runner (Vitest, Jest, pytest, go test, flutter_test, RSpec, cargo test), ranks untested modules by risk using exported surface times git churn times complexity, scaffolds test infrastructure (config, helpers, factories, CI step), generates tests for the ten riskiest modules with happy path, edge cases, and error paths, runs them and self-heals failures for up to three iterations, and reports coverage before and after plus a ledger of real bugs found. Use when you say "this repo has no tests", "bootstrap a test suite", "add tests to this project", "set up testing from scratch", "we have zero coverage", or "get this codebase under test".

Builds programmatic videos (product demos, explainer clips, social videos, launch teasers) with Remotion: verifies node/ffmpeg/Remotion pre-flight, writes a timed storyboard (scene list with durations, on-screen text, and motion notes) as a hard gate before any code, implements scenes as composable React components over a shared theme, renders a low-res preview and self-reviews it frame-by-frame against the storyboard, then produces the final render with destination-aware presets (YouTube 1080p 16:9, Reels/TikTok 9:16, X 16:9 under 2:20). Use when: 'make a video with code', 'Remotion video', 'product demo video', 'animated explainer', 'launch video', 'render a social clip', 'programmatic video', 'turn this into a video', 'video for the release'.

Turns an idea into a clickable, verified prototype in one run: ruthlessly scopes to at most 3 screens with one happy path and an explicit written cut-list, scaffolds on the existing repo stack (or Vite standalone), fills it with realistic seed data instead of lorem ipsum, then actually launches the app and clicks through the happy path (Playwright when available) before delivering run instructions. Use when: 'build a prototype', 'quick mockup I can click', 'proof of concept', 'spike this idea', 'demo for tomorrow', 'MVP of just the flow', 'throwaway version to test the idea', 'clickable demo', 'prototype this feature', 'hack something together fast'.

Creates and edits Word (.docx), PowerPoint (.pptx), Excel (.xlsx), and PDF files programmatically: detects the available runtime and picks the right library per format (python-docx or docx.js, python-pptx, openpyxl or exceljs, reportlab or pdf-lib), installs missing packages into an isolated venv or node env, drafts the document structure first (outline, slide map, or sheet schema), generates with real formatting (styles, headers/footers, page numbers, charts from actual data), then re-opens every file programmatically and asserts its structure before delivery. Use when: 'make a Word document', 'create a PowerPoint', 'build a spreadsheet', 'generate a PDF', 'export this as docx/pptx/xlsx', 'write a report file', 'slide deck from these notes', 'edit this Excel file', 'fill this document template', 'invoice PDF'.

Installs behavioral guardrails against classic LLM coding failures and audits the current session against them. Encodes six enforceable rules: verify APIs exist in node_modules or docs before calling them, state assumptions before coding, prefer minimal diffs over rewrites, re-read the actual error text instead of pattern-matching a fix, never claim done without running the code, and express uncertainty numerically. Writes the rules into CLAUDE.md with an idempotent merge and demonstrates each with a before/after example from this repo. Use when you hear: install guardrails, coding guardrails, stop hallucinating APIs, the agent keeps rewriting everything, add LLM safety rules, make Claude more careful, audit this session, why did you claim it works, anti-slop rules, Karpathy-style guidelines, tighten your coding behavior.

Project-aware skill discovery and installation. Scans the current repo for stack signals and pain points, searches the skills-hub registry and local ~/.claude/skills, scores candidates on relevance, quality, and maintenance, dedupes against what is already installed, and presents a ranked shortlist with exact install commands. Use when you hear: find skills, what skills should I install, discover skills, recommend skills for this project, search skills-hub, is there a skill for X, set up my agent tooling, what agent skills exist for Flutter/Next.js/Python, install the right skills, skill recommendations, browse the skill registry, or when a recurring manual workflow in the session looks like it should be a pre-built skill.

Curated skill bundle installer keyed to project archetype. Classifies the repo as one of six archetypes (Next.js SaaS, Flutter app, API backend, CLI tool, data pipeline, mobile game), maps it to a 5-8 skill stack covering the whole lifecycle (build, test, review, deploy, docs), checks what is already installed, installs the missing pieces with a user-visible manifest, and records the stack plus rationale in .claude/skill-stack.md. Use when you hear: set up skills for this project, skill stack, install a skill bundle, what skills does a Next.js app need, bootstrap my agent tooling, starter skills, equip this repo, recommended skill set, new project skill setup, or when onboarding a fresh repo that has no skills configured yet.

Audit React and Next.js codebases against roughly 50 concrete performance rules spanning re-render hygiene, bundle size, data-fetching waterfalls, images and fonts, list virtualization, and effect discipline, then apply the safest high-impact fixes and prove the win with before/after bundle numbers. Use when someone says "audit React performance", "why is my Next.js app slow", "reduce bundle size", "fix re-renders", "app feels laggy", "optimize my components", "check for waterfalls", "React best practices pass", "lighthouse score is bad", "hydration is slow", or before a launch when a performance sweep of routes and components is needed.

Turn code-review findings into verified fixes, one commit per finding, test-first where a regression test is possible, with an explicit skip ledger for anything too risky to fix blind (auth, payments, migrations). Ingests findings from a report file, PR comments, or pasted text — or runs its own structured review of the diff against main first. Use when someone says "fix the review comments", "address the code review", "apply the findings", "we ran a review, now fix it", "resolve PR feedback", "fix what the audit found", "review this and fix it", or after any review/audit skill produced findings that now need to become commits instead of a to-do list.

Documentation-grounded plan interrogation. Before asking you anything, it extracts every third-party dependency your plan touches, fetches and reads their real documentation (node_modules READMEs and type definitions, official docs URLs, OpenAPI specs in the repo), extracts hard constraints (rate limits, idempotency requirements, size caps, auth models, webhook semantics), and then grills you with questions that cite specific doc lines, like: Stripe requires webhook idempotency, how will you dedupe. Emits a constraints appendix with citations. Use when you hear: grill me with docs, check my plan against the actual docs, what do the docs say about this plan, doc-grounded review, will the API actually support this, verify my integration plan, constraints check, does Stripe/Firebase/AWS allow this, read the docs before I build.

Turns a raw idea, brain dump, or conversation into a complete PRD with mandatory acceptance criteria and measurable success metrics. Extracts the problem, target users, and jobs-to-be-done, runs a quick competitive scan (web if available, logged as a gap if not), drafts the full PRD (problem, personas, user stories with testable acceptance criteria, non-goals, success metrics, launch milestones, open questions, and a distribution section answering how people will find this), then self-critiques against a 10-point rubric and patches gaps before writing docs/prd/<slug>.md. Use when you hear: write a PRD, turn this idea into a spec, product requirements, I have an app idea, formalize this feature, from idea to document, what should the requirements be, draft the product doc, PRD for X, spec out this product, capture this brainstorm.

Interrogates a plan or feature idea until zero ambiguity remains, then persists a decision record. Enumerates every unstated assumption, asks prioritized question batches (blocking, then shaping, then polish, multiple-choice where possible), runs an adversarial pass attacking the plan for edge cases, failure modes, and hidden scope, and emits docs/decisions/<date>-<topic>.md with a decisions table, risk register, and explicit non-goals. Use when you hear: grill me on this plan, interrogate this idea, poke holes in my plan, stress-test this feature, what am I missing, challenge my assumptions, is this plan ready, pre-mortem, devil's advocate review, decision record, ADR for this feature, before I start building, make sure the spec is airtight.

Builds distinctive, production-grade UI by committing to one of 12 named visual directions (editorial, brutalist, luxury-minimal, terminal/dev-native, playful-geometric, glassmorphic, retro-futurist, swiss-grid, organic-soft, data-dense, art-deco-revival, neo-memphis), implementing a real typography scale, spacing system, and one signature flourish, then gating the result through a measurable anti-slop checklist and contrast/touch-target verification. Use when: 'make the UI distinctive', 'this looks like every AI site', 'avoid generic design', 'design a landing page', 'build a beautiful UI', 'frontend design', 'make it not look AI-generated', 'give this app a visual identity', 'pick a design direction', 'redesign this screen'.

Audits UI code against 90+ concrete accessibility and UX rules across ten groups (semantics/ARIA, keyboard navigation, focus management, color contrast, touch targets, motion and reduced-motion, forms, loading/empty/error states, responsive breakpoints, i18n readiness), scanning auth/checkout/navigation routes first and producing a severity-ranked findings table with file:line locations, WCAG references, and concrete fixes, then optionally auto-fixing the mechanical class of issues. Use when: 'audit the interface', 'accessibility audit', 'a11y check', 'review my UI code', 'check WCAG compliance', 'find UX issues', 'web design guidelines', 'is this accessible', 'fix accessibility issues', 'keyboard navigation review', 'contrast check'.

Verifies front-end changes by driving a real browser — spins up the local dev server, navigates to the changed route, executes the affected interaction flow, captures console output and screenshots, then reports pass/fail with structured findings. Works with Claude Code, Cursor, and Codex CLI via Playwright; mirrors the GitHub Copilot browser tools GA workflow announced July 1 2026.

Intelligent task-to-model routing for GitHub Copilot's multi-lab model picker (2026). Audits your workflow, assigns the right model (OpenAI / Anthropic / Google / Microsoft / Moonshot) to each task type, configures VS Code settings, and writes a routing matrix your team can commit. Covers Kimi K2.7 Code, Claude Sonnet 5, GPT-5.6 tiers, Gemini 2.5, and Phi-4. Includes cost-per-accepted-change pilot framework and admin policy checklist for Business/Enterprise plans.

Configures Claude Code's July 2026 async workflow: background agents that auto-commit, push, and open draft PRs when worktree tasks finish. Sets up Notification hooks for agent_needs_input and agent_completed events, enforces Manual permission mode, and wires dynamic workflow sizing. Lets you dispatch multiple agents in the morning and receive reviewable PRs without watching the terminal.

Autonomously selects the right GPT-5.6 tier (Sol / Terra / Luna) for each coding task based on scope, file count, and planning complexity — then applies explicit cache breakpoints for SKILL.md files and system prompts. Reduces monthly AI coding costs by 50–80% without sacrificing output quality on complex tasks.

Connect the X (formerly Twitter) official XMCP server to your AI coding agent. Covers hosted and self-hosted setup, Bearer token and OAuth 2.0 authentication, connection verification, and four production-ready query workflows: mention monitoring, trend analysis, competitive intelligence, and bookmark ingestion.

Audits all connected MCP servers: auth type (OAuth vs static token), token expiry, available tools, and connection health. Flags servers that can migrate to claude mcp login OAuth flow and detects silent auth failures before they break agentic runs.

Build MCP Apps — the interactive HTML UI primitive introduced in the 2026-07-28 MCP specification. Scaffolds UI templates, wires the JSON-RPC back-channel, declares tool manifests, and validates against the conformance suite. Use when adding visual interfaces (forms, data previews, approval flows) to an existing MCP server.

Audits your active Claude Code sessions and CLAUDE.md projects, then recommends the optimal reasoning effort level (low/medium/high) for each workflow type. Configures claude-sonnet-5 as the pinned model with per-workflow effort settings, explains the token cost trade-offs, and validates the change is working as expected.

Audit and configure enterprise-managed MCP authorization (EMA) for organizations using Okta and Claude Team/Enterprise. Inventories current connector state, generates Okta provisioning configuration, validates scope assignments by IdP group, and produces a per-connector access report. Works across Claude Chat, Claude Code, and Cowork.

Audits a repository for all Cascade (legacy Windsurf local agent) references and migrates them to Devin Local. Finds CI configs, shell scripts, Makefiles, agent rules, and tool definitions. Generates a reviewed patch and flags any custom Python tool definitions that need manual rewrites. Run this on or after July 1, 2026 when Cascade reaches end-of-life.