Manual validation and runtime checks are error-prone and costly. This skill teaches type-driven design patterns in Rust that move correctness guarantees from runtime to compile time, eliminating entire classes of bugs before code runs.

Thiserror is a Rust crate that simplifies custom error type creation through derive macros. This skill provides expert guidance on defining error enums with clear messages, chaining source errors, and implementing proper From conversions for ergonomic error handling.

Writing comprehensive tests for Rust code can be time-consuming and error-prone. This skill proactively identifies missing test cases for error paths, edge cases, and business logic so you can write better tests faster.

Rust 2024 introduces powerful new features like let chains and async closures that simplify code. This skill guides developers through identifying migration opportunities and applying modern patterns for cleaner, more idiomatic Rust code.

Creating MCP servers requires understanding a complex protocol with multiple transport options and tool patterns. This skill provides a quick start guide with clear Rust code examples, transport configurations, and testing strategies for building production-ready MCP servers.

Traditional unit tests check specific inputs, but miss edge cases. This skill teaches you property-based testing with proptest to automatically generate test inputs and discover hidden bugs.

Writing code that directly couples to databases, HTTP clients, or file systems creates testing challenges and limits flexibility. This skill helps design port abstractions and adapter implementations for hexagonal architecture, enabling clean separation between business logic and external dependencies.

Parquet files can become slow and bloated without proper optimization. This skill proactively analyzes Parquet operations and suggests improvements for compression, encoding, row group sizing, and statistics to maximize query performance and minimize storage costs.

Cloud storage operations fail intermittently due to network issues, rate limiting, and timeouts. This skill provides expert guidance on implementing robust object storage with proper retry logic, error handling, streaming patterns, and efficient I/O for S3, Azure Blob, and Google Cloud Storage.

Testing code with external dependencies is challenging. This skill provides patterns for creating mock implementations using traits, enabling reliable unit tests without real infrastructure.

Developers building MCP servers need clear guidance on transport layer options. This skill explains stdio, SSE, and HTTP transports with implementation examples, security best practices, and deployment scenarios for different use cases.

Creating MCP tools manually requires understanding complex macro systems and type constraints. This skill provides expert guidance on using the rmcp crate to build type-safe tools with automatic schema generation, validation, and async patterns.

MCP servers need resources to provide data and files to AI assistants. This skill guides developers through implementing URI-addressable resources with caching, streaming, and proper MIME type handling for production-ready integrations.

Building MCP servers requires well-designed prompts to guide AI interactions. This skill provides patterns and examples for creating reusable, parameterized prompts using the rmcp Rust crate.

Building MCP servers for production requires careful attention to architecture, security, and performance. This skill provides expert guidance on proven patterns for creating maintainable and secure MCP server implementations.

Developers writing deeply nested Rust control flow struggle with readability and maintainability. This skill proactively identifies nested if-let patterns (3+ levels) and suggests let chain refactorings for cleaner, more readable Rust 2024 code.

AWS Lambda functions often suffer from slow cold starts and high costs due to inefficient patterns. The Lambda Optimization Advisor analyzes Lambda code and suggests specific improvements for performance, memory configuration, and cost reduction.

Code architecture degrades over time as teams rush to deliver features. This skill proactively identifies architectural violations in Rust codebases and suggests improvements for clean ports and adapters separation.

Rust developers often struggle with proper error handling patterns. This skill proactively reviews code and suggests idiomatic improvements using Result types, custom error types with thiserror, and proper error propagation with the ? operator.

Developers struggle with Rust error type mismatches and repetitive map_err calls. This skill provides idiomatic patterns for converting errors using From trait implementations, the ? operator, and libraries like thiserror and anyhow.