Skill UI

This skill guides the integration of Arize AX tracing into existing applications, especially complex LLM applications. It follows a structured, two-phase, agent-assisted flow: first analyzing the codebase (read-only) to understand dependencies, and then implementing instrumentation. It supports multi-language environments (Python, TypeScript, Java, Go) and integrates deeply with OpenTelemetry and various LLM providers, ensuring comprehensive observability without altering core business logic.

Describes how to analyze a repository, prioritize key docs, and author an llms.txt entry so LLMs immediately understand the project scope, documentation clusters, and configuration artifacts they should consult.

This skill guides the end-to-end process of building automated evaluation pipelines for Python applications powered by Large Language Models (LLMs). It teaches how to define evaluation criteria, instrument the application, build golden datasets, and run real-world evaluations using tools like pixie, ensuring the app's logic (not just the LLM) is rigorously tested. Ideal for QA, benchmarking, and improving LLM-based services.

Maintains the repository's llms.txt guidance file by auditing current documentation, specs, and structure to ensure the navigation summary matches reality and stays compliant with the official specification.

This advanced skill optimizes LLM context usage by implementing strict rules for prompt caching, efficient log pruning, AST-based code inspection, and compact data structuring. It minimizes token consumption and maximizes information density, suitable for highly technical and iterative development workflows.

This guide details advanced strategies for optimizing Claude API usage to reduce latency and cost. Techniques covered include prompt caching (significant cost reduction), strategic model selection (Haiku, Sonnet, Opus) based on task complexity, implementing streaming for perceived speed, and managing token limits. Use this guide when building high-performance, cost-efficient LLM applications that interact with large language models.

Implements a robust, multi-tenant authorization layer for Cohere API v2. This solution enforces Role-Based Access Control (RBAC), manages individual API keys per team, and implements per-team usage limits and daily budget tracking. It is essential for large-scale applications requiring strict resource isolation and cost governance across multiple internal services.

A powerful pre-action hook designed to enforce rigorous checks before AI agents modify code, create files, or execute destructive commands. Instead of relying on superficial self-evaluation, GateGuard forces the LLM to gather concrete facts (like dependencies, data schemas, and impacted modules), significantly improving code reliability and architectural depth. It provides multiple gates for edits, writes, and destructive bash commands.

This guide provides a comprehensive deep dive into migrating applications from OpenAI (GPT) to Anthropic (Claude). It details critical API differences, including changes in system prompt handling, function calling formats, and response parsing. It also demonstrates how to build a robust, multi-provider abstraction layer for seamless LLM switching.

Provides best practices for configuring Large Language Model (LLM) access, specifically for Anthropic Claude, across development, staging, and production environments. This guide details setting up separate API keys, selecting appropriate models (e.g., Haiku, Sonnet, Opus), and managing unique rate limits for robust, scalable, and secure LLM integration in enterprise systems.

This guide provides expert strategies for optimizing GPU inference performance on CoreWeave infrastructure. It covers GPU selection based on workload (LLM, image generation, training), advanced techniques like continuous batching (using vLLM), autoscaling setup (HPA), and benchmarking data. Use this to maximize GPU utilization, minimize latency, and optimize large-scale AI model deployment.

This tool enforces four rigorous coding principles, inspired by Andrej Karpathy's insights on LLM pitfalls. It guides developers to surface assumptions, prioritize simplicity, make surgical changes, and define verifiable goals. Use it when reviewing code, checking diffs, or before committing to ensure high code quality and prevent over-engineering.