Skill UI

This skill specializes in implementing Service Level Objectives (SLOs) and Service Level Indicators (SLIs) to enforce reliability standards. It guides users in designing comprehensive SLO frameworks, calculating error budgets, and building robust monitoring systems. Use this when you need to establish data-driven reliability targets, balance feature velocity with technical health, and align service performance directly with core business objectives.

This skill provides comprehensive, structured audit logging for OpenRouter API interactions. It automatically captures essential metadata like total cost, token usage, model details, latency, and status, while also performing PII redaction. The resulting audit trail is stored in an append-only SQLite database, making it ideal for building compliance-ready systems, detailed cost monitoring, and deep debugging of production environments.

A comprehensive guide on implementing failover and fallback mechanisms for Large Language Models (LLMs) when using OpenRouter. This skill covers native model fallbacks, provider routing strategies, and advanced client-side fallback chains. Use this pattern when building mission-critical or highly resilient systems that must maintain service availability even if a primary model or an entire provider goes offline. It ensures robust API integration and graceful degradation.

Implements standardized function/tool calling across various large language models (LLMs) via OpenRouter. This unified approach allows developers to build sophisticated, multi-step agents and complex workflows, regardless of the underlying provider (e.g., GPT-4o, Claude 3.5). It simplifies the process of achieving structured output and tool-augmented reasoning in production systems.

A comprehensive guide on handling API rate limits and throttling errors (429) when building high-throughput systems, particularly for LLM APIs like OpenRouter. This skill covers best practices, including using exponential backoff, implementing custom client-side rate limiters (Token Bucket), and managing concurrent requests for stable, reliable performance.

This skill provides comprehensive reference architectures for building production-grade AI applications using OpenRouter as a unified LLM gateway. It covers three scaling patterns: simple single-service, standard microservice (with caching and budget enforcement), and enterprise event-driven systems (with message queues and workers). Use this when planning system design, reviewing complex AI pipelines, or ensuring scalability and cost control in your LLM integration.

This skill implements a sophisticated, config-driven rules engine for OpenRouter API calls. It dynamically determines the optimal large language model (LLM) by evaluating a comprehensive context, including user subscription tier, remaining cost budget, specific task type (code, chat), required tools, and latency requirements. This is essential for building production-grade, cost-aware, and robust LLM orchestration systems.

Qdrant is a high-performance, Rust-powered vector database designed for production-grade RAG (Retrieval-Augmented Generation) and semantic search applications. It provides fast nearest neighbor search, supports complex hybrid search using metadata filtering, and offers horizontal scalability through sharding and replication. Ideal for building real-time recommendation systems and enterprise-level knowledge retrieval.

Guides building accessible Radix UI design systems using headless primitives, focusing on theming, composition, keyboard navigation and WCAG compliance for custom component libraries in React-based apps.

Expert in writing, reviewing, and debugging idiomatic Rust code. This skill covers deep systems programming concepts, including mastering ownership, lifetimes, and borrowing patterns for guaranteed memory safety. Specializes in building high-performance, concurrent async applications using Tokio, and designing robust APIs using advanced trait hierarchies. Ideal for projects requiring zero-cost abstractions and maximum reliability.

Expert guidance for building Rust 1.75+ services with async Tokio stacks, advanced type system usage, memory-safe systems programming, and production-grade testing and optimization workflows.

Summarizes Rust systems programming best practices, covering ownership, traits, async patterns, error handling, builders, and safety reminders for building robust server components.