Claude Skills
The open format is called Agent Skills and works in Claude Code, Codex, Cursor and other agents — most people know it as Claude Skills.
Every Agent Skill we could find on GitHub, deduplicated by content. 79 566 files from 1 758 authors, of which 61 913 are unique — the rest is the same skill repackaged into someone else's repository. For each one: what it weighs in tokens, whether it ships runnable scripts, and which MCP servers it needs.
Route the mpp provider-charge plan through canonical charge.
Scan Moltbook for credible opportunities, prepare evidence-bound posts, and publish an exact approved payload through Runx Connect with readback.
Route the mpp payment rail through canonical spend authority and finality.
Validate a runx execution context and hand off a governed payload to an n8n workflow webhook with scoped auth, idempotency, and receipt expectations.
Route the mpp refund plan through canonical receipt- and authority-bound refund.
Operate a Nitrosend account through one governed Runx skill: inspect readiness and analytics, plan and apply campaign/flow/template/segment drafts, import consented contacts through inline or bulk CSV paths, and approve or deliver campaign, flow, and transactional email operations with provider readback.
Resolve a place and fetch global forecast and air-quality evidence through governed, keyless Open-Meteo HTTP calls.
Execute one bounded Nitrosend MCP operation through Runx native HTTP.
Operate a project, workspace, or account from an agent or manager dashboard: inspect state, triage risks, prepare governed actions, route to the right skill lane, require approvals for consequential acts, and verify receipts after execution.
Maintain a provider-neutral local action queue from bounded provider observations and explicit human dispositions.
Fetch National Weather Service forecast evidence through the governed HTTP front, producing a sealed provider packet for downstream weather planning.
Turn bounded search, analytics, site, and market evidence into an evidence-bound SEO and answer-engine growth brief with prioritized actions and a measurement plan, without claiming execution or guaranteed visibility.
Turn a pinned local upstream SKILL.md into an exact native Runx binding bundle, with deterministic source digests, a bounded execution profile, isolated harness proof, and no publication claim. Use when adopting a third-party skill; use skill-lab for first-party Runx skills.
Draft or tighten a Runx operational policy from a governance brief, then validate the exact runx.operational_policy.v1 contract with the native policy engine. Use for repository/source/runner/owner policy design, fail-closed policy linting, or authority attenuation; never use this lane to widen an existing policy.
Govern one GitHub pull-request review comment through Runx Connect or the canonical MCP pattern, with exact approval, retry safety, and independent readback.
Inspect bounded local repository and Runx catalog evidence before a design, draft, or operator decision, then produce citation-bound findings and a reuse, amendment, new-work, or stop recommendation. Use when existing tools, skills, standards, or project patterns must constrain downstream work; use research or web-fetch first for external sources.
Read durable reflect projections, group repeated signals by skill, and emit validated handoffs to skill-lab improve when the evidence clears configured floors.
Detect and remove personal data before content crosses a trust boundary, returning usable scrubbed content only when a deterministic residual scan passes. Use for exports, prompts, logs, support material, or outbound handoffs that need a pass, review, or block verdict; it does not move content or handle credentials.
Produce bounded, source-backed research packets for product, ecosystem, and operator decisions.
Prepare a sealed-receipt-linked refund handoff under bounded authority without claiming money moved.
Prepare, approve, execute, and independently verify a versioned release through a project-owned exact-command profile.
Internal evidence-index analysis and verification stage for the canonical research skill.
Validate one invoice against a real payment authority and prepare an executable canonical spend handoff without moving money.
Read Runx's native receipt history and skill catalog, then return deterministic run outcomes, catalog test coverage, and governance follow-ups without model-authored metrics.
Inspect, safely test, and assess one Runx skill package for capability, trust, and operator readiness. Use when deciding whether to adopt, improve, reject, install, or publish a skill; its evidence-only assess runner is available when native test evidence already exists.
Review receipts and harness failures to propose bounded skill improvements.
Plan and authorize a provider-neutral message or campaign send; this skill never delivers, so use a provider adapter for the actual send and its delivery evidence.
Bind an off-runtime action claim to opaque evidence references in a signed Runx receipt without pretending Runx verified the external action.
Canonical Runx skill-authoring implementation. Use for designing, creating, updating, improving, or adding harness coverage to a Runx skill package; it combines bounded agent judgment with native file writes, inspection, and safe harness validation. When a host skill-creator also triggers, use its general guidance but execute Runx work through this skill.
Plan a digest-bound Slack notification, then deliver the exact approved channel post through a configured Runx Connect grant with provider readback.
Execute one governed outbound payment through deterministic quote, authority reservation, approval, rail fulfillment, and provider evidence.
Generate documentation for a project using Sourcey.
Read bounded Slack search and thread evidence, plan an exact reply, and deliver an approved reply through Runx Connect with stable-message readback.
Fulfill a reserved payment challenge through one rail under attenuated runx authority.
Reconcile an idempotent payment attempt before retrying or sealing.
Deterministically normalize one structured payment signal into a bounded quote and requested payment authority derived from the caller's real parent authority.
Deterministically mint and prove one single-use child payment authority from a native quote and the caller's real parent authority.
Produce a schema-validated, read-only SQL analysis plan and explicit governed execution handoff without running raw SQL.
Route the stripe provider-charge plan through canonical charge.
Execute a governed stripe-spt payment by delegating to the canonical spend authority and finality lane.
Build a scoped taste profile packet from examples, preferences, and explicit dislikes so downstream agents can make style decisions without inventing the user's taste.
Route the stripe refund plan through canonical receipt- and authority-bound refund.
Prepare an evidence-bound vulnerability publication and publish the exact approved advisory through Runx Connect with independent provider readback.
Plan or execute a scoped, time-bounded vault-unseal request through Runx Connect, returning only opaque handle metadata and provider readback.
>- act plans for posting and account hygiene, and gated execution with per-act provider evidence. Nothing reaches a live timeline or mutates an account without an explicit approval recorded in the receipt.
Turn verified exact-version vulnerability evidence into bounded remediation and advisory packets without inventing exposure or claiming publication.
Normalize supplied provider weather evidence into a provenance-bound forecast packet with uncertainty and stop conditions. Use when a downstream planning workflow needs provider-neutral weather context; do not use it to fetch forecasts, make life-safety decisions, or perform downstream actions.
Compile a bounded objective or issue-intake change set into a dependency-safe Runx execution plan, with deterministic checks for evidence preservation, mutation boundaries, catalog references, and skill-package ownership. Use before multi-step or cross-surface work; this skill plans but does not execute.
Validate a runx execution context and hand off a governed payload to a Zapier Catch Hook with scoped auth, idempotency, and receipt expectations.
Fetch and extract one web source within an explicit allowlist, returning the content by digest with full provenance.
Validate an x402 payment challenge against bounded Runx payment authority and prepare the canonical spend quote without pretending a wallet adapter or settlement exists.
Guides architectural decisions for Deep Agents applications. Use when deciding between Deep Agents vs alternatives, choosing backend strategies, designing subagent systems, or selecting middleware approaches.
Create PydanticAI agents with type-safe dependencies, structured outputs, and proper configuration. Use when building AI agents, creating chat systems, or integrating LLMs with Pydantic validation.
Reviews LangGraph code for bugs, anti-patterns, and improvements. Use when reviewing code that uses StateGraph, nodes, edges, checkpointing, or other LangGraph features. Catches common mistakes in state management, graph structure, and async patterns.
Implements stateful agent graphs using LangGraph. Use when building graphs, adding nodes/edges, defining state schemas, implementing checkpointing, handling interrupts, or creating multi-agent systems with LangGraph.
Reviews Deep Agents code for bugs, anti-patterns, and improvements. Use when reviewing code that uses create_deep_agent, backends, subagents, middleware, or human-in-the-loop patterns. Catches common configuration and usage mistakes.
Implements agents using Deep Agents. Use when building agents with create_deep_agent, configuring backends, defining subagents, adding middleware, or setting up human-in-the-loop workflows.
Avoid common mistakes and debug issues in PydanticAI agents. Use when encountering errors, unexpected behavior, or when reviewing agent implementations.
Guides architectural decisions for LangGraph applications. Use when deciding between LangGraph vs alternatives, choosing state management strategies, designing multi-agent systems, or selecting persistence and streaming approaches.
Test PydanticAI agents using TestModel, FunctionModel, VCR cassettes, and inline snapshots. Use when writing unit tests, mocking LLM responses, or recording API interactions.
Claude Skills — questions
Answers built from the skills we actually parsed.