Skills
97,222 packaged capabilities and playbooks for agents. Install any of them with one command.
Agent workflows
This skill synchronizes plugin skills (plugins/synapse-a2a/skills/) with the current implementation, README.md, and guides folder. Use this skill when implementation changes have been made, new features added, or documentation updated, to ensure plugin skills stay up-to-date. Triggered by /sync-plugin-skills command or when significant code changes are detected.
Rigorously evaluate whether a prompt or document will produce the expected output when processed by an LLM. Use when user says "evaluate this prompt", "review my prompt", "will this work?", "critique this", or "check my instructions". Adversarial analysis with expectations scorecard and actionable recommendations.
UiPath solution planner and designer. Always invoke for PDD / SDD files (`pdd.md`, `*-sdd.md`). Authors a Solution Design Document (SDD) from a Process Definition Document (PDD) or another process-knowledge source (Confluence page, SOP, BPMN model, meeting transcript), then derives the multi-skill, multi-project task list from an SDD, emitting live TaskCreate calls. Known-product single-project build, no PDD/SDD → that skill; ambiguous/“what should I build” → here. For `uip solution` lifecycle and `.uipx` → uipath-solution. For non-solution Orchestrator/IS/auth/traces → uipath-platform. For .xaml/.cs → uipath-rpa. For .flow → uipath-maestro-flow. For building/editing .bpmn → uipath-maestro-bpmn (a .bpmn as design input routes here). For agent.json/.py → uipath-agents. Sole case-SDD author. For caseplan.json build → uipath-maestro-case.
Creates a new Claude Code Skill following best practices. Use when the user wants to create a new skill, add a skill, or asks about writing skills for Claude Code. Fetches latest documentation before generating skill content. New skill. Create a skill.
Run an unattended, standing fleet that autonomously implements a repo's ready GitHub-issue backlog — dispatching worktree-isolated workers, gating each on CI, and auto-merging green PRs until stopped. Use when the user wants to go AFK on the issues ("launch workers to do the issues", "run the fleet", orchestrate agents against GitHub issues with orca), or asks for one of its modes: --plan (dry-run), --tick (single pass), --takeover (inherit a dead fleet's claims). Another skill can invoke it to staff an already-decomposed backlog. NOT for decomposing a PRD/epic into issues, implementing a single named issue by hand, or reviewing a PR.
Design principles for building CLI tools that LLM/AI agents can safely and reliably operate. Provides 7 core principles (Machine-readable, Non-interactive, Idempotent, Safe-by-default, Observable, Context-efficient, Introspectable) with scorecard, templates, and anti-patterns. Use when: (1) designing new CLI tools for agent use, (2) improving existing CLIs for agent compatibility, (3) reviewing CLI design for agent-friendliness, or (4) need guidance on JSON output formats, exit codes, authentication flows, or self-describing CLI patterns.
Set up, integrate, build, debug, and ship AgentMark prompts, datasets, experiments, and evals. TRIGGER: setting up / integrating AgentMark into any app or agent, including when an SDK is named (raw Anthropic/OpenAI, Vercel AI SDK, Bedrock, a framework) — the named SDK is the integration TARGET, never a reason to skip; any `.prompt.mdx`, `agentmark.json`, `agentmark.client.ts`, `agentmark_client.py`, an `agentmark/` or `.agentmark/` dir, or `@agentmark-ai/*` imports; `npx create-agentmark` or any `agentmark` command (`init`, `dev`, `doctor`, `run-prompt`, `run-experiment`, `generate-types`, `link`, `pull-models`); driving AgentMark Cloud (`agentmark-mcp`, headless provisioning, git deploys); any mention of AgentMark, prompt versioning, experiments, evals, deployments, or trace observability. SKIP only with NO AgentMark intent or markers: provider-neutral prompt code; generic prompt-engineering or observability questions; competing platforms (Langfuse, LangSmith, Phoenix, Braintrust, Traceloop).
Set up an AI-driven changelog system in any project, code or not. Suitable for both software projects and for non-code projects. Creates a CHANGELOG.md and instructions for agents to log changes. Use when the user wants to add or improve automated changelog management, AI-friendly changelog workflows, version stamping, or set up a changelog system for a new or existing project.
Clarify a task, plan, or decision through dependency-bounded questions. Explicit invocation stops for manual continuation; internal clarification returns to its caller. Use when the user invites questions or clarification, including "ask me" and "askme", even conditionally ("if you have questions, ask me"). Match equivalent intent, not just these phrases. Do not trigger on quoted text, negated requests, or discussion of the skill itself. Russian discovery terms: "узнай у меня", "уточни у меня", "спроси меня", "если есть вопросы - askme", "уточнить задачу".
Design and orchestrate multi-artifact Avonni solutions. MUST activate when a request spans more than one Avonni artifact type (Dynamic Component, Flow Screen Components, Experience site components) or describes a business use case rather than a single named artifact — e.g. a component plus the flow it launches. Do NOT use for a single artifact of a known type — use its skill directly.
Use when an agent is executing work in any project repo and needs to coordinate with a human or other agents via BeadBoard. BeadBoard is the human-facing dashboard running separately; this skill is the agent-side operating contract for state, mail, assignment, and evidence flow.
Use when /better-harness reviews the outer coding-agent Harness for lifecycle controls, repeated work, project feedback, agent assets, session outcomes, repair planning, durable reports, finding-bound fixes, or manual direct fixes. Invoke only via slash command.
Core rules for bkit — PDCA methodology, level detection, agent triggering, quality standards, Sprint management (8-phase container with 4 auto-pause triggers, v2.1.13), and Trust Level scope (L0-L4 gates PDCA + Sprint auto-run). Triggers: bkit rules, core rules, methodology
Integrate and operate BOUND, the deterministic bounded-utility control policy for agent workflows. Use when an agent must install bound-policy, define StepContracts, collect real ExecutionEvidence, evaluate meaningful execution boundaries, react to ACCEPT/RETRY/REPLAN/ROLLBACK, audit an existing BOUND integration, or produce a reproducible numeric integration report.
Capture learnings, patterns, or workflows from the current conversation into a new or existing skill. Use when the user wants to save what was learned, discovered, or built during a conversation as a reusable skill for future sessions. Triggers include "capture this as a skill", "save this for next time", "turn this into a skill", or when a useful workflow, pattern, or piece of domain knowledge emerged during the conversation.
Write and improve CLAUDE.md files following Anthropic best practices. This skill activates when the user says "crear CLAUDE.md", "mejorar CLAUDE.md", "actualizar CLAUDE.md", "revisar CLAUDE.md", "escribir instrucciones del proyecto", "create CLAUDE.md", "improve CLAUDE.md", "review CLAUDE.md", "write project instructions", "optimize docs for Claude", "auditar CLAUDE.md", "audit CLAUDE.md", "limpiar CLAUDE.md", "dead weight", or configures a new repository.
Convenes expert panels for problem-solving. Use when user mentions panel, experts, multiple perspectives, MECE, DMAIC, RAPID, Six Sigma, root cause analysis, strategic decisions, process improvement, or asks for philosophers/ancients (Socratic, Aristotelian, Stoic method experts).
Writes or reviews agent skills and slash commands built from reusable workflows, domain expertise, project conventions, or shortcut instructions. Use before creating, editing, or reviewing any skill or slash-command file, and when the user asks to package repeated instructions behind a name or to evaluate or prune an existing skill.
Persistent, budgeted, DAG-ordered runner for parallel `claude -p`, `codex exec`, or `pi -p` workers in tmux. Use ONLY when you need persistence across sessions, per-worker budget caps, dependency ordering, or mixed models/providers per worker. For ad-hoc parallel sub-agents inside a live conversation, use Claude Code's built-in Agent tool instead.
The one spawn path for `/dispatch` — `scripts/spawn-confined.sh <harness>` forks the worker's worktree, wraps it in a kernel-level jail, and runs the harness headless inside it. Every harness takes this path; there is no in-session arm and no unconfined fallback. The worker cannot commit — it hands back an uncommitted working tree and the orchestrator imports it. Reached from the `/dispatch` router; do not invoke directly
Evaluate project specifications at inception (Step One), deterministically assess Scale & Load, Domain Decoupling, and Resource Intensity vectors, and automatically enforce a distributed Microservices Architecture when warranted, preventing monolith scaffolding.
Configure and audit AI agent harness settings, permissions allowlists, environment variables, editor keybindings, and lifecycle hook integrations. Use when modifying settings.json, adjusting tool permissions, setting up environment variables, or configuring agent lifecycle hooks — even if the user does not explicitly say "fable-config" (e.g. "update settings", "allow command permissions", "configure agent hooks", "setup environment variables"). Do NOT use for application-level business configuration.
Use at the start of any multi-step task and during exploration—before reading files, searching, or re-checking completed work, especially when tempted to read whole files, re-verify known facts, or run independent lookups one at a time.
Execute autonomous, multi-step cowork sessions with silent tool chaining, outcome-first progress reports, and strict safety boundaries. Use for complex background tasks, multi-tool refactoring workflows without conversational noise, or deep automated passes—even if the user doesn't explicitly say "fable-cowork" (e.g. "run autonomously in background", "cowork mode", "execute quietly and report results", "silent refactor pass"). Do NOT use when active user dialogue or step-by-step confirmation is required.
Delegate independent subtasks to parallel workers or subagents with strict disjoint ownership, bounded scope, and explicit acceptance contracts. Use when coordinating multiple independent tasks, parallelizing multi-file work without merge conflicts, or managing subagent task assignments — even if the user does not explicitly say "fable-delegate" (e.g. "split this work among workers", "delegate these subtasks", "run parallel agents", "assign independent pieces"). Do NOT use for tightly coupled sequential tasks or when shared mutable state causes edit collisions.
Discuss a domain with the user, research it from real sources, then generate a trusted skill bundle for it—a step-by-step workflow with a flowchart, a domain adapter, a trap fixture, and a smoke eval. Use when the user says "/fable-domain <sector>", "make a skill for <domain>", "add a domain to the fable method", or "give a lesser model Fable's workflow for <domain>". The bundle is the deliverable; a workflow without its flowchart, sources, and trap is not done.
Provision curated capabilities, manage reproducible capability locks, verify host integrations, and compile capability execution contracts for routed get-fable work. Use when discovering machine capabilities, managing eco profiles, planning capability installations, repairing ecosystem health, or preparing capability-aware execution contracts—even if the user doesn't explicitly say "fable-eco" (e.g. "install eco capabilities", "run eco discover", "repair ecosystem", "explain capability run"). Do NOT use as an independent task router (use get-fable).
Implement one accepted, bounded work card with immediate local verification, invariant preservation, and zero scope drift. Use when executing a planned work card, applying a well-defined code change, implementing an isolated function, or performing targeted single-scope edits — even if the user does not explicitly say "fable-execute" (e.g. "implement this card", "write the code for this step", "apply the agreed changes", "build this component"). Do NOT use when new architectural decisions are required (use fable-plan) or when tests are repeatedly failing (use fable-recover).
Compact session decisions, durable evidence, open blockers, and exact next actions into structured continuation state for resuming work across sessions. Use when pausing a coding session, transferring context to another agent, summarizing long-running work, or creating durable continuation checkpoints—even if the user doesn't explicitly say "fable-handoff" (e.g. "save context for next session", "create a handoff", "pause work here", "summarize where we left off"). Do NOT use as a substitute for verifying code changes (use fable-verify).
Adversarial verification of finished work. Treats any "done" as a set of claims, then re-runs the claimed verifications, diffs what actually changed, detects weakened tests and false completion claims, and delivers an evidence-based verdict (VERIFIED / VERIFIED WITH CAVEATS / REFUTED). Use after any agent or model claims work is complete - "/fable-judge", "judge this work", "verify what it did", "did that actually work?". Also runs the fable-method trap suite against a skill or model via "/fable-judge suite <target>".
Convert sessions and trajectories into durable project engineering knowledge and failure lessons under Failure-lessons/, agent-kernel, and gbrain. Use when extracting session learnings, synthesizing knowledge from conversations, capturing root causes, documenting failure lessons, or recording durable engineering invariants — even if the user does not explicitly say "fable-learning" (e.g. "what did we learn", "convo-learn", "failure lessons", "extract learnings", "save what we learned", "rules we now enforce"). Do NOT use for general code review or diff audits (use fable-review).
Execute bounded recurring polling loops, CI build babysitting, interval-based status monitors, and self-paced test cycles with explicit timeouts and backoff. Use when monitoring async CI/CD pipelines, polling external service status, running interval test watches, or tracking long-running jobs — even if the user does not explicitly say "fable-loop" (e.g. "babysit this build", "poll until completed", "watch CI status", "wait for deployment"). Do NOT use for synchronous one-shot commands or unbounded infinite polling loops.
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.