# Build Efficient Bevy ECS Systems

Bevy ECS design can create borrowing conflicts, slow queries, and unclear scheduling. This skill provides practical Rust patterns for components, systems, resources, filters, and ordering.

## Install

```bash
npx skillstore add sickn33/bevy-ecs-expert
```

## Metadata

- Status: approved
- Slug: sickn33-bevy-ecs-expert
- Skillstore revision: r2
- Version status: missing
- Tree hash: 97d235ea357c61af61e11d765b14f39badf30ba8bc2fa0792900b376edec05bc
- Author: sickn33
- GitHub username: sickn33
- License: MIT
- Repository: https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/bevy-ecs-expert
- Ref: 5a26d1d61d694db29af9b138c661c1981076d9df
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: scripts, external\_commands
- Quality score: 77
- Quality tier: bronze
- Public page: https://skillstore.pages.dev/skills/sickn33-bevy-ecs-expert
- Manifest: https://skillstore.pages.dev/api/skills/sickn33-bevy-ecs-expert/manifest

## Capabilities

- Defines data-oriented Bevy components with Component and Reflect derives.
- Creates systems that query and update component data.
- Models shared game state with Resource, Res, and ResMut.
- Orders systems with schedules and chained execution.
- Uses query filters to reduce unnecessary entity iteration.
- Demonstrates entity spawning with required components and assets.

## Use Cases

- Structure a New Bevy Game: Plan components, resources, systems, and schedules before implementing gameplay.
- Resolve ECS Access Conflicts: Review mutable access patterns and establish explicit system ordering.
- Optimize Entity Queries: Apply filters and narrower access patterns to reduce work and improve parallel execution.

## Prompt Templates

### Create a Component

```
Create a Bevy component for [game concept]. Keep it data-oriented and explain each derive.
```

### Write a System

```
Write a Bevy system that updates [component] using [resource]. Use the narrowest query and resource access possible.
```

### Fix a Query Conflict

```
Review these Bevy systems for conflicting access: [systems]. Propose query filters, ParamSet, or scheduling changes and explain the tradeoffs.
```

### Design an ECS Architecture

```
Design the Bevy ECS architecture for [feature]. Define components, resources, events, systems, filters, schedules, ordering constraints, and performance risks.
```

## Limitations

- The examples may require changes for the Bevy version in your project.
- The skill does not run, compile, benchmark, or test generated Rust code.
- It covers core ECS patterns, not rendering, networking, physics, or deployment.
- Project-specific architecture still requires profiling and validation.

## Best Practices

- Keep components focused on data and place behavior in systems.
- Prefer immutable resource access when mutation is unnecessary.
- Profile representative workloads before changing ECS architecture.

## Anti Patterns

- Do not store unrelated global state in one large resource.
- Do not use broad mutable queries when filters can separate entity sets.
- Do not force system ordering unless data dependencies require it.

## Security Audit

- Audited at: 2026-08-14T10:24:46.351\+00:00
- Summary: All 22 static findings are false positives caused by Rust syntax, Bevy ECS APIs, or Markdown backticks. The guide contains no executable scripts, shell commands, process launches, or prompt injection.

## Stats

- Views: 93
- Downloads: 12
- Favorites: 0
- Popularity score: 0