Delegate tasks to an opencode agent that uses alternative AI models (default: zai-coding-plan/glm-5-turbo). Use this skill whenever the user asks to "run opencode", "launch an opencode agent", "use opencode", or wants to delegate a task to opencode. Also use it when the user asks to run a task with a non-Claude model like GLM, or mentions opencode in any context where they want work done.

Fetch dependency source code to give AI agents deeper implementation context. Use when the agent needs to understand how a library works internally, read source code for a package, fetch implementation details for a dependency, or explore how an npm/PyPI/crates.io package is built. Triggers include "fetch source for", "read the source of", "how does X work internally", "get the implementation of", "opensrc path", or any task requiring access to dependency source code beyond types and docs.

Verify integration after parallel agent execution and generate report

Compact YAML format for defining parallel task specifications with scope, boundaries, and agent assignments. Use when creating task files for parallel development.

Use this agent when analyzing code for performance issues, optimization opportunities, or scalability concerns. Triggers on requests like "performance review", "check for bottlenecks", "scalability analysis".

Reference for the Pinecone MCP server tools. Documents all available tools - list-indexes, describe-index, describe-index-stats, create-index-for-model, upsert-records, search-records, cascading-search, and rerank-documents. Use when an agent needs to understand what Pinecone MCP tools are available, how to use them, or what parameters they accept.

Query integrated indexes using text with Pinecone MCP. IMPORTANT - This skill ONLY works with integrated indexes (indexes with built-in Pinecone embedding models like multilingual-e5-large). For standard indexes or advanced vector operations, use the CLI skill instead. Requires PINECONE_API_KEY environment variable and Pinecone MCP server to be configured.

Browse the web using playwright-cli connected to your running Edge browser via the MCP Bridge extension. Use when the user asks to "open a webpage", "browse to", "take a screenshot", "read this page", "navigate to", "check this site", or needs to interact with web pages for research and exploration.

This skill should be used when the user asks about "Claude Code plugins", "plugin development", "how to build a plugin", "what plugin components exist", "plugin architecture", "extending Claude Code", or needs an overview of plugin development capabilities. Acts as a guide to the 9 specialized plugin-dev skills, explaining when to activate each one. Load this skill first when the user is new to plugin development or unsure which specific skill they need.

Use when setting up project-specific agents via /cc:setup-project or when user requests custom agents for their codebase - analyzes project to create specialized, project-aware implementer agents that understand architecture, patterns, dependencies, and conventions

Evaluate how you use Claude Code — analyze prompt patterns, feature utilization, and get improvement suggestions. Trigger: /prompts:evaluate, prompt analysis, usage evaluation, how am I using Claude

Use this skill when securing AI applications against prompt injection. Activate when the user needs to prevent prompt injection attacks, validate AI inputs, implement input sanitization, or protect against adversarial prompts.

Creates reusable prompt templates with strict output contracts, style rules, few-shot examples, and do/don't guidelines. Provides system/user prompt files, variable placeholders, output formatting instructions, and quality criteria. Use when building "prompt templates", "LLM prompts", "AI system prompts", or "prompt engineering".

QA specialist agent for test planning, execution, and regression analysis

QA specialist agent for test planning, execution, and regression analysis

Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.

Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.

Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.

Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices.\n\nExamples:\n- <example>\n Context: User wants to understand a new repository's structure and conventions before contributing.\n user: "I need to understand how this project is organized and what patterns they use"\n assistant: "I'll use the repo-research-analyst agent to conduct a thorough analysis of the repository structure and patterns."\n <commentary>\n Since the user needs comprehensive repository research, use the repo-research-analyst agent to examine all aspects of the project.\n </commentary>\n</example>\n- <example>\n Context: User is preparing to create a GitHub issue and wants to foll...

Append new field definitions to an in-progress research outline's `fields.yaml` — either from user-supplied input or from a web-search agent that proposes common dimensions in the domain. Use mid-`/research-outline` when you've realised the schema is missing dimensions (e.g. pricing, performance, ecosystem, governance) before running `/research-deep`, so deep agents fill the new fields on first pass instead of needing a re-run.

Append new items (research objects) to an in-progress research outline's `outline.yaml` — sourced from your direct input, a web-search agent, or both. Use mid-`/research-outline` when you've realised the items list is incomplete (a new competitor surfaced, an important historical entry was missed, a category needs broader coverage) before running `/research-deep`, so the new items are part of the parallel deep pass instead of needing a separate run.

Evaluative research type sub-skill. Router-dispatched from research-agent parent on signals like "Did X work", "Impact", "Is X effective", "Worth it", "Evaluate", "Assess". Loads the Impact Assessment pattern (Pattern D) with PICO framework and risk-of-bias summary. Not directly model-invocable.

Retrieves, synthesizes, and prioritizes all recent AI agent results from Amplitude. Queries every agent type available in get_agent_results, validates freshness, and produces a unified narrative ranked by impact. Use when the user asks "what has the AI found", "show me agent insights", "any AI findings", "what did Amplitude discover", "review AI insights", or wants a digest of everything Amplitude's AI agents have surfaced recently.

Analyze AI/ML technical content (papers, articles, blog posts) and extract actionable insights filtered through enterprise AI engineering lens. Use when user provides URL/document for AI/ML content analysis, asks to "review this paper", or mentions technical content in domains like RAG, embeddings, fine-tuning, prompt engineering, LLM deployment.

Prevent destructive operations using Claude Code hooks. Three modes — cautious (warn on dangerous commands), lockdown (restrict edits to one directory), and clear (remove restrictions). Uses PreToolUse matchers for Bash, Edit, and Write.

Semantic code search using the Semble MCP server. Use when exploring an unfamiliar codebase, finding code by what it does rather than exact text, locating an implementation, understanding how a feature works, or discovering related code. Triggers on requests like "where is X handled", "find the code that does Y", "how does Z work", "search the codebase for", or any semantic/exploratory code question where grep's literal matching is a poor fit.

DEPRECATED — superseded by the rosemary skill. MCP server-memory session management. Use rosemary instead when the rosemary CLI is available.

Interactive setup for this plugin. Walks through the prerequisites, creates the required configuration files, and validates that MCP tools and/or LSP are correctly wired. Use when the plugin is first installed or when tools fail with missing-config errors.

Guides the agent through authoring and validating agent skills. Use when creating new skill directories, tightening skill metadata, extracting supporting references, or preparing skillgrade evals. Do not use for general app documentation, generic README editing, or non-agentic library code.

Guide for creating effective agent skills. Use when you want to create a new skill, improve an existing skill, or learn best practices for skill development. Helps codify learned patterns into reusable, discoverable skills.

Query Gemini with Google Maps grounding

Use when users ask to discover, install, list, check, update, remove, back up, restore, sync, or initialize Agent Skills, mention `bunx skills`, `npx skills`, `skills.sh`, or `skills-lock.json`, ask "find a skill for X", or want help extending agent capabilities with installable skills.

Find files with code duplications in a SonarQube project and inspect duplication blocks for a file (project key optional when MCP integration already defines the default project)

Guide for contributing to the stata-skill project. Use when the user wants to run the eval pipeline, analyze test results, improve reference docs, add new package documentation, or work on roadmap items. Covers the testing infrastructure, multi-agent analysis workflow, cost estimates, and links to prior eval results and improvement history.

Extract clean markdown or text content from specific URLs via the Tavily CLI. Use this skill when the user has one or more URLs and wants their content, says "extract", "grab the content from", "pull the text from", "get the page at", "read this webpage", or needs clean text from web pages. Handles JavaScript-rendered pages, returns LLM-optimized markdown, and supports query-focused chunking for targeted extraction. Can process up to 20 URLs in a single call.

Analyze a task, propose an agent team composition with roles and responsibilities, and create the team after user confirmation. Use when the user says "team stack", "create a team", "set up agents for this", or describes a complex task that would benefit from multiple agents working together.

Use when execute command encounters errors - diagnostic guide for phase failures, parallel agent failures, merge conflicts, worktree issues, and recovery strategies

Use when the user invokes /tui-runner to install, configure, or manage the terminal-mcp MCP server for headless terminal emulation in Claude Code.

Multi-agent orchestration that analyzes tasks through specialized expert panels (security, performance, architecture, etc.), synthesizes prioritized actions, then plans and executes. Use when facing complex tasks requiring multiple perspectives, architectural decisions, new features needing security/performance/quality review, or user says "waldstorm", "expert review", "analyze this task".

This skill enables the agent to create high-converting webinar scripts using the frameworks of Jason Fladlien and Jon Penberthy. It covers the entire process from introduction and content structure to offer presentation, objection handling, and closing sequences. Use this skill for webinar script creation, webinar strategy, and improving webinar performance.

Turn the prompt supplied with this skill into a concise, auditable Codex Goal or explain why a Goal is not the right fit. Use when the user asks to draft, formulate, rewrite, tighten, or create a `/goal` from a plain-language task, especially for multi-step work that needs a durable objective, evidence-based completion, constraints, iteration policy, and a default adversarial review loop.

Guides creation of hookify rules in .claude/hookify.{name}.local.md files, including YAML frontmatter fields (name, enabled, event, pattern, action, conditions), event types (bash, file, stop, prompt, all), regex pattern writing, condition operators, and rule organization. Activates when the user asks to create a hookify rule, write a hook rule, configure hookify, or add pattern-based automation rules.

# Product Manager Agent

# QA Test Specifications Agent

MANDATORY verification system that prevents Claude Code instances from making false claims or fabricating evidence. Enforces cryptographic verification, real testing evidence, and automatic claim validation before any success statements can be made.

This skill should be used when the user asks "what is agent-runtime", "why use agent-runtime", "what does this repo do", "agent runtime architecture", "how does agent-runtime work", or needs to understand the purpose, value proposition, and high-level architecture of the @hhopkins/agent-runtime monorepo.

This skill should be used when the user asks to "analyze sessions", "review my Claude usage", "session insights", "what have I been working on", "improve my workflow", "analyze conversation history", or mentions reviewing past Claude Code sessions. Routes to /session-review or /session-stats commands.

Test-Driven Development debug workflow combined with multi-agent collab-fix. Use when the user asks to "TDD debug", "reproduce and fix with a test", or wants a bug fixed with a failing test written first and verified after the fix.

This skill should be used when the user asks to review a completed team's process, run an after-action review, or evaluate team effectiveness. Use this skill when the user says "after action review", "AAR", "process review", "team retrospective", "review team process", "how did the team work", or at the prompt after a team completes its work. Distinct from `/evaluate-spawn` (output quality). AAR evaluates team process. Both can run in the same session.

Drive a real browser to inspect or interact with a web page or app — navigate, take screenshots, read console and network, fill simple forms — for verification tasks, not unattended automation.

Safe content workflow (drafts/reviewed/revised/approved/posted) with human-in-the-loop approval, plus CLI to list/move/review and post to LinkedIn/X. Use when setting up a content pipeline, drafting content, managing review threads, or posting approved content.

Create and manage agent graphs — directed graphs of configs connected by edges with handoff logic. Use when building multi-agent workflows where configs route to each other.

Start, monitor, and cancel durable multi-agent coding loops via Inngest. Use when the user wants to run autonomous coding workloads, execute a PRD with multiple stories, kick off an AFK coding session, have agents implement features from a plan, or manage running loops. Triggers on "start a coding loop", "run this PRD", "implement these stories", "go AFK and code this", "check loop status", "cancel the loop", "joelclaw loop", or any request for autonomous multi-story code execution.

Use HTTPie to call AI Universe MCP server for multi-model analysis

Complete workflow for using AI Universe MCP /secondo command

File a bug report or feedback on the Antithesis skills by opening a pre-filled GitHub issue URL (skill name, skill version, agent, short summary). Load when the user wants to report a problem with, or give feedback on, any Antithesis skill. Does not auto-submit — presents the URL for the user to review.

Universal VC investor analysis and outreach agent. Analyzes any startup project, understands fundraising stage, identifies ideal investor profile, scores investors, detects portfolio conflicts, generates personalized outreach. Starts with discovery questions to understand the project. Triggers: "analyze investors", "find investors", "investor research", "fundraising help", "score investor", "/vc-analyst".

Phase 2: Run mechanical checks and Gemini formatted audit

Autonomously create and implement a complete spec workflow with multi-agent collaboration, bypassing manual review steps through intelligent consensus-building

This skill should be used when the user asks about "parallel agents", "background tasks", "run_in_background", "non-blocking agents", "check agent progress", "TaskOutput", "retrieve agent results", or discusses running multiple agents concurrently. Covers patterns for launching agents in background, monitoring progress, and retrieving results.

PR creation workflow for Agent Config following the issue-first enforcement system. Trigger: When creating a pull request, opening a PR, or preparing changes for review.

Guides the agent through upgrading a Capacitor app project to a newer major version. Covers multi-version jumps, dependency alignment, native platform checks, and verification. Do not use for plugin library upgrades or non-Capacitor mobile frameworks.

Guides the agent through upgrading a Capacitor plugin to a newer major version. Covers dependency alignment, native platform changes, example app verification, and multi-version jumps. Do not use for app project upgrades or non-Capacitor plugin frameworks.

Guide for using Zotero MCP tools to manage references, search academic papers, generate citations, and build knowledge graphs. Use when user asks about Zotero, citations, bibliography, literature review, academic search, or knowledge graph.

How to build Claude Code-specific components — agents, hooks, plugins, marketplaces, MCP servers. User preferences, gotchas Claude gets wrong, and architecture decisions. Use when creating Claude-only components that need tool restrictions, hooks, or plugin infrastructure. For skills, use the agent-skills skill instead — skills default to the universal AgentSkills format.

Launch an isolated Claude reviewer for the current branch, a specific commit, or uncommitted changes. Uses Claude's agent runtime with worktree isolation so the review has an independent read-only view of the code before findings are reported back.

Designs implementation blueprints for features using exploration findings and architectural best practices (converted from agent)

Use Claude's Code Execution tool to run Python in a sandboxed environment as part of a response — for calculation, data analysis, chart generation, and verification. Covers enabling, file upload, persistence across turns, and limitations. Use this skill when building features that need Claude to actually run code (not just write it), such as data analysis, math verification, or chart creation. Activate when: Claude code execution, Python sandbox, run code tool, data analysis agent, code interpreter, code_execution_20250522.

Explores codebases to find relevant files, trace execution paths, and map architecture with team communication capabilities for collaborative analysis (converted from agent)

Run a local multi-agent code review before pushing or creating a PR. Use this skill whenever the user says 'code-review', 'pre-review', 'review my changes', 'review before push', 'check my branch', 'local review', 'pre-PR review', or wants feedback on their current branch changes before submitting a pull request. Also use when the user asks to 'review the diff', 'check for issues before PR', or mentions wanting to catch review feedback early. This skill spawns multiple specialized review agents in parallel to give comprehensive feedback fast.

Use this agent when reviewing code changes to ensure they are as simple and minimal as possible. Applies when implementation is complete but before finalizing changes. Triggers on requests like "check for over-engineering", "review for simplicity", "YAGNI review".

Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles. Examples: <example>Context: The user has just implemented a new feature and wants to ensure it's as simple as possible. user: "I've finished implementing the user authentication system" assistant: "Great! Let me review the implementation for simplicity and minimalism using the code-simplicity-reviewer agent" <commentary>Since implementation is complete, use the code-simplicity-reviewer agent to identify simplification opportunities.</commentary></example> <example>Context: The user has written complex business logic and wants to simplify it. user: "I think this order processing logic might be overly complex" assistant: "I'll use the code-simplicity-reviewer agent to analyze the complexity...

Orchestrates a dual-AI engineering loop where Claude Code plans and implements, while Codex validates and reviews, with continuous feedback for optimal code quality

Independent cross-model code review via Codex CLI. Codex reviews code changes (PR, branch, or staged files), the active agent addresses findings directly, user controls the loop. Use after implementation, before merge.

Independent cross-model plan review via Codex CLI. Codex reviews spec.md + prd.json, the active agent revises them directly, user controls the loop. Use after /workflows-plan or /workflows-deepen-plan, before /workflows-work.

Creates a conventional git commit using git-agent. This skill should be used when the user requests "commit", "git commit", "create commit", or wants to commit staged and unstaged changes following the conventional commits format. The executing AI auto-derives its own co-author string from its runtime model identity (e.g., `Claude Opus 4.7 <[email protected]>`) and passes it to `--co-author`. `$ARGUMENTS`, if provided, overrides the auto-derived value.

Creates conventional git commits using git-agent and pushes to the remote repository. This skill should be used when the user asks to "commit and push", "push my changes", or wants to commit and immediately push to remote. The executing AI auto-derives its own co-author string from its runtime model identity (e.g., `Claude Opus 4.7 <[email protected]>`) and passes it to `--co-author`. `$ARGUMENTS`, if provided, overrides the auto-derived value.

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.

Supplementary context protocol for agents executing in a repo that has a CLAUDE.md / AGENTS.md (or equivalent config). Use to make an execution agent read project conventions first, treat inputs by trust level, surface plan-vs-convention conflicts instead of silently picking a side, and reuse existing patterns before writing new code.

This skill should be used when the user asks to "set up a status line", "configure the footer", "show context window usage", "add a statusline", "visualize context window", "customize the Claude Code footer", or wants to display token counts, cost, or session metrics in the Claude Code terminal footer.

Apply a simple code transform via agent-booster's WASM engine — sub-millisecond, deterministic, $0 (no LLM call). Companion to cost-booster-route.

Build a `BaseDynamicContextProvider` that injects a named, titled block into an agent's system prompt at every `run()` — current time, user identity, retrieved RAG docs, session state, cached DB schema. Use when the user asks to "add a context provider", "inject X into the prompt", "give the agent dynamic context", "wire up RAG", "make a `BaseDynamicContextProvider`", or runs `/atomic-agents:create-atomic-context-provider`.

Interactive plugin creation wizard - guides you through scaffolding a new Claude Code plugin

Create a new Claude Code skill from scratch. Use when the user asks to "create a skill", "make a skill", "new skill", "build a skill", "/create-skill", or says something like "create a skill for that" referencing something in the conversation.

Create custom deliverable types with templates, tool requirements, and instructions for the deliverable agent. Use when user says 'create deliverable type', 'add a type', 'custom deliverable'.

Use when "CrewAI", "multi-agent systems", "agent orchestration", "AI crews", or asking about "autonomous agents", "agent collaboration", "role-based agents", "agent workflows", "AI team coordination"

Authoring playbook for building agents that triage and reply to customer messages — support tickets, email inquiries, chat questions, refund requests, or product issues. Use this when the user wants an agent that handles inbound customer questions, drafts replies, escalates hard cases, summarizes tickets, or follows a support playbook.

Use this agent when you need to review database migrations, data models, or any code that manipulates persistent data. This includes checking migration safety, validating data constraints, ensuring transaction boundaries are correct, and verifying that referential integrity and privacy requirements are maintained. <example>Context: The user has just written a database migration that adds a new column and updates existing records. user: "I've created a migration to add a status column to the orders table" assistant: "I'll use the data-integrity-guardian agent to review this migration for safety and data integrity concerns" <commentary>Since the user has created a database migration, use the data-integrity-guardian agent to ensure the migration is safe, handles existing data properly, and maintains referential integrity.</commentary></example> <example>Context: The user has implemented a service that transfers data between models. user: "Here's my new service that moves user data from the legacy_users table...

Select DB technology for a use case. Evaluates DB classes (relational / document / wide-column / key-value / graph / time-series / search / vector / cache / analytical / ledger / newSQL) against consistency / scale / query patterns / schema flex / ops / cost / ecosystem.

Handle blocked destructive commands. Use when dcg blocks rm -rf, git reset --hard, DROP DATABASE, kubectl delete, or when configuring agent safety guardrails.

Dispatch and coordinate parallel agent execution. Manages concurrent task processing with result aggregation and error handling.

Generate ADRs end-to-end from an upstream artifact (BRD/PRD/EARS/BDD), a prompt, or an IPLAN - detect input, scope the decision, generate, validate, and run the audit/fix cycle. Use to create or batch-create ADRs.

Generate EARS documents end-to-end from a PRD, a prompt, or an IPLAN - detect input, validate readiness, generate formal statements, validate, and run the audit/fix cycle. Use to create or batch-create EARS.

Generate IPLANs end-to-end from a SPEC/TDD, a prompt, or an existing IPLAN - detect input, plan a test-first file manifest, generate, validate, and run the audit/fix cycle. Use to create or batch-create IPLANs.

Generate TDDs end-to-end from a SPEC, a prompt, or an IPLAN - detect input, plan the test pyramid, generate test cases, validate, and run the audit/fix cycle. Use to create or batch-create TDDs.

Use when "DSPy", "declarative prompting", "automatic prompt optimization", "Stanford NLP", or asking about "optimizing prompts", "prompt compilation", "modular LLM programming", "chain of thought", "few-shot learning"