Our review

This skill specializes the agent in Rust development for async services, safe systems programming, and production tooling, using Tokio, Axum, SQLx, and Clippy-driven quality checks.

Strengths

Enforces clippy and rustfmt as non-optional quality gates.
Supports modern frameworks like Tokio, Axum, and SQLx.
Pragmatic approach to error types and concurrency primitives.

Limitations

Assumes prior familiarity with Rust and its core concepts (ownership, lifetimes).
Does not automatically handle complex environment setup (CI/CD, deployment).
Architectural decisions are left to the developer.

When to use it

Use this skill when writing or refactoring Rust code in projects involving async services, systems components, or CLI tools.

When not to use it

Avoid this skill if you are new to Rust or if your project does not require Rust code (consider a more general skill).

Examples

Build async HTTP server with Axum

Create a new Rust project using Axum that exposes a GET /hello endpoint returning a JSON response. Include error handling with custom error types, proper async main with Tokio, and add a few unit tests. Ensure clippy passes with -D warnings.

Refactor Rust module for safety

Refactor the Rust module in src/unsafe_ops.rs to minimize unsafe code. Isolate any remaining unsafe blocks with documentation, replace raw pointers with safe abstractions where possible, and verify no panics in non-test code. Run cargo fmt and clippy after changes.

Integrate SQLx with existing service

Add a SQLx database layer to the existing Rust service in src/main.rs. Connect to a PostgreSQL database, define a query function for fetching users by ID, and wrap it in a Result type. Add integration tests and ensure all clippy warnings are addressed.

name: moai-lang-rust description: Rust specialist for async services, safe systems programming, and production tooling with Tokio, Axum, SQLx, and clippy-driven quality checks. Use when building or refactoring Rust code. license: Apache-2.0 compatibility: Designed for Claude Code allowed-tools: Read, Grep, Glob, Bash user-invocable: false metadata: version: "2.0.0" category: "language" status: "active" updated: "2026-02-22"

Rust Development (Lean)

When to use

.rs files and Cargo.toml
Async services, CLI tools, systems components
Ownership/lifetime, trait, or performance-sensitive work

Defaults

Prefer explicit error types at library boundaries.
Keep unsafe usage isolated and documented.
Use clippy and rustfmt as non-optional quality gates.
Favor simple ownership flows over complex lifetimes when possible.

Quick workflow

Identify crate boundaries and public APIs.
Implement minimal change with clear types/errors.
Add/update tests for changed behavior.
Run fmt, clippy, and tests.

Commands

Format: cargo fmt --all
Lint: cargo clippy --all-targets --all-features -- -D warnings
Test: cargo test --all-features
Build release: cargo build --release

Implementation checklist

Result<T, E> and ? used consistently.
Avoid panics in non-test code paths unless explicitly fatal.
Serialization contracts versioned when exposed externally.
Concurrency primitives chosen deliberately (Mutex, RwLock, channels, semaphore).

Validation checklist

cargo fmt clean.
cargo clippy clean.
Tests pass.
New dependencies justified.

References

references/reference.md - compact guidance and docs links
references/examples.md - concise service/test patterns
../AGENT_SKILL_SPEC.md - shared Anthropic/Copilot alignment

Rust Specialist

Recommended for