Guidance for creating polyglot files that are valid in both Python and C. This skill applies when tasked with writing code that must be parseable and executable by both the Python interpreter and C compiler. Covers polyglot syntax techniques, testing strategies, and critical cleanup requirements.
Guidance for implementing high-performance portfolio optimization using Python C extensions. This skill applies when tasks require optimizing financial computations (matrix operations, covariance calculations, portfolio risk metrics) by implementing C extensions for Python. Use when performance speedup requirements exist (e.g., 1.2x or greater) and the task involves numerical computations on large datasets (thousands of assets).
Guidance for implementing tensor parallelism in PyTorch, including ColumnParallelLinear and RowParallelLinear layers. This skill should be used when implementing distributed tensor parallel operations, sharding linear layers across multiple GPUs, or simulating collective operations like all-gather and all-reduce for parallel computation.
Guide for implementing combinational/sequential logic circuits using gate-level descriptions in text-based simulators. This skill applies when building circuits for mathematical functions like integer square root, Fibonacci sequences, or similar computations that require both combinational logic (arithmetic operations) and sequential logic (feedback loops, state machines). Use this skill when the task involves generating gate netlists, implementing multi-bit arithmetic circuits, or debugging event-driven circuit simulators.
Guidance for cross-compiling complex C programs (like Doom) to run on custom MIPS virtual machines or emulators. This skill should be used when tasked with building software for non-standard MIPS targets that use custom syscall interfaces, require freestanding compilation (-nostdlib), or involve running binaries in JavaScript/custom VM environments.
Guide for building CompCert, the formally verified C compiler, from source. This skill should be used when compiling, building, or installing CompCert, or when working with Coq-based software that has strict dependency version requirements. Covers OCaml/opam setup, Coq version compatibility, memory management, and common build pitfalls.
Guidance for building digital logic circuits that compute composite functions like Fibonacci of integer square root. This skill applies when implementing combinational and sequential logic in gate-level simulators, particularly when combining algorithms (like isqrt and Fibonacci) under resource constraints (gate counts, simulation steps). Use for circuit synthesis, HDL-style logic design, or gate-level algorithm implementation tasks.
This skill provides guidance for implementing custom compression encoders that must be compatible with existing decoders (especially arithmetic coding). It should be used when the task requires writing a compressor/encoder that produces output compatible with a given decompressor/decoder, or when implementing arithmetic coding or similar bit-level compression schemes.
Nix patterns for flakes, overlays, unfree handling, and binary overlays. Use when working with flake.nix or shell.nix.
Guidance for building MIPS interpreters or emulators that execute MIPS binaries. This skill applies when implementing CPU emulation, ELF loaders, instruction decoders, or syscall handlers for MIPS architecture. Use when tasks involve creating virtual machines for MIPS executables, interpreting MIPS assembly instructions, or emulating MIPS system calls.
Guide for optimizing Python numerical computations with C extensions. This skill should be used when tasks involve creating C extensions for Python, implementing mathematical algorithms (matrix operations, linear algebra) in C, or optimizing computational bottlenecks to achieve significant speedup. Particularly relevant for portfolio risk/return calculations, scientific computing, and performance-critical code requiring validation against baseline implementations.
This skill provides guidance for implementing tensor parallelism in PyTorch, specifically column-parallel and row-parallel linear layers. Use when implementing distributed neural network layers that split weights/activations across multiple ranks, working with torch.distributed for model parallelism, or implementing ColumnParallelLinear and RowParallelLinear classes.
Guidance for compiling POV-Ray 2.2 (a 1990s-era ray tracing software) from source on modern Linux systems. This skill should be used when the task involves downloading, extracting, and building POV-Ray 2.2 or similar legacy/historical software that requires special handling for modern compiler compatibility.
Guide for implementing MIPS CPU interpreters/emulators, particularly for running compiled MIPS ELF binaries. This skill applies when building virtual machines to execute MIPS32 code, creating emulators for retro game ports (like Doom), or implementing CPU simulators. Use for tasks involving ELF parsing, instruction decoding, syscall emulation, and memory management for MIPS architecture.
Guidance for implementing encoders/compressors that must produce output compatible with an existing decoder/decompressor. This skill applies when tasked with writing compression algorithms, arithmetic coders, entropy encoders, or any encoder that must be the inverse of a given decoder implementation.
Reviews Rust firmware code for the BVR (Base Vectoring Rover) with focus on safety-critical systems, CAN bus protocol compliance, motor control logic, state machine correctness, and embedded testing patterns. Use when reviewing BVR firmware changes, debugging actuator control, testing motor communication, validating safety mechanisms, checking async patterns, or evaluating control system modifications. Covers watchdog implementation, e-stop handling, rate limiting, VESC motor controller integration, and Tokio async runtime patterns.
Generalised autonomous optimisation loop — soft RLVR for any artifact a user can measure. Web runtime package: uses memory in this order: connector-backed, project-pack, none. Never assumes subprocess access or unrestricted local files. Use this skill whenever a user wants to iteratively improve an artifact — code, prompts, documents, configs, designs, content — by running structured experiments, evaluating results against a multi-dimensional rubric, and learning from each attempt. Triggers include: "optimise this", "keep improving until it's good", "run experiments on", "autoresearch", "iterate on this overnight", "try different approaches and pick the best", or any request implying repeated evaluate-and-improve cycles.
VRChat UdonSharp で重い再構築処理、replay、reset、段階実行、分割適用が必要な runtime を設計・実装するときに使う。大量オブジェクト更新、操作列の再適用、1 フレームで終わらない処理を安全に扱いたい場合に使う。
Improve interface resilience through better error handling, i18n support, text overflow handling, and edge case management. Use when user says "harden this", "handle edge cases", "error handling", "i18n support", "make it robust", "production-ready", or when an interface needs to handle real-world conditions.
Implementing idiomatic, safe, and performant Rust code.
How to define and use defineErrors from wellcrafted. Use when creating new error types, updating error definitions, or reviewing error patterns. Covers variant factories, extractErrorMessage for cause, InferErrors/InferError for types, and call site patterns.
Guide for integrating safety validation into new inference backends
Optimize Inertia Rails application performance. Use when implementing code splitting, prefetching, deferred props, infinite scrolling, polling, or other performance optimizations.
Guide for implementing dplyr verbs (filter, mutate, select, etc.) for custom backends. Use when building dplyr-compatible table classes like database connections (dbplyr), data.table wrappers (dtplyr), Arrow tables, Spark DataFrames, or GPU tables. Covers S3 method dispatch, rlang expression parsing, NAMESPACE exports, Rcpp integration, and testing patterns.
