agent-skills

Read Fluidify Regen incidents and extract the join keys needed to pivot from an incident into its underlying OTel telemetry. Regen is a self-hosted incident / on-call tool with a REST API but no MCP server; this agent makes incidents first-class and emits a ready-to-run SigNoz filter hint -- the incident side of the incident <-> telemetry loop (SigNoz is the telemetry side). TRIGGER when: user asks about Regen incidents, on-call/paging state, "what's on fire", incident triage, ack/resolve an incident, or invokes "/regen"; or wants the service.name + labels + time window to feed into SigNoz. DO NOT TRIGGER when: user is working on the regen agent code itself; or wants to query the telemetry directly (use the signoz skill -- regen hands off to it).

SigNoz MCP tool reference for querying a live observability backend (OTel metrics, traces, logs) plus alerts, dashboards, saved views, and notification channels. Covers all ~41 signoz_* tools, the 4 built-in MCP prompts, the resource-attribute-first filtering rule, and the regen incident -> SigNoz correlation loop on the mini-axol/Riddler deployment. TRIGGER when: user asks to query SigNoz, inspect a service's errors/latency, search OTel logs or traces, read/aggregate metrics, triage an alert, or uses signoz_* MCP tools; or pivots from a regen incident into telemetry. DO NOT TRIGGER when: user wants to DESIGN SLOs/alerts/dashboards conceptually (use observability-designer skill), or READ/ack/resolve incidents in Regen itself (use the regen agent/skill -- signoz is the telemetry side of that loop).

Blockscout MCP tool reference for on-chain data queries. Covers all 16 tools: address info, transactions, token transfers, NFTs, contract ABI/source, read-only calls, ENS resolution, and block data across 8+ chains. TRIGGER when: user asks about on-chain data, contract state, token balances, transaction history, ENS lookup, NFT holdings, or uses blockscout MCP tools. DO NOT TRIGGER when: user asks about crypto market prices or trading volume (use coingecko skill), or writing Solidity code (use solidity-auditor skill).

Monitor on-chain contracts for anomalous transactions. Checks for large transfers, ownership changes, unusual methods, and selfdestruct calls via Blockscout API v2. TRIGGER when: user asks about contract monitoring, "check this contract", on-chain alerts, "any suspicious transactions", or invokes "/sentinel". DO NOT TRIGGER when: user is working on sentinel agent code itself.

Agentic commerce for Raxol agents in Elixir: the raxol_payments + raxol_acp packages (Xochi/Riddler/MPP/Permit2/x402 protocols, agent wallets, spend limits, stealth + privacy tiers, ZKSAR trust scores, and the ACP job lifecycle). TRIGGER when: mix.exs lists :raxol_payments or :raxol_acp; code imports Raxol.Payments.* or Raxol.ACP.*; user asks about agent wallets, HTTP 402 auto-pay, Xochi/Riddler cross-chain transfers, stealth addresses / privacy tiers, ZKSAR attestations, spend gating, or the ACP (Agent Commerce Protocol) job state machine / offerings. DO NOT TRIGGER when: writing or auditing Solidity contracts (use solidity-auditor skill); general Ethereum tooling / RPC / explorer questions (use ethskills skill); ZK circuit design in Noir (use noir skill); the core Raxol agent/TUI framework (use raxol skill); the Symphony orchestrator (use raxol-symphony skill).

Raxol terminal framework for TUI apps and AI agents in Elixir (v2.6, 15-package monorepo). TRIGGER when: code imports Raxol modules (Raxol.Agent, Raxol.Core, Raxol.MCP, Raxol.LiveView, Raxol.Workflow, Raxol.Headless), mix.exs lists :raxol / :raxol_agent / :raxol_core / :raxol_mcp as a dependency, user asks about building TUI apps or AI agents with Raxol, agent memory/self-improvement, the workflow engine, or Raxol headless/MCP tools. DO NOT TRIGGER when: general Elixir patterns (use droo-stack skill), Claude API / Anthropic SDK usage (use claude-api skill), agentic commerce / payments / ACP job sessions (use raxol-payments skill), the Symphony coding-agent orchestrator (use raxol-symphony skill), or other TUI frameworks (Scenic, Termbox, etc.).

Symphony: the Raxol tracker-driven coding-agent orchestrator (raxol_symphony, pre-alpha). Turns tracker issues into autonomous agent runs in isolated workspaces, surfaces evidence (CI/PR/asciinema), and supports human-in-the-loop paused runs across six surfaces. TRIGGER when: mix.exs lists :raxol_symphony; code imports Raxol.Symphony.*; there is a WORKFLOW.md driving an orchestrator; user asks about tracker-driven agent orchestration, Symphony runners (RaxolAgent/Codex), evidence capture, or paused-run resume with Raxol. DO NOT TRIGGER when: building a single Raxol agent or the core framework (use raxol skill); agent payments / ACP job sessions (use raxol-payments skill); generic multi-agent system design without Symphony (use agent-designer skill); the Claude Agent SDK (use claude-api).

Solidity development standards and security auditing. TRIGGER when: working with .sol files, foundry.toml, hardhat.config.*, smart contract auditing, security review, or vulnerability analysis. Covers Foundry-first development patterns, vulnerability taxonomies, and audit methodology. DO NOT TRIGGER when: general Ethereum tooling/ecosystem questions (use ethskills skill), or Noir/ZK circuits (use noir skill).

Pre-audit report generator for ZK + EVM hybrid protocols (Noir circuits + Solidity verifier / oracle layers). Produces an x-ray report, a classified entry-points map, an invariant catalog with a Circuit↔Solidity Consistency section, a per-circuit map, and an EIP-readiness verdict. TRIGGER when: project has both `foundry.toml` (or hardhat config) AND a `Nargo.toml` workspace; user asks for "zk-x-ray", "audit zk", "audit zkp", "zk readiness", "pre-eip review", "circuit-solidity audit", or "zk pre-audit"; EIP/ERC draft is being prepared for submission and a hybrid Solidity + Noir codebase needs a structural readiness check. DO NOT TRIGGER when: protocol is Solidity-only (use solidity-auditor skill or pashov's x-ray); deep circuit-design questions without Solidity integration (use noir skill); general Ethereum tooling questions (use ethskills); when a full external audit is the goal rather than a pre-audit briefing.

ffmpeg upstream contributions (hand-written assembly in libavcodec/libavfilter/libswscale) and custom ffmpeg integration (building, embedding, calling libav* APIs). Covers x86_64 (SSE/AVX/AVX2/AVX-512) and AArch64 (NEON/SVE/SVE2) idioms specific to ffmpeg's x86inc.asm and aarch64/asm.S macro frameworks, the checkasm and FATE test harnesses, and the ffmpeg upstream patch workflow. TRIGGER when: editing .asm files under libav*/x86/, .S files under libav*/aarch64/ or libav*/arm/, working with x86inc.asm, x86util.asm, or aarch64/asm.S macros, writing *_init.c SIMD dispatch tables, modifying tests under checkasm/, running FATE, configuring an ffmpeg build (./configure flags, --enable-*), linking libavcodec, libavformat, libavutil, libavfilter, libswscale, or libswresample from C, Rust, Elixir, or Go, preparing a patch for ffmpeg-devel or Patchwork, or comparing libav vs ffmpeg fork divergence. DO NOT TRIGGER when: general SIMD or intrinsics questions outside ffmpeg's macro framework (use droo-stack for C/Rust synt

Auto-generate onboarding documentation from codebase analysis, tailored to the reader's experience level. TRIGGER when: user asks to onboard someone to a codebase, document this codebase, generate project documentation for new team members, write a codebase walkthrough or tour, create a getting-started guide, or explain a codebase to a specific audience. DO NOT TRIGGER when: user wants API reference docs (use language-specific tooling), or wants to understand a single file (just read it).

CoinGecko and GeckoTerminal API reference for crypto market data, token prices, DEX pools, and on-chain analytics. TRIGGER when: user asks about token/coin prices, market caps, trading volume, DEX pools, trending tokens, price history, crypto market data, or CoinGecko API usage. DO NOT TRIGGER when: user asks about on-chain contract state or transactions (use blockscout skill), or Solidity/smart contract code (use solidity-auditor skill).

UI/UX design patterns and design system architecture. TRIGGER when: working on component design, layout/grid decisions, design tokens, color palettes, typography, accessibility (WCAG), responsive design, TUI aesthetics, or creating DESIGN.md documentation. Covers React, Tailwind CSS, terminal UI, and mobile patterns with a monospace-first, constraint-based design philosophy. DO NOT TRIGGER when: writing React/TypeScript code logic (use droo-stack skill), building Raxol TUI framework features (use raxol skill), working with CSS-in-JS runtime concerns (this skill covers design decisions, not runtime), or designing API/module/public-surface interfaces (use interface-designer skill).

Detailed coding patterns for a polyglot stack. TRIGGER when: working in Elixir, TypeScript, Go, Rust, Python, Lua, C, Zig, Shell/Bash, Noir, or chezmoi templates. Provides incorrect/correct examples that complement CLAUDE.md preferences. DO NOT TRIGGER when: working with Claude API or Anthropic SDK (use claude-api skill), Raxol TUI/agent framework patterns (use raxol skill), Solidity smart contracts (use solidity-auditor skill), ZK circuit domain questions (use noir skill -- this skill only covers Noir language syntax), NIF/SIMD domain questions for BEAM integration (use native-code skill -- this skill only covers C and Zig general syntax), or ffmpeg upstream / libav* assembly work (use ffmpeg-asm skill).

Ethereum ecosystem tooling and standards reference. TRIGGER when: asking about Ethereum development tools, framework selection, RPC providers, block explorers, EIP/ERC standards, or general Web3 development workflow. DO NOT TRIGGER when: writing or auditing Solidity code (use solidity-auditor skill), or working with Noir/ZK circuits (use noir skill).

Design interfaces using Ousterhout's "Design It Twice" method with parallel sub-agents. TRIGGER when: user asks to design an API, interface, module boundary, or public surface area, or says "design it twice." DO NOT TRIGGER when: user already has a specific interface and wants implementation, or is refactoring internals without changing the public API.

NIF (Native Implemented Functions) development and SIMD patterns for Elixir/BEAM. TRIGGER when: writing NIFs in C or Rust (Rustler), using erl_nif.h, Zig SIMD code for BEAM integration, tree-sitter grammar NIFs, or discussing native performance boundaries in Elixir. DO NOT TRIGGER when: general C/Zig/Rust language questions (use droo-stack), general Elixir patterns (use droo-stack), Raxol framework (use raxol skill), or ffmpeg upstream / libav* hand-written assembly (use ffmpeg-asm skill).

Nix language, flakes, NixOS, Home Manager, and agent-skills packaging. TRIGGER when: working with .nix files, flake.nix, flake.lock, Nargo.toml (Nix packaging context), NixOS configuration, Home Manager modules, nix-agent MCP tools, agent-skills-nix deployment, or rigup.nix riglets. DO NOT TRIGGER when: only using nix PATH (chezmoi handles that), or working on ZK circuits (use noir skill), or Nix language is incidental to another domain.

Zero-knowledge circuit design with Noir (Aztec's ZK DSL). TRIGGER when: working with .nr files, Nargo.toml, ZK circuits/proofs, Aztec contracts, zoir extension, or discussing zero-knowledge proof design. Covers circuit architecture, constraint optimization, ZK-specific security, and Aztec integration. DO NOT TRIGGER when: only Noir language syntax is needed (droo-stack handles that), working with Solidity only (use solidity-auditor skill), or hybrid Solidity + Noir projects with both foundry.toml and Nargo.toml (use zk-x-ray skill).

Polymath split-brain research methodology. Maps the possibility space of open-ended problems by building a max-distance lens roster across three relatedness tiers (close/mid/far), composing polymath expert personas from the tiers, spawning N parallel sub-agents, then synthesizing their disagreements into a landscape map. TRIGGER when: the user explicitly invokes the technique ("polymath", "split-brain", "multiagency", "let's run agents to/for X", "remember our polymath multiagency"); OR asks to brainstorm/ideate across multiple framings of an architecture, design, or strategy problem; OR when ALL of these are true: (a) the problem is research/strategy/framing-level, (b) the user has indicated framing uncertainty (not debugging), (c) the cost of picking the wrong frame is high, (d) the user has not already specified an approach. DO NOT TRIGGER when: debugging ("stuck on this regex/error/build/typo/merge conflict"), file/syntax lookups, single-answer questions, naming/styling micro-decisions, or anything where

Property-based and generative testing across the polyglot stack. TRIGGER when: user asks about property-based testing, generative testing, QuickCheck, Hypothesis, proptest, StreamData, fast-check, fuzzing test inputs, or finding edge cases that example tests miss. DO NOT TRIGGER when: user asks about TDD workflow (use tdd), mutation testing (use tdd), load testing (use performance-profiler), or security fuzzing (use security-auditor).

Bug triage and issue creation. Single-issue investigation with TDD fix plans, or interactive multi-bug QA sessions with background codebase exploration. TRIGGER when: user reports a bug, unexpected behavior, or regression; wants to triage an issue; wants to run a QA session; says "qa session"; or asks to create an issue for a bug. DO NOT TRIGGER when: user is actively implementing a fix themselves (use focused-fix -- qa is for triage, reproduction, and issue authoring, not the fix work), or wants a code review of a PR (use code-review).

General-purpose application security auditing across Python, TypeScript, Go, and Rust. TRIGGER when: user asks for a security audit, vulnerability assessment, threat modeling, code security review, OWASP analysis, variant analysis, or asks about injection, XSS, SSRF, path traversal, deserialization, or crypto misuse in application code. DO NOT TRIGGER when: working with .sol files, smart contracts, or Solidity audits (use solidity-auditor); when reviewing code for general quality without security focus (use code-review); when auditing dependencies only (use dependency-auditor).

Automated tech debt scanning, classification, and cost-of-delay prioritization. TRIGGER when: user asks to find tech debt, audit code quality or code health, prioritize refactoring, track debt trends, identify cleanup candidates, or assess where to invest engineering effort; user runs /tech-debt or /debt-scan. DO NOT TRIGGER when: writing new features, doing code review (use code-review skill), debugging specific bugs.

Writing voice calibration from studied authors. Accepts combinatorial voice arguments to blend multiple writer influences. TRIGGER when: user invokes "/writing-voice" or asks to "write like", "in the style of", "voice of", "blend voices", or references a specific writer influence for their prose. Also when user asks to review writing for voice/tone/style quality. DO NOT TRIGGER when: user asks to humanize existing text (use humanize skill), write code, generate commit messages, or produce technical documentation where voice is irrelevant.

Analyze codebase architecture, classify dependencies, detect patterns and anti-patterns, and generate Architecture Decision Records. TRIGGER when: user asks about architecture, dependency analysis, ADRs, coupling, or wants to understand how a codebase is structured. DO NOT TRIGGER when: user wants a code review of specific files (use code-review), or wants to fix a bug (use focused-fix).

Structured code review with blast radius analysis, security scanning, quality scoring, and a 30+ item checklist. TRIGGER when: user asks to review a PR, diff, changeset, or code for quality/security/breaking changes; user runs /review or /code-review; reviewing staged or committed changes. DO NOT TRIGGER when: writing new code from scratch, refactoring without review context, general debugging.

Schema analysis, ERD generation, index optimization, and migration safety. TRIGGER when: user asks about database schema design, normalization, index strategy, query optimization, migration planning, or choosing between database engines. DO NOT TRIGGER when: application-level ORM usage without schema concerns, or general API design (use relevant language skill).

Structured 5-phase bug fix methodology with root cause verification. TRIGGER when: user wants to fix a bug, debug an issue, investigate a failure, or says "focused fix". Also when a fix attempt has failed and the user wants a systematic approach. DO NOT TRIGGER when: user wants architecture analysis (use architect), QA triage (use qa), or code review (use code-review).

Profiling and optimization across languages in the polyglot stack. TRIGGER when: user asks about performance profiling, flamegraphs, benchmarks, load testing, memory leaks, or optimizing slow code paths in Node.js, Python, Go, Elixir, or Rust. DO NOT TRIGGER when: database-specific optimization (use database-designer), or build/bundle size issues without runtime perf concern.

Convert a PRD into a phased implementation plan using tracer-bullet vertical slices, then optionally create GitHub issues from the plan. TRIGGER when: user has a PRD and wants an implementation plan, says "plan this", asks to break a feature into phases, wants to convert requirements into tasks, asks to break a PRD into issues, create issues from a plan, or says "prd to issues". Also when user wants to stress-test a plan, get grilled on their design, or says "grill me". DO NOT TRIGGER when: user wants to execute a plan (just code it), review existing code, or do general architecture discussion without a PRD.

Systematic refactoring methodology with safety guarantees for polyglot codebases. TRIGGER when: user asks to refactor code, restructure a module, split a monolith, do a large rename, extract a service, apply strangler fig, or plan a safe migration of existing code. Also when tech-debt-tracker findings need execution. DO NOT TRIGGER when: user is fixing a bug (use focused-fix), doing TDD on new code (use tdd), or finding tech debt without a plan to fix it (use tech-debt-tracker).

Release management with changelog generation, semantic versioning, and readiness checks. TRIGGER when: user asks to prepare a release, generate a changelog, bump version, check release readiness, or create a release tag; user runs /release or /changelog. DO NOT TRIGGER when: writing commit messages (use conventional commits directly), deploying to infrastructure, debugging production issues.

Interactively scaffold new Claude Code skills with correct frontmatter, trigger clauses, sub-files, and linter compliance. TRIGGER when: user asks to create a new skill, scaffold a skill, add a skill to agent-skills, or says "new skill" or "skill creator". DO NOT TRIGGER when: user is editing an existing skill, writing CLAUDE.md instructions, or building an MCP server (use mcp-server-builder skill).

Test-driven development workflow for polyglot codebases. TRIGGER when: user asks to write tests first, do TDD, red-green-refactor, or requests test-driven implementation of a feature. DO NOT TRIGGER when: user asks to add tests after the fact, debug existing tests, or fix failing tests without a TDD workflow.

Devil's advocate code review with three adversarial personas that challenge assumptions and find hidden issues. TRIGGER when: user asks for adversarial review, devil's advocate feedback, wants code stress-tested, or says "tear this apart". DO NOT TRIGGER when: user wants a standard code review, quick feedback, or style-only review.

Multi-agent system design with orchestration patterns, tool schemas, and guardrails. TRIGGER when: user asks to design an agent system, choose agent architecture, define tool schemas, add guardrails, or evaluate agent performance; user runs /agent-design or /agent-architect. DO NOT TRIGGER when: using a specific agent framework (use framework docs), writing prompts for single-turn LLM calls, general API integration without agent orchestration.

Analyze and reduce LLM API costs through model routing, caching, and prompt optimization. TRIGGER when: user asks about LLM costs, API spend reduction, token optimization, model routing, or prompt caching. DO NOT TRIGGER when: user asks about model quality comparison, fine-tuning, or general prompt engineering.

SLO/SLI design, alert optimization, and dashboard generation for production services. TRIGGER when: user asks to define SLOs, design alerts, create dashboards, reduce alert fatigue, set error budgets, or improve observability; user runs /observability or /slo. DO NOT TRIGGER when: debugging a specific incident (use debugging tools), writing application code, configuring CI/CD pipelines.

Browser automation and end-to-end testing with Playwright (Python and TypeScript). TRIGGER when: user asks about browser automation, e2e testing, web scraping with a browser, Playwright setup, page navigation, selectors, screenshots, PDF generation, network interception, file uploads, auth flows, mobile viewports, or accessibility testing with Playwright. Also when code imports playwright, @playwright/test, pytest-playwright, or references playwright.config. DO NOT TRIGGER when: user asks about Cypress, Selenium, Puppeteer, or other browser automation tools; unit testing without a browser; HTTP-only scraping (use requests/httpx); or general pytest usage without Playwright.