More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    rust-style: Rust 1.99 Coding Standard

    1

    A coding standard that holds your agent to the bar of a Rust crate maintainer, not just "compiles and passes clippy".

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    rust-style: Rust 1.99 Coding Standard

    rust-style: Rust 1.99 Coding Standard

    Example session with this skill installed

    Can you review src/config.rs before I merge?

    use lazy_static::lazy_static;
    
    lazy_static! {
        static ref DEFAULTS: Config = Config::load_defaults();
    }
    
    pub fn load(path: &str, verbose: bool) -> Config {
        let text = std::fs::read_to_string(path).unwrap();
        let mut cfg = DEFAULTS.clone();
        cfg.merge(toml::from_str(&text).unwrap());
        if verbose { eprintln!("loaded {path}"); }
        cfg
    }
    
    • Read your context and instructions
    • Compiled the rust-style

    Findings

    SeverityRuleLocationFindingFix
    StaleRS-CONC-27src/config.rs:3lazy_static! for a lazily initialised globalstatic DEFAULTS: LazyLock<Config> = LazyLock::new(Config::load_defaults); and drop the lazy_static dependency
    IncorrectRS-ERR-03src/config.rs:8unwrap() on reading a user-supplied pathReturn Result<Config, ConfigError>; propagate with ? and attach the path as context
    IncorrectRS-ERR-03src/config.rs:10unwrap() on parsing user-written TOMLSame error type, with a Parse variant that keeps the toml error as its source()
    DesignRS-API-24src/config.rs:7verbose: bool parameter: the call site reads load(p, true)Move the logging to the caller, or name the flag with a two-variant enum

    Discussion

    The two unwraps are the merge blockers. load runs on input the user controls, so a missing file or a typo in the TOML crashes the program instead of printing a message. Once load returns a Result, verbose probably stops being needed: the caller can log success itself, and the function no longer writes to stderr from library code.

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

    About this skill

    A coding standard that holds your agent to the bar of a Rust crate maintainer, not just "compiles and passes clippy".

    It is built on three sources: the Rust API Guidelines (public surface, naming, trait impls), the conventions of ripgrep and the BurntSushi crates (crate architecture, disciplined performance, CLI shape) and a functional-first default for function bodies. Where they disagree, it picks a side and says why.

    It targets Rust 1.99 stable, edition 2024, and starts with a reality check of what changed: -> impl Trait now captures every lifetime in scope, if let temporaries drop before else, env::set_var is unsafe, and LazyLock, cfg_select!, assert_matches! and async fn in traits replace the crates people still reach for.

    What's inside

    • 593 rules across 19 chapters: naming, API design, errors, functional style, ownership, traits and generics, modules and workspaces, build and supply chain, testing, documentation, performance, concurrency and async, unsafe and FFI, CLI applications, data modelling, types, output and logging, migration, and macros.
    • A migration table of every spelling edition 2024 and the releases through 1.99 left behind, with an rg command that finds them in your code.
    • Bundled assets: a workspace Cargo.toml with the full [workspace.lints] table, clippy.toml, rustfmt.toml, rust-toolchain.toml, and a GitHub Actions ci.yml (clippy with deny-warnings, per-feature builds, three platforms, MSRV, beta, rustdoc, audit, semver checks).
    • Also in a bundle: the Systems Languages Pack sells rust-style and zig-style together for less than the two separately.

    How it works

    • Section 2 — reality check. A table of every spelling the target release changed: what still compiles but now behaves differently, what no longer compiles, and what was gained. Your agent reads it before writing a single line, because most code on the public internet (and most of what a model has read) is stale.
    • Section 4 — core rules. The rules that bind on their own and reach nearly every file.
    • One chapter at a time. Each topic chapter opens with a table of contents of the rules it owns. The agent loads only the chapter the task needs, so the standard costs context in proportion to the task, not its size.
    • Tiered rules. [M] mandatory, [M!] mandatory in library and high-reliability code (each states a relaxed form for scripts and prototypes), [S] default that needs a one-line justification to break.
    • Every rule has a Why and a Check. The Check is something concrete to grep for or look at, so a review is reproducible rather than taste.
    • Labelled examples. Each code block says whether it was verified against the target toolchain, is a fragment, or is shown because a tool rejects it.
    • Review protocol. A seven-level severity model (Unsound, Stale, Incorrect, Contract, Design, Performance, Style), a fixed review order, a mechanical grep pass, and an output table of severity, rule ID, location, finding and fix. Includes the order in which to refactor an existing codebase.

    Where it stops

    • It is a standard your agent follows, not a linter or formatter. It tells the agent which tools to run and how to configure them, but it runs nothing on its own.
    • It targets one release. Older releases appear only in the migration chapter, as spellings to move away from.
    • Rust 1.99 and edition 2024 only.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Targets Rust 1.99 stable and edition 2024 only. rustfmt.toml uses two nightly-only options, so it is formatted with cargo +nightly fmt. It is a standard the agent follows, not a linter, and does not run tools on its own.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    Nothing to install. It runs in your AI agent.

    Optional
    Rust 1.99 toolchainripgrep (rg)

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    File Scopes

    **/*.rs
    **/Cargo.toml
    clippy.toml
    rustfmt.toml
    rust-toolchain.toml
    .github/workflows/*.yml

    Instructions and reference text only: no scripts, no network access, no credentials. Read and write cover the code you ask it to write, review or refactor. The shell is optional, for running cargo, clippy, tests and the rg checks the rules name. Bundled config templates are copied into a project only when you ask.

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    Rust 1.99 stable with edition 2024. Section 2 lists what changed, and the migration chapter covers everything edition 2024 and the releases through 1.99 left behind.

    The agent reads SKILL.md (core rules, reality check, review checklist), then loads only the chapter the task needs. Chapters are never loaded all at once.

    `[M!]` rules bind only in library and high-reliability code. Elsewhere each one gives a relaxed form the agent may use instead.

    Yes. bevy-style is a delta on top of rust-style and expects both to be installed.

    New in Code Quality & Review