ai-skills

This skill should be used when the user wants to find AI-generated code slop — unnecessary comments, defensive checks, `any` casts, and style inconsistencies — in a branch's changes. Produces suggestions only; does not apply edits.

Workflow-native quality gate for branch changes — parallel reviewers (Bug, SOLID, Security, Simplify+Slop, optionally React/a11y/i18n/migration) with tier-scaled adversarial verify, CLAUDE.md/ADR enforcement, and a stable PASS / PASS WITH NOTES / FAIL verdict. Read-only. Runs from a static shipped workflow script.

Publish a pull request with automated type detection, Linear/Jira linking, PR templates, and Slack review message.

This skill should be used when the user wants to triage a pull request's review feedback and CI status — retrieving inline review comments, review summaries, conversation comments, and failing status checks, then classifying each item as P1 / P2 / Nit and proposing an ordered action plan. Triggers on "review PR feedback", "check PR comments", "what's blocking my PR", "classify review comments", "PR CI failures", "triage PR", or a bare PR number/URL.

This skill should be used when the user wants to write their end-of-day / evening "build-in-public" update for a given Linear project — 2-3 impact-focused bullets plus a Next line synthesized from the project's Linear activity and the repo's git/PR shipping evidence, ready to paste into the pod thread. Invoke as /build-in-public with a Linear project ID. Triggers on "build-in-public post", "evening update", "what did I ship today", "end-of-day update", or any variant of "what did I do today" for a work update — even without the word "skill". Default to drafting; never post anywhere automatically.

Babysit your open PRs on a loop. Each tick scans your PRs for new reviews, bot comments, and CI, triages via /pr-feedback, batches clear nits through /pr-respond, and PushNotifications on APPROVE or a merge-ready PR. Triggers on "babysit my PRs", "surveille mes PRs", "watch my open PRs".

Watch a PR's CI hands-free after a push. A persistent Monitor streams each check as it lands; the skill auto-handles the mechanical (rebase a clean conflict, fix lint) and STOPs on any judgment (failing tests, a stack restack, going ready). Triggers on "watch CI", "surveille la CI", "attends la CI", or right after /pr or a push.

Draft Benjamin's daily Slack update for the Naboo team from Linear. Pulls his issues closed since the previous work day (DONE), currently started (IN PROGRESS), and optionally blocked (BLOCKERS), formats them in the team's Slack style, and iterates in chat until approved. Triggers on "daily update", "daily post", "write my daily", "standup post", or "what did I do yesterday".

This skill should be used when reviewing someone else's pull request and you want to turn gate / gate-wf findings into posted GitHub comments — each comment drafted through humanizer and posted as a standalone inline comment at its file:line, after one confirmation. Triggers on "post these as review comments", "comment the gate findings on the PR", "draft and post my review", "leave review comments", after a gate / gate-wf run on a PR you're reviewing.

Deterministic quality gate for branch changes — runs parallel reviewers (React, SOLID, Security, Simplify, Slop) with self-consistency, returns a stable PASS / PASS WITH NOTES / FAIL verdict. Read-only by default; opt-in --fix applies BLOCKER fixes only.

This skill should be used after pr-feedback triage, when the user has picked which review items to act on and wants them applied and answered — apply the agreed code change per item, then post the reply, reaction, and (for inline threads) thread resolution in one confirmed batch. Triggers on "apply the PR feedback", "respond to the reviewers", "resolve the threads", "post my replies", or selecting items after a pr-feedback report.

Specialist for TypeScript backend development including Node.js servers, NestJS applications, APIs, databases (PostgreSQL, MongoDB, Redis), authentication, testing, deployment, server-side code, microservices, database queries, migrations, controllers, services, repositories, and middleware. Use for ANY work involving .ts backend files, server-side architecture, performance optimization, and backend security.

Specialist for modern React applications, TypeScript frontend code, UI development, TanStack Query, component creation, CSS styling, responsive design, accessibility, form validation, state management, routing, and performance optimization. Use for ANY work involving .tsx/.jsx files, React components, frontend bugs, or client-side development tasks.

Create and manage Claude Code hooks for automating workflows, validating inputs, and customizing behavior. Use when users request to create hooks, set up automation for tool usage (PreToolUse, PostToolUse), add session context (SessionStart), validate prompts (UserPromptSubmit), control stopping behavior (Stop, SubagentStop), or configure permission handling (PermissionRequest).

Run parallel quality reviews (React, SOLID, Security, Simplification, Slop) on branch changes and auto-fix issues

Investigate a High/Urgent bug on Linear and post a structured root-cause comment in the team's format (Root cause → Timeline of PRs → Category → what the fix does → follow-up). Drafts in chat first; posts to Linear only on explicit approval. This skill should be used when asked to document why a bug happened, write a root-cause comment, or "post the root cause" for a Linear issue ID or URL.

Audit and refactor CLAUDE.md, AGENTS.md, and .claude/rules/ files to follow progressive-disclosure principles. This skill should be used when the user wants to reorganize, clean up, or optimize their instruction files and rules by splitting monolithic files into a minimal root, domain-scoped rules with path globs, and linked reference docs. Triggers on requests like "refactor my CLAUDE.md", "clean up my rules", "audit my instructions", "organize my agent config", "optimize my rules files", or "migrate my CLAUDE.md to rules".

Reflect on the work done on the current branch vs main — mine devsql history, git log, and session transcripts for back-and-forths, rollbacks, and wasted time, then interview the user to distill durable lessons into a local-ignored CLAUDE.local.md.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".

Re-explain a technical concept, code path, or review finding you just produced in plain language, for a reader who is not in that domain. Use when the user says it's "charabia"/gibberish, asks you to "explique simplement", "traduis en clair", "je comprends pas", "explain like I'm not a specialist", or otherwise signals the previous explanation was too jargon-dense.

Execute a qa-plan interactively. The plan can live locally (qa-plan-X.md) or remotely on Linear (sub-issue created by /qa-plan --linear). Walks through each scenario with the user, logs status + findings + notes to a sibling qa-results.md (append-only, source of truth). When the source is Linear, mirrors findings and the final summary as comments on the sub-issue. Supports resume — re-running picks up at the first unchecked or failed case. Verification stays browser-only (admin UI + email sandbox); no terminal/DB/GraphQL is used to confirm a pass. A dev runner may read the source to root-cause a failure and cite file:line in the finding. This skill should be used to run a manual QA pass against a plan produced by /qa-plan, whether the runner is the dev (dogfooding before handoff) or the PM/QA tester.

Build or harden a reliable browser-automation skill through a self-improving loop, with no Anthropic API key. Each iteration runs a headless `claude -p` inner agent that drives a local isolated Chrome via chrome-cdp, reads the run trace, adds one heuristic to strategy.md, and repeats until the task passes — then publishes a standalone skill. Use when asked to make a browser navigation task reliable, build/improve a browser automation skill, auto-tune a web workflow, or run a "self-improving browser loop". Local Chrome only (no Browserbase/remote, no codegen, no parallel fan-out).

Draft a manual QA test plan for a pull request, tailored for a PM or QA tester (not a developer). Auto-detects the current PR from the branch, or takes a PR number/URL. Produces steps that can be run with only a browser and the app's admin UI — no terminal, SQL, GraphQL, or code access. Always renders in chat for review and iteration first; publishes to a markdown file, GitHub issue, or Linear sub-issue only on explicit approval. Companion skill `qa-run` (future) will guide the tester through executing the plan. This skill should be used when asked to create a QA plan, test checklist, or manual test cases for a PR.

Remove signs of AI-generated writing from text and progressively learn the user's personal writing style. Use when editing or reviewing text to make it sound natural and human-written, or when the user says "humanizer init" / "humanizer update: ..." to customize the skill. Based on Wikipedia's "Signs of AI writing" guide; detects inflated symbolism, promotional language, superficial -ing analyses, vague attributions, em/en dash overuse, rule of three, AI vocabulary words, passive voice, negative parallelisms, hyphenated-pair overuse, authority tropes, signposting, and filler phrases. Supports a personal STYLE.md at ~/.config/humanizer/STYLE.md (shared across Claude Code and Codex) that overrides the default rules. Credits: Original skill by @blader - https://github.com/blader/humanizer

Extract and reproduce a specific person's coding style from a git repository. Use this skill whenever the user wants to analyze how a teammate codes, build a reusable style profile from someone's commits or PRs, make code generation match a particular author's conventions, onboard into a codebase by mirroring its dominant author, or clone/imitate a coding style. Triggers on requests like "match X's style", "how does X code", "write this the way X would", "extract someone's coding patterns", "reproduce my teammate's conventions" — even when not phrased as a "skill" and even when the author is referred to indirectly.

Announce that a feature is ready for manual QA on its ephemeral environment by creating a "[PRODUCT QA]" sub-issue on Linear with the QA label applied at creation, so the team's product_bot auto-posts the ephemeral-env links to the #product-qa Slack channel. Drafts the body from the PR diff and the parent Linear issue (what-to-test + scope + env block), renders in chat for approval, and publishes only on explicit confirmation. This skill should be used when asked to announce a feature for product QA, signal that a PR is ready for QA on an ephemeral/preview env, notify the QA channel, or "annonce QA".

Investigate a task or conversation from an issue tracker (Linear or Jira) or Slack. Fetch context from the tracker ticket, Slack threads, previous work, and the codebase to understand an issue and plan next steps. This skill should be used when asked to investigate, look into, or gather context about an issue ID (e.g. ENG-1234, MITB-565), an issue URL (Linear or Jira), or a Slack message/thread URL.

Use Atlassian CLI (acli) to manage Jira work items, projects, and workflows from the command line. Ideal for bulk operations, automation, scripting, and when users request CLI-based Jira interactions. Trigger on requests like "use Jira CLI", "create Jira issues via CLI", "bulk update Jira tickets", "automate Jira workflows", or when users want to script Jira operations.

This skill should be used when implementing code that requires SOLID principles and clean code practices. It provides detailed guidance on Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles with comparison examples in TypeScript.

Interact with a local Chrome browser session via Chrome DevTools Protocol (only on explicit user approval after being asked to inspect, debug, or interact with a page open in Chrome). Pass `--isolated` to drive a sandboxed Chrome with a dedicated profile instead of the user's real browser.

Use OpenAI Codex CLI in non-interactive mode for automated code analysis, review, and programmatic task execution. Trigger on requests like "use Codex to analyze", "run codex exec", "codex code review", or when users want AI-powered code analysis without interactive prompts. Ideal for automation workflows, code quality checks, and generating structured analysis reports.

Stage and commit pending changes with an automatically generated concise message. This skill should be used when the user asks to "commit", "stage and commit", "make a commit", or "save changes to git". Does not push or create PRs.

Use confluence-cli (NPM package) to manage Confluence content, pages, and spaces from the command line. Ideal for documentation workflows, bulk content operations, page migration, and when users request CLI-based Confluence interactions. Trigger on requests like "use Confluence CLI", "create Confluence pages via CLI", "migrate Confluence content", "automate documentation workflows", or when users want to script Confluence operations.

Run a structured prompt N times and consolidate via deterministic vote (self-consistency, Wang et al. 2022). Use when output stability matters more than latency — code review, finding extraction, classification, triage. Triggers on "self-consistency", "consensus", "vote on", "stable output", "run N times and merge".

This skill should be used when the user wants a ranked list of the highest-leverage technical or architectural improvements to make to their project, presented as a ranking matrix. The technical counterpart to `innovate`. Triggers on requests like "elevate", "biggest tech wins", "best architectural moves", "what should I upgrade", "improvement opportunities", or "tech audit". Accepts an optional focus argument (e.g., "feedback-loop", "dx", "build speed", "testing", "observability") to constrain the search.

This skill should be used when the user wants a ranked list of the highest-value product additions or feature changes to make to their project, presented as a ranking matrix with one explicit recommendation. The product counterpart to `elevate` (which targets architecture/tooling/DX). Triggers on requests like "innovate", "what should I build next", "best product moves", "next big thing", or "what feature would matter most". Accepts an optional focus argument (e.g., "activation", "differentiation", "AI", "onboarding").

Interview user to clarify any topic - exploring codebase, investigating issues, planning features, understanding requirements, or drilling into plans. Socratic questioning to uncover details.

Create autonomous iterative loops (Ralph Wiggum pattern) for multi-step tasks. Use when setting up automated workflows that iterate over a backlog of tasks with clear acceptance criteria. Triggers on requests like "create a ralph loop", "set up an iterative agent", "automate this migration", or "create an autonomous loop".

This skill should be used when the user wants to rebuild a just-completed implementation from scratch on a fresh branch, applying everything learned during the first pass. The first pass is exploration; the second pass is the real solution. Triggers on "second pass", "rewrite now that you know", "rebuild from scratch", "do it again better", or "knowing what you know now".