- Home
- Skills
- Game Development
- bevy-style: Bevy 0.20 Coding Standard
More screenshots
Works with the AI Agents you already use
bevy-style: Bevy 0.20 Coding Standard
A coding standard for Bevy 0.20 games and plugins, written as a delta on top of rust-style.
Free
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
| Severity | Rule | Location | Finding | Fix |
|---|---|---|---|---|
| Stale | BV-ECS-20 | lamps.rs:2 | iter_many yields a Result per id in 0.20, so .count() counts every child, lit or not. This is the wrong total | lit.iter_many(c).matched().count() |
| Design | BV-ECS-24 | lamps.rs:2 | total.0 = … writes every frame, so Changed<LitLamps> fires even when the count is the same | total.set_if_neq(LitLamps(now)) |
| Stale | BV-ECS-11 | lamps.rs:6 | remove_children no longer compiles | detach_children |
| Stale | BV-MIG-02 | lamps.rs:7 | On<Pointer<Click>> and pointer_location are gone | On<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.tomlfor a game (exact Bevy pin, feature collection, the lint table with its two Bevy relaxations) and a GitHub Actionsci.yml. It reusesrust-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.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
Free to use
No account required to browse
Trust & safety
Security scan
Security scan passed 2 days ago
- Free with an Agensi account
- Software
- rust-style skill
- Optional
- Rust 1.99 toolchainripgrep (rg)
Install rust-style too: this skill covers only what changes once Bevy is in the project.
Permissions
File Scopes
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.