More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    bevy-style: Bevy 0.20 Coding Standard

    1

    A coding standard for Bevy 0.20 games and plugins, written as a delta on top of rust-style.

    Free

    Security scanned
    bevy-style: Bevy 0.20 Coding Standard

    bevy-style: Bevy 0.20 Coding Standard

    Example session with this skill installed

    We just bumped to Bevy 0.20 and it builds, but the lamp counter is wrong. Can you review this?

    fn count_lit(posts: Query<&Children>, lit: Query<(), With<Lit>>, mut total: ResMut<LitLamps>) {
        total.0 = posts.iter().map(|c| lit.iter_many(c).count()).sum();
    }
    
    fn setup(mut commands: Commands, post: Single<Entity, With<Post>>, old: Res<OldLamp>) {
        commands.entity(*post).remove_children(&[old.0]);
        commands.add_observer(|ev: On<Pointer<Click>>| info!("{:?}", ev.pointer_location));
    }
    
    • Read your context and instructions
    • Compiled the bevy-style

    Findings

    SeverityRuleLocationFindingFix
    StaleBV-ECS-20lamps.rs:2iter_many yields a Result per id in 0.20, so .count() counts every child, lit or not. This is the wrong totallit.iter_many(c).matched().count()
    DesignBV-ECS-24lamps.rs:2total.0 = … writes every frame, so Changed<LitLamps> fires even when the count is the sametotal.set_if_neq(LitLamps(now))
    StaleBV-ECS-11lamps.rs:6remove_children no longer compilesdetach_children
    StaleBV-MIG-02lamps.rs:7On<Pointer<Click>> and pointer_location are goneOn<PointerClick>, reading ev.pointer.position

    Discussion

    The first row explains your bug. 0.20 changed iter_many to yield a Result per id, so code written for 0.19 still compiles but now counts unmatched children too. Every other iter_many in the project needs the same check: each one should go through .matched() or handle the Result explicitly. The rg command after the migration table in references/migration.md finds the remaining 0.19 spellings.

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

    About this skill

    A coding standard for Bevy 0.20 games and plugins, written as a delta on top of rust-style.

    Everything that standard says about naming, errors, ownership, functional style, modules, documentation and Cargo still holds. This one states only what changes once Bevy is in the dependency list, and section 3 lists every place the two depart.

    It targets Bevy 0.20 on Rust 1.99, edition 2024. Bevy's API turns over faster than any other dependency a game has, and most Bevy code online, and most of what a language model has read, is 0.15 or older. The reality check catches the changes that still compile: iter_many now yields a Result per id, so a bare .count() counts entities the query does not match; TextFont::default sizes text in rem; Camera2d brings a different tonemapping. It also maps renames such as Pointer<Click> to PointerClick, remove_children to detach_children, and GLSL to WESL.

    What's inside

    • 173 rules across 11 chapters: architecture and plugins, ECS (components, queries, change detection, relationships, reflection), scheduling and the fixed timestep, messages/events/observers, resources and states, fallible systems and error handlers, assets, build and features, UI/cameras/materials/shaders, headless testing, and migration.
    • A game is treated as high-reliability code: a panic takes down the player's process, a server parses what clients send, and saves are data nobody can reconstruct. Jam prototypes and example scenes get each [M!] rule's relaxed form.
    • Bundled assets: a workspace Cargo.toml for a game (exact Bevy pin, feature collection, the lint table with its two Bevy relaxations) and a GitHub Actions ci.yml. It reuses rust-style's clippy, rustfmt and toolchain files unchanged.

    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.
    • Bevy 0.20 only. Engine rendering internals (render graph, pipeline specialisation) are out of scope.
    • Install rust-style as well. For anything that is a Rust question rather than a Bevy question, this skill defers to it.

    Targets Bevy 0.20 only. Requires rust-style for everything that is not Bevy-specific. Engine rendering internals (render graph, pipeline specialisation, reflection internals) are out of scope. 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 any payment.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    • Free with an Agensi account

    Requires

    rust-style skill

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    File Scopes

    **/*.rs
    **/*.wesl
    **/Cargo.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

    Yes. bevy-style only states what changes once Bevy is in the dependency list, and defers to rust-style for everything else, including its tiers and three of its config files.

    Bevy 0.20 on Rust 1.99, edition 2024. The migration chapter covers every spelling 0.15 through 0.20 left behind.

    Jam prototypes, example scenes and throwaway tools take each `[M!]` rule's relaxed form. Shipped games and plugin crates get the strict form.

    It covers cameras, materials, WESL shaders, post-processing, UI and gizmos as a game uses them. The render graph and pipeline specialisation are out of scope.

    New in Game Development