Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    RUST Engineering

    1

    Build and refactor idiomatic Rust crates with a focus on ownership, safety, and performance.

    $5

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    Security scanned
    RUST Engineering

    RUST Engineering

    Example session with this skill installed

    I have a library that clones too much data. Can you refactor this struct and its methods to use references and lifetimes instead, while keeping it idiomatic?

    • Read your context and instructions
    • Compiled the rust engineering

    I have analyzed your struct and methods. The primary issue was excessive String and Vec cloning during read-only operations. I have refactored the implementation to use borrowed types with explicit lifetimes, ensuring the code remains idiomatic and safe.

    Refactored Rust Library

    use std::fmt;

/// ProcessedData now uses a lifetime 'a to hold references
/// to the source buffer instead of cloning the data.
pub struct ProcessedData<'a> {
    pub id: u64,
    pub tag: &'a str,
    pub payload: &'a [u8],
}

impl<'a> ProcessedData<'a> {
    /// Creates a new view into the source data.
    /// This avoids heap allocations by borrowing from the input.
    pub fn new(id: u64, tag: &'a str, payload: &'a [u8]) -> Self {
        Self { id, tag, payload }
    }

    /// Returns a summary without allocating a new String.
    pub fn display_summary(&self) -> impl fmt::Display + '_ {
        struct Summary<'b>(&'b ProcessedData<'b>);
        impl<'b> fmt::Display for Summary<'b> {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "ID: {} | Tag: {}", self.0.id, self.0.tag)
            }
        }
        Summary(self)
    }
}

pub fn process_batch<'a>(raw_tags: &'a [String], raw_payloads: &'a [Vec<u8>]) -> Vec<ProcessedData<'a>> {
    raw_tags.iter()
        .zip(raw_payloads.iter())
        .enumerate()
        .map(|(i, (tag, payload))| {
            ProcessedData::new(i as u64, tag.as_str(), payload.as_slice())
        })
        .collect()
}

    Next steps

    1. Run cargo test to ensure the lifetime bounds correctly propagate through your calling code.
    2. Check for any T: 'static bounds in your upstream services that might conflict with these borrowed types.
    3. Review the display_summary implementation if you need to pass the result across thread boundaries.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Wrestling with the borrow checker or debugging cryptic async deadlocks slows down production cycles. This skill provides a systematic approach to building and refactoring Rust systems, ensuring idiomatic code that balances performance with memory safety.

    What it does

    • Architectural planning helps define crate structures for binaries, libraries, and workspaces.
    • Idiomatic refactoring reduces unnecessary cloning and simplifies complex lifetime-heavy APIs.
    • Safety enforcement audits code for hidden unwrap calls and isolates unsafe blocks.
    • Performance tuning identifies allocation bottlenecks and contention in async runtimes.
    • Error modeling designs Result-based flows that encode domain invariants into the type system.

    How it works

    1. Analyze environment by inspecting the Rust edition, feature flags, and dependency graph.
    2. Review ownership to identify where borrowing patterns can be simplified to satisfy the compiler.
    3. Execute changes using small, composable modules and explicit traits.
    4. Verify output through strict linting, formatting, and unit testing via cargo.

    Frameworks & tools

    Works with standard Rust toolchains, cargo, and common async runtimes like Tokio or smol. It follows conventions for CLI tools, system services, and library development.

    Why this beats prompting it yourself

    Generic prompts often struggle with specific Rust nuances like interior mutability or Send/Sync bounds. This skill applies a "safety-first" hierarchy that prioritizes idiomatic ownership over low-level hacks, preventing technical debt before it is compiled.

    Use cases

    • Refactor a complex service to use better async state management.
    • Debug memory leaks or performance degradation in systems code.
    • Convert a prototype into a production-ready library with clean traits.
    • Implement robust error handling across a multi-crate workspace.

    Known limitations

    Does not perform automated benchmarking or low-level assembly tuning. Requires an existing Rust environment to run validation commands.

    How to use

    Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean today

    • Passed all security checks, Safe to install

    Listedtoday

    What's inside

    Frequently Asked Questions