Verified skills

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

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.

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

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.

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

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.

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.

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

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

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

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

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

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

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

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.

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

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

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.

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.

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

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.

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.

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

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

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.

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.

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

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

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

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 external LLM code reviews (OpenAI Codex or Google Gemini CLI) on uncommitted changes, branch diffs, or specific commits.

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

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

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

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

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