Skill UI

A specialized skill for writing highly efficient, memory-safe, and robust C code. This guide focuses on best practices for systems programming, including rigorous memory management (malloc/free), advanced pointer arithmetic, POSIX compliance, multi-threading (pthreads), and embedded systems constraints. It emphasizes using static analysis tools, implementing comprehensive error handling, and ensuring performance through proper profiling. Ideal for complex, low-level system tasks.

A specialist guide for designing, implementing, and optimizing high-performance C++ applications using modern standards (C++20/23). Expertise covers advanced topics like concepts, coroutines, template metaprogramming, and zero-overhead abstractions. Use this when tackling complex memory management, concurrency bottlenecks, or integrating build systems via CMake, ensuring code meets industrial quality standards through rigorous sanitization and profiling.

A comprehensive deep dive guide for migrating translation memory (TM) and localization content from competing Translation Management Systems (TMS) like Crowdin, Phrase, or POEditor into Lokalise. This process involves exporting data from the source platform, transforming key variables and file structures to match Lokalise conventions, and finally performing a bulk API upload to establish a new, centralized localization repository. Perfect for re-platforming or migrating existing translation pipelines.

Provides cross-language patterns for developing memory-safe systems code. This skill covers crucial concepts like RAII, ownership models, smart pointers, and robust resource management. It is essential for preventing common vulnerabilities such as use-after-free, memory leaks, and ensuring reliable resource handling across complex systems.

This skill provides comprehensive strategies for implementing robust caching mechanisms for OpenRouter API calls. It covers in-memory caching using Python, persistent caching with Redis for scalability, and utilizing provider-specific features like Anthropic prompt caching. By implementing deterministic key generation and managing Time-To-Live (TTL), developers can significantly reduce API costs and improve application latency when handling repetitive or similar LLM queries, making it ideal for RAG systems and high-volume applications.

This skill simulates an expert performance engineer capable of diagnosing complex bottlenecks across the entire technology stack. It covers modern observability techniques (OpenTelemetry, APM), advanced profiling (CPU, Memory, I/O), and sophisticated load testing strategies (k6, Chaos Engineering). Use this when optimizing scalability, reducing latency, improving throughput, or architecting highly reliable, performant distributed systems in cloud environments.

Expert skill for writing, reviewing, and debugging idiomatic Rust code, focusing on memory safety and zero-cost abstractions. Specializes in advanced concepts like ownership patterns, explicit lifetime management, trait-based API design, and building concurrent async applications using Tokio. Use this when developing high-performance, reliable, systems-level software in Rust.

Expert skill for building high-performance, memory-safe systems, web services, and complex libraries using modern Rust (1.75+). Specializes in advanced async programming with Tokio, zero-cost abstractions, and mastering ownership and lifetime rules. Ideal for implementing scalable backend APIs, low-level networking, and performance-critical components where memory safety is paramount.

This comprehensive guide outlines best practices for optimizing vector indexes for production systems. It covers critical techniques such as tuning HNSW parameters, implementing quantization strategies, and optimizing memory usage. Use this when you need to balance search latency, recall, and scalability for large-scale vector databases.

This skill outlines the comprehensive process of memory forensics on compromised Linux systems. It guides users through acquiring volatile memory using the LiME kernel module and analyzing the resulting image with the Volatility 3 framework. Key artifacts extracted include process lists, network connections, bash history, and loaded kernel modules, making it an essential technique for incident response, threat hunting, and security investigations.

This guide provides essential knowledge on resource limitations within WebContainer environments (such as memory, CPU, file system size, and process count). It is crucial for developers utilizing the WebContainers API or StackBlitz SDK to understand these constraints. Learn best practices for monitoring memory usage, optimizing mounted file systems by excluding unnecessary assets (like test or documentation folders), and managing dependencies to prevent common issues like Out-Of-Memory (OOM) crashes and slow build times.

This skill guides the design and optimization of production-grade multi-agent systems. It specializes in using LangGraph, LangChain, and DeepAgents to create structured, complex AI workflows. It covers state management, agent routing, memory integration, and tool calling, making it ideal for building robust, scalable agents like supervisors, planners, and coders.