How to use the Rust Patterns agent skill: setup and examples

What does the rust-patterns skill make the agent do?

The skill reinforces Rust conventions in six areas: ownership and borrowing, error propagation with Result and the ? operator, enums with exhaustive pattern matching, traits and generics, safe concurrency, and small public APIs organised by domain.

In practice it nudges the agent to borrow instead of cloning, to avoid unwrap() in production code, to use thiserror for libraries and anyhow for applications, and to model states with enums so that invalid states cannot be represented. The guidance is written in Spanish and includes Rust code examples marked as good or bad.

• Pass references when ownership is not needed, and take ownership only when storing or consuming data.
• Use Result and ? with context instead of unwrap().
• Use thiserror for library error types and anyhow for application errors.
• Prefer enums and exhaustive matches over catch-all wildcards in business logic.
• Accept generics as input and return concrete types where possible.
• Use Arc<Mutex<T>> for shared mutable state, plus channels and async/await.

How do you install the rust-patterns skill?

Download the skill ZIP from this page and unzip it. The skill is a single file, SKILL.md. Then choose one of the options below depending on where you want it available.

For Claude Code, place the unzipped skill folder in your personal skills directory ~/.claude/skills/ to make it available across projects, or in a project's .claude/skills/ folder to share it with one codebase.

In the Claude apps, you can upload the skill instead under Settings → Capabilities → Skills.

• Personal (all projects): ~/.claude/skills/
• Single project: .claude/skills/ inside the project folder
• Claude apps: Settings → Capabilities → Skills

How do you trigger the skill with natural requests?

You do not need a special command. The agent decides to use a skill when your request matches its description, which for this skill covers Rust patterns, ownership, error handling, traits, concurrency and best practices. Mention Rust and the task you want done, and the skill is a good candidate to load.

The skill's own list of when to use it covers writing new Rust code, reviewing Rust code, refactoring existing Rust code, and designing crate structure and module organisation. If the agent does not seem to apply the conventions, state the Rust context explicitly in your request.

• Write a function in Rust that reads a config file and returns a typed error.
• Review this Rust module for unwrap() calls and unnecessary clones.
• Refactor this Rust enum-based state machine so invalid states cannot be represented.
• Should this library use thiserror or anyhow? Look at my Cargo crate layout.

What does the skill change in real examples?

The skill's examples show the difference between a conventional and a non-idiomatic version of the same code. For instance, it contrasts a function that clones a Vec<u8> just to read its length with one that borrows a slice, and a loader that calls unwrap() with one that uses with_context and ? to explain failures.

Another example replaces a match with a wildcard arm that silently ignores future enum variants with a match that lists each variant. Expect the agent to explain these trade-offs rather than only rewriting the code.

What do you need before using it?

The source lists no required tools, packages or accounts for this skill. The skill runs no scripts and makes no network calls; it is a Markdown instruction file. It only applies to Rust code, so you still need a Rust project to point the agent at.

The skill's examples use crates such as anyhow and thiserror, and the agent may suggest adding them to your project. Check your Cargo configuration before accepting those suggestions.

• Requires: nothing listed in the skill metadata
• Runs scripts: no
• Uses network: no
• Files: SKILL.md

What are the safety notes?

Because the skill runs no scripts and uses no network access, it has no direct effect on your system beyond the instructions it gives the agent. Its influence comes from the guidance: the agent will still write code in your project, so review its changes as you would any pull request.

The skill is a short checklist and does not cover every edge case. Treat its suggestions as conventions to check against your own requirements, not as a guarantee of correct or safe code.

Tips for getting better results

Give the agent the code and the context: whether the crate is a library or an application determines whether thiserror or anyhow fits. Ask for the reasoning behind a change so you can learn the convention, not just accept it.

Use the skill for review passes as well as writing. A prompt such as reviewing a module for unwrap() calls, needless clones or wildcard match arms gives a focused checklist-style result.

• State whether the code is a library or an application.
• Ask for the reason behind each suggested change.
• Combine the skill with your own tests and cargo checks rather than relying on it alone.