New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Bevy Reflection

by nolantait in nolantait/bevy-starter

Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes.

MITAuto-check passed

Install Bevy Reflection

skills CLI
$ npx skills add nolantait/bevy-starter --skill bevy-reflection -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install nolantait/bevy-starter bevy-reflection --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/nolantait/bevy-starter.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/bevy-reflection .claude/skills/bevy-reflection && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
bevy-reflection
GitHub stars
132
Token cost
~541 tokens
SKILL.md length
88 words
Files
1
Skills in repo
24
Repo updated
First seen
Licence
MIT

At a glance

Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes.

  • Works in 4 steps: Fork and derive → Convert to/from a reflectable type → Newtype wrapper → …
  • SKILL.md covers Basics, Registering types, Dynamic field access and Reflection subtraits, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Bevy Reflection is an agent skill from nolantait/bevy-starter. Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes.

Its SKILL.md is about 540 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: A minimalist starter for bevy and rust. The licence is MIT.

Example prompts

  • “/bevy-reflection”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Fork and derive
  2. Convert to/from a reflectable type
  3. Newtype wrapper
  4. Reflect Serialize/Deserialize via serde

What it can do on your machine

Read from SKILL.md and the folder at commit 821df7d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are rust).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Bevy Reflection loads about 541 tokens when it runs. Until then it costs about 35 tokens; SKILL.md has 88 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~35
When it runs · the whole SKILL.md, loaded when a task matches
~541

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from nolantait/bevy-starter at commit 821df7d, republished under its MIT licence (© nolantait). 88 words, ~541 tokens.

Download SKILL.mdSave it as .claude/skills/bevy-reflection/SKILL.md (or your agent's skills folder).
name
bevy-reflection
description
Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes.
metadata.crate
bevy_reflect
metadata.bevy
0.19

Basics

Derive Reflect to enable runtime introspection, dynamic field access, and serialization:

rust
#[derive(Reflect)]
struct Slider {
  #[reflect(@RangeInclusive::<f32>::new(0.0, 1.0))]
  value: f32,
}

Registering types

rust
app.register_type::<Slider>();

This adds the type to AppTypeRegistry (shared TypeRegistry).

Dynamic field access

rust
let mut slider = Slider { value: 0.5 };
*slider.get_field_mut("value").unwrap() = 2.0;
assert_eq!(*slider.get_field::<f32>("value").unwrap(), 2.0);

Reflection subtraits

Derive macro infers: Struct, TupleStruct, Enum, Tuple, List, Array, Map, Set. Opaque types can't be broken down further.

Foreign types that don't implement Reflect

Options:

  1. Fork and derive
  2. Convert to/from a reflectable type
  3. Newtype wrapper
  4. Reflect Serialize/Deserialize via serde:
rust
#[derive(Reflect, Serialize, Deserialize, Clone)]
#[reflect(opaque)]
#[reflect(Serialize, Deserialize)]
struct Trader { balance: Decimal }

Serialization (RON)

rust
fn serialize(type_registry: Res<AppTypeRegistry>) {
  let reg = type_registry.read();
  let serializer = ReflectSerializer::new(&slider, &reg);
  let ron = ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
}

Trait reflection

rust
#[reflect_trait]
trait DoThing { fn do_thing(&self) -> String; }

#[derive(Reflect)]
#[reflect(DoThing)]
struct MyType { value: String }

impl DoThing for MyType { fn do_thing(&self) -> String { format!("{} World!", self.value) } }

// Dynamic access:
let reflect_do_thing = type_registry.get_type_data::<ReflectDoThing>(reflect_value.type_id()).unwrap();
let my_trait: &dyn DoThing = reflect_do_thing.get(&*reflect_value).unwrap();

Scenes

Reflection powers scene serialization. Register types with register_type, then DynamicWorld::from_world(world).serialize(&type_registry) to produce RON.

© nolantait, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/bevy-reflection of nolantait/bevy-starter.

Open the folder on GitHubat commit 821df7d

Compare with similar skills

Bevy Reflection next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Bevy Reflection compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Bevy Reflection this skillnolantait/bevy-starter132—~541Automated safety check: PassMIT
Reflectalirezarezvani/claude-skills28k1 repos~2.4kAutomated safety check: PassMIT
Reflection Coachpaperclipai/paperclip99k—~3kAutomated safety check: PassMIT
Dynamic Workflow Modeaffaan-m/ECC275k1 repos~1.3kAutomated safety check: PassMIT
Molecular DynamicsK-Dense-AI/scientific-agent-skills48k1 repos~4.7kAutomated safety check: PassMIT
Longbridge Derivativessickn33/agentic-awesome-skills47k1 repos~1.1kAutomated safety check: PassMIT

Similar skills

  • Reflect

    alirezarezvani/claude-skills

    Mid-conversation reflection skill that pauses execution and zooms out from detail-mode to honestly reassess direction, assumptions, and bias.

    28k GitHub starsUsed in 1 repo~2.4k tokens
    Agent WorkflowsAuto-check passed

  • Reflection Coach

    paperclipai/paperclip

    Reflect on another agent's recent execution record and propose the smallest durable instruction, skill, or tool-description change.

    99k GitHub stars~3k tokensUpdated today
    Sales & SupportAuto-check passed

  • Dynamic Workflow Mode

    affaan-m/ECC

    Design task-local harnesses, eval gates, and reusable skill extraction for Claude dynamic workflow mode and other adaptive agent harnesses.

    275k GitHub starsUsed in 1 repo~1.3k tokens
    Auto-check passed

  • Molecular Dynamics

    K-Dense-AI/scientific-agent-skills

    Runs and analyzes molecular dynamics simulations with OpenMM and MDAnalysis.

    48k GitHub starsUsed in 1 repo~4.7k tokens
    Research & ScienceAuto-check passed

  • Longbridge Derivatives

    sickn33/agentic-awesome-skills

    Curated upstream guidance for Longbridge Derivatives; use when the workflow matches the user goal.

    47k GitHub starsUsed in 1 repo~1.1k tokens
    Business, Finance & HRAuto-check passed

  • Dynamic Workflow

    NousResearch/hermes-agent

    Plan-in-code fan-outs, adversarial verification, waves. An agent skill from NousResearch/hermes-agent.

    252k GitHub stars~2.8k tokensUpdated today
    Auto-check passed

More from nolantait/bevy-starter

All 24 skills in this repo

  • Bevy Events

    nolantait/bevy-starter

    Reference for events, messages, and observers in Bevy — Message/MessageReader/MessageWriter, Event/EntityEvent, triggers, observers, and propagation.

    132 GitHub stars~867 tokensUpdated 16 days ago
    Auto-check passed

  • Avian

    nolantait/bevy-starter

    Reference for Avian physics engine — rigid bodies, colliders, joints, spatial queries, collision events, character controllers, and debug rendering.

    132 GitHub stars~3k tokensUpdated 16 days ago
    Auto-check passed

  • Bevy Assets

    nolantait/bevy-starter

    Reference for loading, managing, and tracking assets in Bevy — AssetServer, handles, loading states, events, custom loaders, and hot reloading.

    132 GitHub stars~871 tokensUpdated 16 days ago
    Auto-check passed

  • Bevy Audio

    nolantait/bevy-starter

    Reference for playing and controlling audio in Bevy — AudioPlayer, AudioSink, spatial audio, volume, and playback settings.

    132 GitHub stars~713 tokensUpdated 16 days ago
    Auto-check passed

  • Bevy Bsn

    nolantait/bevy-starter

    Reference for Bevy Scene Notation (BSN) — the bsn!. An agent skill from nolantait/bevy-starter.

    132 GitHub stars~1.1k tokensUpdated 16 days ago
    Auto-check passed

  • Bevy Cameras

    nolantait/bevy-starter

    Reference for cameras in Bevy — Camera2d, Camera3d, viewports, projection, render layers, mouse-to-world, and free camera controllers.

    132 GitHub stars~976 tokensUpdated 16 days ago
    Auto-check passed

Questions about Bevy Reflection

What does Bevy Reflection do?

Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes. Bevy Reflection is an agent skill from nolantait/bevy-starter. Reference for Bevy's reflection system — Reflect derive, dynamic field access, serialization, trait reflection, and scenes.

How do I install Bevy Reflection in Claude Code?

Run `npx skills add nolantait/bevy-starter --skill bevy-reflection -a claude-code`. Or copy the skill folder (.agents/skills/bevy-reflection in nolantait/bevy-starter) into .claude/skills/bevy-reflection in your project. Claude Code loads it when a task matches its description.

How do I install Bevy Reflection in Codex?

Run `npx skills add nolantait/bevy-starter --skill bevy-reflection -a codex`. Or copy the skill folder (.agents/skills/bevy-reflection in nolantait/bevy-starter) into .agents/skills/bevy-reflection in your project. Codex loads it when a task matches its description.

Can I use Bevy Reflection in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add nolantait/bevy-starter --skill bevy-reflection -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/bevy-reflection, .gemini/skills/bevy-reflection, .github/skills/bevy-reflection and .opencode/skills/bevy-reflection in your project.

What does Bevy Reflection need to run?

SKILL.md names no scripts, command-line tools or credentials: Bevy Reflection is instructions for the agent only.

Does Bevy Reflection access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Bevy Reflection safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Bevy Reflection use?

Bevy Reflection is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Bevy Reflection use?

About 541 tokens (SKILL.md is roughly 2.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Bevy Reflection?

Skills that share tags, products or a category with Bevy Reflection: Reflect (alirezarezvani/claude-skills, 28k stars), Reflection Coach (paperclipai/paperclip, 99k stars), Dynamic Workflow Mode (affaan-m/ECC, 275k stars) and Molecular Dynamics (K-Dense-AI/scientific-agent-skills, 48k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Bevy Reflection?

nolantait (a GitHub user) maintains it in nolantait/bevy-starter, which has 132 GitHub stars. The repository holds 24 skills in this directory. The repository was last updated on September 22, 2026.

Source: nolantait/bevy-starter on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.