Latest Agent Skills

Configures mewt or muton mutation testing campaigns — scopes targets, tunes timeouts, and optimizes long-running runs.

Set up continuous fuzzing infrastructure for open-source projects using Google's OSS-Fuzz platform, including building and running fuzz harnesses locally and enrolling new projects.

Fuzz Python code and C extensions with coverage guidance and AddressSanitizer support using a libFuzzer-based fuzzer.

Draws a Tarot spread to inject randomness into decision-making when prompts are vague or multiple approaches are equally valid.

Diagnose pod crashes, restart loops, Redis failures, resource pressure, and other service misbehavior in the crs namespace on Kubernetes.

Runs full Trailmark structural analysis by building a graph and computing pre-analysis passes for hotspots, taint, blast radius, privilege boundaries, and attack surface.

Build custom fuzzers with a modular Rust library, supporting advanced mutation strategies, custom feedback mechanisms, and non-standard target architectures.

Translates Mermaid sequence diagrams of cryptographic protocols into ProVerif formal verification models (.pv files) for proving security properties like secrecy, authentication, and forward secrecy.

Coverage-guided fuzzing for Ruby code and C extensions using libFuzzer and sanitizers.

Fuzz C/C++ projects with multi-core support using AFL++, a fork of AFL with better performance and advanced features.

Parse, analyze, and process SARIF files from static analysis tools like CodeQL and Semgrep, including filtering, deduplication, aggregation, and CI/CD integration.

Iteratively reviews and fixes Claude Code skill quality issues by running automated fix-review cycles using the skill-reviewer agent until they meet standards.

Runs external LLM code reviews (OpenAI Codex or Google Gemini CLI) on uncommitted changes, branch diffs, or specific commits.

Projects external audit findings from SARIF static analysis results and weAudit annotation files onto Trailmark code graphs as annotations and subgraphs, enabling cross-referencing with pre-analysis data like blast radius and taint.

Detects missing zeroization of sensitive data in source code and identifies zeroization removed by compiler optimizations, with assembly-level analysis and control-flow verification. Use for auditing C/C++/Rust code handling secrets, keys, passwords, or other sensitive data.

Runs a Trailmark summary analysis on a codebase to auto-detect languages, count entry points, and list dependencies.

Configures Python projects with modern tooling (uv, ruff, ty) for new projects, scripts, or migrations from legacy tools.

Generates Mermaid diagrams from code graphs, including call graphs, class hierarchies, module dependency maps, and data flow visualizations.

Compares Trailmark code graphs at two source code snapshots to surface security-relevant structural changes that text diffs miss, such as new attack paths, blast radius growth, and privilege boundary modifications.

Provides expertise for analyzing DWARF debug files and understanding the DWARF debug format (v3-v5). Triggers when understanding DWARF information, interacting with DWARF files, answering DWARF-related questions, or working with code that parses DWARF data.

Run Semgrep static analysis scans with automatic language detection, parallel subagent execution, and merged SARIF output. Supports full ruleset coverage or high-confidence security vulnerability filtering.

Identifies error-prone APIs, dangerous configurations, and footgun designs that enable security mistakes in API designs, configuration schemas, and cryptographic library ergonomics.

Audits Rust codebases for safe/unsafe boundary issues, memory safety in unsafe blocks, concurrency hazards, panic-induced DoS, FFI safety, and async runtime mistakes.

Safely analyzes and cleans up local git branches and worktrees by categorizing them as merged, squash-merged, superseded, or active work.

Uses mutation testing to systematically identify gaps in test vector coverage for cryptographic algorithms, then generates new test vectors that close those gaps. Measures effectiveness by comparing mutation kill rates before and after.

Scans a codebase for security vulnerabilities using CodeQL's interprocedural data flow and taint tracking analysis, with support for multiple languages, scan modes, and data extension models.

Builds and queries multi-language source code graphs for security analysis, including blast radius, taint propagation, privilege boundaries, and entry point enumeration.

Triage mutation testing results by combining survived mutants, unnecessary test statements, and code graph analysis to identify false positives, missing test coverage, and fuzzing targets.

Verifies suspected security bugs to eliminate false positives, producing a TRUE POSITIVE or FALSE POSITIVE verdict with documented evidence for each.

Performs comprehensive C/C++ security review for memory corruption, integer overflows, race conditions, and platform-specific vulnerabilities. Use when auditing native C/C++ applications, reviewing daemons or services for memory safety, or hunting integer overflow / use-after-free / race conditions in userspace code.

Enforces authenticated gh CLI workflows over unauthenticated curl/WebFetch patterns for GitHub operations.

Create scroll-driven animations with pinning, scrubbing, and trigger-based timelines using GSAP ScrollTrigger.

Optimize GSAP animations for smooth 60fps by preferring transforms, avoiding layout thrashing, using will-change, batching reads and writes, and following best practices for stagger, quickTo, and ScrollTrigger performance.

Animates Vue, Nuxt, Svelte, and SvelteKit components with GSAP, handling lifecycle hooks, scoped selectors, and cleanup on unmount.

Sequence and choreograph multi-step animations using GSAP timelines, including nesting, labels, position parameter, and playback control.

Register and use GSAP plugins including ScrollToPlugin, ScrollSmoother, Flip, Draggable, Inertia, Observer, SplitText, ScrambleText, SVG plugins, and custom easing plugins.

Provides GSAP utility functions for math, value mapping, randomization, snapping, and unit parsing in animations.

Animate React and Next.js components with GSAP using the useGSAP hook, refs, and context-safe patterns for automatic cleanup and SSR compatibility.

Animate DOM and SVG elements with GSAP's core engine: tweens, easing, staggers, transforms, and responsive matchMedia.

Diagnoses and resolves slow Qdrant indexing and data ingestion by optimizing batching, sharding, HNSW parameters, and payload indexing strategies.

Diagnoses and resolves slow Qdrant search performance issues including high latency, low throughput, and slow filtered searches.

Diagnoses and reduces Qdrant memory usage by analyzing resident memory, page cache, and providing optimization techniques like quantization, on-disk storage, and async_scorer.

Creates an integration testing plan for .NET data access artifacts during Oracle-to-PostgreSQL database migrations, analyzing a project to identify repositories, DAOs, and service layers that interact with the database, then producing a structured testing plan.

Creates GitHub Issues for unimplemented requirements from specification files, checking the codebase and existing issues to avoid duplicates.

Generates integration test cases for .NET data access artifacts during Oracle-to-PostgreSQL database migrations, producing DB-agnostic xUnit tests with deterministic seed data that validate behavior consistency across both database systems.

Guides scaling Qdrant vector search with time-based data rotation using shard rotation, collection rotation, or filter-and-delete strategies.

Scaffolds an xUnit integration test project for validating Oracle-to-PostgreSQL database migration behavior in .NET solutions, including transaction-rollback base class and seed data manager.

Diagnoses Qdrant capacity needs and guides horizontal scaling decisions, including node count, shard count, replication factor, and resharding trade-offs.

Creates GitHub Issues from implementation plan phases using feature_request.yml or chore_request.yml templates.

Guides vertical scaling decisions for Qdrant vector databases, covering when to scale up, how to resize nodes in Qdrant Cloud or self-hosted deployments, RAM sizing formulas, and when to switch to horizontal scaling.

Guides scaling Qdrant for multi-tenant workloads using payload partitioning, custom sharding, and tiered multitenancy.

Discovers all projects in a .NET solution, classifies each for Oracle-to-PostgreSQL migration eligibility, and produces a persistent master migration plan.

Creates structured bug reports for defects found during Oracle-to-PostgreSQL migration, documenting behavioral differences with severity, root cause, and remediation steps.

Translates Oracle PL/SQL stored procedures to PostgreSQL PL/pgSQL, preserving method signatures and type-anchored parameters while applying Oracle-compatible sorting and leveraging orafce.

Creates a GitHub issue from a specification file using a feature request template, checking for existing issues first.

Generates detailed, technology-agnostic implementation blueprints by analyzing project architecture, technology stacks, and data flow patterns.

Suggests relevant GitHub Copilot instruction files from the awesome-copilot repository based on current repository context and chat history, avoiding duplicates with existing instructions and identifying outdated ones.

Creates a formal, AI-optimized specification for an existing GitHub Actions CI/CD workflow, focusing on behavior and requirements rather than implementation details.

Upgrade GitHub Actions to supported runtimes by selecting safe action versions, preserving workflow behavior, and validating post-upgrade execution.

Analyzes differences between two project versions to generate precise migration instructions for GitHub Copilot, enabling consistent code transformations during technology migrations, refactoring, or framework upgrades.