Claude Skills

This skill validates Claude context files by checking sizes, analyzing patterns, and generating reports. It includes tools to optimize MCP configurations and apply improvements across workspace repositories. Use it to maintain efficient context management and reduce token usage in development workflows.

This mandatory skill enforces size limits for Claude configuration files (CLAUDE.md variants) to maintain context efficiency. It provides validation scripts to check compliance and specifies required content categories for these files. Developers use it to ensure their Claude workspace configurations remain within optimal boundaries for effective AI assistance.

This skill defines structured output rules for managing large responses in Claude Code, including constraints on tables, code blocks, and lists. It mandates a specific status format for responses and prohibits actions like echoing input or providing unbounded outputs. Developers should use it to enforce consistency and prevent context overload when generating lengthy or complex content.

This quick reference skill provides essential limits and metrics for managing Claude's context files. It specifies file size constraints for different CLAUDE.md types and shows runtime token usage with alert thresholds. Use this skill when you need to quickly check context management parameters during development.

This skill automatically analyzes your development patterns across sessions to optimize Claude's context usage. It tracks frequently referenced files, identifies rarely used content, and generates daily improvement reports. Use it to maintain efficient context management and receive data-driven suggestions for better Claude performance.

This core skill manages agent context files by enforcing size limits and optimizing token allocation. It provides essential capabilities for file management, recovery patterns, and scheduled maintenance tasks. Use it when you need to control context growth and ensure efficient token usage in Claude Code projects.

This skill provides best practices for implementing usage tracking, focusing on consistent log formatting, metadata inclusion, and log rotation. It helps developers create maintainable tracking systems with proper timestamps and input validation. Use this reference when setting up or auditing usage tracking implementations.

The usage-tracker skill enables developers to track and analyze tool or resource usage over time through timestamped logging and reporting. It's designed for generating periodic usage reports, monitoring quotas, and detecting usage trends, but is not suitable for real-time or high-frequency event tracking. Key capabilities include daily/weekly/monthly breakdowns and pattern analysis for building dashboards.

This skill analyzes usage trends over time by comparing periods and identifying patterns in your Claude Code logs. It provides functions like `get_daily_trend()` to retrieve daily totals for specified categories and days. Use it when you need to track usage patterns, calculate moving averages, or perform historical data analysis.

This skill generates human-readable usage summary reports from Claude API logs, organizing data by model type (Opus, Sonnet, Haiku) and time periods. It provides formatted output with color-coded statistics for quick analysis of API consumption patterns. Use this when you need to monitor and report on Claude model usage across different timeframes.

This skill provides basic usage logging functionality with pipe-delimited timestamped logs for easy parsing. It creates and maintains a structured log file tracking events by category, item, value, and metadata. Use this when you need simple, standardized logging for monitoring tool usage or activity tracking in development workflows.

This reference skill provides best practices for managing application state directories, including using standard locations and proper initialization. It covers essential maintenance tasks like permission handling, cleanup, and log rotation. Use this sub-skill to implement robust and maintainable local state management in your tools.

This skill provides XDG-compliant persistent state directory management for bash scripts, handling path resolution and cleanup automatically. It's ideal for CLI tools needing to store configuration, cache data, or maintain logs between executions. Developers should use it when building portable scripts that require state persistence across runs.

This skill provides cache management with TTL (time-to-live) expiration for storing and retrieving cached data in bash scripts. It offers functions to check cache validity, get cached items, and manage cache files with configurable expiration times. Use this when you need to implement persistent caching with automatic expiration in your command-line tools or scripts.

This skill provides state file operations for tracking persistent data between script executions. It includes functions to initialize, read, and update JSON state files for tracking run history, progress, and status. Use this when you need to maintain state across multiple runs of your Claude Code scripts.

This skill implements the XDG Base Directory Standard for managing application state, providing cross-platform directory paths for configuration, data, cache, and state files. It automatically handles environment variable fallbacks and creates application-specific subdirectories. Use this when building CLI tools or applications that need standardized, organized file storage across different operating systems.

This skill enables parallel task execution in bash using xargs and job control for significant performance gains. It's ideal for batch operations on independent items like multiple files or repositories, particularly for I/O-bound tasks. Developers should use it when order doesn't matter and avoid it for tasks with dependencies or shared resource requirements.

This skill provides progress tracking for parallel batch execution, enabling real-time monitoring with atomic updates using file locking. It tracks completion counts and success/failure statuses for each processed item. Use this when you need visibility into parallel task execution with reliable progress reporting.

This skill provides basic parallel execution using xargs to process multiple items concurrently with controlled parallelism. It demonstrates fundamental patterns for handling input streams and includes error handling capabilities. Developers should use this for simple parallel processing tasks where xargs provides sufficient control over worker concurrency.

This skill provides best practices for implementing parallel batch execution in shell scripts, starting with setting safe defaults for parallelism. It includes validation, failure handling, logging, and resource cleanup patterns to ensure robust execution. Use this when building batch processors that need to handle concurrent tasks reliably.

This skill provides bash configuration parsing patterns for INI, key=value, and JSON files using tools like jq. It's ideal for loading configs into bash scripts, generating JSON reports, and managing settings with associative arrays. Avoid it for complex nested configurations where Python would be more suitable.

This skill enables YAML configuration file parsing in bash scripts using yq when available, with fallback to jq for JSON-compatible YAML subsets. It provides a standardized method to load YAML configurations as JSON for consistent processing across tools. Use this when your bash scripts need to read YAML config files in environments where yq or jq might be available.

This skill enables environment variable overrides for JSON configuration loading, allowing developers to prioritize environment settings over file-based values. It provides a Bash implementation that loads configurations from files while supporting prefixed environment variables as higher-priority overrides. Use this when you need flexible configuration management where environment-specific settings should supersede default file configurations.

This skill parses INI-style configuration files with section headers into structured data. It supports [section] headers, section.key access patterns, and includes error handling for missing files. Use it when you need to process multi-section configuration files in bash scripts.