Skills
97,725 packaged capabilities and playbooks for agents. Install any of them with one command.
Development
React composition patterns that scale. Use when refactoring components with boolean prop proliferation, building flexible component libraries, or designing reusable APIs. Triggers on tasks involving compound components, render props, context providers, or component architecture. Includes React 19 API changes.
Integrate, test, debug, and harden Verify.et transaction verification API implementations. Use when building Verify.et server-side adapters, payment or checkout verification, account webhook registration (dashboard or API), webhook receivers and signing secrets, opt-in receipt image processing (QR or OCR), polling or SSE status flows, API-key auth, idempotency, credits or quota handling, bank-specific payloads, or production error handling.
Query and answer questions about Volcengine API specifications. Trigger this skill whenever a user asks about Volcengine API parameters, error codes, request methods, enum values, required fields, response structures, pagination, parameter dependencies, or API comparisons — even if they don't explicitly say "API". Typical triggers include questions like "What parameters does DescribeInstances have?", "What values does Status support?", "What does InvalidInstanceId.NotFound mean?", "Does Volcengine have a batch tag deletion API?", "Which APIs does ECS support?", "How do I pass parameters to CreateDatabase?", "Is ChargeType required?", "What fields does DescribeInstances return?", "How do I paginate instance lists?", "What's the difference between these two APIs?", "RunInstances returns InvalidParameterValue". When the user needs runnable SDK code, hand off to the volcengine-sdk-generator skill. When the user needs CLI-based operations, hand off to the volcengine-cli skill. Supports both Chinese and English prompts.
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.
Use when you need to turn a vague idea into a confirmed design spec before implementation (new feature/component/behavior change). First check project context, then ask one question at a time, provide 2-3 options with trade-offs, finally output design in segments (~200-300 words each) with confirmation after each. Triggers: brainstorm, clarify idea, design spec, refine concept, requirement clarification.
Use when you need to ship a single PR-sized feature end-to-end (plan -> implement -> verify) with artifacts. Ship core product features quickly in a Next.js codebase: turn a feature idea into an executable plan, implement in PR-sized slices, and keep artifacts under runs/ (or OpenSpec changes/ when available). Supports plan-only mode for early scoping. For prototype UI work, include a demo-ready wow moment (animation/micro-interaction) by default unless user opts out.
Pre-work validation before starting implementation. Use when beginning work on an issue, feature, or fix to verify remote state, check for existing PRs, detect branch conflicts, and prevent redundant work. Catches problems that cause wasted effort: already-merged fixes, stale branches, unclean diffs.
Extract a shareable runnable template under templates/NNN-slug/ from a real project: copy + de-brand + remove secrets + add env examples + docs, with minimal refactors. Use when you have a working project and want to turn it into a template.
Use when you have a finalized brainstorm-beagle spec at `.beagle/concepts/<slug>/spec.md` and need a bite-sized, TDD-driven implementation plan before any code is written. Triggers on: "write a plan", "plan this spec", "turn the spec into a plan", "now plan the implementation", "write-plan". Reads the spec, designs the file structure, decomposes work into 2-5 minute TDD steps with exact paths and commands, self-reviews against the spec, gets user approval, then writes to `.beagle/concepts/<slug>/plan.md` and offers to generate an execution handoff prompt via the subagent-prompt skill. Does NOT brainstorm specs, write code, or execute the plan — produces the plan document (and an optional handoff prompt) only.
This skill should be used when a developer wants to open a pull request for a completed trace branch — for example "create a PR", "open a pull request", "submit this for review", "make a PR for trace #42", "push this up for review", or "create PR from current branch". Reads the Trace + Feature + Epic hierarchy to write a meaningful PR description. Handles branches with or without a linked WTF trace issue.
Extract text, tables, metadata, and images from 107 document formats (PDF, Office, images, HTML, email, archives, academic) using Xberg. Use when writing code that calls Xberg APIs in Python, Node.js/TypeScript, Rust, or CLI. Covers installation, extraction (sync/async), configuration (OCR, chunking, output format), batch processing, error handling, and plugins.
Yup schema validation library. Popular with Formik for form validation. Use when building forms with React/Formik or needing schema-based validation. USE WHEN: user mentions "Yup", "Formik validation", asks about "yup schema", "Formik setup", "form validation library" DO NOT USE FOR: Zod projects (use zod skill), NestJS/class-validator (use class-validator skill), new projects (prefer Zod)
This skill should be used when the user asks to "create a 1C customization", "implement 1C functionality", "add a new capability to 1C", "develop a 1C module", "make a customization in 1С", or needs the full 1C customization development cycle from analysis to implementation with plan validation and acceptance checks.
Creates a Pull Request from current changes for OneKey app-monorepo. Use when user wants to create PR, submit changes, or merge feature branch. Handles branch creation, commit, push, and PR creation with conversation context extraction for code review AI.
Mount tRPC as Express middleware with createExpressMiddleware() from @trpc/server/adapters/express. Access Express req/res in createContext via CreateExpressContextOptions. Mount at a path prefix like app.use('/trpc', ...). Avoid global express.json() conflicting with tRPC body parsing for FormData.
Use when the user asks to migrate, convert, compatibilize, or modernize legacy ADVPL procedural code to TLPP object-oriented classes on TOTVS Protheus -- turning User Functions/Static Functions into namespaced classes with methods and data properties, replacing Private/Public scoping, and preserving backward-compatible wrappers for existing callers. Also triggers on Portuguese phrasing like "migrar para tlpp", "compatibilizar fonte", "converter prw para tlpp", "transformar em classe", "modernizar rotina", or requests naming a `custom.<agrupador>.<servico>` / `totvs.protheus.<segmento>.<agrupador>` namespace.
Battle-tested engineering principles for AI coding agents. Covers plan-first workflow, subagent delegation, self-improvement loops, verification gates, elegant solutions, autonomous bug fixing, and structured task management. Use when configuring agent behavior, writing AGENTS.md files, or improving agent reliability and code quality.
Interfaces with a model in the loop. Streaming text without layout thrash, thinking and reasoning states, tool calls and their status, approvals, citations, the composer, stop and regenerate, scroll pinning, markdown rendering, latency masking, and honesty about what the system is doing. Use when building chat, copilots, agent dashboards, AI features inside a product, or anything that shows model output as it is produced.
Mandatory coding discipline rules that prevent common AI coding anti-patterns. MUST be loaded for ALL code writing, editing, reviewing, bug fixing, and testing tasks. Trigger on: writing code, editing code, fixing bugs, writing tests, implementing features, refactoring, code review, creating functions, adding error handling, debugging. This skill enforces fail-fast principles, proper error propagation, meaningful tests, and disciplined debugging workflows. Always active when Claude writes or modifies code.
Scans .NET code for ~50 performance anti-patterns across async, memory, strings, collections, LINQ, regex, serialization, and I/O with tiered severity classification. Use when analyzing .NET code for optimization opportunities, reviewing hot paths, or auditing allocation-heavy patterns.
Data layer reference for Android app development (Kotlin). Jetpack androidx. Room / Room 3 (androidx.room3) (Entity, Dao, Query, Migration, prepopulate, createFromAsset), DataStore (Preferences/Proto, Direct Boot), MediaStore, SharedPreferences, scoped storage, Retrofit, OkHttp.
Platform fundamentals reference for Android app development (Kotlin). Activity, Intent, Application, ContentProvider, AndroidManifest, androidx, runtime permissions, NotificationCompat, CallStyle, Bubbles (BubbleMetadata), WindowInsets, splash screen, Glance widgets.
Guides architecture decisions about service/module boundaries, system trade-offs, ADRs, data flow, rendering strategy, scaling strategy, API protocols, persistence choices, and code organization. Use when the user asks "how should I structure this", "what's the right approach", or needs a decision that affects multiple modules, teams, deployment boundaries, or future reversibility. Do not use for routine React implementation, PR review, or simple refactors unless the user is making an architectural decision.
Project architecture and file structure conventions for all process types. Use when: (1) Creating new files or modules, (2) Deciding where code should go, (3) Converting single-file components to directories, (4) Reviewing code for structure compliance, (5) Adding new bridges, services, agents, or workers.
Build a compilable type-level skeleton from a high-level architecture spec before writing any implementation logic. Use when you have an architectural assessment, design doc, or restructuring plan and need to prove the new architecture is sound before migrating code. Also use when asked to "scaffold the new architecture", "create type stubs", "build the shell", "flesh out this spec", "skeleton the modules", or any request to turn architectural intent into verified structure. This skill follows the "Human Builds the Shell" paradigm: types are hard constraints that the compiler enforces, so if the skeleton compiles, the architecture is structurally sound. Especially valuable for large refactors where you don't trust agents to maintain coherence.
Senior embedded software engineer specializing in firmware and driver development for ARM Cortex-M microcontrollers (Teensy, STM32, nRF52, SAMD). Decades of experience writing reliable, optimized, and maintainable embedded code with deep expertise in memory barriers, DMA/cache coherency, interrupt-driven I/O, and peripheral drivers.
Use this skill ANY time you need to search for code structure, refactor symbols, analyze impact, find dead code, or trace dependencies. ALWAYS invoke BEFORE using grep for structural code analysis. Trigger categories: structural pattern search (e.g. useEffect without deps, async without try-catch, fetch calls outside src/api), bulk code migration/transformation (wrap handlers, replace API calls), dependency & impact analysis (blast radius, transitive deps, which modules depend on X), safe renaming across codebases, dead code & circular import detection, ast-grep rule authoring. Trigger keywords: try-catch, useEffect, async without, circular imports, safe rename, blast radius, bulk migration, never imported, unused exports, ast-grep, enforce pattern, structural search, depends on, which modules. Do NOT trigger for: grep-able string searches, file-name lookups, reading READMEs, writing regex, CSV/data scripts.
Write correct async Rust — runtime choice, Send and Sync bounds, cancellation safety, blocking work inside async contexts, and shared state across tasks. Use when writing or reviewing async code, when a future is held across an await point, when the user hits a Send bound error on a spawned task, when a runtime stalls or deadlocks, or when the user asks about tokio, select!, or spawn_blocking.
Karpathy-inspired autonomous research loop. Agent edits one file, evals, keeps or discards, repeats. Plateau-triggered web search breaks through ceilings. Git as state machine. Runs until stopped or budget exhausted. Supports claude, codex, and pi providers.
Use only when the user wants to install, configure, invoke, or troubleshoot Autoverse CLI itself. Covers login, credential profiles, accounts and points, command syntax, JSON/exit codes, and atomic command contracts. Do not trigger for ordinary requests to find papers, prepare research proposals, or expand from seed papers.
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.