Skills
97,222 packaged capabilities and playbooks for agents. Install any of them with one command.
Development
(NS) Generate and update execution-handoff.md for planned SDD versions — operational prompt, per-task status table, and time tracking in seconds. Use at the end of planning after all task-NNN-*.md files exist, when tasks exist but handoff is missing, or when updating task status during version implementation. Do NOT use for ad-hoc coding without a version lifecycle, version partitioning (pm-version-partitioner), or GitLab-only issue execution (execution-gitlab-issue).
Build FastAPI applications using Clean Architecture principles with proper layer separation (Domain, Infrastructure, API), dependency injection, repository pattern, and comprehensive testing. Use this skill when designing or implementing Python backend services that require maintainability, testability, and scalability.
Help developers use FineUI buttons and their dropdown menus: Button (semantic color/icon/size/badge), server-side and client-side click, confirm button, LinkButton, ButtonGroup (button grouping/mutually exclusive press/multi-press), Menu/MenuButton dropdown menus (MenuHyperLink/MenuCheckBox/MenuText/MenuSeparator). Covers F.js (JavaScript), Pro (WebForms), FineUI.Core's MVC (Fluent API)/RazorForms/RazorPages (TagHelper), and FineUI.Java (Spring Boot + Thymeleaf dialect tags, kebab-case). Trigger phrases: "FineUI 按钮", "F.Button", "Button", "ButtonColor", "语义颜色按钮", "OnClick", "ClickHandler", "客户端点击", "确认按钮", "ConfirmText", "LinkButton", "下拉菜单", "MenuButton", "Menu", "MenuHyperLink", "MenuCheckBox", "徽标", "Badge", "IconFont", "ButtonGroup", "按钮分组", "pressGroup", "互斥按下", "EnablePress", "EnablePressGroup", "FineUI.Java", "Spring Boot", "Thymeleaf", "@FineUIPage", "f:button", "button-color", "enable-press-group".
Builds NUI interfaces for FiveM using React 18 + TypeScript + Vite + Tailwind CSS v3 + Zustand. Use when the user mentions NUI, interface, UI, menu, HUD, panel, overlay, React, Vite, Tailwind, or any in-game interface for FiveM — regardless of the backend framework (vRP, QBCore, Qbox, ESX). Covers project structure, FiveM CEF restrictions, observe/Post hooks, VisibilityProvider, animations, dynamic config/theme, and performance rules.
Trace the dependency relationships around a GrowthBook feature flag — what it depends on (prerequisites), what depends on it (reverse lookup), which experiments link to it, and any holdout associations. Use when the user asks "what depends on flag X", "what flags does flag X require", "will deleting this flag break anything", "show me the dependency graph", "what experiments are linked to this flag", "find everything that uses flag X", or "is it safe to clean up this flag". Read-only — for making changes to prerequisites, use flag-prerequisites. For cleanup, use flag-cleanup.
Comprehensive guide for implementing animations in Flutter. Use when adding motion and visual effects to Flutter apps: implicit animations (AnimatedContainer, AnimatedOpacity, TweenAnimationBuilder), explicit animations (AnimationController, Tween, AnimatedWidget/AnimatedBuilder), hero animations (shared element transitions), staggered animations (sequential/overlapping), and physics-based animations. Includes workflow for choosing the right animation type, implementation patterns, and best practices for performance and user experience.
Forguncy plugin development expert — creates server commands (ServerCommand), cell types (CellType), client commands (ClientCommand), server APIs and middleware for the Forguncy low-code platform. Use this skill whenever the user mentions "make a plugin", "create a custom command", "develop a cell type", "Forguncy extension", "Forguncy custom feature", or asks "write me a server command" or "implement a control". Trigger this skill whenever Forguncy feature development is involved, even if the user does not explicitly say "plugin expert".
Format or verify trusted .NET projects with the SDK-provided `dotnet format` command. USE FOR: applying or checking `.editorconfig`-driven whitespace, code-style, or analyzer fixes; adding a `--verify-no-changes` CI gate; diagnosing formatter scope or load failures. DO NOT USE FOR: repositories where another formatter exclusively owns the affected files; analyzer policy with no formatter work; mutating files when the user requested only diagnosis.
Interface with Gitea instances via the tea CLI. Manage repositories, issues, pull requests, releases, labels, milestones, CI/CD actions, webhooks, organizations, wiki pages, SSH keys, comments, and notifications. Use when user mentions "Gitea", "tea CLI", or asks to create/list/edit/close issues, create/review/merge pull requests, manage repos, create releases, view CI/CD workflow runs, manage webhooks, track time, or perform any code hosting task on a Gitea server. Do NOT use for GitHub (use gh CLI) or GitLab.
Commit changes, create a feature branch, open a GitHub pull request, wait for CI, and merge the PR once GitHub Actions go green — or push new commits to an existing PR and merge after CI succeeds. Ships one issue per commit and per PR: when the working tree holds work for several issues it stages them one at a time instead of bundling them into a single review. Use whenever someone says ''commit and push'', ''create a PR'', ''open a pull request'', ''send for review'', ''push my changes'', ''commit issue #12'', ''merge when CI passes'', or is done with their work and ready to ship it. Also triggers for ''commitold be'', ''nyiss PR-t'', ''mergeld ha zöld a CI'', or any variation of wanting to get changes into a pull request and landed. Handles conventional commit messages, issue linking with auto-close keywords (Closes #N), sensitive file detection, PR template integration, auto-merge with branch cleanup, and local validation in place of CI when GitHub billing stops the Actions run
Create, view, close, comment on, label, triage, and list GitHub issues with standardized structure — including batch-filing issues from a code audit or review report (e.g. a CODE_AUDIT_*.md from code-analyzer). Use when someone says 'create an issue', 'file a bug', 'open an issue for this', 'turn the audit findings into issues', 'open issues for the high/critical items', 'triage issues', 'label issue #N', 'close #N as duplicate', 'list open issues', 'hozz létre egy issue-t', 'csinálj issue-kat az audit alapján', or wants to manage GitHub issues in any way. Checks for duplicates first, enforces templates with required sections (Summary, Proposed Solution), and validates labels exist before use. Not for running a fresh audit and filing its findings in one go (github-audit-to-issues), implementing an issue (github-do-issue) or opening pull requests (github-commit-pr)
Use when writing BK-CI Go Agent code, such as Agent API calls, task processing, concurrency patterns, error handling, logging, and host-side tool development. Prefer this when the user is writing Go build-agent-side code rather than backend Kotlin services.
Provides Go (Golang) engineering guidance for designing packages, services, and CLIs. Use whenever the task involves Go implementation, refactors, code reviews, API design, package layout, interfaces, constructors/config, error handling, logging, dependency or framework selection, HTTP/service wiring, concurrency/lifecycle, tests, benchmarks, godoc, or maintainability decisions.
Use when an incompatible interface needs to look like an expected one — phrases like "Adapter pattern", "the third-party library's API doesn't match what I need", "wrap this legacy class to look like the new interface", "interface mismatch", "translate between two APIs". Defines Adapter as wrapping one interface to satisfy another, so client code can use otherwise incompatible classes through a uniform interface
Use when an abstraction and its implementation must vary independently—phrases like “Bridge pattern”, “I have N shapes times M renderers and don't want N*M subclasses”, “decouple the abstraction from its implementation”, “two orthogonal dimensions of variation”. Defines Bridge as separating an abstraction from its implementation so the two can vary independently—a cousin of Adapter, but designed up front rather than retrofitted.
Use when constructing an object requires many parameters or optional configuration steps — phrases like “Builder pattern”, “telescoping constructors”, “I have a constructor with 12 parameters half of which are optional”, “fluent API for construction”, “step-by-step object construction”, “type-safe builder”, “DSL builder”. Defines Builder as separating construction of a complex object from its representation, letting the same construction process create different representations.
Use when encapsulating a request as an object — phrases like "Command pattern", "undo/redo", "queue this operation", "remote control with arbitrary buttons", "macro of operations", "the invoker shouldn't know what the operation does". Defines Command as wrapping a request (target + action + arguments) into an object that can be parameterized, queued, logged, or undone.
Use when treating individual objects and groups of objects uniformly — phrases like "Composite pattern", "tree structure", "menus and submenus both behave like menu items", "I want to call `display()` on either a leaf or a branch and have it work", "part-whole hierarchy". Defines Composite as composing objects into tree structures so clients can treat individual leaves and composite branches uniformly through a shared interface.
Use when adding behavior to an object dynamically without subclassing — phrases like "Decorator pattern", "wrap this with extra behavior", "the Java I/O Streams pattern", "compose responsibilities at runtime", "I need 16 variants of Beverage and don't want 16 subclasses", "add features without modifying the underlying class". Defines Decorator as wrapping an object in another object that adds responsibility while preserving the original's interface
Use when simplifying access to a complex subsystem — phrases like "Facade pattern", "home theater example", "make this subsystem easier to use", "hide the complexity behind one method", "high-level interface to many classes". Defines Facade as a single entry-point class that orchestrates a set of subsystem classes behind a simpler interface, without preventing direct subsystem access.
Use when object creation is non-trivial enough to deserve its own abstraction — phrases like "Factory pattern", "Factory Method", "Abstract Factory", "Simple Factory", "I keep `new`-ing different concrete types", "creation logic is leaking into client code", "the constructor takes too much and is doing too much". Covers Simple Factory, Factory Method, and Abstract Factory together, with picking criteria for choosing between them
Use when the user has a design problem and is asking which GoF pattern, if any, fits — phrases like "which design pattern should I use", "is this an Observer or a Mediator", "what pattern handles this", "I'm not sure if it's Strategy or State", "help me pick a pattern for this scenario". Diagnostic mode that walks the problem statement to a candidate pattern (or rules patterns out) and hands off to the relevant pattern skill.
Use when traversing a collection without exposing its internals — phrases like “Iterator pattern”, “the menus use different internal structures but the diner shouldn't care”, “encapsulate iteration”, “hide whether it's an array, list, or hash map”. Defines Iterator as providing a uniform way to access elements of a collection sequentially without revealing the collection's underlying representation.
Use when a change in one object's state must notify many dependent objects — phrases like "Observer pattern", "publish-subscribe", "listeners", "the weather station needs to notify multiple displays", "broadcast a change", "one-to-many notification". Defines Observer as a subject maintaining a list of observers and notifying them on state changes, without the subject knowing observer concrete types.
Use when controlling access to an object — phrases like “Proxy pattern”, “lazy initialization”, “remote proxy”, “virtual proxy”, “protection proxy”, “the client should not know they're talking to a stand-in”, “wrap an expensive object with a placeholder”. Defines Proxy as a stand-in for another object that controls access to it (creation timing, location, permission).
Use when an object's behavior must change based on its internal state — phrases like “State pattern”, “the gumball machine behaves differently in each state”, “state machine”, “huge switch over a status enum”, “the same action does different things depending on the current state”. Defines State as encapsulating each state of an object in its own class and letting the context object delegate behavior to whichever state it currently holds.
Use when behavior varies independently of the object that uses it—phrases like “Strategy pattern”, “swap the algorithm at runtime”, “this class has a giant switch over behavior types”, “the duck class is hardcoded to one quacking style”, “encapsulate the algorithm”. Defines Strategy as encapsulating a family of interchangeable algorithms behind a common interface, letting clients vary the algorithm without subclassing.
Use when an algorithm has a fixed skeleton with variable steps — phrases like “Template Method pattern”, “the steps are the same but one varies”, “Coffee and Tea both brew via boil-brew-pour-add-condiments but differ in two steps”, “hook method”, “the Hollywood principle don't call us we'll call you”. Defines Template Method as a base class that defines an algorithm's skeleton in a final method, deferring some steps to subclasses.
Use when adding new operations over an existing object hierarchy without modifying it — phrases like "Visitor pattern", "double dispatch", "I want to add operations to this AST/tree without changing the node classes", "separate algorithm from data structure". Defines Visitor as representing an operation to be performed on the elements of an object structure — letting you define a new operation without changing the classes of the elements on which it operates.
Configure and use GoReleaser for release automation with `.goreleaser.yaml`, `goreleaser build`, and `goreleaser release`. Use this skill when creating or editing GoReleaser config, setting up GitHub Actions release pipelines, building cross-platform binaries, publishing to Homebrew, Scoop, AUR, nFPM, Docker, or other package targets, generating changelogs, or automating release artifacts for Go, Rust, Zig, TypeScript, or Python projects.
Install and use GSAP (GreenSock Animation Platform) for high-performance JavaScript animations. Covers core utilities (Tween, Timeline), React integration (@gsap/react/useGSAP), Eases, and popular plugins like ScrollTrigger, ScrollSmoother, and Flip. Use when creating complex animations, scroll-based effects, UI transitions, or SVG animations, or when the user mentions GSAP, GreenSock, or ScrollTrigger.
A Socratic coding tutor that guides developers through implementing a spec or plan step by step without ever writing code for them. Use when the user asks to be guided through implementation, wants to learn by doing, requests tutoring, or otherwise wants to build something themselves with guidance. Also use when they explicitly want to learn while building.
Computer vision expert specializing in real-time hand tracking and gesture interface design. Use when "hand tracking, gesture recognition, mediapipe, hand gestures, touchless interface, sign language, hand pose, finger tracking, mediapipe, hand-tracking, gesture-recognition, computer-vision, hci, touchless, ml" mentioned.
Set up OpenAI's harness engineering methodology in any repository. Creates the full agent-first infrastructure: AGENTS.md progressive disclosure map, architectural layer boundaries with mechanical enforcement, testing framework, CI pipeline, golden principles documentation, garbage collection scripts, and pre-commit hooks. Use when asked to "set up harness engineering," "make the repo agent-ready," "add architectural boundaries," "set up testing and CI," or "adopt agent-first engineering." Works with any stack — React, Next.js, Python, Go, Rails, etc.
Design FHIR R4 API interactions — search queries, operations ($), validation, workflow patterns, and custom SearchParameter / OperationDefinition resources. The user provides requirements; the skill recommends a concrete R4 approach with trade-offs.
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.