Rust Skills

Skills for writing idiomatic Rust code. These skills help Claude understand ownership, borrowing, lifetimes, and Rust-specific patterns so it produces code that compiles and follows community conventions.

40 skills

rust-mcp-server-generator

github/awesome-copilot

7.3k

26.4k

The rust-mcp-server-generator skill generates a complete, production-ready Rust Model Context Protocol server project using the official rmcp SDK, automatically creating project structure, Cargo.toml, source files, and tests based on user specifications for project name, description, transport type, and tools. It is for developers building MCP servers in Rust who need scaffolded boilerplate code for tools, prompts, resources, and transport configurations rather than writing them manually.

rust-async-patterns

wshobson/agents

5.8k

31.9k

rust-best-practices

apollographql/skills

4.3k

The rust-best-practices skill guides developers in writing idiomatic Rust code based on Apollo GraphQL's best practices handbook, covering borrowing vs cloning, error handling, performance optimization, testing, and documentation. It's designed for developers writing, reviewing, or refactoring Rust code who need reference materials on ownership patterns, Result types, Clippy linting, and type safety techniques. The skill solves the problem of maintaining consistent, performant, and safe Rust code by providing structured guidance aligned with industry standards.

ideabrowser.com

Find trending startup ideas with real demand. Launch with a team of AI agents.

startupsai agentsideas

Get trending startup ideas →

Sponsored

m15-anti-pattern

zhanghandong/rust-skills

3.1k

895

The m15-anti-pattern skill helps developers identify and refactor common code anti-patterns during code reviews, focusing on Rust-specific issues like excessive cloning, unwrap calls in production, and fighting the borrow checker. It's designed for Rust developers and code reviewers who need to distinguish between solving symptoms versus root causes, and who want guidance on more idiomatic approaches. The skill maps anti-patterns to their underlying design problems and traces them to related skills for deeper understanding of ownership, error handling, and domain design.

rust-engineer

jeffallan/claude-skills

1.4k

7.1k

The rust-engineer skill provides senior-level Rust code writing, review, and debugging support, specializing in memory safety, ownership patterns, trait design, async/await concurrency with tokio, and error handling with Result/Option types. It serves Rust developers building systems software who need expert guidance on borrowing, lifetimes, trait hierarchies, zero-cost abstractions, and performance optimization. The skill solves problems related to understanding Rust's ownership system, designing safe and idiomatic APIs, implementing concurrent applications, and writing memory-safe code without sacrificing performance.

coding-guidelines

zhanghandong/rust-skills

895

The coding-guidelines skill provides developers with Rust-specific code style standards and best practices, covering naming conventions, data types, error handling, memory management, concurrency, and async patterns. It serves Rust programmers who need guidance on naming conventions, code formatting, and adherence to Rust idioms during code review and development. The skill solves the problem of inconsistent code style and suboptimal practices by offering a centralized reference to the 50 core rules from the official Rust Coding Guidelines.

cargo-fuzz

trailofbits/skills

996

3.8k

m10-performance

zhanghandong/rust-skills

700

895

The m10-performance skill guides developers through systematic performance optimization by establishing whether optimization is necessary before implementing solutions. It maps performance goals—such as reducing allocations, improving cache efficiency, and parallelizing workloads—to specific design choices and implementation techniques in Rust, while emphasizing measurement through profiling and benchmarking tools like criterion and flamegraph. The skill traces constraints from business requirements down to low-level implementation decisions, helping developers identify actual bottlenecks and understand the complexity-versus-speed trade-offs involved in optimization.

m07-concurrency

zhanghandong/rust-skills

654

895

The m07-concurrency skill guides developers through Rust's concurrency and async patterns by mapping errors to underlying design questions about workload type, data sharing models, and thread safety requirements. It serves Rust developers encountering Send/Sync errors, deadlocks, or race conditions, helping them diagnose whether problems stem from incorrect primitive choice (threads vs. async), sharing strategy (channels vs. Mutex), or domain-specific constraints. The skill prioritizes tracing errors upward to domain context (web APIs, fintech, CLI) before applying fixes, preventing misuse of concurrency primitives like Rc in thread-safe contexts.

m06-error-handling

zhanghandong/rust-skills

647

895

The m06-error-handling skill teaches Rust developers how to choose appropriate error handling strategies by distinguishing between expected failures, normal absence, and bugs—using Result, Option, panic, and crates like thiserror and anyhow. It's designed for developers writing both library and application code who need to decide when to propagate errors, return Options, panic, or add context to failures. The skill solves the problem of unclear error handling decisions by providing a decision framework that traces back to domain design and down to specific implementation patterns.

m01-ownership

zhanghandong/rust-skills

637

895

The m01-ownership skill diagnoses and resolves Rust ownership, borrowing, and lifetime errors by guiding developers to understand data ownership requirements rather than applying quick fixes. It serves Rust developers encountering errors like E0382, E0597, and E0506 by providing a systematic thinking process that traces problems to their design roots and determines appropriate patterns like move semantics, references, or shared ownership types. The skill prevents repeated ownership errors by distinguishing between symptom fixes and underlying design issues, escalating to higher-level design skills when patterns persist.

m04-zero-cost

zhanghandong/rust-skills

636

895

The m04-zero-cost skill helps Rust developers choose between static and dynamic polymorphism when working with generics and trait objects, addressing common type system errors like E0277 and E0599. It's designed for programmers struggling with trait bounds, monomorphization, and zero-cost abstraction decisions by reframing compiler errors as design questions about whether types should be known at compile time or runtime. The skill traces upward to domain design and downward to specific implementation patterns, helping developers avoid unnecessary trait objects and code bloat while maintaining flexibility.

m05-type-driven

zhanghandong/rust-skills

633

895

The m05-type-driven skill teaches developers how to use Rust's type system to prevent invalid states and encode invariants at compile time rather than relying on runtime validation. It covers patterns like newtypes, type state, PhantomData, marker traits, and builders that allow developers to make invalid states unrepresentable. This skill is for Rust engineers building robust systems who need to shift validation logic from runtime checks to compile-time type constraints.

m02-resource

zhanghandong/rust-skills

624

895

m02-resource guides developers through selecting appropriate smart pointers and resource management patterns in Rust by asking design questions rather than prescribing solutions. It's for Rust developers encountering ownership and memory management challenges who need to understand when to use Box, Rc, Arc, RefCell, or other smart pointers based on their specific ownership model, thread context, and mutability requirements. The skill solves the problem of cargo-cult smart pointer usage by connecting implementation choices back to underlying design decisions about single vs. shared ownership, single-threaded vs. multi-threaded access, and reference cycles.

m03-mutability

zhanghandong/rust-skills

611

895

The m03-mutability skill diagnoses and resolves Rust mutability errors (E0596, E0499, E0502) by guiding developers to understand whether mutation is architecturally necessary and which mutability pattern fits their use case—from simple `&mut T` borrows to interior mutability types like `Cell`, `RefCell`, and `Mutex`. It serves Rust developers debugging borrow checker conflicts by transforming "add mut" impulses into design questions, then tracing issues upward to data structure problems or downward to the appropriate implementation pattern. The skill solves the common problem of developers treating mutability as a tactical syntax issue rather than a design decision about ownership and access control.

rust-router

zhanghandong/rust-skills

601

895

rust-router guides users through Rust programming questions by systematically routing them through three cognitive layers—language mechanics (ownership, borrowing, lifetimes), design patterns and architecture, and domain-specific constraints—ensuring that compiler errors, design questions, and comparisons are addressed with appropriate depth and context. It's designed for Rust developers at all levels who need help understanding error messages, implementing async patterns, making architectural decisions, or building domain-specific applications like web services or financial systems. The skill solves the problem of determining whether a Rust question requires foundational language clarification, higher-level design guidance, or domain expertise by tracing through these interconnected layers rather than jumping directly to answers.

m12-lifecycle

zhanghandong/rust-skills

600

895

The m12-lifecycle skill guides developers through designing resource lifecycles in Rust by answering when resources should be created, used, and cleaned up. It covers patterns like RAII, lazy initialization, connection pooling, and scope guards, tracing decisions from domain constraints down to implementation details using ownership and the Drop trait. This skill is for Rust developers designing systems that manage expensive resources like database connections, helping them choose appropriate patterns based on resource cost, scope, and error handling requirements.

rust-refactor-helper

zhanghandong/rust-skills

596

895

The rust-refactor-helper skill enables developers to safely refactor Rust code by leveraging Language Server Protocol (LSP) analysis to identify all affected locations before making changes. It supports multiple refactoring operations—including renaming symbols, extracting functions, inlining functions, and moving symbols across modules—with optional dry-run previews that show impact analysis, potential conflicts, and side effects like documentation updates or public API changes. This skill solves the problem of performing large-scale code transformations in Rust while minimizing the risk of introducing bugs or breaking dependent code.

m09-domain

zhanghandong/rust-skills

594

895

The m09-domain skill guides developers in applying Domain-Driven Design (DDD) principles to Rust code by helping them classify domain concepts as entities, value objects, aggregates, or repositories before implementation. It's designed for Rust developers building complex business domains who need to understand how to translate domain concepts into appropriate Rust ownership patterns and type structures. The skill solves the problem of misaligning code architecture with business logic by providing a decision framework that traces domain modeling choices upward to business constraints and downward to concrete Rust implementation patterns.

m11-ecosystem

zhanghandong/rust-skills

588

895

The m11-ecosystem skill helps developers select appropriate Rust crates and manage dependencies by providing decision matrices, evaluation criteria, and integration patterns for common use cases like serialization, async runtimes, HTTP frameworks, and language interoperability. It's designed for Rust developers and maintainers who need to make informed choices about adding external dependencies, assessing crate quality and maintenance status, and understanding how new crates integrate with existing code architecture. The skill solves the problem of decision paralysis when choosing between multiple crate options and ensures selections align with project constraints and team expertise.

m14-mental-model

zhanghandong/rust-skills

587

895

The m14-mental-model skill helps Rust learners build accurate conceptual frameworks for understanding ownership, borrowing, and other core Rust concepts by providing mental models, analogies, and diagrams that clarify how to think about language features. It targets developers transitioning from other languages (Java, Python, C++) who are confused about Rust's design choices and need to understand the "why" behind compiler errors. The skill directly addresses learning barriers by mapping misconceptions to correct mental models and showing how Rust's safety guarantees connect to language rules.

DeFi MCP

Connect your Claude agent to onchain data via 1inch: prices, trade routes and wallet activity.

defimcpcrypto

Install now

FAQ

Can Claude Code write good Rust code?

With Rust skills installed, Claude understands ownership rules, idiomatic patterns, and common crates. The skills significantly improve the quality of generated Rust code.

Related categories

Backend & APIs279 Debugging80 Testing & QA159