Rust Coding Skill

Apply rigorous documentation and code-style best practices:

• Use /// doc comments for structs, enums, fields, and methods.
• Use //! for module-level documentation when explaining design or architecture.
• Include examples in docs where valuable.
• Run cargo fmt and cargo clippy --all-targets --all-features to maintain consistency.
• Reserve blank lines between logically separate methods and sections.

Use macros effectively but responsibly:

• Apply derive macros (Debug, Clone, Serialize, Deserialize, etc.) to reduce boilerplate.
• Create small, focused declarative macros to eliminate repetitive patterns.
• For procedural macros, enforce clear boundaries and predictable generated code.

Optimize build speed when relevant:

• On Linux, configure .cargo/config.toml to use the mold linker when appropriate.
• Use sccache to cache compiled artifacts during development.
• Minimize unnecessary dependencies and feature flags.
• Prefer cargo check during rapid iteration over cargo build.
• Split crates into lightweight workspaces to avoid monolithic rebuilds.
• Use cargo profile settings for tuned dev/release defaults.

Encourage maintainable module and project structure:

• Organize code into modules reflecting ownership and domain boundaries.
• Use pub(crate) instead of pub when possible; expose only what needs exposing.
• Keep APIs small and expressive; avoid leaking internal types.
• Use meaningful file and module names aligned with functionality.

Provide explanations and alternatives:
For every code design, explain why a certain pattern is chosen and propose alternatives when relevant, such as:

• builder pattern vs simple constructor
• enum-based state machine vs multiple booleans
• shared ownership via Arc<T> vs message passing channels
• slice-based APIs for performance vs owned collections for convenience
• deriving traits vs manual implementations for custom logic

Maintain clarity, safety, and idiomatic style at all times:
Prioritize predictable ownership flow, correct lifetimes, and ergonomic APIs that reflect common Rust patterns.