Catalog of all 197 ECC skills

Full diagnostic audit of the 12-layer agent stack — wrapper regression, memory pollution, tool discipline failures, hidden retry loops, and rendering corruption — producing severity-ranked findings with code-first fixes.

Design and optimize AI agent action spaces, tool definitions, and observation formatting to improve completion rates and error recovery in agentic workflows.

Structured self-debugging workflow for AI agent failures: captures failure state, diagnoses root causes, applies contained recovery, and produces a human-readable debug report before escalating.

Operating model for agentic engineering: eval-first execution, task decomposition into agent-sized units, cost-aware model routing, and quality gates for AI-generated code.

Build persistent multi-agent operating systems on Claude Code with kernel architecture, specialist agents, slash commands, file-based memory, and scheduled automation — no external databases needed.

Engineering process and architecture guide for teams where AI agents generate a large share of code — covers review focus, eval-driven quality, and hiring signals for AI-first engineers.

Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems with context persistence and quality gates.

Orchestrates parallel Claude Code agents via Claude DevFleet: plans projects into mission DAGs, dispatches agents to isolated git worktrees, monitors progress, and reads structured reports — use when multiple agents need to work on coding tasks concurrently.

Patterns and loop-selection guidance for continuous autonomous agent loops with quality gates, evals, and recovery controls — use when setting up long-running agentic workflows that need structured failure recovery and progress gating.

DEPRECATED legacy v1 stop-hook skill extractor — route all continuous learning requests to continuous-learning-v2, which supersedes this with instinct-based, project-scoped, hook-reliable learning.

Instinct-based learning system that observes Claude Code sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills, commands, or agents — v2.1 adds project-scoped storage to prevent cross-project contamination.

Convenes four advisor voices (Architect, Skeptic, Pragmatist, Critic) to surface tradeoffs and structured disagreement for ambiguous decisions — use when multiple credible paths exist and a go/no-go call needs adversarial challenge.

Build a fully automated AI-powered data collection agent that scrapes any public source on a schedule, enriches results with Gemini Flash, and stores them in Notion/Sheets/Supabase — running free on GitHub Actions — use when automating public data monitoring or collection.

Orchestrate parallel AI agent sessions across Claude Code, Codex, OpenCode, and other harnesses using dmux, a tmux-based pane manager — use when splitting complex tasks across multiple concurrent agent sessions.

Design task-local harnesses, eval gates, and reusable skill extraction for Claude dynamic workflow mode and other adaptive agent harnesses — use when a task needs a custom loop, evaluator, or observable control-plane checkpoint.

Operates long-lived, cloud-hosted agent workloads with observability, security boundaries, lifecycle controls, and incident response patterns — use when managing continuously running agents that need runtime controls beyond a single CLI session.

Formal evaluation framework implementing eval-driven development (EDD) for Claude Code sessions — defines pass/fail criteria, pass@k metrics, and regression suites for agent reliability — use when measuring or benchmarking agent performance across prompt or model changes.

Four-phase loop pattern for progressively refining context passed to subagents, solving the problem of agents not knowing what codebase context they need upfront — use when designing multi-agent workflows where upfront context is unpredictable.

Build MCP servers with the Node/TypeScript SDK: tools, resources, prompts, Zod validation, and stdio vs. Streamable HTTP transport. Use when implementing or debugging MCP servers for AI assistants.

Restructure a task into independent parallel lanes — batched reads, concurrent agents, isolated worktrees, and verification passes — to maximise speed without losing correctness. Use when a job has clearly separable work that shares no write surfaces.

RFC-driven multi-agent DAG execution pattern that decomposes large features into independently verifiable work units with quality gates and merge queue rules. Use when a feature is too large for a single agent pass.

Structured rollout loop that tracks candidates, decision marks, and coherence across repeated trials with an auditable evidence ledger. Use for stochastic optimisation, ensemble comparison, or recursive reasoning with a visible evidence trail.

Manages multi-agent workflows as a structured team with Kanban work items, explicit ownership, branch isolation, and merge gates. Use when tasks span multiple agents, branches, or worktrees.

Interactive menu for browsing available agent personas and composing ad-hoc parallel teams from flat or domain-subdirectory collections. Use when you want to pick and dispatch a squad of agents for a task.

Cost optimization patterns for LLM API usage: automatic model routing by task complexity, immutable budget tracking, retry logic with exponential backoff, and prompt caching — use when building applications that call LLM APIs and need to control spend.

Queries a local SQLite cost-tracking database to report Claude Code token usage, spending, and budget breakdowns by project, tool, session, model, or date — use when the user asks about costs, spending, or usage history.

Analyses a draft prompt, identifies gaps, matches ECC skills/agents/hooks, and outputs a ready-to-paste optimised prompt. Advisory only — never executes the task itself.

Decision framework for choosing between regex and LLM when parsing structured text: use regex for the 95–98% majority of cases and reserve LLM calls for low-confidence edge cases only.

Suggests manual /compact calls at logical task boundaries — after exploration, between phases, or after milestones — to preserve context more reliably than arbitrary auto-compaction. Use in long multi-phase sessions approaching context limits.

Intercepts the response flow to let the user choose answer depth (short/medium/exhaustive) based on an estimated token cost before Claude replies. Use when the user wants to control response length or token budget.

Builds an evidence-backed ECC install plan for a specific repo by classifying skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using codebase-aware review passes.

Turns a one-line objective into a step-by-step construction plan for multi-session, multi-agent projects — each step has a self-contained context brief so a fresh agent can execute it cold.

Generates CodeTour `.tour` JSON files with step-by-step walkthroughs anchored to real file lines for onboarding, architecture overviews, PR reviews, and RCA tours — use when you want a reusable guided artifact rather than a one-off explanation.

Baseline cross-project coding conventions covering naming, immutability, readability, KISS/DRY/YAGNI, and error handling — use when starting a project, reviewing code quality, or onboarding contributors to shared standards.

Interactive installation wizard for Everything Claude Code that guides users through selecting and installing skills and rules to user-level or project-level directories, then verifies and optionally optimizes the installation — use to bootstrap or update an ECC setup.

Audits runaway costs in the ECC Tools GitHub App — PR over-creation, quota bypass, premium-model leakage, and billing spikes — use when investigating unexpected burn or over-created PRs in the ECC-Tools repo.

Explains the Hookify rule file format, frontmatter fields, and pattern/condition syntax for writing rules that watch for events and display messages to Claude — use when creating or configuring Hookify rules in a project.

Run and extend NanoClaw, ECC's zero-dependency session-aware REPL built on claude -p. Use when operating or customizing claw.js for persistent sessions, model switching, dynamic skill loading, and history compaction.

Integration reference for Plankton, a write-time code quality system that auto-formats, lints, and routes violations to Claude subprocesses on every file edit via PostToolUse hooks. Use when setting up automated formatting and linting enforcement in Claude Code projects.

Translate PRD intent, roadmap items, or product discussions into an implementation-ready capability plan that surfaces constraints, invariants, interfaces, and unresolved decisions. Use when product intent is clear but architecture and policy implications must be made explicit before multi-service work begins.

Enforces a research-before-coding workflow by searching npm, PyPI, GitHub, and MCP skill sources for existing solutions before writing custom code. Use when starting any feature that likely has an existing library, utility, or pattern.

Searches local, marketplace, GitHub, and web skill sources before recommending creation of a new skill, to avoid duplicating existing community work. Use whenever a user says 'create a skill', asks if a skill exists for X, or is about to build a new workflow skill.

Audits all installed Claude skills and commands for quality using a checklist and AI judgment, in either Quick Scan (changed skills only) or Full Stocktake mode with sequential subagent batch evaluation. Use when reviewing skill health or validating a skill library before release.

Read-only audit of the active repo, MCP servers, plugins, env surfaces, and harness setup to recommend the highest-value ECC skills, hooks, agents, and workflows. Use when setting up Claude Code or assessing available capabilities.

Regression testing strategies tailored for AI-assisted development, addressing the blind spot where the same model writes and reviews code — uses sandbox-mode API testing to catch bugs automatically.

Converts "make it faster" requests into a bounded, measured optimization loop: establishes baselines, generates hypotheses, runs variants, rejects failures, and promotes the fastest safe implementation.

TDD workflow for modern C++ using GoogleTest/GoogleMock with CMake/CTest: writing tests, configuring test discovery, adding sanitizers, and diagnosing flaky or failing tests — use only for C++ test writing, configuration, or failure investigation.

TDD workflow for Django using pytest-django, factory_boy, mocking, and coverage, including patterns for testing DRF APIs, models, views, and serializers — use when writing tests for Django projects.

Full verification loop for Django projects: environment checks, linting, migration safety, test coverage, security scans, and deployment readiness — run before PRs, after major changes, or pre-deploy.

Playwright E2E testing patterns including Page Object Model, CI/CD integration, artifact management, and flaky test mitigation — use when building or improving an E2E test suite for a web application.

TDD workflow for Kotlin using Kotest, MockK, coroutine testing, property-based tests, and Kover coverage reporting. Use when writing tests or adding coverage to Kotlin projects.

Red-Green-Refactor TDD workflow for Laravel using PHPUnit and Pest, with database strategies, factories, fakes, and 80%+ coverage targets. Use for any new Laravel feature or bug fix.

Pre-PR and pre-deploy verification pipeline for Laravel covering env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness. Run before opening a pull request or releasing.

Perl testing patterns using Test2::V0, Test::More, the prove runner, mocking, and Devel::Cover for coverage, following TDD methodology. Use when writing new Perl code, designing test suites, or migrating from Test::More to Test2::V0.

Python TDD workflow with pytest covering fixtures, mocking, parametrisation, and 80%+ coverage targets. Use when writing tests, setting up test infrastructure, or reviewing test coverage for Python projects.

TDD workflow for Quarkus 3.x with JUnit 5, Mockito, REST Assured, Camel test utilities, and JaCoCo at 80%+ coverage. Use when adding features, fixing bugs, or testing event-driven Quarkus services.

Full verification pipeline for Quarkus projects: build, static analysis (Checkstyle/PMD/SpotBugs), tests with JaCoCo coverage, security scans, native compilation, and diff review. Run before PRs or deployments.

React component testing with React Testing Library, Vitest/Jest, MSW network mocking, axe accessibility assertions, and guidance on when to use RTL vs. Playwright E2E. Use when writing or fixing tests for React components, hooks, or pages.

Rust TDD workflow with unit tests, integration tests, async testing, property-based tests via proptest, mockall mocking, and cargo-llvm-cov coverage at 80%+. Use when writing or adding tests to Rust projects.

Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo with an 80%+ coverage target. Use when adding features, fixing bugs, or refactoring Spring Boot services.

Full verification pipeline for Spring Boot projects — build, static analysis (SpotBugs, PMD, Checkstyle), tests with JaCoCo coverage, security scan, and diff review. Use before opening a pull request, after major refactoring, or pre-deployment.

Enforces a write-tests-first TDD cycle with 80%+ coverage across unit, integration, and E2E tests, including Git checkpoints at each stage. Use for any new feature, bug fix, or refactor.

Runs a structured six-phase check — build, type, lint, tests with coverage, security scan, and diff review — after code changes or before a PR. Use to confirm quality gates pass before merging.

End-to-end testing for Windows native desktop apps (WPF, WinForms, Win32, Qt) using pywinauto and Windows UI Automation, including CI/CD integration on GitHub Actions. Use when writing or diagnosing GUI automation tests for Windows apps.

Generates Angular code and provides architectural guidance for components, services, signals, forms, routing, SSR, accessibility, animations, and testing across Angular versions.

Sets an ECC-specific design direction for production web UI — purpose, audience, tone, and one memorable visual idea — before writing frontend code — use when UI needs to feel purposeful and polished rather than generic or templated.

Modern React and Next.js patterns for components, state management, data fetching, performance optimization, forms, routing, and accessible UI — use when building or reviewing any React-based frontend.

Creates zero-dependency, animation-rich HTML presentations in a single file, or converts PowerPoint files to web — use when building a talk or pitch deck, or helping a non-designer discover their visual style through previews.

Design-engineering fixes for polished UI: concentric radius, optical alignment, shadows, text wrapping, hit areas, hover/focus states, and motion. Use when a UI feels flat, cramped, or unfinished.

Production-ready UI motion system for React/Next.js using the Motion library: accessible animations, state transitions, and layout continuity with reduced-motion support. Use when adding meaningful animation to web interfaces.

Idiomatic React 18/19 patterns: hooks discipline, server/client component boundaries, Suspense, form actions, state management decision trees, and accessibility-first composition. Use when writing or reviewing React components.

70+ React and Next.js performance rules organised by priority: waterfall elimination, bundle size, server-side rendering, re-renders, and Core Web Vitals. Use when reviewing or optimising React/Next.js code for performance.

Records polished WebM demo videos of web apps using Playwright with visible cursor, natural pacing, and a discover-rehearse-record pipeline. Use when the user needs a demo video, walkthrough, or screen recording.

Batch-converts UI design screenshots into Vue 3 Composition API components wired to Vant, Element Plus, or Ant Design Vue. Use when converting a directory of design exports to a first-pass Vue 3 codebase.

Build a new API connector by matching the target repo's existing integration pattern exactly — file layout, config schema, auth, error handling, tests, and registry wiring.

REST API design patterns — resource naming, HTTP status codes, pagination, filtering, error responses, versioning, and rate limiting for consistent production APIs.

Backend architecture patterns for scalable Node.js, Express, and Next.js applications — REST/GraphQL design, repository layer, N+1 optimization, caching, background jobs, and middleware.

Caches expensive file-processing results (PDF parsing, image analysis) using SHA-256 content hashes as keys, so the cache survives renames and auto-invalidates on content changes — use when building file pipelines with repeated processing of the same files.

Production-grade Django architecture patterns covering project structure, Django REST Framework API design, ORM best practices, caching, signals, and middleware — use when building or structuring Django applications.

Production-oriented FastAPI patterns covering routers, Pydantic schemas, async endpoints, dependency injection, auth, OpenAPI docs, and tests — use when building or reviewing a FastAPI service.

JPA/Hibernate patterns for entity design, relationships, N+1 prevention, transactions, auditing, pagination, and HikariCP pooling in Spring Boot — use when modeling data, writing repository queries, or tuning database performance.

Ktor server patterns covering routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication-based integration tests. Use when building or reviewing Ktor HTTP services in Kotlin.

Production-grade Laravel architecture covering controllers, service layers, Eloquent ORM, queues, events, caching, and API resources. Use when structuring or building Laravel web apps and APIs.

Find and evaluate Laravel packages via LaraPlugins.io MCP, checking health scores and Laravel/PHP version compatibility. Use when deciding which package to add to a Laravel project.

Engineering patterns for latency-sensitive systems: hot-path mapping, p95/p99 tracking, caching, batching, streaming, and backpressure. Use for real-time dashboards, market data feeds, queues, or execution gateways.

Production-grade NestJS architecture patterns for modular TypeScript backends — modules, controllers, providers, DTO validation, guards, interceptors, config, and testing. Use when building or structuring NestJS APIs and services.

Quarkus 3.x architecture patterns with Apache Camel, JAX-RS, CDI, Panache, async processing, and native compilation. Use when building Java cloud-native or event-driven backend services.

Spring Boot architecture patterns for REST API design, controller-service-repository layering, Spring Data JPA, caching, async processing, and event-driven workflows. Use for Java Spring Boot backend development.

OAuth auth patterns, rate limits, and code examples for posting tweets/threads, reading timelines, searching, and analytics via the X (Twitter) API. Use when integrating programmatic X interactions into an application.

ClickHouse schema design, query optimization, materialized views, and ingestion patterns for high-performance OLAP workloads — use when building analytics pipelines, real-time dashboards, or migrating from PostgreSQL/MySQL to ClickHouse.

Diagnose and fix bottlenecks in large data ingestion, ETL, backfill, export, or warehouse loading pipelines while preserving data correctness — use when a data pipeline needs to run significantly faster.

Safe, reversible database schema and data migration patterns for PostgreSQL, MySQL, and ORMs (Prisma, Drizzle, Django, TypeORM, golang-migrate), including zero-downtime techniques — use when changing production database schemas.

JetBrains Exposed ORM patterns: DSL queries, DAO, transactions, HikariCP pooling, Flyway migrations, and repository pattern for Kotlin backend services — use when setting up or optimizing database access with Exposed.

Production ML engineering workflow covering data contracts, reproducible training, quality gates, model deployment, monitoring, and rollback. Use when turning notebook code into a maintainable ML system.

MySQL and MariaDB patterns for schema design, indexing, slow-query investigation, transactions, keyset pagination, and connection pools. Use when working on production MySQL/MariaDB databases or migrations.

PostgreSQL best practices for query optimisation, schema design, indexing strategy, Row Level Security, and connection pooling. Use when writing SQL queries or migrations, designing schemas, or troubleshooting slow queries.

Production Prisma ORM patterns for TypeScript backends — schema design, query optimisation, transactions, pagination, and critical traps like updateMany count-not-records, $transaction timeouts, and serverless connection exhaustion. Use when writing or reviewing Prisma queries, migrations, or bulk operations.

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer design with Room, SQLDelight, and Ktor.

Patterns for Compose Multiplatform and Jetpack Compose: ViewModel state, navigation, theming, recomposition optimization, and platform-specific UI across Android, iOS, Desktop, and Web — use when building shared KMP UI or Compose-based Android apps.

Production-ready Dart/Flutter patterns covering null safety, BLoC/Riverpod/Provider state management, GoRouter navigation, Dio networking, Freezed code generation, and widget testing — use when building or reviewing Flutter features.

Integrates Apple's FoundationModels framework for on-device LLM in iOS 26+ apps — text generation, structured output with @Generable, tool calling, and streaming — use when building privacy-preserving AI features without cloud dependency.

Kotlin Coroutines and Flow patterns for structured concurrency, StateFlow/SharedFlow reactive streams, error handling, and coroutine testing in Android and KMP projects — use when writing async code or managing concurrent operations.

iOS 26 Liquid Glass design system with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit. Use when building or migrating apps to Apple's iOS 26 design language.

Patterns for thread-safe data persistence layers in Swift using actors — in-memory cache backed by file storage — eliminating data races at compile time. Use when building offline-first apps or any Swift 5.5+ persistence layer that needs safe concurrent access.

Swift 6.2 Approachable Concurrency patterns — single-threaded by default, @concurrent for explicit background offloading, isolated protocol conformances — to resolve data-race compiler errors. Use when migrating Swift projects to 6.2 or designing MainActor-based app architecture.

Abstracts file system, network, and external APIs behind focused Swift protocols to enable deterministic unit tests without real I/O. Use when writing testable Swift code that touches external dependencies.

Modern SwiftUI state management with @Observable, type-safe NavigationStack, view composition, and rendering performance. Use when building iOS/macOS UIs with SwiftUI.

C++ coding standards based on the C++ Core Guidelines for modern C++17/20/23: RAII, immutability, type safety, and clear intent — use when writing, reviewing, or refactoring C++ code to enforce safe and idiomatic practices.

C# and .NET testing patterns using xUnit, FluentAssertions, NSubstitute/Moq, Testcontainers, and WebApplicationFactory — use when writing or reviewing tests for .NET projects.

Idiomatic C# and .NET patterns for immutability, dependency injection, async/await, and service architecture with ASP.NET Core — use when writing or reviewing .NET application code.

Patterns for robust error handling in TypeScript, Python, and Go — typed errors, boundaries, retries, circuit breakers, and user-facing messages — use when designing error hierarchies, adding retry logic, or reviewing APIs for missing error coverage.

F# testing patterns with xUnit, FsUnit, Unquote, and FsCheck property-based testing — unit, integration, and test organization best practices — use when writing or reviewing tests for F# and .NET applications.

Idiomatic Go patterns and best practices for writing clear, robust, and maintainable applications — use when writing, reviewing, or refactoring Go code or designing Go packages.

Go testing patterns — table-driven tests, subtests, benchmarks, fuzzing, and TDD workflow using the standard library — use when writing new Go functions, adding coverage, or following a RED-GREEN-REFACTOR cycle.

Coding standards for Java 17+ in Spring Boot and Quarkus: naming, immutability, Optional, streams, exceptions, generics, CDI, and reactive patterns — automatically applies framework-specific conventions based on the detected build file.

Idiomatic Kotlin patterns covering null safety, coroutines, sealed classes, DSL builders, and Gradle Kotlin DSL. Use when writing, reviewing, or refactoring Kotlin application code.

Modern Perl 5.36+ idioms, best practices, and architecture conventions for robust, maintainable applications. Use when writing new Perl code, refactoring legacy modules, or reviewing Perl for idiomatic compliance.

Idiomatic Python patterns covering PEP 8, type hints, EAFP error handling, and maintainability best practices. Use when writing, reviewing, or refactoring Python code.

Idiomatic Rust patterns covering ownership, borrowing, Result/? error propagation, traits, generics, safe concurrency, and crate structure. Use when writing, reviewing, or refactoring Rust code.

Evidence-first audit of live automations — inventories cron jobs, hooks, connectors, MCP servers, and wrappers, then produces keep/merge/cut/fix recommendations before any changes are made.

Review patterns and safe-change workflows for Cisco IOS and IOS-XE: show commands, ACL placement, wildcard masks, and change-window verification — use when reviewing router/switch configs or troubleshooting without risking connectivity.

Build operator-focused monitoring dashboards for Grafana, SigNoz, and similar platforms, structured around real operating questions rather than every available metric — use when turning a metrics list into a working operational dashboard.

CI/CD pipeline patterns, Docker containerization, rolling/blue-green/canary deployment strategies, health checks, rollback plans, and production readiness checklists for web applications — use when planning or setting up deployments.

Docker and Docker Compose best practices for local development, multi-container orchestration, container security, networking, and volume management — use when setting up or reviewing containerized development environments.

Manages GitHub repos via the gh CLI — issue triage, PR review, CI/CD debugging, release prep, Dependabot alerts, and contributor experience — use for any GitHub operational task beyond basic git commands.

Planning and safety checklist for homelab changes involving VLANs, local DNS, and WireGuard-style VPN before touching router, firewall, or DHCP config — use to produce a staged migration plan with rollback procedures.

Practical design guide for home and small-lab networks covering gateway/switch/AP roles, IP ranges, DHCP reservations, DNS, and common beginner mistakes — use when planning a new network or troubleshooting double-NAT and unstable addressing.

Safe Python Netmiko patterns for SSH-based network device automation — read-only collection, bounded batch SSH, TextFSM parsing, guarded config changes, timeouts, and error handling. Use when scripting automation against routers, switches, or firewalls.

Read-only BGP troubleshooting patterns for diagnosing neighbor state, missing routes, prefix policy, and AS path issues. Use when a BGP session is down, flapping, or established but missing expected prefixes.

Pre-deployment validation of router and switch configuration for dangerous commands, duplicate IPs, subnet overlaps, stale ACL/route-map references, and IOS security hygiene. Use before change windows or automated config pushes.

Diagnose interface errors, CRCs, drops, duplex mismatches, flapping, and speed negotiation issues on routers, switches, and Linux hosts. Use when a host has packet loss or a switch port shows rising error counters.

Audits a shipped or near-launch application for production readiness — config gaps, runtime risks, missing observability — using only local repo and CI evidence, without sending data to external services.

Evidence-first workflow for running commands, inspecting git state, debugging CI failures, and pushing narrow fixes with traceable proof of what was executed and verified. Use when the user needs real repo execution with auditable outcomes.

Consolidates GitHub, Linear, CI, hook events, and connected communication surfaces into one ECC-native notification lane with severity, ownership, and routing. Use when alert fragmentation, noise, or inbox overload is the real problem.

Django security best practices covering authentication, authorization, CSRF, SQL injection, XSS prevention, and hardened production settings — use when securing or reviewing a Django application before deployment.

Covers data classification, access control, audit trails, and encryption patterns for PHI and PII in healthcare apps — use when building or reviewing any feature that touches patient records under HIPAA, GDPR, or DISHA.

Thin HIPAA-specific entry point that routes to the right implementation skills for PHI handling, audit logging, and breach posture — use when a task is explicitly framed around US healthcare compliance, covered entities, or BAAs.

Laravel security best practices covering authentication, authorization, CSRF, validation, file uploads, rate limiting, secrets, and secure deployment. Use when hardening any Laravel application.

Security patterns for autonomous LLM trading agents: prompt injection defense, spend limits, pre-send simulation, circuit breakers, MEV protection, and wallet key isolation. Use when building or auditing agents with transaction authority.

Perl security patterns covering taint mode, input validation, safe process execution, parameterized DBI queries, and web security (XSS/SQLi/CSRF). Use when reviewing or writing Perl that handles user input, web requests, shell commands, or database queries.

Review prediction-market, basket, oracle, and trading-agent workflows for compliance, data quality, privacy, and execution risk before they handle venue auth, user portfolio data, or API keys. Use as a pre-implementation gate for any workflow that touches financial context.

Security best practices for Quarkus: JWT/OIDC authentication, RBAC, input validation, CORS, CSRF, secrets management, and dependency CVE scanning. Use when adding or auditing auth and security controls in Quarkus services.

Scans a repository for exploitable, remotely reachable vulnerabilities — SSRF, auth bypass, SQL injection, RCE, XSS — focused on findings that qualify for responsible disclosure or bug bounty submissions. Use when the goal is practical vulnerability discovery rather than a broad best-practices review.

Comprehensive security checklist and code patterns covering secrets management, input validation, CSRF, XSS, rate limiting, and secure API design. Use when implementing authentication, handling user input, creating API endpoints, or working with payment or sensitive data.

Audits a Claude Code project's .claude/ configuration — CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions — for injection risks, overly permissive allow-lists, and hardcoded secrets using the AgentShield tool. Use before committing configuration changes or when onboarding to a repository with existing Claude Code configs.

Spring Security best practices for JWT/OAuth2 authentication, role-based authorisation, input validation, CORS/CSRF, secrets management, rate limiting, and dependency CVE scanning. Use when adding auth, handling user input, or creating secured endpoints in Spring Boot services.

Inspect Blender characters, rigs, poses, and animation retargeting by extracting structured scene state — use when screenshots alone cannot reveal axis conventions, bone names, or ground-contact errors.

Generates images, videos, and audio via fal.ai models through MCP — text-to-image, text/image-to-video, text-to-speech, and video-to-audio — use when the user wants AI-generated media of any kind.

Build animated technical explainers in Manim for graphs, architecture diagrams, and product walkthroughs. Use when precision motion matters more than photorealism and the deliverable is a clean, short MP4.

Rules and patterns for Remotion video creation in React, covering 3D, animations, audio, captions, charts, fonts, and transitions across 29 rule files. Use whenever working with Remotion code.

AI-assisted pipeline for editing real footage via FFmpeg, Remotion, ElevenLabs, and fal.ai into short-form content, vlogs, or demo videos. Use when the user wants to cut, structure, or augment existing video.

Ingests video/audio from files, URLs, RTSP feeds, or live desktop capture; builds visual/semantic/temporal indexes; and performs timeline edits, transcoding, subtitle generation, overlays, and real-time event alerts. Use for any programmatic video perception, search, or editing task.

Security checklist and hardened code patterns for Solidity AMM contracts, covering reentrancy, CEI ordering, donation/inflation attacks, oracle manipulation, slippage, and admin controls — use when writing or auditing DeFi AMM or liquidity-pool contracts.

Prevents silent decimal mismatch bugs across EVM chains by querying decimals at runtime and using decimal-safe math for balances and USD values — use when reading ERC-20 balances, comparing cross-chain amounts, or building bots, dashboards, or DeFi tools.

Compares Itô prediction-market baskets against a user's knowledge base, portfolio notes, or research thesis to identify fit, exposure gaps, and conflicting signals — read-only, no investment advice or trade execution.

Architecture and workflow guide for building a background agent that watches data sources, drafts prediction-market basket parameters, and hands results to a human for review — use for planning, not live trade execution.

Gathers read-only prediction-market intelligence — event discovery, venue comparison, underlier research, and Itô API-backed market briefs — use for source-grounded briefings without investment advice or order execution.

Builds a structured, non-executing worksheet for a prediction-market idea: venues, underliers, resolution rules, fees, and manual action steps — use to inspect constraints and open questions before any execution-capable tooling is involved.

Prevent Ethereum hashing bugs in JavaScript/TypeScript by using correct Keccak-256 instead of Node's NIST SHA-3. Use when computing function selectors, event topics, EIP-712 signatures, Merkle proofs, or storage slots.

Research prediction markets as data sources or oracle signals for products, agents, and dashboards — evaluating market-implied probabilities, liquidity, resolution rules, and integration patterns. Use when incorporating prediction market signals into a decision-intelligence or data layer.

Produces thorough, cited research reports by searching the web via firecrawl and exa MCP tools, then synthesizing findings from multiple sources — use when in-depth research with evidence and source attribution is needed.

Neural web, code, and company search via the Exa MCP server — use when you need current web information, code examples, company intel, or people lookup with AI-powered neural search.

Manages a multi-layered knowledge system for ingesting, organizing, syncing, deduplicating, and searching across local files, MCP memory, vector stores, and Git repos — use when saving, organizing, or retrieving information across knowledge systems.

Agent-powered lead intelligence pipeline covering signal scoring, warm-path discovery, voice modeling, and channel-specific outreach via email, LinkedIn, and X. Use when finding, qualifying, and reaching high-value contacts.

Source-cited market research covering TAM/SAM/SOM sizing, competitive analysis, investor diligence, and technology scans with contrarian evidence and decision-oriented summaries. Use when research must inform a real business decision.

Operator wrapper that orchestrates ECC research skills (exa-search, deep-research, market-research, lead-intelligence) for evidence-first, source-separated research workflows. Use when the user needs fresh facts, comparisons, or evidence-backed recommendations.

Builds PubMed and NCBI E-utilities search workflows for biomedical literature using MeSH terms, field tags, PMID lookup, and citation retrieval. Use when a task requires systematic or reproducible searches of MEDLINE and life-sciences databases.

Guides USPTO patent and trademark record lookups using official APIs, PatentSearch, TSDR, and assignment data for reproducible prior-art and IP landscape research. Use when a task requires verified US patent or trademark records.

Runs quick bioinformatics lookups across Ensembl, BLAST, protein, pathway, and disease-association databases using the gget CLI or Python package. Use for fast first-pass genomic evidence before moving to full pipelines.

Runs a structured literature review workflow covering search planning, source screening, synthesis, and citation checks for academic, biomedical, and technical topics. Use when building a systematic, scoping, or narrative review from peer-reviewed sources.

Evaluates academic and scientific work — papers, proposals, literature reviews, methods sections — against a structured rubric scoring problem clarity, methodology, evidence support, and citation quality. Use when reviewing or comparing scholarly output for quality or revision feedback.

Write long-form articles, blog posts, guides, tutorials, and newsletter issues in a distinctive voice derived from supplied examples or brand guidance — avoids generic AI writing tropes.

Builds a reusable writing style profile from real posts, essays, launch notes, or site copy, then applies that voice consistently across articles, outreach, and social content.

Reorganizes X and LinkedIn networks with review-first pruning, follow/add recommendations, and warm outreach drafts in the user's real voice — use when cleaning up following lists, growing toward current priorities, or rebalancing a social graph.

Creates platform-native content for X, LinkedIn, TikTok, YouTube, and newsletters from source material without flattening the author's voice — use when drafting social posts, threads, video scripts, or repurposing one asset across multiple platforms.

Distributes content across X, LinkedIn, Threads, and Bluesky by adapting it per platform's constraints and conventions — never posting identical copy — use when a launch, update, or essay needs platform-specific versions.

Creates and updates pitch decks, one-pagers, investor memos, financial models, and accelerator applications while keeping all numbers internally consistent — use when building or aligning multiple fundraising assets around a single source of truth.

Writes personalized cold emails, warm intro blurbs, follow-ups, and investor updates for fundraising outreach to angels, VCs, and accelerators — use when you need concise, proof-driven messaging that avoids generic investor clichés.

Audits and improves technical SEO, on-page optimisation, structured data, Core Web Vitals, and keyword mapping for better search visibility. Use when diagnosing crawlability issues, fixing meta tags, adding schema markup, or planning sitemap and internal linking changes.

Manages carrier portfolios, freight rate negotiation, RFPs, scorecards, and routing guides for transportation managers — use when building or maintaining carrier relationships, benchmarking rates, or reallocating freight.

Operate real customer billing workflows — investigate subscriptions, refunds, churn, and failed renewals using connected billing tools like Stripe — use when a customer has a billing issue or when auditing revenue-impacting operations.

Expert guidance on HS/HTS tariff classification, customs documentation, FTA duty optimization, denied-party screening, and penalty response across US, EU, UK, and APAC jurisdictions — use for import/export compliance tasks.

Evidence-first mailbox triage, drafting, sending, and sent-mail verification workflow — use when organizing an inbox, drafting or sending email through a real mail surface, or confirming what landed in Sent.

Expert guidance on electricity and gas procurement, tariff optimization, demand charge management, PPA evaluation, and multi-facility energy cost strategy — use when procuring energy, optimizing tariffs, or evaluating renewable energy contracts.

Operator-level workflow for revenue snapshots, pricing comparisons, team-billing truth, and code-backed billing behavior — broader than customer remediation — use when you need Stripe sales data, per-seat billing reality, or competitor pricing benchmarks.

Operates Google Drive, Docs, Sheets, and Slides as a unified workflow surface — find, summarize, edit, migrate, and clean up assets — use when managing shared documents, trackers, or decks without dropping to raw tool calls.

Senior demand planner expertise for forecasting, safety stock optimization, replenishment planning, and promotional lift across multi-location retailers — use when forecasting demand, setting safety stock, or managing seasonal transitions for hundreds of SKUs.

Fetches, analyzes, and updates Jira tickets from an AI coding workflow via MCP or direct REST API calls — use when retrieving requirements, extracting acceptance criteria, adding comments, transitioning issues, or running JQL searches.

Freight exception handling for delays, damages, losses, carrier disputes, and claims across LTL, FTL, parcel, and ocean modes. Use when resolving shipping exceptions or building exception-handling SOPs.

Live message retrieval from iMessage, DMs, or social platforms: read threads, recover one-time codes, and inspect conversations with proof of source. Use when a task depends on a live local messaging surface.

Process, convert, OCR, extract, redact, sign, and fill documents via the Nutrient DWS API. Use when automating PDF/DOCX/XLSX/PPTX/image workflows such as format conversion, PII redaction, or form filling.

Expert production scheduling for discrete and batch manufacturing — job sequencing, line balancing, changeover optimisation, bottleneck resolution, and disruption response — drawing on TOC, SMED, OEE, and ERP/MES workflows.

Coordinates GitHub issues and PRs with Linear by triaging, classifying, and linking work across both platforms. Use when managing backlog triage, PR classification, or GitHub-to-Linear execution flow.

Senior quality engineer expertise for NCR lifecycle, CAPA, root cause analysis (5-Why, Ishikawa), SPC interpretation, and supplier quality in FDA/IATF 16949/AS9100 environments. Use when investigating non-conformances, managing CAPAs, or preparing for audits.

Senior returns operations expertise covering RMA eligibility, condition grading, disposition routing (restock/refurbish/liquidate/scrap/RTV), fraud pattern detection, and warranty claims. Use when handling product returns, reverse logistics, or return fraud.

Weighted graph-ranking engine for scoring network connections by intro value, mapping warm paths to a target list, and measuring bridge scores across first- and second-order connections on X and LinkedIn. Use when the goal is the ranking math itself, not the broader lead generation or network-maintenance workflow.

Extracts text from visa application document images via OCR, translates to English preserving document structure, and produces a bilingual PDF. Use when preparing translated document packages for visa applications.