roblox

Engine API Reference (always the source of truth for classes/properties): https://create.roblox.com/docs/reference/engine

Full documentation indexes for agents:

This hub skill gives the big picture and routes to specialist

SKILL.md

entry points. Each specialist owns its deep

references/

index so agents load only the material needed.

Specialist skills

Choose the skill matching the task. Each specialist links to its own detailed references.

roblox-core: Choose services, types, serialization, and script locations
roblox-networking: Design remotes, validate client requests, and control replication
roblox-datastores: Save player data, handle concurrent writes, and recover versions
roblox-user-interfaces: Build responsive GUIs, handle input, and add UI effects
roblox-animation: Animate rigs, configure IK, tween properties, and time marker events
roblox-vfx: Build particles, flipbooks, beams, trails, and highlights
roblox-audio: Build audio graphs, mix effects, and migrate legacy Sound code
roblox-gamepasses: Handle passes, products, subscriptions, transfers, and purchase policy
roblox-open-cloud: Automate Roblox resources through REST APIs or supported HttpService calls
roblox-teleport: Move players between places, coordinate matchmaking, and hand off data
roblox-rojo: Set up filesystem projects, sync with Studio, build, and export places
roblox-mcp: Connect agents to Studio, inspect instances, edit scripts, and playtest
roblox-physics: Build mechanisms, choose constraints, and assign physics ownership
roblox-npcs: Navigate NPCs, handle blocked paths, and build patrol or chase behavior
roblox-testing: Reproduce bugs, write tests, and profile performance

Server authority first. Validate or simulate on the server. Client is for input, prediction, and cosmetics.
Everything that talks to the cloud is fallible. Wrap DataStore, Marketplace, Http, etc. calls in pcall. Have a plan for transient vs permanent errors.
Preload assets. ContentProvider:PreloadAsync for animations, images, sounds, models.
Use modern APIs. Animator + LoadAnimation, task.* scheduler, TweenService, IKControl, CollectionService tags, Attributes, etc. Avoid deprecated BodyMovers, wait/spawn/delay, Humanoid:LoadAnimation, etc.
Respect limits. DataStore budgets scale with concurrent users but are still finite. Particles and transparent UI are fill-rate expensive. Profile early.
Structure for maintainability. ServerScriptService for authority, ReplicatedStorage for shared modules, StarterGui for client UI roots, clear module boundaries, consistent naming.
Test the hard parts. Studio with API access only on test places. Multiple device classes. Low graphics quality for effects/UI. Concurrency (multiple servers touching the same keys).

Deferred events: Set
```
Workspace.SignalBehavior = Enum.SignalBehavior.Deferred
```
(or use the corresponding project setting) so events queue and flush, avoiding re-entrancy issues.
Chat: Use
```
TextChatService
```
for modern chat; the legacy
```
Chat
```
service still exists but is the older API.
MemoryStore: Use
```
MemoryStoreService
```
for cross-server, short-lived, or high-throughput data, not regular DataStores.
Parallel Luau: Use
```
Actor
```
instances and
```
task.synchronize()
```
/
```
task.desynchronize()
```
for compute-heavy work, with careful shared-state rules.
buffer type: Use the
```
buffer
```
Luau type for compact binary data, serialization, and bit/byte manipulation.
UI safe zones: Use
```
ScreenGui.ScreenInsets
```
and related properties to respect device notches and safe areas.
ConfigService: Use a centralized configuration system (commonly a custom ConfigService module or
```
Configuration
```
instances) for live configuration and feature flags.

Load the specialist that owns the task. For broad architecture work, also read architecture-principles.md.
Follow that specialist's reference links for the feature or failure you are handling. For systems that interact, read cross-skill-integration.md.
Adapt script examples to the project and check their maturity labels. Validate changes in a dedicated test experience.
Before handing off, report which checks passed, which need Roblox integration, and any unresolved API or policy questions. Check uncertain behavior against the official sources above.

architecture-principles.md: Choose authority boundaries, data flow, or project structure across systems.
cross-skill-integration.md: Combine purchases with persistence, or animation with effects and UI.