Skip to main content

Skills

Reusable instruction sets that any agent in the fleet can load to perform a class of work. This category exists so the fleet's skills live in one place every agent can read, regardless of vendor or host.

Source and import convention. These pages were imported from jknash/hermes-shared-skills, branch hermes-jkdev001, commit 1d0d545c3970, where the Hermes fleet maintains its skill library (428 active skills). The fleet-relevant set (35 skills) was imported on 2026-10-03; the complete library followed on 2026-10-04 (story AF-43), so every active skill in the source library is now here, organized into subfolders that mirror the source categories. Each page carries a provenance note with its exact source path; supporting files (references, scripts, tests) stay in the source repository and are linked from the page.

Reading note. Pages reproduce the source skill text in full and are archival references: read them, do not execute anything from them blindly. One page is labeled in its provenance as a host operating record (assessor-lane-controller): it documents the installed lane controller on host jkdev001 and is retained for the record, not as a general skill.

The library machinery at a glance (the prose and the registry govern):

General (no source category)​

  • Archify — Create polished, validated architecture, workflow, sequence, data-flow, and lifecycle/state diagrams as explorable standalone HTML with inline SVG, dark/light themes, optional trace motion, and PNG/JPEG/WebP/SVG/WebM export. Accept plain-language requirements or pasted Mermaid flowchart, sequenceDiagram, and stateDiagram input; inspect repository evidence when the diagram must reflect real code. Use when the user asks to visualize system architecture, infrastructure, cloud/security/network topology, technical workflows, API call sequences, request lifecycles, data pipelines, ETL/ELT, data lineage, state machines, or to convert/beautify Mermaid.
  • Assessor Lane Controller — Use when managing Assessor's persistent four lanes.
  • Bounded Exact Source Packet Repair — Use when repairing capped exact-source review packets.
  • Bounded Failure Diagnostic Repair — Use when repairing lost isolated-worker diagnostics.
  • Codebase Memory — Use the codebase knowledge graph for structural code queries. Triggers on: explore the codebase, understand the architecture, what functions exist, show me the structure, who calls this function, what does X call, trace the call chain, find callers of, show dependencies, impact analysis, dead code, unused functions, high fan-out, refactor candidates, code quality audit, graph query syntax, Cypher query examples, edge types, how to use search_graph.
  • Docusaurus Docker Publishing — Use when publishing to the Dockerized Docusaurus docsite (docs, tags, git sync).
  • Fleet Runtime Bootstrap — Use when bootstrapping a private fleet-runtime repository.
  • Launcher Cis Recovery Owner Expectations — Use when reporting or recovering the CIS launcher.
  • Skill Updater — Update third-party imported agent skills and report changes.

Anthropic​

  • Algorithmic Art — Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
  • Canvas Design — Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.
  • Claude Api
  • Doc Coauthoring — Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
  • Internal Comms — A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).
  • Mcp Builder — Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
  • Web Artifacts Builder — Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.
  • Webapp Testing — Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

Apple​

  • Apple Notes — Manage Apple Notes via memo CLI: create, search, edit.
  • Apple Reminders — Apple Reminders via remindctl: add, list, complete.
  • Findmy — Track Apple devices/AirTags via FindMy.app on macOS.
  • Imessage — Send and receive iMessages/SMS via the imsg CLI on macOS.

Automation​

Autonomous Ai Agents​

  • Advanced Evaluation — This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.
  • Agent Skill Bundle Governance — Use when governing skill bundles across agent fleets.
  • Bdi Mental States — This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations, rational agency traces, cognitive agents, BDI ontologies, and neuro-symbolic AI integration.
  • Claude Code — Delegate coding to Claude Code CLI (features, PRs).
  • Codex — Delegate coding to OpenAI Codex CLI (features, PRs).
  • Computer Use — Drive the desktop background-first; escalate on signal.
  • Context Compression — This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.
  • Context Degradation — This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.
  • Context Fundamentals — This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.
  • Context Optimization — This skill should be used for improving context efficiency: context budgeting, observation masking, prefix or KV-cache strategy, partitioning, token-cost reduction, retrieval scoping, and extending effective context capacity without lowering answer quality.
  • Evaluating Agent Skill Repos — Triage GitHub repos for useful agent skills or MCP servers.
  • Evaluation — This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.
  • Filesystem Context — This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.
  • Harness Engineering — This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs, novelty gates, pruning, rollback, PR preparation, and human approval boundaries.
  • Hermes Agent — Use, configure, theme, extend, and orchestrate Hermes Agent.
  • Hermes Memory Provider Management — Use when installing or migrating a Hermes memory provider.
  • Hermes Profile Lifecycle — Use when managing the lifecycle of Hermes profiles.
  • Hermes Provider Account Routing — Use when picking which subscription Hermes bills.
  • Hosted Agents — This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.
  • Importing Agent Skills — Use when importing external agent-skill repos into Hermes.
  • Latent Briefing — This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.
  • Long Horizon Prompting — This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.
  • Massgen — Invoke MassGen's multi-agent system. Use when the user wants multiple AI agents on a task: writing, code, review, planning, specs, research, design, or any task where parallel iteration beats working alone.
  • Mcp Server Management — Use when connecting/verifying MCP servers inside Hermes.
  • Memory Systems — This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.
  • Merge Reconciler — Neutral third-party resolution of agent merge conflicts.
  • Multi Agent Patterns — This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.
  • Opencode — Delegate coding to OpenCode CLI (features, PR review).
  • Project Development — This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.
  • Self Improvement Loops — This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.
  • Tool Design — This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.

Caveman​

  • Cavecrew
  • Caveman
  • Caveman Commit
  • Caveman Compress
  • Caveman Discover
  • Caveman Evidence Review
  • Caveman Explore — Read-only repository explorer for cold-start orientation, broad cross-file localization, or when a direct search failed. Skip it when the exact file or symbol is already named. Returns path:line citations only; its reads stay out of main context.
  • Caveman Help
  • Caveman Learn — Act on a Caveman learn report - review the ranked token sinks, apply cost-lowering fixes with per-edit consent, and report what those fixes returned. Use when asked to lower an agent's token cost, what caveman has saved, to trim a heavy CLAUDE.md, or to offload re-pasted context into cavemem.
  • Caveman Manage
  • Caveman Optimize
  • Caveman Review
  • Caveman Setup
  • Caveman Stats
  • Investigate First — Diagnose ambiguous failures before editing. Use for unknown causes, intermittent behavior, performance regressions, or investigations needing evidence-ranked hypotheses.
  • Lean Build — Build feature work with high overbuilding risk. Use for new behavior, product slices, or integrations where repository reuse, strict scope, and an explicit stop condition matter.
  • Migration — Implement reversible compatibility-safe transitions. Use for schema, data, API, protocol, configuration, or dependency migrations requiring rollback and preservation proof.
  • Safe Refactor — Restructure code while preserving behavior. Use for extraction, consolidation, ownership moves, or cleanup where verification must bracket structural edits.
  • Surgical Patch — Fix bugs and small behavior changes at the narrowest responsible layer. Use when regression proof, preserved surrounding behavior, and task-relevant tests matter.
  • Verify And Stop — Prove existing work meets acceptance conditions without expanding scope. Use for validation-only tasks, completion checks, focused gate runs, and last-mile proof.

Claude​

Composio​

  • Artifacts Builder — Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.
  • Brand Guidelines — Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
  • Changelog Generator — Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes. Turns hours of manual changelog writing into minutes of automated generation.
  • Competitive Ads Extractor — Extracts and analyzes competitors' ads from ad libraries (Facebook, LinkedIn, etc.) to understand what messaging, problems, and creative approaches are working. Helps inspire and improve your own ad campaigns.
  • Connect — Connect Claude to any app. Send emails, create issues, post messages, update databases - take real actions across Gmail, Slack, GitHub, Notion, and 1000+ services.
  • Connect Apps — Connect Claude to external apps like Gmail, Slack, GitHub. Use this skill when the user wants to send emails, create issues, post messages, or take actions in external services.
  • Content Research Writer — Assists in writing high-quality content by conducting research, adding citations, improving hooks, iterating on outlines, and providing real-time feedback on each section. Transforms your writing process from solo effort to collaborative partnership.
  • Developer Growth Analysis — Analyzes your recent Claude Code chat history to identify coding patterns, development gaps, and areas for improvement, curates relevant learning resources from HackerNews, and automatically sends a personalized growth report to your Slack DMs.
  • Domain Name Brainstormer — Generates creative domain name ideas for your project and checks availability across multiple TLDs (.com, .io, .dev, .ai, etc.). Saves hours of brainstorming and manual checking.
  • File Organizer — Intelligently organizes your files and folders across your computer by understanding context, finding duplicates, suggesting better structures, and automating cleanup tasks. Reduces cognitive load and keeps your digital workspace tidy without manual effort.
  • Image Enhancer — Improves the quality of images, especially screenshots, by enhancing resolution, sharpness, and clarity. Perfect for preparing images for presentations, documentation, or social media posts.
  • Invoice Organizer — Automatically organizes invoices and receipts for tax preparation by reading messy files, extracting key information, renaming them consistently, and sorting them into logical folders. Turns hours of manual bookkeeping into minutes of automated organization.
  • Langsmith Fetch — Debug LangChain and LangGraph agents by fetching execution traces from LangSmith Studio. Use when debugging agent behavior, investigating errors, analyzing tool calls, checking memory operations, or examining agent performance. Automatically fetches recent traces and analyzes execution patterns. Requires langsmith-fetch CLI installed.
  • Lead Research Assistant — Identifies high-quality leads for your product or service by analyzing your business, searching for target companies, and providing actionable contact strategies. Perfect for sales, business development, and marketing professionals.
  • Meeting Insights Analyzer — Analyzes meeting transcripts and recordings to uncover behavioral patterns, communication insights, and actionable feedback. Identifies when you avoid conflict, use filler words, dominate conversations, or miss opportunities to listen. Perfect for professionals seeking to improve their communication and leadership skills.
  • Pptx — Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks
  • Raffle Winner Picker — Picks random winners from lists, spreadsheets, or Google Sheets for giveaways, raffles, and contests. Ensures fair, unbiased selection with transparency.
  • Skill Creator — 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.
  • Skill Share — A skill that creates new Claude skills and automatically shares them on Slack using Rube for seamless team collaboration and skill discovery.
  • Slack Gif Creator — Toolkit for creating animated GIFs optimized for Slack, with validators for size constraints and composable animation primitives. This skill applies when users request animated GIFs or emoji animations for Slack from descriptions like "make me a GIF for Slack of X doing Y".
  • Tailored Resume Generator — Analyzes job descriptions and generates tailored resumes that highlight relevant experience, skills, and achievements to maximize interview chances
  • Template Skill — Replace with description of the skill and when Claude should use it.
  • Theme Factory — Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.
  • Twitter Algorithm Optimizer — Analyze and optimize tweets for maximum reach using Twitter's open-source algorithm insights. Rewrite and edit user tweets to improve engagement and visibility based on how the recommendation system ranks content.
  • Video Downloader — Download YouTube videos with customizable quality and format options. Use this skill when the user asks to download, save, or grab YouTube videos. Supports various quality settings (best, 1080p, 720p, 480p, 360p), multiple formats (mp4, webm, mkv), and audio-only downloads as MP3.

Creative​

  • Animate — Build an animation from scratch, making the decisions in the order that determines whether it feels right — should it animate at all, what purpose, which tool, which properties, which curve and duration, how it interrupts, how it exits. Writes the implementation. Use when asked to animate something, add motion, make a component feel alive, or build a transition. For critiquing existing motion use review-animations; for auditing a whole codebase use improve-animations.
  • Animate Expo — Build animations in React Native and Expo, making the decisions in the order that determines whether they feel right — should it animate, which thread it runs on, which properties, spring or timing, how the gesture hands off, how it degrades. Writes the implementation with Reanimated, Gesture Handler, Expo Router and expo-haptics. Use when animating anything in an Expo app, adding gestures, sheets, screen transitions, press feedback or haptics, or fixing motion that stutters on device. For web animation use animate.
  • Animation Vocabulary — Reverse-lookup glossary that turns a vague description of a web animation or motion effect into its exact term ("the bouncy thing when a popover opens" → Pop in; "the iOS rubber-band scroll" → Rubber-banding). Use when the user asks "what's it called when…", or describes a motion effect without knowing its name and wants the right word to prompt an AI or designer with. For naming an effect, not designing or building one.
  • Apple Design — Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.
  • Architecture Diagram — Dark-themed SVG architecture/cloud/infra diagrams as HTML.
  • Ascii Art — ASCII art: pyfiglet, cowsay, boxes, image-to-ascii.
  • Ascii Video — ASCII video: convert video/audio to colored ASCII MP4/GIF.
  • Ask Sonner — Guide to Sonner, the React toast library — install and wire up the Toaster, pick the right toast() call, promise and loading toasts, updating, dismissing and persisting toasts, styling, theming and icons, positioning and multiple toasters. Use when working with Sonner or troubleshooting it — toasts that don't appear, appear twice, lose their styles, ignore Tailwind classes, sit behind a modal, or don't follow dark mode.
  • Banner Design — Design banners for social media, ads, website heroes, creative assets, and print. Multiple art direction options with optional generated or supplied visuals. Actions: design, create, generate banner. Platforms: Facebook, Twitter/X, LinkedIn, YouTube, Instagram, Google Display, website hero, print. Styles: minimalist, gradient, bold typography, photo-based, illustrated, geometric, retro, glassmorphism, 3D, neon, duotone, editorial, collage.
  • Baoyu Infographic — Infographics: 21 layouts x 21 styles (信息图, 可视化).
  • Brand — Brand voice, visual identity, messaging frameworks, asset management, brand consistency. Activate for branded content, tone of voice, marketing assets, brand compliance, style guides.
  • Brandkit — Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations. Trained for minimalist, cinematic, editorial, dark-tech, luxury, cultural, security, gaming, developer-tool, and consumer-app brand systems. Optimized for intentional logo concepting, refined composition, sparse typography, strong symbolic meaning, premium mockups, art-directed imagery, and flexible grid layouts.
  • Claude Design — Design one-off HTML artifacts (landing, deck, prototype).
  • Comfyui — Generate images, video, and audio via diffusion workflows.
  • Dense Architecture Diagram Layout — Hub-and-spoke diagrams that must pass strict lint.
  • Design — Comprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG, Gemini 3.1 Pro), social photos (HTML→screenshot, multi-platform). Actions: design logo, create CIP, generate mockups, build slides, design banner, generate icon, create social photos, social media images, brand identity, design system. Platforms: Facebook, Twitter, LinkedIn, YouTube, Instagram, Pinterest, TikTok, Threads, Google Ads.
  • Design Md — Author/validate/export Google's DESIGN.md token spec files.
  • Design System — Token architecture, component specifications, and slide generation. Three-layer tokens (primitive→semantic→component), CSS variables, spacing/typography scales, component specs, strategic slide creation. Use for design tokens, systematic design, brand-compliant presentations.
  • Diagram Authoring — Generate architecture/workflow diagrams via Archify.
  • Emil Design Eng — This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.
  • Excalidraw — Hand-drawn Excalidraw JSON diagrams (arch, flow, seq).
  • Find Animation Opportunities — Search a codebase or UI for places that don't animate but should, and reject everything that shouldn't. Read-only; it proposes motion with exact values, it does not implement it. Use when the user asks "what could be animated here?" or wants to "make this feel more alive". For fixing existing animations, use improve-animations or review-animations instead.
  • Gpt Tasteskill — Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.
  • Hallmark — Anti-AI-slop design skill for greenfield pages, audits, redesigns, and design extraction from URLs or screenshots. Use when the user asks to build a new app or landing page, wants to redesign something, invokes Hallmark by name, or uses audit/redesign/study.
  • Humanizer — Humanize text: strip AI-isms and add real voice.
  • Image To Code Skill — Elite website image-to-code skill for Codex. For visually important web tasks, it must first generate the design image(s) itself, deeply analyze them, then implement the website to match them as closely as possible. In Codex, it must prefer large, readable, section-specific images instead of tiny compressed boards, generate fresh standalone images for sections or detail views instead of cropping old ones, avoid lazy under-generation, avoid cards-inside-cards-inside-cards UI, and keep the hero clean, spacious, readable, and visible on a small laptop.
  • Imagegen Frontend Mobile — Elite mobile app image-generation skill for creating premium, app-native screen concepts and flows. Designed for iOS, Android, and cross-platform mobile products. Prioritizes clean hierarchy, comfortably readable text, strong multi-screen consistency, controlled color palettes, non-generic creative direction, textured surfaces, image-led composition, tasteful custom iconography, and clean phone mockup framing. By default, screens should be shown inside a subtle premium iPhone or similar phone mockup with a visible frame, while the main focus stays on the app content itself. This skill generates images only. It does not write code.
  • Imagegen Frontend Web — Elite frontend image-direction skill for generating premium, conversion-aware website design references. CRITICAL OUTPUT RULE — generate ONE separate horizontal image FOR EVERY section. A landing page with 8 sections produces 8 images. Never compress multiple sections into one image. Enforces composition variety (not always left-text / right-image), background-image freedom, varied CTAs, varied hero scales (giant / mid / mini minimalist), narrative concept spine, second-read moments, and a single consistent palette across all images. Optimized for landing pages, marketing sites, and product comps that developers or coding models can accurately recreate.
  • Impeccable — Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pages, dashboards, product UI, app shells, components, forms, settings, onboarding, and empty states. Handles UX review, visual hierarchy, information architecture, cognitive load, accessibility, performance, responsive behavior, theming, anti-patterns, typography, fonts, spacing, layout, alignment, color, motion, micro-interactions, UX copy, error states, edge cases, i18n, and reusable design systems or tokens. Also use for bland designs that need to become bolder or more delightful, loud designs that should become quieter, live browser iteration on UI elements, or ambitious visual effects that should feel technically extraordinary. Not for backend-only or non-UI tasks.
  • Improve Animations — Survey a codebase's animation and motion code as a senior motion advisor, then produce a prioritized audit and self-contained implementation plans for other agents (or cheaper models) to execute. Read-only on source code — it plans improvements, it does not apply them. Use when the user asks to "improve the animations", "audit the motion", "make this app feel better", or wants a roadmap of animation fixes rather than a review of a single diff.
  • Manim Video — Manim CE animations: 3Blue1Brown math/algo videos.
  • Minimalist Skill — Clean editorial-style interfaces. Warm monochrome palette, typographic contrast, flat bento grids, muted pastels. No gradients, no heavy shadows.
  • No Ai Slop — Edit drafts into sharper, more human writing while preserving the writer's personal voice, or detect AI-slop patterns without rewriting. Use when the user wants a draft clearer, more direct, more opinionated, or less AI-sounding, or asks whether writing reads as AI.
  • Output Skill — Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.
  • P5js — p5.js sketches: gen art, shaders, interactive, 3D.
  • Pick Ui Library — Pick the right library for a given frontend task from a curated, opinionated list — numbers, OTP inputs, charts, command menus, virtualization, drag and drop, toasts, state, styling, and more. Only runs when explicitly invoked; it does not trigger on its own.
  • Popular Web Designs — 54 real design systems (Stripe, Linear, Vercel) as HTML/CSS.
  • Pretext — Build creative browser demos with DOM-free text layout.
  • Redesign Skill — Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS.
  • Review Animations — Reviews animation and motion code against a high craft bar derived from Emil Kowalski's design engineering philosophy. Default to flagging; approval is earned.
  • Sketch — Throwaway HTML mockups: 2-3 design variants to compare.
  • Slides — Create strategic HTML presentations with Chart.js, design tokens, responsive layouts, copywriting formulas, and contextual slide strategies.
  • Soft Skill — Teaches the AI to design like a high-end agency. Defines the exact fonts, spacing, shadows, card structures, and animations that make a website feel expensive. Blocks all the common defaults that make AI designs look cheap or generic.
  • Songwriting And Ai Music — Songwriting craft and Suno AI music prompts.
  • Stitch Skill — Semantic Design System Skill for Google Stitch. Generates agent-friendly DESIGN.md files that enforce premium, anti-generic UI standards — strict typography, calibrated color, asymmetric layouts, perpetual micro-motion, and hardware-accelerated performance.
  • Touchdesigner Mcp — Control TouchDesigner via twozero MCP.
  • Ui Styling — Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Use when building user interfaces, implementing design systems, creating responsive layouts, adding accessible components (dialogs, dropdowns, forms, tables), customizing themes and colors, implementing dark mode, generating visual designs and posters, or establishing consistent styling patterns across applications.
  • Ui Ux Pro Max — UI/UX design intelligence for web, mobile, and desktop. This skill should be used when designing, building, reviewing, or fixing interfaces, including pages, components, design systems, accessibility, interaction, responsive layout, typography, color, charts, and stack-specific UI implementation. Searchable local data: 79 searchable styles (50 active), 192 product palettes and reasoning profiles, 74 font pairings, 119 UX guidelines, 105 icons, 17 GSAP presets, 25 chart types, and 22 stacks.
  • Write Swift — How to write modern Swift well — modeling with value types, Swift 6 data-race safety and approachable concurrency (@concurrent, main-actor-by-default, actors, task groups), protocols and generics (some vs any), API design, performance and ARC, Swift Testing, macros, and the modern language features agents don't know about yet. Use when writing, reviewing, or migrating Swift, or when a concurrency error, a hang, a data race, a retain cycle, or a performance problem needs fixing.

Development​

  • Context7 Mcp — Use before coding against external libraries or APIs.

Devops​

  • Sdlc Review — Review Kanban handoffs and route verified outcomes.

Ecc​

  • Agent Eval — Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.
  • Agent Harness Construction — Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent's tool set, action space, or observation format.
  • Agent Introspection Debugging — Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.
  • Continuous Agent Loop — Patterns for continuous autonomous agent loops with quality gates, evals, and recovery controls. Use when running an agent loop that must self-check, gate on evals, and recover from failures.
  • Enterprise Agent Ops — Operate long-lived agent workloads with observability, security boundaries, and lifecycle management. Use when running long-lived agent workloads that need observability, security boundaries, or lifecycle control.
  • Parallel Execution Optimizer — Use when the user wants a task done much faster through parallel work, concurrent agents, batched tool calls, isolated worktrees, or many independent verification lanes without losing correctness.

Ecc Code​

  • Agentic Engineering
  • Api Design
  • Backend Patterns
  • Coding Standards
  • Content Hash Cache Pattern — Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.
  • Cpp Coding Standards — C++ coding standards based on the C++ Core Guidelines (isocpp.github.io). Use when writing, reviewing, or refactoring C++ code to enforce modern, safe, and idiomatic practices.
  • Cpp Testing — Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.
  • Database Migrations
  • Deep Research — Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations.
  • Django Patterns — Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.
  • Django Security — Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.
  • Docker Patterns
  • E2e Testing
  • Fastapi Patterns — FastAPI patterns for async APIs, dependency injection, Pydantic request and response models, OpenAPI docs, tests, security, and production readiness.
  • Frontend Patterns
  • Golang Patterns
  • Golang Testing
  • Java Coding Standards — Java coding standards for Spring Boot and Quarkus services: naming, immutability, Optional usage, streams, exceptions, generics, CDI, reactive patterns, and project layout. Automatically applies framework-specific conventions.
  • Jpa Patterns — JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.
  • Kotlin Patterns — Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders.
  • Kotlin Testing — Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices.
  • Nestjs Patterns — NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends.
  • Nextjs Turbopack — Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.
  • Postgres Patterns
  • Python Patterns
  • Python Testing
  • Pytorch Patterns — PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading.
  • React Patterns — React 18/19 patterns including hooks discipline, server/client component boundaries, Suspense + error boundaries, form actions, data fetching, state management decision trees, and accessibility-first composition. Use when writing or reviewing React components.
  • React Testing — React component testing with React Testing Library, Vitest/Jest, MSW for network mocking, accessibility assertions with axe, and the decision boundary between component tests and Playwright/Cypress end-to-end runs. Use when writing or fixing tests for React components, hooks, or pages.
  • Rust Patterns — Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.
  • Search First
  • Springboot Patterns — Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work.
  • Springboot Security — Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.
  • Swift Actor Persistence — Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design.
  • Swift Protocol Di Testing — Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing.

Email​

  • Email Inbox Triage — Triage an inbox: prioritize threads, draft replies safely.
  • Himalaya — Himalaya CLI: IMAP/SMTP email from terminal.

Engineering​

  • Api And Interface Design — Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.
  • Api Credential Verification — Use before trusting a stored API key.
  • Autonomous Agent Code Review — Whole-repo code audits via Codex/Claude CLI agents.
  • Backup And Disaster Recovery — Use when defining RPO/RTO or backup/restore systems.
  • Browser Testing With Devtools — Tests in real browsers via Chrome DevTools MCP. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data. Requires the chrome-devtools MCP server to be configured.
  • Build Artifact Chain — Use when starting a new build. Enforce artifact gates.
  • Catalog Driven Security Testing — Use when testing database authority from live catalogs.
  • Ci Cd And Automation — Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.
  • Code Review And Quality — Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.
  • Code Simplification — Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.
  • Coding Behavior Rules — Guardrails for coding: caution, simplicity, git safety.
  • Constraint Driven Development — Establishes a project's quality bar as a written contract and stops agents quietly lowering it. Interviews the user on which dimensions matter, supplies sane default thresholds when they have no number in mind, records everything in CONSTRAINTS.md, and watches the diff for a weakened bar — new @ts-ignore or eslint-disable suppressions, skipped or deleted tests, assertions stripped out, unimplemented stubs, thresholds edited down. Use when no quality bar is written down, when the user says "set up constraints" or "define our standards", when the user wants dimensions they care about — accessibility, web performance, coverage — set up as enforced constraints, when an agent keeps silencing checks or skipping tests to get to green, when you need a coverage or performance threshold and don't know what number to pick, or when an agent writes more code than anyone will read.
  • Context Engineering — Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.
  • Context Hub Registry Management — Use when maintaining Context Hub (chub) or its registry.
  • Contract Registry Work Package Remediation — Use when separating contract registries from backlogs.
  • Debugging And Error Recovery — Guides systematic root-cause debugging. Use when tests fail, builds break, something that worked yesterday broke, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need to figure out what broke and why — a systematic approach to finding and fixing the root cause rather than guessing.
  • Deprecation And Migration — Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code.
  • Docker Image Reproducibility Receipts — Use when proving Docker image reproducibility.
  • Documentation And Adrs — Records decisions and documentation. Use when you need to document an architecture decision (ADR) or the reasoning behind a design choice, when changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.
  • Doubt Driven Development — Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when you want every assumption cross-examined before proceeding, when stress-testing a plan for hidden failure modes, when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production auth, security-sensitive logic, a high-stakes migration, irreversible operations), or any time a confident output would be cheaper to verify now than to debug later.
  • Durable Fleet Delivery — Use when making agent fleets deliver durably.
  • Electron Desktop Delivery — Use when shipping Electron desktop changes securely.
  • Electron Native App Ci Packaging — Use when building Electron native installers in CI.
  • Enterprise Architecture Specification — Use when designing production enterprise applications.
  • Enterprise Assessment Engagements — Use when operating M365/Azure assessment engagements.
  • External Coding Agent Orchestration — Use when orchestrating autonomous coding CLI workers.
  • Frontend Ui Engineering — Builds production-quality, accessible, responsive user-facing UIs. Use when building or modifying interfaces and pages, creating components, implementing layouts, meeting WCAG accessibility requirements, managing state, or when the output needs to look and feel production-quality rather than AI-generated.
  • Git Workflow And Versioning — Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, splitting uncommitted work in a messy working tree into clean atomic commits, opening or reviewing a pull request (PR), pushing to a remote, or when you need to organize work across multiple parallel streams. Use when cutting a release, choosing a semantic version bump, tagging, or writing a changelog.
  • Hermes Content Guard Refusals — Use when Hermes blocks content on a threat pattern.
  • Idea Refine — Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan".
  • Incremental Implementation — Delivers changes incrementally in thin, verifiable slices. Use when implementing any feature or change that touches more than one file, or when picking up the next task from a plan. Use when rolling a change out behind a feature flag, when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
  • Independent Review Remediation — Use when remediating an independently reviewed candidate.
  • Interview Me — Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invokes ("interview me", "grill me", "are we sure?", "stress-test my thinking"), or when you catch yourself silently filling in ambiguous requirements before any plan, spec, or code exists.
  • Javascript Dependency Governance — Use when governing npm dependency support migrations.
  • Javascript Dependency Modernization — Use when modernizing JavaScript dependency graphs.
  • Live Delivery Reconciliation — Use when reconciling live delivery status.
  • Multi Agent Delivery Verification — Use when agents implement, review, and gate changes.
  • Multi Agent Program Delivery — Use for phased software delivery across multiple agents.
  • Non Reproducing Failure Diagnosis — Use when a failure will not reproduce under probes.
  • Normative Contract Compilation — Use when compiling prose into normative contracts.
  • Observability And Instrumentation — Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.
  • Offline Custody Generation Continuation — Use when implementing offline custody transitions.
  • Package Dependency Governance — Use when governing package dependency support and migration.
  • Performance Optimization — Optimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.
  • Planning And Task Breakdown — Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.
  • Removing Single Model Gates — Use when one model blocks a fleet. Remove the gate.
  • Report Contract Engineering — Use when reconciling canonical reporting contracts.
  • Research Hub Enterprise Architecture — Use when designing Research Hub enterprise SaaS.
  • Reviewer Packet Sandbox Probes — Use when proving credential-free reviewer isolation.
  • Role Based Model Binding — Use when code names a model. Bind models to roles.
  • Secure Launcher Integration — Use when integrating secure high-level process launchers.
  • Security And Hardening — Hardens code against vulnerabilities. Use when auditing an input handler for vulnerabilities, when handling user input, authentication, data storage, or external integrations, or when checking a login flow is safe against the OWASP Top Ten. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services. Use when auditing dependencies for known vulnerabilities, triaging package-manager audit findings, or assessing supply-chain risk in a new package. Use when personal data or privacy compliance (GDPR, CCPA) is involved.
  • Shipping And Launch — Prepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.
  • Source Driven Development — Grounds every implementation decision in official documentation. Use when you want to verify an approach against the official docs before implementing it, or when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.
  • Spec Driven Development — Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when drafting a PRD or requirements document with objectives and scope, or when requirements are unclear, ambiguous, or only exist as a vague idea. Use when a single requirement spans several independently testable capabilities and needs decomposing into a capability map of modules before specifying.
  • Spec Prior Art Reconciliation — Use when reconciling a spec draft with existing repos.
  • Specification Evidence Governance — Use when validating specs before implementation.
  • Supported Dependency Migrations — Use when replacing unsupported dependency chains.
  • Test Driven Development Osmani — Drives development with tests using the red-green-refactor loop. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.
  • Using Agent Skills — Discovers and invokes agent skills. Use when starting a session, or when you need to decide which skill or workflow applies to the piece of work at hand. This is the meta-skill that governs how all other skills are discovered and invoked.

Github​

Media​

  • Gif Search — Search/download GIFs from Tenor via curl + jq.
  • Songsee — Audio spectrograms/features (mel, chroma, MFCC) via CLI.
  • Youtube Content — YouTube transcripts to summaries, threads, blogs.

Mlops​

  • Huggingface Hub — HuggingFace hf CLI: search/download/upload models, datasets.

Mlops — Evaluation​

Mlops — Inference​

  • Llama Cpp — llama.cpp local GGUF inference + HF Hub model discovery.
  • Serving Llms Vllm — vLLM: high-throughput LLM serving, OpenAI API, quantization.

Note Taking​

  • Obsidian — Read, search, create, and edit notes in the Obsidian vault.

Operations​

Productivity​

  • Airtable — Airtable REST API via curl. Records CRUD, filters, upserts.
  • Box — Box manages cloud files, sharing, search, and metadata.
  • Document To Action Items — Extract cited obligations, deadlines, tasks from documents.
  • Docx — Create, read, edit, template, and review Word .docx files.
  • Google Workspace — Gmail, Calendar, Drive, Docs, Sheets via gws CLI or Python.
  • I Have Adhd — Shape output for a reader with ADHD: lead with the next action, number multi-step work, restate state across turns, suppress tangents, give specific time estimates, make wins visible. Invoke with /i-have-adhd; stays on until "stop adhd mode".
  • Maps — Geocode, POIs, routes, timezones via OpenStreetMap/OSRM.
  • Meeting Action Items — Turn meeting notes into cited decisions, owners, tickets.
  • Nano Pdf — Edit text in existing PDFs via natural-language prompts.
  • Notion — Notion API + ntn CLI: pages, databases, markdown, Workers.
  • Ocr And Documents — Extract text from PDFs/scans (pymupdf, marker-pdf).
  • Pdf — PDF files: create, read, merge, fill, OCR, edit text.
  • Powerpoint — Create, read, edit .pptx decks with python-pptx.
  • Product Price Monitor — Watch product, flight, or listing prices; alert on target.
  • Session Librarian — Organize sessions by prompt: find, rename, archive, prune.
  • Teams Meeting Pipeline — Teams meeting summaries, job replay, Graph subscriptions.
  • Weekly Review Planning — Weekly reset: commitments, stalled work, next-week plan.
  • Xlsx — Create, read, edit Excel .xlsx workbooks and CSVs.

Research​

  • Arxiv — Search arXiv papers by keyword, author, category, or ID.
  • Blogwatcher — Monitor blogs and RSS/Atom feeds via blogwatcher-cli tool.
  • Competitor News Monitor — Watch named companies for material news; cited digests.
  • Compiling Research Artifacts — Use when papers, repositories, experiment logs, benchmark mappings, notes, or source packets must become a structured, falsifiable, machine-traversable Agent-Native Research Artifact.
  • Evidence Matrix Research — Use when building large source-bound evidence matrices.
  • Graphify — Use for any question about a codebase, its architecture, file relationships, or project content — especially when graphify-out/ exists, where the question should be treated as a graphify query first. Turns any input (code, docs, papers, images, videos) into a persistent knowledge graph with god nodes, community detection, and query/path/explain tools.
  • Grounded Citations — Ground answers and documents in cited, verifiable sources.
  • Llm Wiki — Karpathy's LLM Wiki: build/query interlinked markdown KB.
  • Orchestrating Research — Use when a user asks for research, deep research, benchmark or standards analysis, competitive investigation, literature review, evidence-backed recommendations, or CIS benchmark automation research.
  • Polymarket — Query Polymarket: markets, prices, orderbooks, history.
  • Qmd — Search local markdown knowledge bases, notes, docs, and wikis with QMD. Use when users ask to find notes, retrieve documents, inspect a wiki, answer from indexed markdown, or set up QMD access.
  • Recording Research Epilogues — Use when a research task or meaningful research checkpoint is complete and its decisions, evidence, experiments, failed approaches, pivots, and open threads must be preserved for later sessions.
  • Research Paper Writing — Write ML papers for NeurIPS/ICML/ICLR: design→submit.
  • Reviewing Research Rigor — Use when a structurally validated research artifact needs independent semantic review before publication, decision-making, or final delivery.
  • Routing Research Requests — Use when the user asks for research, deep research, an evidence-backed report, benchmark or standards analysis, competitive investigation, literature review, or CIS benchmark automation research.
  • Web Research Via Curl — Fetch/verify web facts via curl when no web_search tool.

Smart Home​

  • Openhue — Control Philips Hue lights, scenes, rooms via OpenHue CLI.

Social Media​

  • Xurl — X/Twitter via xurl CLI: raw post search, posting, DM, media.

Software Development​

  • Ask Matt — Ask which skill or flow fits your situation. A router over the skills in this repo.
  • Brainstorming — You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
  • Cf Worker Hono Supabase Monorepo — Build a CF Worker Hono + Supabase + React SPA pnpm monorepo.
  • Claude Handoff — Hand the current conversation off to a fresh background agent that picks up the work immediately.
  • Code Review — Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/spec asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".
  • Codebase Design — Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.
  • Codebase Inspection — Inspect codebases w/ pygount: LOC, languages, ratios.
  • Codebase Review — Deep-review an existing repo's architecture, security, and hardening posture (building on the spec→repo build).
  • Diagnosing Bugs — Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.
  • Dispatching Parallel Agents — Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
  • Dogfood — Exploratory QA of web apps: find bugs, evidence, reports.
  • Domain Modeling — Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a CONTEXT.md, or recording or editing an ADR.
  • Executing Plans — Use when you have a written implementation plan to execute in a separate session with review checkpoints
  • Finishing A Development Branch — Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
  • Git Guardrails Claude Code — Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.
  • Github — GitHub via gh CLI: PRs, issues, reviews, repos, auth.
  • Grill Me — A relentless interview to sharpen a plan or design.
  • Grill With Docs — A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.
  • Grilling — Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.
  • Handoff — Compact the current conversation into a handoff document for another agent to pick up.
  • Hermes Agent Skill Authoring — Author in-repo SKILL.md files: frontmatter and structure.
  • Implement Spec — Implement a specification in code.
  • Improve — Survey any codebase as a senior advisor and produce prioritized, self-contained implementation plans for OTHER models/agents to execute. Strictly read-only on source code — never implements, fixes, or refactors anything itself. Use when asked to audit a codebase, find improvement opportunities (bugs, security, performance, test coverage, tech debt, migrations, DX), suggest features or where to take the project next (roadmap, product direction), or generate handoff plans for another agent to implement.
  • Improve Codebase Architecture — Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
  • Inspecting Hermes Desktop Dom — Read the live Hermes desktop DOM/CSS over CDP.
  • Loop Me — Grill me about specs for the workflows I want to build, within this workspace.
  • Migrate To Shoehorn — Migrate test files from as type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace as in tests, or needs partial test data.
  • Node Inspect Debugger — Debug Node.js via --inspect + Chrome DevTools Protocol CLI.
  • Plan — Write a markdown plan to .hermes/plans/; no execution.
  • Ponytail
  • Ponytail Audit
  • Ponytail Debt
  • Ponytail Gain
  • Ponytail Help
  • Ponytail Review
  • Prototype — Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
  • Python Debugpy — Debug Python: pdb REPL + debugpy remote (DAP).
  • Receiving Code Review — Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
  • Requesting Code Review — Pre-commit review: security scan, quality gates, auto-fix.
  • Research — Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.
  • Resolving Merge Conflicts — Use when you need to resolve an in-progress git merge/rebase conflict.
  • Retro — Conduct a retrospective on a coding session.
  • Scaffold Exercises — Create exercise directory structures with sections, problems, solutions, and explainers that pass linting. Use when user wants to scaffold exercises, create exercise stubs, or set up a new course section.
  • Setup Matt Pocock Skills — Configure this repo for the engineering skills: set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.
  • Setup Ts Deep Modules — Wire dependency-cruiser into a TypeScript repo so each package is a deep module, with implementation hidden in subfolders and reachable only through its entry-point files. User-invoked.
  • Shared Skills Sync — Sync eligible Hermes skills to a shared git repo safely.
  • Simplify Code — Parallel 4-agent cleanup of recent code changes.
  • Spike — Throwaway experiments to validate an idea before build.
  • Subagent Driven Development — Use when executing implementation plans with independent tasks in the current session
  • Systematic Debugging — 4-phase root cause debugging: understand bugs before fixing.
  • Tdd — Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.
  • Teach — Teach the user a new skill or concept, within this workspace.
  • Test Driven Development — TDD: enforce RED-GREEN-REFACTOR, tests before code.
  • To Questionnaire — Turn a decision you can't fully answer into a questionnaire for someone else to fill in.
  • To Spec — Turn the current conversation into a spec and publish it to the project issue tracker: no interview, just synthesis of what you've already discussed.
  • To Tickets — Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker (edges as text in one file per ticket locally, or native blocking links on a real tracker).
  • Triage — Move issues and external PRs through a state machine of triage roles, categorise, verify, grill if needed, and write agent-ready briefs.
  • Using Git Worktrees — Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
  • Using Superpowers — Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions
  • Verification Before Completion — Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
  • Wait What — Stop. That last message did not land: re-pitch it.
  • Wayfinder — Plan a huge chunk of work (more than one agent session can hold) as a shared map of decision tickets on your issue tracker, and resolve them one at a time until the way to the destination is clear.
  • Wizard — Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for steps the agent can perform itself.
  • Writing Beats — Writing, exploit; assemble raw material into a journey of beats, grounding each term before a beat leans on it.
  • Writing For Agents — Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.
  • Writing Fragments — Writing, explore: mine raw fragments, no structure yet.
  • Writing Plans — Use when you have a spec or requirements for a multi-step task, before touching code
  • Writing Shape — Writing, exploit: shape raw material into an article, paragraph by paragraph.
  • Writing Skills — Use when creating new skills, editing existing skills, or verifying skills work before deployment

Understand Anything​

  • Understand — Analyze a codebase to produce an interactive knowledge graph for understanding architecture, components, and relationships
  • Understand Chat — Use when you need to ask questions about a codebase or understand code using a knowledge graph
  • Understand Dashboard — Launch the interactive web dashboard to visualize a codebase's knowledge graph
  • Understand Diff — Use when you need to analyze git diffs or pull requests to understand what changed, affected components, and risks
  • Understand Domain — Extract business domain knowledge from a codebase and generate an interactive domain flow graph. Works standalone (lightweight scan) or derives from an existing /understand knowledge graph.
  • Understand Explain — Use when you need a deep-dive explanation of a specific file, function, or module in the codebase
  • Understand Figma — Analyze a Figma file via the Figma REST API and generate an interactive design knowledge graph (pages, screens, components, component sets, instances, design tokens) with a kind:"design" dashboard.
  • Understand Knowledge — Analyze a Karpathy-pattern LLM wiki knowledge base and generate an interactive knowledge graph with entity extraction, implicit relationships, and topic clustering.
  • Understand Onboard — Use when you need to generate an onboarding guide for new team members joining a project

Web​

Wondelai​

Published by Muse · 2026-10-04.