Latest Agent Skills

Write the executable feature specification — the WHAT and WHY artifact that agents and reviewers treat as source of truth. Owns both /specify and /clarify modes. Load when the user asks to write a feature spec, write a specification, write an executable spec, define functional requirements, capture acceptance criteria as Given/When/Then, or when the spec-driven-development orchestrator routes here. Also triggers on "feature spec", "executable spec", "/specify", "/clarify", "write the spec for this feature", "specification for", "spec-driven", "machine-readable spec". Output: docs/specs/YYYY-MM-DD-<slug>-feature-spec.md. Hard gate: cannot Approve while [NEEDS CLARIFICATION] markers remain.

Identify the right tool for a process step. Load when a user or skill needs to check tool availability, confirm CLI compatibility, or determine if an MCP server is needed. Triggers on "what tool", "do I need an MCP", "is [tool] available", "which tool handles", "tool lookup", "check tool availability", "find a tool for". Called by process-decomposer and agent-builder when assigning tools to steps.

Reduce an oversized SKILL.md by checking whether an existing skill already covers the excess sub-workflow before creating a new child skill only when none fits. Load when a skill exceeds 200 lines and compress-skill determines excess content is genuinely CORE, when the same sub-workflow appears in multiple skills, or when universal-skill-creator or improve-skills identifies a coherent sub-capability. Also triggers on "split this skill", "extract a sub-skill", "this skill is doing too much", or "make this skill reusable". Always checks for an existing home before creating a new skill.

Apply one logical code change with mandatory impact mapping, git snapshot, verification, and automatic revert on failure. Load when the user asks for a safe edit, verified change, one change at a time with rollback, or codespine-style edit loop. Also triggers on "safe change", "edit with verification", "don't break the build", "revert if tests fail", or any non-trivial code edit where blast radius matters. Always runs dependency-mapping first. Pairs with incremental-implementation for multi-slice work; this skill is one atomic verify cycle per invocation.

Critically audit agent skills and remove content that is outdated, disproven, model-specific, or based on poorly cited sources. Load when improve-skills runs its per-skill cycle, when the user asks to prune skills, remove outdated techniques, check if skills are still valid, verify citations in skills, audit skill sources, or update skills for a new model release. Also triggers on "are these skills still valid", "check for obsolete techniques", "verify skill citations", or "update skills for GPT-5/Claude 4/Gemini 2". Runs before split-skill and compress-skill — removing bad content first means the remaining content is worth preserving.

Run a structured discovery interview and produce a complete, developer-ready Product Requirements Document. Load when the user asks to write a PRD, create product requirements, document a feature, define user stories with acceptance criteria, or turn a rough idea into a formal product requirements document. Also triggers on "document this feature", "write requirements for", "create a one-pager", "turn this into a PRD", "I need a PRD for", or any request to produce a structured product document for stakeholder alignment or engineering handoff. Supports Full PRD, Lean PRD, and One-Pager formats. Note: for executable feature specifications (FRs, NFRs, ACs as Given/When/Then consumable by AI coding agents), route to `feature-spec` instead — PRDs frame the product, feature-specs encode the implementable contract.

Orchestrator for the eval-output skill suite — evaluate LLM and agent outputs for quality, accuracy, helpfulness, and safety using structured rubrics and LLM-as-judge techniques. Load when the user says "evaluate this output", "score this response", "run an eval", "LLM as judge", "evaluate agent output", "how good is this response", "rate this answer", "eval this", or provides an LLM output that should be assessed for quality. Single entry point for all output evaluation workflows.

Guided first-run that produces a real verified win in under five minutes using the skill library on a seeded offline fixture. Load when a new user asks how to start, run the demo, try agent-loom, or get a quick win. Also triggers on "quickstart", "first run", "demo agent-loom", "try the skills", or onboarding to the library. Zero external credentials required. Idempotent — safe to run multiple times.

Run a pre-mortem — imagine the project has already failed one year from now and work backward to find the root causes before they happen. Load when the user asks for a pre-mortem, wants to imagine failure before committing, asks "what could go wrong before we start", "assume this fails — why", "risk analysis before launch", "what kills this project", "what could go wrong", or when deep-thinking diagnoses a pre-mortem frame. Based on Gary Klein's prospective hindsight method, which surfaces failure causes more effectively than forward risk analysis. Most useful right before a major commitment.

Orchestrator for the learn-from suite - auto-detects source type (academic paper, GitHub repo, blog/web article, or in-conversation learnings) and routes to the correct sub-skill for credibility check, security scan, insight extraction, and application. Load when the user says "learn from", "learn from this", "extract insights from", "apply learnings from", "what can we learn from", or provides a URL, file path, or pasted content that should be ingested as knowledge. Single entry point for all learning workflows.

Mirror issues and status across issue trackers with stable external-ID mapping to avoid duplicates. Load when syncing GitHub and Linear issues, mirroring ticket status, or keeping two trackers in sync. Also triggers on "issue sync", "sync issues", "mirror issues to", "keep Linear and GitHub in sync", or bidirectional issue tracker updates. Requires API access on both sides — stops if credentials missing.

Score LLM and agent outputs using LLM-as-judge techniques — direct scoring against rubrics or pairwise comparison between two outputs. Includes built-in bias mitigation for position bias, length bias, and self-enhancement bias. Load when the user asks to score an output, judge a response, evaluate against a rubric, compare two outputs, do direct scoring, run pairwise comparison, or says "rate this", "which response is better", "score this against the rubric", "judge this output", "LLM as judge this". Sub-skill of eval-output orchestrator.

Append structured execution traces across operational, cognitive, and contextual surfaces with minimal overhead. Load when inspecting agent runs, logging tool calls and observations, enabling post-run debugging, or pairing with structured-planning step IDs. Also triggers on "trace this run", "log execution", "agent observability", "run log", or when fault-localize needs evidence. Default-on during multi-step plans. Traces live at .agent-loom/traces/ — git-ignored by default.

Flip a problem, goal, or decision 180 degrees to find what forward thinking misses. Asks what would guarantee failure, then works backward to what must be avoided or changed. Load when the user says "invert this", "flip this problem", "what would guarantee failure", "think backward", "reverse engineer the goal", "think about it backwards", or when deep-thinking diagnoses an inversion frame. Also triggers on "what's the opposite of success here", "how would we sabotage this". Two methods: Failure Inversion and Opposite Goal. Max 2 clarifying questions before inverting. Always returns forward actions. For broader analysis, deep-thinking calls this.

Break a stuck or complex problem into the smallest sub-question that, if answered, unlocks the next step — then answer it and repeat until the path forward is clear. Load when a problem feels genuinely stuck, when reasoning keeps circling, or when deep-thinking diagnoses a Socratic frame. Also triggers on "I keep going in circles", "what is the real question here", "help me reason through this step by step", "unstick my thinking", "recursive questioning", "what is the root question". Based on the recursive Socratic questioning method (EMNLP 2023) which outperforms CoT and Tree-of-Thought on complex reasoning tasks.

Orchestrate persistent agent memory across coding sessions, repos, and tools. Load when the user asks to remember, recall context, save project memory, create a handoff, manage global memory, update memory, compact memory, audit memory, forget memory, continue from prior sessions, or before commit/push/git operations that checkpoint project state.

Decompose an unknown quantity into 3-5 estimable factors and produce a defensible order-of-magnitude answer without needing precise data. Load when the user needs to size something without data — market size, resource requirements, effort estimates, user numbers, costs — or when a decision is blocked by "we don't know the numbers". Also triggers on "ballpark this", "rough estimate", "how big is this market", "how long would this take", "how many users", or when deep-thinking diagnoses a sizing/estimation frame. The goal is not precision — it is a defensible answer that enables a decision to be made. Based on Enrico Fermi's estimation method.

Apply Boyd's OODA loop to navigate fast-moving, uncertain, or competitive situations — Observe what is actually happening, Orient through mental models and context, Decide on the clearest path, Act quickly, then loop again. Load when the situation is changing faster than the current plan, when a competitive response is needed, when the user is stuck in analysis paralysis in a dynamic environment, when shipping under uncertainty, or when deep-thinking diagnoses a fast-moving / competitive frame. Triggers on "what should we do right now", "the situation is changing", "how do we respond to this", "competitive response", "we need to move fast", or "we're stuck deciding". Based on John Boyd's OODA loop — Observe, Orient, Decide, Act — adapted for product and business contexts (OODA Canvas 2026).

Design the architecture for a multi-command skill system — the shared state schema, the command map, the router, and the boundary each command stops at — before any skill files get written. Use when the user wants to turn one skill into a system, combine several related or overlapping skills into a single coherent one, build a skill with subcommands (like `/thing audit`, `/thing polish`), design a suite, family, or collection of skills, or asks "how should I structure this skill set". Also trigger on "skill system", "skill architecture", "multi-command skill", "system of skills", "make these skills work together", "skill with slash commands", or complaints that their skills overlap, collide, duplicate each other, or never fire. Produces an architecture spec only — it never writes SKILL.md or reference files. Hand the finished spec to skill-creator to build from.

Blog and web-content system for agency work — plan topics, interview the author for their real take, brief the angle, draft the article, plan images, verify claims, score drafts for quality and AI tells, revise, publish, and refresh aging posts. Shorthand "wltbo" also triggers it. Commands share a per-client memory of brand voice, the author's positions and stories, verified facts with expiry dates, and every published post. Use for blog posts, articles, long-form content, refreshes, keyword targeting, search intent, titles and H1s, meta descriptions, internal linking, cannibalization checks, E-E-A-T, and information gain. Also use when the complaint is "it doesn't sound like us", "it reads AI-written", "it's generic", "we already wrote this one", "the facts are made up", "there are no images", "it's too thin", or "nobody thought this through". Not for social posts, emails, internal comms, case studies (case-study-builder), site audits (website-audit), or content calendars (content-strategy).

Pre-writing interview that captures the author's real opinions, experiences, and stances on a blog topic before the post is written on their behalf — the companion that runs BEFORE seo-blog-writer. Use this skill automatically whenever a blog post or article is about to be drafted under the user's name or brand — run the topic interview first, then hand the resulting Opinion Packet to seo-blog-writer. Also use it when the user says "interview me about this topic", "get my take first", "ask me what I think", or "update my opinion bank". Scope: blog/article topics only — not emails, docs, social posts, or other writing. If a blog post is about to be written as the user's voice and their take on the topic hasn't been captured, this skill triggers — even if they only asked for "a blog post about X".

Mine a codebase or product for underexploited assets — capabilities, infrastructure, data, integrations, and workflows built for one narrow purpose that could produce far more value. Finds platform primitives hiding inside features, internal tooling that could serve customers, and data accumulated but never leveraged. Produces an evidence-gated report (max 5 opportunities, mandatory kill list, one forced answer) plus a wwbd_packet JSON. Use whenever the user says "WWBD", "what would Bezos do", "what are we sitting on", "what did we accidentally build", "what could this become", "find opportunities in this repo", "what are we underexploiting", "is there a product hiding in here", or wants to know if existing infrastructure has a bigger economic surface than it currently serves. Trigger on casual phrasings too ("anything valuable buried in this codebase?"). Analyzes what EXISTS — missing features go to gap-scan, broken code to code-audit, confusing flows to ux-audit, weak persuasion to conversion-audit.

Rewrite any prompt, instruction, task description, or spec into a "genie-proof" version — instructions so explicit, literal, and loophole-free that even a maliciously literal genie (or an LLM, contractor, or junior dev) could not misinterpret them. Use this skill whenever the user asks to genie-proof, tighten, harden, de-ambiguate, or "make bulletproof" a prompt or instruction; whenever they complain that an AI/model/person "didn't do what I meant," "took me too literally," or "found a loophole"; or whenever they hand over a vague prompt and ask to make it precise, explicit, unambiguous, or idiot-proof. Also trigger on phrases like "wish to a genie," "monkey's paw," "lawyer-proof this prompt," or "leave nothing to interpretation."

Score any piece of writing for AI-generation tells and produce a weighted 0-100 scorecard with flagged evidence and ranked fixes. Use this skill whenever the user asks "does this sound AI-written", "run this through the AI detector", "score this writing", "check this for AI tells", "would this pass as human", "humanize check", or wants any article, blog post, email, or copy audited for AI patterns before publishing. Also use it when the user pastes or points to text and asks how it reads, whether it's too "ChatGPT-ish", or wants a QA pass on generated content. Works on pasted text, files, and URLs.

Build client case studies through a low-overwhelm, multiple-choice interview plus whatever files the user can dig up — producing web-ready case study copy with a media plan (what images/videos to provide, find, or generate). Use this whenever the user wants a case study, client success story, portfolio write-up, results page, testimonial feature, or says "write up what we did for [client]". Also trigger when the user mentions having clients but no case studies, wants to turn a finished project into marketing proof, or casually says "I should really do a case study for X" — even without the word "case study" (e.g. "I want to show off the work we did for that gym").

Check whether any custom Claude skills are missing from the skills repo (github.com/Theycallmeholla/skills, cloned at /Users/cursivemedia/skills) and add them in the repo's expected format, update the README index, then commit and push. Use when the user says "sync my skills repo", "check for new skills", "update the skills repo", "push my skills to github", "backup my skills", or right after a new custom skill has been created. Also use for a dry-run check like "are any skills missing from my repo?".

Synchronizes Claude skills from the skills repo (github.com/Theycallmeholla/skills) to the local ~/.claude/skills directory, ensuring local skills match the repo's latest versions. Compares each skill to detect new or changed content, creates a tarball for manual Claude app upload, and preserves local-only skills that aren't in the repo. Use when the user says "push skills out", "sync repo to local", "update my local skills from the repo", "distribute skills", "my local skills are stale", "refresh skills from github", or after pulling updates from the skills repo. Runs in dry-run mode by default to preview changes before applying them with --apply.

Audit a landing page or marketing site through one lens: what is the ONE thing this page wants the visitor to do, and does every element on the page move them toward it? Reconstructs who lands on the page and why, spawns visitor-persona agents to react to it cold, maps the belief chain a visitor must climb before acting, inventories CTAs and everything competing with them, then delivers a prioritized cut/move/add/rewrite plan. Use whenever the user asks "what do we want people to do on this page", "is this page converting", "critique this landing page", "why would someone book/buy/sign up here", "audit the funnel on X page", or wants strategic critique of page content and structure (not visual polish). Works from frontend code in a repo, a live URL via browser tools, or pasted copy/screenshots. Judges persuasion and intent-alignment; for flow usability and friction use ux-audit, for visual and aesthetic quality use the impeccable critique/audit skills.

Show the quick-reference guide for the whiteboard planning system (whiteboard, hot-seat, napkin, connotation-cop) — the flow, what to say, and the rules. Use when the user asks "whiteboard help", "how do I use the whiteboard", "what's the flow", "remind me how whiteboard works", "which skill do I use", or seems unsure how to start or continue a whiteboard effort. This skill only DISPLAYS the guide — it never starts a board, resolves tickets, or does any work.

Generate browser walkthrough recordings as GIF and MP4 from a natural language description. Use this skill whenever the user wants to record a browser walkthrough, create a product demo, document a UI flow, generate onboarding visuals, or produce a "how to" screen recording for any web app. Triggers include: "record a walkthrough of", "create a GIF showing how to", "make a demo of", "capture the flow for", "show how [feature] works in the browser", "document this UI flow", or any request combining a browser/web app with recording/capture/demo output. The skill generates a local Node.js/TypeScript project that the user runs on their machine using Stagehand + Playwright for AI-controlled browser automation, and gifski/ffmpeg for output. For quick one-off captures in the user's live browser session, prefer the claude-in-chrome gif_creator tool instead; use this skill when a re-runnable script, MP4, high-quality GIF, clean-profile recording, or CI repeatability is needed.

Assess the test suite of a codebase — where tests are missing, where they exist but are weak, and which gaps actually matter. Use this skill whenever the user asks about test coverage, test quality, "are there enough tests", "where should we add tests", testing gaps, test debt, untested code paths, flaky tests, or generally wants to know whether a codebase is well-tested. Trigger even on casual phrasings ("is this tested?", "what's the test situation?", "audit our tests"). This skill does NOT write tests — it only assesses what exists and identifies what's missing. For test generation, this is the wrong skill.

Research-driven SEO content writer that produces publication-ready markdown articles built around search intent, verified claims, and original value. Use this skill whenever the user asks for a blog post, article, long-form content, "content for our site", a post targeting a keyword, a content refresh or audit of an existing article, or anything meant to be published on a website — even if they never say "SEO". Also use it when the user mentions keywords, search rankings, organic traffic, content marketing, meta descriptions, keyword cannibalization, or asks to "write something about X for the blog". If a piece of writing is destined for the web and could benefit from search visibility, use this skill.

Police the project's vocabulary — bust vague terms, keep the CONTEXT.md glossary sharp, and lock in decisions worth remembering as ADRs. Use when the user debates naming, says "what should we call this", asks to pin down terminology, wants a decision recorded, or when another skill (hot-seat, whiteboard) surfaces a decision that clears the ADR bar. Just reading the glossary for vocabulary is NOT this skill — trigger only when the words or decisions are being changed.

Analyze a website page's UI for obvious oddities: the same information repeated multiple times (a phone number shown three times in the header, a '24/7' badge in two places, a bullet list restating the paragraph above it), duplicated or near-duplicate copy and sections, stray/orphaned text near CTAs, copy that doesn't match the business or section subject, placeholder text, overcrowded heroes, misaligned elements, and imagery that doesn't fit the business. Use this whenever the user asks to check, audit, review, sanity-check, QA, or 'look over' a web page, landing page, or UI — whether they give a live URL, a localhost/dev-server URL, a screenshot, or HTML/JSX/template files — even if they only say something casual like 'does this page look right?', 'find anything weird on this page', or 'anything off about my landing page?'.

Auto-audit any website end-to-end — technical health, SEO basics, broken links, mobile rendering, design quality, copy clarity, and conversion readiness — producing a scored, evidence-backed report. Two modes: PROSPECT mode (fast audit of a lead's site to generate evidence for outreach; emits a portable audit_packet JSON other tools can consume) and QA mode (deep pre-launch / post-launch gate on a site you built, with pass/fail checklist). Use whenever the user asks to "audit this site", "run a website audit", "what's broken on this site", "check this prospect's website", "QA this build", "is this site ready to launch", or provides a URL asking what works and what doesn't.

Generate user-friendly "Explain Like I'm 5" feature documentation for end users by reading the codebase. Use this skill whenever the user wants to document a feature for non-technical users, write help docs, create an explainer for a feature in their app, produce onboarding content, or asks "make a user doc for X". Trigger on phrasings like "ELI5 the closeout flow", "write user docs for the kanban view", "explain this feature to a customer", "make a help article for X", "document this for end users". Also known as "E-features-LI5". This skill produces plain-language docs written for someone with the app open trying to get something done — not internal developer docs (use the `teach` skill for those) and not feature announcements.

Propose specific, actionable test cases for a target module — without writing the actual test code. Use this skill whenever the user wants to know "what should I test", "what test cases would catch real bugs in X", "I have a finding from test-assessment, what tests would close that gap", "suggest tests for this file", or wants to think through coverage before writing. Pairs with the test-assessment skill (which finds gaps); writing the test code itself happens as a normal follow-up task once the suggestions are reviewed. This skill stops at suggestions — if the user wants code generated, redirect them. Trigger even on casual phrasings ("what should I test in auth.ts", "give me test ideas for this module").

Write the context brief a first-time tester gets before testing an app, tool, codebase, or product — it explains WHAT the thing is and why it exists, while deliberately withholding HOW anything works. The companion to the fresh-eyes skill; the brief it produces is the "starting information" handed to a fresh-eyes tester. Use this whenever the user is preparing a fresh-eyes or first-time-user test and needs the setup material, or says things like "describe my app without giving anything away", "write the context card for the tester", "explain what it is but not how to use it", "set up the newcomer test", "what would the tester be told going in?", or wants a spoiler-free description of their product. Also use it when someone asks for the briefing/intro that a new tester, new hire, or evaluator should receive before first contact with the thing being tested.

Plan a chunk of work too big for one agent session by putting it on a shared whiteboard — a map of investigation tickets on GitHub Issues — working them until nothing is left to decide, then snapshotting the board into a handoff artifact. Tickets needing nobody are worked back-to-back; the session stops when the human is the blocker. Use only when the user explicitly invokes whiteboard or asks to draw, work, run, or snapshot a whiteboard/map — not for ordinary planning requests.

Runs a Tinder-style swipe interview to pull requirements out of someone's head. Claude generates a deep pool of question cards, the user swipes right/left/up/down (yes / no / absolutely / not sure), the deck reshapes itself around every swipe, and it ends in a written brief once a saturation meter fills. Use this whenever a request is vague, broad, or taste-dependent and you would otherwise fire off a list of clarifying questions — kicking off a project, scoping a build, planning a trip or event, choosing a direction, naming something, deciding what to eat, or any "help me figure out what I want". Trigger on "swipe", "swipe deck", "tinder style", "interview me", "ask me questions", "quiz me", "20 questions me", "figure out what I want", "get it out of my head". Also reach for it proactively any time you catch yourself about to ask more than three clarifying questions in a row, or when someone says a batch of questions felt like a chore or a form.

Sets up and audits the Claude Code harness for a project: CLAUDE.md, .claude/rules, skills, subagents, settings.json permissions, hooks, verification loop. Commands: kickoff (scaffold new setup), check-playbook (score an existing one), scouting-report (last scorecard), adjust (fix bloat/misplaced instructions), drill (turn advisory prose into real hooks/permissions/CI), decline (record an accepted risk), gameplan (work order with acceptance criteria before building), watch-film (check a diff against that order for scope creep/weakened tests/false claims). Use for setting up Claude Code, or on: "Claude ignores my CLAUDE.md", "it's huge and still misses things", "it said done but ran nothing", "it changed files I didn't ask about", "it weakened a test to pass", "rule, skill, or hook?", "is my setup any good". Not for code quality (code-audit), test coverage (test-assessment), one-off prompt wording (genie-proof-prompts), new skill authoring (skill-creator), or compacting a conversation (handoff).

Approach an app, tool, codebase, website, or product as a genuine first-time user with zero insider context — try it out using only the information provided, get confused where a real newcomer would, and surface the "obvious" questions that people who built or use the thing daily can no longer see. Use this whenever the user wants a first-time-user test, a fresh perspective, a naive walkthrough, a cold read of their README/onboarding/docs/UI, or says things like "pretend you've never seen this", "would a new user get this?", "test my app like a beginner", "what would confuse someone new?", or "give me fresh eyes on this". Also use it when someone wants to find gaps in onboarding, docs, or first-run experience — even if they don't say "fresh eyes" explicitly.

Perform a structured audit of a codebase covering security, code quality, performance, dependencies, architecture, and testing hygiene, then produce a prioritized findings report. Use this skill whenever the user asks for a code review, code audit, security review, codebase assessment, "look over this repo", "what's wrong with this codebase", legacy-code triage, pre-acquisition technical due diligence, or any request to systematically evaluate the health of a project. Trigger even when the user is casual ("can you eyeball my repo?") — this skill imposes the structure that ad-hoc review misses. This skill audits a whole repository at a point in time — for reviewing a diff or PR use the built-in code-review skill; for security checks on pending changes use security-review.

Reconstruct a product flow, then audit how usable it is — whether it makes sense, where users get confused or stuck, whether the copy and instructions are clear, and where friction causes drop-off. Produces a prioritized, severity-weighted findings report. Works from three inputs: frontend code in a repo, a live running app driven via a browser, or a written flow / spec / screenshots. Use this skill whenever the user asks for a UX review, usability audit, "is this flow confusing", "does this signup/onboarding/checkout make sense", "why are people dropping off", "audit this form", "where's the friction", or hands over a flow and asks whether it's user-friendly. Trigger even on casual phrasings ("is my checkout any good?") — it imposes the structure ad-hoc UX opinions miss. Audits flow usability and friction; for visual polish and interface quality the impeccable audit/critique skills apply instead.

Put the user in the hot seat — one question at a time until their plan, decision, or idea actually holds up. Use whenever the user says "hot seat me", "grill me", "stress-test this", "poke holes in this", "am I missing anything", or drops a plan and wants it challenged before anyone acts on it — even if they never say the words. Also used as a sub-procedure by the whiteboard and connotation-cop skills.

Scan a codebase, live app, or site and find the features that obviously should exist but don't — missing exports, bulk actions, search/filter, undo, history, notifications, dead-end workflows, data collected but never surfaced, backend endpoints with no UI, and half-built features that stopped partway. Produces an evidence-backed, ranked punch list (top 10 max) with a portable gap_packet JSON. Use whenever the user asks "what features are missing", "what's this app lacking", "find gaps", "run gap-scan", "feature audit", or wants proposal ammo from a prospect's app. Also use it to recheck an existing gap_packet — "what's left to do", "recheck the gaps", "what got built since" — re-verifying findings against current code and marking stale ones superseded. Flags ABSENCE only — broken code goes to code-audit, confusing flows to ux-audit, weak persuasion to conversion-audit, underexploited assets to a WWBD-style analysis. If something exists but is bad, it's not a gap — hand it off.

Restructure any response for an ADHD brain — TL;DR first, ELI16 clarity, short punchy steps, one clear next action, zero walls of text. Use this skill whenever the user says "elihadhd", "adhd mode", "tldr", "eli16", "eli5", "too long", "overwhelmed", "shorter", "just tell me what to do", "break this down", "snap it", "gauntlet", or shows signs of overwhelm (e.g. "wait what", "I'm lost", "too much"). Also use it when the user asks for the simple version, the quick version, or the punchy version of anything — explanations, plans, debugging help, docs, decisions. When in doubt about whether a response is too heavy, use this skill.

Compact the current conversation into a handoff document so a fresh agent can pick up the work with zero prior context. Use when the user wants to end a session and continue later, is running low on context, says "write a handoff", "hand this off", "summarize for the next session", "compact this", or wants to transfer work to another agent or teammate.

Build throwaway code that answers exactly one design question — a tiny terminal app to feel out logic/state models, or several radically different UI variants switchable on one route. Use when the user wants to "prototype", "mock up", "sketch", "try a few versions", "see what it'd look like", "feel out this state machine", or is stuck choosing between designs they can only judge by seeing or driving them. Also used by the whiteboard skill for napkin-type tickets.

Generates a structured developer-facing markdown document that teaches how a specific feature, module, or piece of functionality works in the codebase. Use this skill whenever the user runs `/teach`, asks "how does X work", "explain the auth flow", "document how payments work", "walk me through the webhook system", or any request to understand and document internal codebase functionality. Also trigger when the user wants to produce onboarding docs, feature walkthroughs, or "how it works" references for developers. Always use this skill even if the user only gives a vague description — use the provided context or file hints to locate the relevant code yourself and build the teaching doc from there. This skill writes for developers reading the codebase — for end-user/customer-facing help docs, use the eli5-features skill instead.

Crie e gerencie arquivos de planejamento markdown persistentes para execução estruturada de tarefas. Use quando o usuário pedir para "criar um plano", "acompanhar progresso", "iniciar um projeto de pesquisa", ou quando uma tarefa exigir mais de 5 chamadas de ferramenta e precisar de rastreamento de fases estruturado para manter o foco e evitar desvio de objetivo.

Template do pack (backend/04-go-chi-gorm.md). Orienta o agente em APIs, servicos e arquitetura backend alinhado a esse contexto.

Otimize conteúdo para ser citado por mecanismos de busca com IA — ChatGPT, Perplexity, Google AI Overviews, Claude, Gemini, Copilot. Use quando quiser que seu conteúdo apareça em respostas geradas por IA, não apenas ranqueado em links azuis. Gatilhos: 'otimizar para busca IA', 'ser citado pelo ChatGPT', 'AI Overviews', 'citações Perplexity', 'AI SEO', 'busca generativa', 'visibilidade em LLM', 'GEO' (otimização para motores generativos). NÃO para SEO tradicional (use seo-audit). NÃO para criação de conteúdo (use content-production).

Rastreie sites inteiros usando a API /crawl do Cloudflare Browser Rendering. Inicia jobs de rastreamento assíncronos, monitora a conclusão e salva os resultados como arquivos markdown. Útil para ingerir sites de documentação, bases de conhecimento ou qualquer conteúdo web no contexto do seu projeto. Requer variáveis de ambiente CLOUDFLARE_ACCOUNT_ID e CLOUDFLARE_API_TOKEN.

Realize análises de código seguindo as práticas de engenharia da Sentry. Use ao revisar pull requests, examinar alterações de código ou fornecer feedback sobre qualidade de código. Abrange segurança, performance, testes e revisão de design.

Visualização estatística. Gráficos de dispersão, boxplots, violins, mapas de calor, matriz de pares, regressão, matrizes de correlação, KDE, gráficos facetados, para análise exploratória e figuras para publicação.

Biblioteca Python para trabalhar com arquivos DICOM (Digital Imaging and Communications in Medicine). Use essa skill ao ler, escrever ou modificar dados de imagens médicas em formato DICOM, extrair dados de pixel de imagens médicas (TC, RM, Raio-X, ultrassom), anonimizar arquivos DICOM, trabalhar com metadados e tags DICOM, converter imagens DICOM para outros formatos, processar dados DICOM comprimidos ou processar conjuntos de dados de imagens médicas. Aplica-se a tarefas envolvendo análise de imagens médicas, sistemas PACS, fluxos de trabalho de radiologia e aplicações de imagem médica.

Featurização molecular para ML (100+ featurizadores). ECFP, MACCS, descritores, modelos pré-treinados (ChemBERTa), converter SMILES em features, para QSAR e ML molecular.

Filtros de química medicinal. Aplique regras de similaridade a fármacos (Lipinski, Veber), filtros PAINS, alertas estruturais, métricas de complexidade, para priorização de compostos e filtragem de bibliotecas.

Análise de espectrometria de massas. Processa mzML/MGF/MSP, similaridade espectral (cosine, modified cosine), harmonização de metadados, identificação de compostos, para metabolômica e processamento de dados MS.