huiali/rust-skills
Overview
This skill provides a compact, searchable index of Rust engineering skills and capabilities for fast navigation and targeted queries. It maps 38 modular skills across core, advanced, and expert levels, plus newly added testing, database, and observability topics. Use it as a single entry point to find the right Rust expertise for diagnosis, design, or optimization tasks.
How this skill works
The index organizes skills by category, difficulty, and domain so you can quickly locate the best skill for a given problem. It links each topic to its detailed skill entry and recommends which skill to consult for common error classes and scenarios. Trigger words like "skill", "index", "目录", and others surface relevant entries for interactive workflows or automation chains.
When to use it
- You need a fast pointer to the right Rust skill for a specific bug or design question.
- Planning a learning path or onboarding developers to Rust best practices.
- Triage which specialist skill to call for complex issues (FFI, eBPF, GPU, embedded).
- Mapping problems to remediation steps during incident response or code review.
- As an orchestration layer to route tasks to modular reasoning units in automation flows.
Best practices
- Start from the quick-check table to pick core skills for common problems before escalating.
- Follow difficulty and domain classifications to match expertise level with task complexity.
- Use the problem-to-skill mapping for rapid triage (ownership, async, performance, etc.).
- Combine adjacent skills (e.g., async + middleware + web) for cross-cutting issues.
- Keep the index updated with new skills and map additions like testing, database, and observability.
Example use cases
- Resolve a borrow checker or lifetime error by consulting the ownership skill mapping.
- Design an async web handler by combining rust-async, rust-web, and rust-middleware entries.
- Plan performance improvements by linking rust-performance with rust-embedded or rust-gpu where applicable.
- Triage a CI test failure by routing to rust-testing and rust-coding guidance.
- Integrate a native library safely by following rust-ffi and rust-unsafe checklists.
FAQ
Use the problem-to-skill quick-check mapping: match your error type (ownership, Send/Sync, async, etc.) to the recommended skill listed in the index.
Can I extend the index with new skills?
Yes. Add a concise skill entry, assign category and difficulty, and map likely problem types so automation and users can discover it through the same lookup rules.
18 skills
This skill provides a fast entry point to navigate and query Rust skills, enabling quick access to core, advanced, and expert entries.
This skill helps design and optimize Rust actor systems for reliable message passing, isolation, and fault tolerance using supervision patterns.
This skill helps you optimize Rust performance by guiding profiling, memory layout, and NUMA-aware strategies to reduce hot-path costs.
This skill helps Rust engineers leverage const generics, const fn, and compile-time validation to optimize performance and safety.
This skill helps you design, analyze, and optimize Rust eBPF workflows, from maps and tail calls to kprobes, improving kernel tracing and performance.
This skill helps optimize GPU memory management and CUDA/OpenCL workflows in Rust engineering, enabling efficient data transfer, memory access, and kernel
This skill helps engineers write safer, higher-performance unsafe Rust code by enforcing SAFETY comments, validating patterns, and guiding FFI and pointer use.
This skill helps engineers harness Rust macros and proc-macros to reduce boilerplate, improve compile-time checks, and generate robust, reusable code patterns.
This skill helps you diagnose and optimize Rust code by guiding ownership, lifetimes, concurrency, and async patterns with practical examples.
This skill helps Rust engineers diagnose, design, and optimize concurrent and async code, ensuring thread safety, deadlock prevention, and efficient runtime
This skill explains and optimizes Rust smart pointers and resource management with practical examples for Box, Rc, Arc, RefCell, and Drop.
This skill helps you implement safe Rust FFI with C/C++ bindings, generate bindings, and design robust interop patterns.
This skill helps you design and implement Rust web services with axum, actix, and domain-driven patterns for scalable APIs.
This skill helps you enforce Rust coding conventions and idiomatic patterns with naming, spacing, clippy, rustfmt, and documentation practices.
This skill analyzes and applies linear type principles to Rust ownership, ensuring resource safety, unique ownership, and deterministic destruction.
This skill helps you implement and optimize advanced Rust async patterns, including streams, backpressure, cancellation, and join operations, across real-world
This skill analyzes Rust ownership patterns, diagnoses common errors, and guides safe borrowing, lifetimes, and memory management to prevent compile-time
This skill analyzes Rust interior mutability patterns and guides safe, efficient use of Cell, RefCell, Mutex, and RwLock across single- and multi-threaded
