oimiragieo

YARA-X detection rule authoring with expert judgment, linting, atom analysis, and best practices. Teaches how to think like an expert YARA author for malware detection, threat hunting, and indicator-of-compromise identification using YARA-X (the Rust-based successor to legacy YARA).

Excel spreadsheet generation using openpyxl and xlsxwriter. Convert Claude output, data analysis results, and tabular data into formatted .xlsx files with charts, formulas, conditional formatting, and multiple sheets. Use for generating Excel reports programmatically.

TDD applied to documentation - create production-ready skills. Use when authoring new skills. Includes writing style guidelines for clear prose.

Research-backed workflow to refresh existing workflow files with phase-gate regression checks, idempotency validation, and ecosystem alignment.

TDD task implementation patterns - red-green-refactor cycle, phase checkpoints, git commits, and verification protocols for quality assurance.

Creates multi-agent orchestration workflows for complex tasks. Handles enterprise workflows, operational procedures, and custom orchestration patterns. Use when user needs to automate multi-phase processes with agent coordination.

Spawn and manage Windows Terminal (wt.exe) windows and tabs from Node.js scripts and Claude Code hooks, with App Execution Alias resolution, correct CLI flags, and anti-patterns to avoid

Expert WebSocket and real-time communication engineering — WebSocket protocol (RFC 6455), ws/Socket.IO server implementation, authentication, heartbeat/reconnection, horizontal scaling with Redis pub/sub, Server-Sent Events (SSE), WebRTC signaling, and observability. Use for chat, live dashboards, multiplayer, collaborative editing, and event-driven real-time systems.

WebMCP — browser-side API that lets web applications expose their own functionality as MCP tools TO AI agents. Use when designing or integrating with web apps that surface UI actions (forms, buttons, data queries) as callable agent tools. NOT for web scraping or fetching external pages.

Test local web applications using Playwright with Python. Verify frontend functionality, debug UI behavior, capture screenshots, and view browser console logs. Supports static HTML files, dynamic webapps with running servers, and automated test generation.

Web3 and blockchain expert including Solidity, Ethereum, and smart contracts

Structured 5-phase web performance audit workflow with Core Web Vitals thresholds and actionable optimization recommendations. Use when auditing website performance, diagnosing slow page loads, optimizing Core Web Vitals scores, or reviewing frontend performance patterns. Covers Webpack, Vite, Next.js, and Nuxt optimization.

Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".

Build elaborate, multi-component web artifacts using React 18 + TypeScript + Tailwind CSS + shadcn/ui. Produces a single self-contained HTML file with all assets inlined. Use for complex artifacts requiring state management, routing, or shadcn/ui components. NOT for simple single-file HTML/JSX.

Fresh-process orchestration for EPIC-tier batch pipelines. Spawns a new Bun process per wave via the Claude Agent SDK, preventing GC-related crashes in long-running sessions.

Vue.js ecosystem expert including Vue 3, Composition API, Nuxt, and Pinia

Use when generating new content that must match an established writing style profile. Loads the style profile from style-analyzer, constructs a style-constrained system prompt, generates content, and performs A/B comparison against original samples for quality verification.

Defines the visual aspects of the game and how the player observes the world. This includes map color-coding, screen effects, and the overall simulation style.

Gate function preventing unverified completion claims. Use before claiming any task is done.

Zero-auth Vercel deployment workflow with automatic framework detection for 20+ frameworks. Use when deploying web applications to Vercel, creating preview deployments, or setting up deployment pipelines. Supports Next.js, Vite, Remix, SvelteKit, Astro, Nuxt, and more.

Best practices for using the Vercel AI SDK in Next.js 15 applications with React Server Components and streaming capabilities.

Discover vulnerability variants by identifying similar code patterns across a codebase using CodeQL and Semgrep pattern matching, finding instances where a known bug class may recur.

Create isolated development workspaces with safety verification. Use when needing parallel development branches.

UX research methodology skill — usability testing protocols, user interview frameworks, persona development, journey mapping, heuristic evaluation (Nielsen's 10), A/B test analysis, accessibility auditing, and research synthesis using NNGroup methodology.

Test user journey assertions against real surfaces (Web UI, CLI, API) with evidence collection and isolation boundaries

UI component library expert including Chakra, Material UI, and Mantine

Verify completed work against acceptance criteria, collect evidence, and produce a PASS/FAIL UAT report

TypeScript and JavaScript expert including type systems, patterns, and tooling

AI text-to-speech generation using OpenAI TTS, ElevenLabs, and Google TTS backends. Converts text to audio files with voice selection, speed control, and format options.

Defines general rules for tsconfig.json. It suggest using strict TypeScript checks

Regression troubleshooting workflow for hook/router/memory/search failures with enforced evidence and fix validation

Audio and video transcription using Whisper AI via the transcribe-anything package. Supports local files, YouTube URLs, and microphone input with multiple backends (faster-whisper, openai-whisper, Whisper API).

Track management methodology - creating and managing logical work units (features, bugs, refactors) through specification, planning, and implementation phases.

Research-backed CLI tool refresh workflow for updating existing tools with TDD checkpoints and CLI invocation validation.

Semantic tool search with embeddings for scalable tool discovery. Enables on-demand tool loading to reduce context usage by 90%+ for large tool libraries.

Creates tool files for the Claude Code framework. Tools are executable utilities organized by category in .claude/tools/.

Helper skill that deduplicates token-saver memory records before persistence.

Helper skill that exposes adaptive token-saver compression ratios for large context corpora.

Structured thinking patterns for agent self-reflection. Includes think-about-collected-information (validate research), think-about-task-adherence (stay on track), and think-about-whether-you-are-done (completion validation).

Convert natural language queries to SQL. Use for database queries, data analysis, and reporting.

Generates test code from specifications, components, and API endpoints. Creates unit tests, integration tests, and E2E tests following project testing patterns and conventions.

Terraform infrastructure operations with safety controls

Research-backed template refresh workflow for updating existing templates with placeholder verification and rendering validation.

Render templates by replacing {{TOKEN}} placeholders with actual values, supporting all three templates (specification, plan, tasks) with schema validation and security sanitization

Creates and registers templates for agents, skills, workflows, hooks, and code patterns. Handles post-creation catalog updates, consuming skill integration, and README registration. Use when creating new template types or standardizing patterns.

Use when building, debugging, or documenting Telegram bot polling flows that need safe agent routing, state tracking, and final-only replies without webhooks.

6-phase multi-agent pipeline with approval gates. Orchestrates Plan→Design→Implement→Review→Test→Deploy phases with explicit entry/exit criteria, phase-level agent assignment, and human-in-the-loop approval checkpoints.

Canon TDD for humans and AI agents. Use for production code changes by writing tests first, proving RED, implementing minimal GREEN, and refactoring safely. 2026 edition adds TDP, flakiness gate, ralph-loop integration, memory-search in Step 0, PBT as Step 5.5, mutation testing gate in Step 4, and CJS LSP warning.

Rules specific to Svelte UI component development in Tauri applications.

General rules for developing desktop applications using Tauri with Svelte and TypeScript for the frontend.

Security-related rules for Tauri application development.

Rules for integrating Tauri's native APIs in the frontend application.

Protocol for task synchronization, context handoff, and cross-session coordination using Claude Code task tools. Ensures agents properly update tasks with findings and enables seamless work continuation.

Agent task delegation patterns — spawn protocols, handoff metadata, drain gate, parallel limits, and model selection for multi-agent orchestration

General guidelines for TALL stack development, emphasizing Laravel and PHP best practices.

Verifies repository baseline test passing state and available memory/GPU resources to ensure safe mission execution.

Multi-agent swarm coordination patterns. Orchestrates parallel agent execution, manages agent communication, handles task distribution, and coordinates results aggregation.

Svelte and SvelteKit expert including components, stores, and routing

Structured workflow for summarizing code changes after completing tasks. Creates clear, actionable summaries of what was changed, why, and what to verify.

Execute plans via autonomous agents with two-stage review per task. Use for complex implementations requiring quality gates.

CSS and styling expert including Tailwind, CSS-in-JS, and responsive design

Use when ingesting text samples to extract quantitative writing style metrics. Produces a structured JSON style profile with vocabulary patterns, sentence structure, tone markers, and formatting preferences. Invoke before voice-clone-generator to establish style constraints.

Strictly adheres to specified user flow and game rules, making sure to follow documented features.

Run CodeQL and Semgrep static analysis with SARIF output for vulnerability detection, code quality assessment, and security compliance scanning across multiple languages.

State management expert including MobX, Redux, Zustand, and reactive patterns

Specific rules for Starknet React projects, focusing on blockchain integration.

Ripgrep-powered dead-code crawler that finds stale, broken, or orphaned JavaScript/CJS/MJS modules in the Agent Studio framework. Walks a target directory, checks each file for external references, and surfaces (or deletes) unreferenced files. Prevents registry bloat and silent tool dropouts from modules no one calls.

Verify that implementation code faithfully implements its specification — checks function contracts, API contracts, and protocol compliance against source specifications

Unified skill that guides spec creation through structured, interactive process.

Requirements gathering workflow for specification creation. Use when starting a new feature, task, or project that needs structured requirements.

Self-critique specification documents using extended thinking — surfaces hidden assumptions, contradictions, missing edge cases, and scope creep before implementation

SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration

SolidJS expert including reactivity, components, and store patterns

Git-aware smart revert for tracks, phases, and tasks. Handles rewritten history, finds related commits, and provides safe rollback with multiple confirmation gates.

AI-assisted debugging specialist with deep knowledge of modern debugging tools, observability platforms, and automated root cause analysis. Implements Cursor Debug Mode methodology — structured hypothesis ranking, targeted code instrumentation, human-in-the-loop reproduction gate, log-confirmed root cause, and mandatory cleanup.

Slack messaging, channels, and notifications - send messages, manage channels, interact with users, upload files, and add reactions. Use for team communication, incident notifications, and workflow alerts.

Expert-level Slack platform development using Bolt SDK — build Slack apps with slash commands, interactive components (buttons, modals, shortcuts), home tabs, event subscriptions, workflows, Socket Mode, and Block Kit. Use for building Slack bots, workflow automation, and rich interactive Slack experiences.

Research-backed skill refresh workflow for updating existing skills with TDD checkpoints, memory-aware integration, and EVOLVE/reflection trigger handling.

How agents discover and use skills. Use to understand skill invocation protocol.

Create, validate, and convert skills for the agent ecosystem. Enforces standardized structure for consistency. Enables self-evolution by creating new skills on demand, converting MCP servers and codebases to skills.

Living catalogue of 7 known hazard entries (SE-01 through SE-07) specific to agent-studio: Windows backslash paths, prototype pollution, hook exit codes, async swallowing, ReDoS in glob-to-regex, DST arithmetic, array mutation during iteration. Each entry: symptom, root cause, fix, test assertion.

Deep expertise on shadcn/ui component library including installation, customization, theming, and accessibility patterns. Use when building UI with shadcn/ui components, integrating Radix UI primitives, configuring Tailwind CSS v4 themes, or implementing dark mode. Covers Next.js App Router, Pages Router, and Vite setups.

Check if voice message handling is configured — verify Whisper, ElevenLabs/OpenAI TTS keys, and required tools.

Check Telegram bot configuration and guide setup if anything is missing.

Parses and merges Claude .jsonl transcripts with debug logs to generate a timeline heuristics report of API limits, context overflows, hook blocks, and tool failures.

Parse Claude Code JSONL session logs from ~/.claude/projects/ for tool call inventory, token costs, error detection, subagent traces, and compaction detection

Initiate a session handoff to transfer context and pending actions to a new terminal session. Executing this skill safely drains tasks and launches a new cross-platform window natively.

Defines the structure and implementation of service classes, enforcing the use of interfaces, ServiceImpl classes, DTOs for data transfer, and transactional management.

Sequential thinking and structured problem solving. Break down complex problems into steps with revision and branching capabilities. Use for multi-step analysis, planning, and hypothesis verification.

Comprehensive 7-phase SEO optimization workflow covering technical SEO auditing, keyword research strategy, on-page optimization, content SEO and E-E-A-T, structured data implementation, link building, and AI search optimization. Use when auditing search engine visibility, diagnosing ranking issues, implementing schema markup, conducting keyword research, optimizing content for E-E-A-T signals, or adapting for AI-driven search (AI Overviews, SGE).

Provides SEO and Meta Tags guidelines in SvelteKit.

Sentry error tracking and performance monitoring for real-time visibility into application errors, performance issues, and release health

Create custom Semgrep rules for detecting project-specific vulnerabilities, enforcing coding standards, and building domain-specific security checks with proper testing and metadata.

Automated security scanning pipeline covering SAST (Semgrep), SCA (OWASP dependency-check), SBOM generation (Syft), vulnerability scanning (Grype), and secrets detection (detect-secrets). Invoked by security-architect for pre-commit gates, CI integration, and finding triage.

Security architecture and threat modeling. OWASP Top 10 2025 analysis, OWASP Agentic AI Top 10 (ASI01-ASI10), AI/LLM security patterns, supply chain security, modern API authentication (OAuth 2.1, DPoP, Passkeys/WebAuthn), vulnerability assessment, and security review for code and infrastructure.

Comprehensive scientific research toolkit with 139 specialized skills for biology, chemistry, medicine, data science, and computational research. Transforms Claude into an AI research assistant with access to scientific databases, analysis tools, and domain-specific workflows.

Research-backed JSON Schema refresh workflow for updating existing schemas with validation checkpoints and cross-reference verification.

Creates JSON Schema validation files for skills, agents, hooks, workflows, and data structures. Ensures type safety and input validation across the framework.

Schedule recurring tasks and heartbeat monitoring using Claude Code's cron system (CronCreate/CronList/CronDelete). Implements the Agentic Heartbeat Pattern for ecosystem health monitoring.

Rust programming expert including ownership, borrowing, lifetimes, async Tokio patterns, error handling, trait system, performance optimization, testing, and production systems development

Creates rule files for the Claude Code framework. Rules are markdown files in .claude/rules/ that are auto-loaded by Claude Code.

Validates code against coding standards and best practices. Reports compliance violations and suggests fixes.

Enhanced code search with custom ripgrep binary supporting ES module extensions and advanced patterns.

Specifies standards for RestController classes, including API route mappings, HTTP method annotations, dependency injection, and error handling with ApiResponse and GlobalExceptionHandler.

Rates responses and plans against quality rubrics. Used for plan validation, response quality audits, and multi-agent consensus.

Research best practices and synthesize into design decisions for artifact creation. Invoke BEFORE any creator skill to ensure research-backed decisions.

Dispatch code-reviewer agent for two-stage review. Use after completing implementation tasks.

Validate systems and processes against GDPR/CCPA privacy regulations, privacy-by-design principles, ADA/WCAG accessibility standards, data processing agreements (DPAs), and provide compliance checklists with regulatory change monitoring guidance.

Search and read public Reddit posts, subreddits, and comments via the unauthenticated JSON API. Safe read-only access with SSRF-prevention hostname allowlist.

Workflow recovery protocol for resuming workflows after context loss, session interruption, or errors. Handles state reconstruction, artifact recovery, and seamless workflow continuation.

Detect capability gaps and record standardized evolution recommendations.

Process and act on code review feedback. Use when receiving review results.

Use when creating, updating, or generating README and documentation files for projects and libraries

React Native and Expo best practices for building performant mobile apps. Use when building React Native components, optimizing list performance, implementing animations, or working with native modules. Triggers on tasks involving React Native, Expo, mobile performance, or native platform APIs.

React ecosystem expert including hooks, state management, component patterns, React 19 features, Shadcn UI, and Radix primitives

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

Autonomous iteration loop with dual-mode support. Standalone mode uses Stop hooks (RALPH_ACTIVE=1). Multi-agent mode uses router-managed iteration. Never traps the host/router session.

Qwik framework expert including resumability, lazy loading, and optimization

QA validation and fix loop workflow — validates implementation completeness then iterates fix cycles until all acceptance criteria pass and quality gates clear

Python backend expert including Django, FastAPI, Flask, SQLAlchemy, and async patterns

PyQt6 desktop GUI development rules -- signal/slot architecture, QSS theming, QThread concurrency, layout management, and cross-platform rendering. Enforces MVC separation and responsive UI patterns.

Master network protocol reverse engineering including packet analysis, protocol dissection, and custom protocol documentation. Use when analyzing network traffic, understanding proprietary protocols, or debugging network communication.

fast-check patterns for JS/TS — 6 canonical property categories with worked examples targeting agent-studio utilities (path normalization, safe-json, glob-to-regex, routing logic)

Detect project maturity stage (new/early/mid/mature) from file structure and route to appropriate onboarding workflow

Guided project onboarding for new codebases. Helps agents understand project structure, build systems, test commands, and development workflows by creating persistent knowledge memories.

Automated brownfield codebase analysis with weighted keyword scoring, three-stream analysis, and design pattern recognition. Detects project type, frameworks, dependencies, architecture patterns, and generates comprehensive project profile.

Automated health checks for framework artifacts modified during a pipeline. Validates hook syntax, security patterns (SE-01/SE-02), skill wiring, agent consistency, and routing correctness. Invoked as the final pipeline step when framework artifacts were created, modified, or deleted.

Prioritizes the use of new features available in Python 3.12 and later versions.

Generate structured Product Requirements Documents using hypothesis-driven methodology with Implementation Phases tracking.

PowerPoint presentation generation using python-pptx. Create slides from Claude output, data analysis, or structured content. Covers slide templates, shapes, charts, tables, and themed presentations. Use for generating .pptx files programmatically.

PowerShell 7+ scripting and Windows system administration -- cross-platform automation, secure credential handling, Pester testing, DSC, and JEA patterns.

Write effective blameless postmortems with root cause analysis, timelines, and action items. Use when conducting incident reviews, writing postmortem documents, or improving incident response processes.

Python dependency management with Poetry and Rye -- lockfile-driven workflows, dependency groups, monorepo patterns, and migration paths. Covers pyproject.toml-centric packaging for projects not yet on uv.

Manus-style file-based planning for complex tasks. Use task_plan.md, findings.md, and progress.md to maintain persistent context. Use for multi-step tasks, research, or work spanning many tool calls.

Verifies implementation plan quality across 8 dimensions (requirement-coverage, task-completeness, dependency-validity, scope-sanity, artifact-wiring, risk-assessment, testability, estimation-quality) and returns pass/fail with per-dimension scores.

Creates structured plans from requirements. Generates comprehensive plans with steps, dependencies, risks, and success criteria. Coordinates with specialist agents for planning input and validates plan completeness. Uses template-renderer for formatted output.

Improve router-facing pipeline and reflection narration to reduce noisy status churn and make Step 0/Reflection outcomes explicit. Use when updating Router output contract, reflection reminder wording, or post-pipeline notification batching.

Evaluates completed agent pipelines across 5 scoring dimensions and produces a composite verdict with actionable recommendations

PHP expert including Laravel, WordPress, and Drupal development

Use when you need to auto-log all tool interactions into a self-organizing vector DB with instant recall. Intercepts interactions, extracts key information, generates embeddings, stores in LanceDB, auto-categorizes, and builds a retrieval index. Inspired by OpenClaw SQLite LCM + summary DAG pattern.

Details Paraglide.js i18n implementations.

Focuses on pandas-specific rules for data manipulation, including method chaining, data selection using loc/iloc, and groupby operations.

Feed actual task results back into agent memory for calibration. Compares predicted vs actual outcomes, records accuracy scores, and tracks estimation quality, prediction quality, and decision quality over time to improve future agent performance.

Master on-call shift handoffs with context transfer, escalation procedures, and documentation. Use when transitioning on-call responsibilities, documenting shift summaries, or improving on-call processes.

Use when the user wants to use Google Gemini for analysis, large files or codebases, sandbox execution, or brainstorming. Uses headless Gemini CLI scripts (no MCP). Triggers on "use Gemini", "analyze with Gemini", "large file", "sandbox", "brainstorm with Gemini".

Shell out to Cursor Agent CLI for headless IDE-aware code tasks. Supports multi-model routing (auto mode routes to Claude, Gemini, GPT). Requires Cursor Pro/Business subscription.

Shell out to OpenAI Codex CLI for headless code generation, analysis, and question-answering. Optimized for code tasks. Requires OPENAI_API_KEY env var.

Shell out to Claude Code CLI to invoke a second Claude session headlessly. Useful for cross-validation, second opinions, and isolated analysis without sharing current agent context. Requires Anthropic account.

Configurable regex-based alert system for detecting patterns in tool calls and session activity. Supports error triggers, content regex matching, token threshold triggers, and pattern detection with configurable actions.

Node.js backend expert including Express, NestJS, and async patterns

Next.js framework expert including App Router, Server Components, and API routes

Structured workflow for upgrading Next.js applications across major versions. Use when migrating a Next.js project from one major version to another (e.g., 13 to 14, 14 to 15, 15 to 16). Covers codemod automation, breaking change detection, incremental migration paths, and post-upgrade validation.

Next.js 16 caching model expertise covering the 'use cache' directive, cacheLife() API, cacheTag() for invalidation, cacheComponents configuration, and Partial Prerendering (PPR). Use when implementing caching strategies in Next.js 16+ applications, migrating from unstable_cache, or optimizing server component rendering.

Provides specific version compatibility notes for NativeWind and Tailwind CSS to prevent common installation errors.

NativeScript best practices and patterns for mobile applications

Decision matrix for selecting multi-agent topologies (Supervisor, Swarm, Hierarchical, Conductor) with token economics, failure modes, and escalation paths

Outlines the monorepo structure and tooling conventions, emphasizing the use of Taskfile.yml, and proper handling of environment variables.

Modern Python tooling best practices using uv, ruff, ty, and pytest. Mandates the Trail of Bits Python coding standards for project setup, dependency management, linting, type checking, and testing. Based on patterns from trailofbits/cookiecutter-python.

General rules pertaining to Mobile UI development. Covers UI/UX best practices, state management, and navigation patterns.

Focuses on rules and best practices for mobile-first design and responsive typography using tailwind.

Autonomous fixed-budget ML experiment loop — setup, iterative hypothesis testing, git-based keep/discard tracking, and indefinite autonomous execution. Implements the karpathy/autoresearch protocol.

Semantic search over global agent memory. Use to retrieve previously learned patterns, decisions, gotchas, and workarounds. Prevents stale-context errors across long sessions and multi-agent pipelines.

Audit memory retrieval quality (drift, staleness, citation-groundedness) and produce remediation backlog.

Master memory forensics techniques including memory acquisition, process analysis, and artifact extraction using Volatility and related tools. Use when analyzing memory dumps, investigating incidents, or performing malware analysis from RAM captures.

Comprehensive health check across CC auto-memory and agent-studio memory systems — detects orphans, duplicates, staleness, and threshold violations

Medusa v2 rules and best practices for modular commerce architecture, Workflow SDK, data models, services, and admin customizations.

Guide developers in creating Model Context Protocol (MCP) servers. Use for building MCP tools that enable LLMs to interact with external services. Covers TypeScript (primary) and Python FastMCP (secondary), tool annotations, Zod/Pydantic validation, and evaluation question creation.

Convert files to Markdown using Microsoft's MarkItDown library

Content strategy, copywriting frameworks (AIDA/PAS/BAB/4Ps/FAB), editorial calendar management, platform-specific content, A/B testing, campaign planning, audience targeting, and content performance measurement.

Compiler-level code intelligence via native LSP — definitions, references, types, call hierarchies, and diagnostics.

Employs the logging module judiciously to log important events, warnings, and errors.

Orchestrate multi-LLM parallel debate and synthesis. Dispatches prompts to available omega CLI wrappers in parallel, collects independent responses, runs anonymized peer review ranking, and synthesizes via a chairman model. Supports collaboration templates, idle watchdog, inter-agent messaging, worktree isolation, and multi-turn sessions. No server required.

Linear project management - issues, projects, cycles, and roadmaps. Use for Linear-related tasks like managing issues, tracking sprints, and organizing projects.

Specific optimization strategies for Python scripts working with larger-than-memory datasets via Dask.

Kubernetes cluster management and troubleshooting. Query pods, deployments, services, logs, and events. Supports context switching, scaling, and rollout management. Use for Kubernetes debugging, monitoring, and operations.

Entity and relation tracking skill using MCP memory server patterns and local knowledge graph storage. Build persistent knowledge graphs of entities, relationships, and observations across agent sessions. Covers the MCP memory server (@modelcontextprotocol/server-memory), local JSON-based graphs, and entity-relation querying patterns for long-running agents.

Applies general coding standards and best practices for Kafka development with Scala.

Implement Kubernetes security policies including NetworkPolicy, PodSecurityPolicy, and RBAC for production-grade security. Use when securing Kubernetes clusters, implementing network isolation, or enforcing pod security standards.

Create production-ready Kubernetes manifests for Deployments, Services, ConfigMaps, and Secrets following best practices and security standards. Use when generating Kubernetes YAML manifests, creating K8s resources, or implementing production-grade Kubernetes configurations.

Guidelines for structuring and documenting Jupyter notebooks for reproducibility and clarity.

Independent LLM judge evaluates task completion separately from the executing agent, catching false success claims by reviewing task goal, actions taken, final state, and evidence. Produces PASS/FAIL with confidence score and reasoning.

Jira project management and issue tracking integration

Java and Spring Boot expert including REST APIs, JPA, and microservices

iOS development expert including SwiftUI, UIKit, and Apple frameworks

Structured interactive questionnaire framework for gathering requirements from users. Uses A/B/C/D/E multiple choice patterns with additive vs exclusive question classification.

Records atomic learned behaviors with confidence scores. Project-scoped instincts are isolated per project and auto-promote to global scope at confidence threshold 0.8. Stores instincts in .claude/context/memory/instincts.jsonl

Extract actionable insights from completed coding sessions. Use when a session completes to capture learnings for future sessions.

Detect hardcoded credentials, default passwords, fail-open configurations, insecure default settings, and other security misconfigurations that ship as default behavior in applications.

Auto-evolution skill to initialize a new repository with AGENTS.md localized context.

Create structured incident response runbooks with step-by-step procedures, escalation paths, and recovery actions. Use when building runbooks, responding to incidents, or establishing incident response procedures.

Gate for HIGH/EPIC tasks that validates plan completeness and architecture compliance before implementation begins

Google Imagen image generation via Vertex AI — text-to-image, image editing, inpainting, and upscaling using ImageGenerationModel

Hugging Face Hub operations, model inference, dataset management, PEFT/LoRA fine-tuning, and Spaces deployment via MCP tools and Python APIs

HTMX expert including hypermedia patterns, Django/Flask integration

Sets the AI to act as an expert in HTML, Tailwind CSS, and vanilla JavaScript, focusing on clarity and readability for all HTML, JS, and CSS files.

Documents the hook enforcement system, bypass mechanisms, and common failure patterns to help agents avoid getting stuck on protected path writes

Research-backed hook refresh workflow for updating existing hooks with TDD checkpoints and settings.json registration validation.

Creates and registers hooks for the Claude Code framework. Handles pre/post tool execution, validation, memory, and session hooks. Use when new validation, safety, or automation hooks are needed.

Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or implementing templated deployments.

Start and manage the full heartbeat ecosystem for agent-studio. Registers all 7 heartbeat loops plus auto-reschedule task via CronCreate to keep the agent ecosystem healthy, indexed, informed, and connected.

GraphQL expert including schema design, Apollo Client/Server, and caching

Google Workspace integration skill for Gmail, Calendar, Drive, Docs, and Sheets via Python client libraries and MCP servers

Verify that task outputs actually achieve stated goals through 4 progressive levels of verification

Go programming expert including APIs, gRPC, concurrency, and best practices

Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management.

Workflow for repository reconnaissance and operations using GitHub CLI (gh). Optimizes token usage by using structured API queries instead of blind file fetching.

GitHub API operations - repositories, issues, pull requests, actions, code security, discussions, gists, and more. Use for GitHub-related tasks like managing PRs, issues, searching code, and monitoring workflows.

Advanced Git operations wrapper. Optimizes token usage by guiding complex git workflows into efficient CLI commands.

AI-powered code vulnerability analysis and dependency scanning using Gemini CLI security extension patterns. Detects hardcoded secrets, injection attacks, weak cryptography, authentication flaws, and LLM prompt injection. Also scans dependencies against the OSV.dev vulnerability database.

Google Cloud CLI operations and resource management

Detect missing docs, undocumented files, project health issues, and coverage gaps on session start or on-demand. Scans for README gaps, TODO/FIXME counts, and test coverage holes.

Game development expert including DragonRuby, Unity, and game mechanics

This rule enforces the single responsibility principle, ensuring functions are short and focused.

Frontend development expert including UI/UX patterns, responsive design, and accessibility

Create distinctive, production-grade web interfaces with intentional aesthetic direction. Avoids generic AI aesthetics (centered layouts, Inter/Arial, purple gradients, uniform corners). Use for UI components, dashboards, landing pages, React/HTML/CSS layouts where design quality matters.

Load and synthesize framework architecture context for reflection and planning tasks.

Use when monitoring online forums (Reddit, HN, ProductHunt) for recurring user pain points, feature requests, and unmet needs. Invoke for market research, pain-point discovery, trend detection, and competitive intelligence. Designed for scheduled execution via CronCreate.

Enforces the use of Zod for form validation throughout the project.

Describes Form and Actions implementations.

Flutter and Dart expert including widgets, state management, and platform integration

Verify fix commits address security findings without introducing new bugs or regressions. Analyzes diffs for anti-patterns like removed validation, weakened access control, reduced error handling, reordered external calls, and changed integer operations. Generates structured FIX_REVIEW_REPORT with finding status tracking.

Fintech engineering expertise — payment processing (Stripe, Plaid), PCI DSS compliance, financial data modeling (double-entry bookkeeping), fraud detection patterns, bank-grade security (encryption, tokenization), open banking APIs, cryptocurrency/blockchain integration, regulatory compliance (KYC/AML), and idempotent financial transaction design. Use for payment systems, banking apps, trading platforms, and fintech infrastructure.

Complete development with structured merge/PR options. Use when ready to merge or submit work.

File system operations guidance - read, write, search, and manage files using Claude Code's built-in tools.

Figma design-to-code workflow. Read Figma files, inspect components, extract design tokens, and translate designs to implementation. Use when working with Figma designs, extracting styles, or building design systems.

Focuses on routing, CSRF protection, context handling, and template usage within the internal handlers directory.

Applies best practices for logging (zerolog/zap), project structure (cmd/internal/pkg), middleware registration order, and environment configuration in Go Fiber v2/v3 applications.

Customer feedback analysis — sentiment detection, NPS/CSAT frameworks, feature request clustering, support ticket triage, churn signal detection, and feedback-to-roadmap translation

Feature flag lifecycle management -- safe feature toggling, gradual rollouts, A/B testing patterns, flag cleanup strategies, and technical debt prevention. Covers LaunchDarkly, Unleash, OpenFeature, and custom implementations.

Specifies best practices and conventions for Expo-based mobile app development.

Expo Framework-specific guidelines. Includes best practices for Views, Blueprints, and Extensions.

Scheduled Exa web search monitor. Uses CronCreate to search configured topics every 4 hours via mcp__Exa__web_search_exa, deduplicates URLs via MemoryRecord, and stores summaries for morning briefing integration.

Refresh evaluation harnesses with live/fallback parser reliability, SLO gates, and regression checks.

5-level error recovery escalation: retry, nudge, replan, fallback, force-done — each with entry criteria and timeout before escalating

Transforms vague UI/feature requests into structured, optimized prompts with design system awareness. Use when generating prompts for UI implementation, feature specification, or design-to-code translation. Triggers on tasks requiring prompt refinement, UI specification, or design system integration.

Start Telegram monitoring. Auto-enables voice pipeline if ElevenLabs or OpenAI TTS keys are detected.

Elixir and Phoenix expert including OTP, Ecto, and functional programming

Expert Electron desktop application development — main/renderer process architecture, IPC communication, native OS APIs (menus, tray, notifications, dialogs), auto-updates, code signing, packaging with electron-builder/forge, security hardening (contextIsolation, sandbox), and performance optimization. Use for building cross-platform desktop apps.

Deeply analyzes Agent Studio framework structural health: catching phantom require() references, wrong module depth paths, missing skill/agent dependencies, bloated configurations, archived references in active code, stale catalog counts, and empty tool/skill directories.

Discover, parse, and call external HTTP APIs at runtime using OpenAPI specs, tool templates, and iterative chaining. Adapted from UTCP (Universal Tool Calling Protocol) patterns for Node.js and Claude Code agents.

Sets standards for Data Transfer Objects (DTOs), typically records, including parameter validation in compact canonical constructors.

This rule enforces the Don't Repeat Yourself principle to avoid code duplication and improve maintainability.

Rules for Drizzle ORM schema design, query patterns, migration workflows, and relational query usage. Ensures type-safe, production-ready database interactions.

Docker Compose container orchestration and management. Manage multi-container applications, services, networks, and volumes. Use for local development, testing, and orchestration of containerized applications.

Generates comprehensive documentation from code, APIs, and specifications. Creates API documentation, developer guides, architecture docs, and user manuals with examples and tutorials.

Collaborative document creation via a structured three-stage workflow. Use for writing specs, PRDs, design docs, proposals, RFCs, and any long-form document where quality and clarity matter. Brainstorms 5-20 options per section, builds iteratively, and tests with reader sub-agents.

Concurrent investigation of independent failures. Use when multiple unrelated issues need parallel resolution.

Stop the Telegram channel daemon.

Perform security-focused review of code diffs and pull requests, identifying newly introduced vulnerabilities, security regressions, and unsafe patterns in changed code.

Generates architecture, database, and system diagrams using Mermaid syntax. Creates visual representations of system architecture, database schemas, component relationships, data flows, and standalone HTML exports.

Design system lookup, CSS best practices, and AI-driven UI component generation via MCP tools

Specifies design and user experience guidelines, including dark mode compatibility, responsive design, performance optimization, modern UI, and accessibility. This rule promotes a user-friendly and vi

Analyzes project dependencies, detects outdated packages, identifies breaking changes, and suggests safe update strategies. Helps maintain dependency health and security.

Multi-step autonomous research methodology for deep investigation tasks with structured synthesis

Systematic 4-phase debugging with root cause investigation. Use when fixing bugs to prevent random fixes.

Structured debug log analysis for Claude Code sessions — auto-discovers most recent log, runs reducer, extracts error patterns, correlates with full log, produces observability report. Fills 5 identified gaps: hook error body capture, agent identity, file path tracking, stall correlation, success visibility.

Two-agent cleanup pattern. Implementer works freely, then a dedicated cleanup agent removes unused imports, console.logs, commented-out code, dead code, and formatting issues. Produces a diff of what was cleaned.

Database expert including Prisma, Supabase, SQL, and NoSQL patterns

Database design and optimization specialist. Schema design, query optimization, indexing strategies, data modeling, and migration planning for relational and NoSQL databases.

Data processing expert including parsing, transformation, and validation

Background orchestrator that drains the system-wide cron-actions-queue.jsonl queue safely, preventing LLM context pollution in the primary router.

Decision framework for agents to determine WHEN and WHETHER to use Claude Code's native cron scheduler (CronCreate/CronList/CronDelete) vs OS cron, GitHub Actions, or simple Task() delegation.

Validate whether a proposed new artifact is feasible in the current stack before creator workflows run.

C++ coding standards and best practices.

Applies general rules for Convex development, emphasizing schema design, validator usage, index-first query patterns, function registration, and correct handling of system fields.

Context-Driven Development methodology - treating project context as managed artifacts alongside code for consistent AI interactions and team alignment.

Token-range severity zones (Green/Yellow/Orange/Red/Critical) with detection checklist, early warning indicators, and corrective routing actions for context window degradation

Compress large context before reasoning to reduce token usage while preserving evidence. Use this whenever the user mentions huge files, long prompts, RAG payloads, prompt caching, expensive sessions, codebase context, chat history compaction, or wants the same answer quality with fewer tokens.

Estimate per-turn token attribution across 6 categories in Claude Code sessions to show where context budget is spent

Automated security scanner for external skill/agent content fetched from GitHub or web sources. Runs a 7-step PASS/FAIL security gate against fetched markdown/text content.

Use when analyzing published content (blog posts, social media, newsletters) for sentiment, structural quality, hook effectiveness, readability, topic classification, and engagement correlation. Invoke for daily post analysis, content audits, or engagement driver identification.

Rules for creating and maintaining Dockerfiles.

Container orchestration expert including Docker, Kubernetes, Helm, and service mesh

Byzantine consensus voting for multi-agent decision making. Implements voting protocols, conflict resolution, and agreement algorithms for reaching consensus among multiple agents.

Configuration management techniques

Aims for high test coverage using pytest, testing both common and edge cases.

Requires detailed type annotations for all Python functions, methods, and class members.

Rules pertaining to Composer dependency management, promoting best practices for declaring and updating dependencies.

Validate planned changes against local framework rules and policy guardrails before implementation or creation.

AI-based complexity assessment for task analysis. Use when determining the appropriate workflow, phases, and validation depth for a task.

Detect Claude Code context compaction events in session JSONL logs. Identifies compaction boundaries, measures token delta before/after, reports compaction events with timestamps and token impact.

Validates commit messages against Conventional Commits specification using programmatic validation. Replaces the git-conventional-commit-messages text file with a tool that provides instant feedback.

Analyze code changes (commits, PRs, diffs) for security vulnerabilities using STRIDE analysis and CWE mapping

Creates command files for the Claude Code framework. Commands are user-facing shortcuts that delegate to skills.

Programmatic code style validation using AST analysis. Complements (not replaces) code-style rules by providing automated checking and instant feedback.

Use ast-grep for AST-based code pattern matching.

Semantic code search using Phase 1 vector embeddings and Phase 2 hybrid search.

Code quality expert including clean code, style guides, and refactoring

Structural code graph queries via CodeGraphContext MCP (tree-sitter + KuzuDB). Find callers, callees, class hierarchies, dead code, and module dependencies.

Static code analysis and complexity metrics

Cloudflare Workers edge computing — Durable Objects, KV, R2, D1, Workers AI, AI Gateway

Google Cloud Run deployment, service management, traffic splitting, and log inspection. Use when deploying containerized apps to Cloud Run, managing services, or inspecting Cloud Run logs.

Cloud and DevOps expert including AWS, GCP, Azure, and Terraform

Build apps with the Claude API or Anthropic SDK. TRIGGER when: code imports `anthropic`/`@anthropic-ai/sdk`/`claude_agent_sdk`, or user asks to use Claude API, Anthropic SDKs, or Agent SDK. DO NOT TRIGGER when: code imports `openai`/other AI SDK, general programming, or ML/data-science tasks.

Uses GitHub Actions or GitLab CI for CI/CD implementation.

Browser automation with two integrations - Chrome DevTools MCP (always available, performance tracing) and Claude-in-Chrome extension (authenticated sessions, GIF recording). Use DevTools for testing/debugging, Claude-in-Chrome for authenticated workflows.

Generate context-aware quality checklists for code review and QA using IEEE 1028 base standards plus LLM contextual additions

Check voice message pipeline config — verify Whisper, ElevenLabs/OpenAI TTS keys and dependencies.

Manage Claude Code --channels sessions (start/stop/status/health) via channel-manager.cjs and terminal-tracker.cjs.

Smart contract and secure API contract security analysis — invariant checking, access control, reentrancy, and integer overflow patterns. Implements Checks-Effects-Interactions pattern, formal invariant verification, and OpenSCV vulnerability taxonomy for Solidity/EVM and Rust/Solana contracts.

Build tools expert including Vite, Webpack, and bundler configuration

Programmatic web automation using Playwright Python — data extraction, form filling, multi-step workflows, auth session management, screenshot/PDF capture, and anti-detection patterns. Use for scripted automation tasks, not interactive MCP-based browser control.

Audit content and assets for brand compliance — style guide validation, tone of voice checking, visual identity consistency, brand asset management, and cross-channel coherence.

Socratic design refinement before implementation — challenges assumptions, surfaces alternatives, identifies risks before code is written

Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries.

Specifies best practices, including following RESTful API design principles, implementing responsive design, using Zod for data validation, and regularly updating dependencies. This skill promotes modern coding standards and helps developers write consistent, maintainable code.

Detect when agents are stuck in repetitive action loops using a rolling 20-action window with escalating nudges — replan after 3 similar actions, explore after 5, force-done after 8.

Azure DevOps integration covering pipelines, boards, repos, artifacts, and work item management via Azure CLI and REST API

AWS cloud operations for CloudWatch, S3, Lambda, EC2, and IAM

Use when you need semantic retrieval from perpetual memory at query time. Parses query intent, searches vector store, ranks by relevance and recency, and injects context. Complements memory-search.cjs with the perpetual_memory LanceDB table.

OAuth 2.1 compliant authentication flows (MANDATORY Q2 2026). PKCE required for ALL clients, Implicit Flow removed, modern token security.

OAuth 2.1, JWT (RFC 8725), encryption, and authentication security expert. Enforces 2026 security standards.

Ultra-granular code analysis for deep architectural context building. Line-by-line and block-by-block analysis using First Principles, 5 Whys, 5 Hows methodology at micro scale. Builds mental models, tracks invariants and assumptions, and maps cross-function call flows for security audit preparation.

Atlassian ecosystem integration covering Jira project management, Confluence documentation, Bitbucket source control, and cross-product automation workflows

Specifies the preferred syntax for asynchronous operations using async/await and onMount for component initialization. This results in cleaner and more readable asynchronous code.

Astro framework expert including components, content collections, and integrations

Benchmark external agent frameworks, auto-detect source type, scan for prompt injection, and convert findings into a concrete TDD upgrade backlog for agent-studio evolution.

Ask the minimum clarifying questions before implementation when requirements are ambiguous or missing crucial details

Scheduled ArXiv paper monitor. Uses CronCreate to search configured keywords every 6 hours, deduplicates via MemoryRecord, and stores summaries in named memory for morning briefing integration.

Search and retrieve academic papers from arXiv.org using WebFetch and Exa. No MCP server required - uses existing tools to access arXiv API directly.

Unified lifecycle management for all framework artifacts (skills, agents, hooks, workflows, templates, schemas)

Deep integration analysis for newly created artifacts

Architecture review and design validation. Evaluates system designs against best practices, identifies anti-patterns, and ensures architectural decisions align with non-functional requirements.

API security testing and validation for REST/GraphQL/gRPC endpoints, contract testing, load testing, fuzzing, and Postman/Bruno/Hurl workflows

API development expert including REST design, OpenAPI, and documentation

Angular framework expert including components, services, RxJS, templates, and testing

Comprehensive Android development expert covering Jetpack Compose, Kotlin coroutines/Flow, Architecture Components, Hilt DI, Navigation, testing, performance, Material Design 3, and modern Android patterns (MVI, Clean Architecture).

AI and ML expert covering PyTorch, TensorFlow, Hugging Face, scikit-learn, LLM integration, RAG pipelines, MLOps, and production ML systems

Research-backed workflow to refresh existing agent prompts/frontmatter with diff-based risk scoring, TDD gates, and ecosystem validation.

The Agent Tool Contract — 5 principles for designing tools agents call reliably: predictable signature, rich errors, token-efficient output, idempotency, graceful degradation. Includes anti-pattern table with 8 common mistakes.

LLM-as-judge evaluation framework with 5-dimension rubric (accuracy, groundedness, coherence, completeness, helpfulness) for scoring AI-generated content quality with weighted composite scores and evidence citations

Creates specialized AI agents on-demand when no existing agent matches a request. Use when the Router cannot find a suitable agent for a task. Enables self-evolution by generating persistent agents.

Force adversarial code review stance that eliminates confirmation bias — reviewer must find issues or re-analyze

N-round opposing-stance debates for trade-off analysis. Assigns pro/con roles to agents, runs structured debate rounds with quality scoring, and produces a moderator synthesis with confidence-rated recommendation. Generalizable to architecture, technology, security, and design decisions.

Use when you want to improve response quality through meta-cognitive reasoning. Applies 15+ reasoning methods to reconsider and refine initial outputs.

Ensure accessibility in UI components including semantic HTML, ARIA attributes, keyboard navigation, and WCAG 2.2 AA compliance.