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.

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.

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.

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.

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.

Domain models often become simple data containers with no behavior. This skill guides developers in creating expressive, type-safe domain models using value objects, entities with identity, and domain events following DDD principles.

Data lakes require careful architectural decisions around partitioning, storage tiers, and schema design that impact performance and cost. This skill provides expert guidance on building scalable lakehouse architectures using modern patterns and best practices.

AWS Lambda cold starts cause latency spikes in serverless applications. This skill provides expert guidance on reducing cold start times for Rust Lambda functions through binary optimization, lazy initialization patterns, and deployment best practices.

Manual browser testing and web scraping are time-consuming and error-prone. This skill provides enterprise-grade browser automation using WebDriver protocol, enabling reliable form filling, screenshot capture, performance monitoring, and multi-step web workflows across Chrome, Firefox, and Edge.

AI agents lose context when conversations end. This skill uses GitHub Issues as permanent memory that survives context exhaustion and enables seamless collaboration across multiple sessions.

Managing multi-phase development workflows requires manually tracking and closing threads. This skill automates phase transitions in GitHub Elements, closing the current thread and opening the next phase thread with proper validation.

Managing feature requirements without a structured system leads to scope creep and misaligned implementations. This skill provides versioned markdown requirements files with automated GitHub issue linking and SERENA memory backup for persistent, traceable development workflows.

Developers often lose context when switching between GitHub issues during collaborative coding sessions. This skill enables natural language control over issue thread transcription, automatic state tracking, and seamless switching between multiple development contexts.

GitHub Elements users need quick visibility into their active threads and workflow state before starting work. This read-only skill provides an instant overview of active threads, phase distribution, and workflow health without modifying anything.

Users need detailed analysis of their GitHub Elements workflow performance. This skill generates comprehensive reports including metrics, health assessments, and epic-specific analysis to help teams understand their development velocity and identify areas for improvement.