Roblox World Creation

Use this skill to take a Roblox experience from empty Studio place to a published, retainable world using the engine, language, and platform reality of July 2026. It covers the durable build spine (greybox → first playable → detail → ship) and fences the volatile platform layer (rates, limits, renamed APIs) so you teach what is true today, not what was true in 2023 — or in May 2026 (the RFY discovery algorithm, DataStore budget model, and 2D UGC publishing rules all materially changed since then; see the dated corrections in references/discovery-economy-policy.md and references/luau-and-architecture.md).

This is a software/game-development domain skill. It is self-contained: pick the stage you are in, load the one reference for that stage, do the work, verify volatile claims before quoting them.

Quick Reference

Stage	Read or Run	Durable default (Jul 2026)
Setup & toolchain	references/setup-and-toolchain.md	Studio + Rojo + Rokit + Wally for git-native teams; Script Sync (Full Release since Jun 2026, Team-Create compatible) if you need Team Create; default.project.json defines the DataModel tree
Language & architecture	references/luau-and-architecture.md	--!strict Luau; task.wait/spawn/defer never wait()/spawn(); server-authoritative; RemoteEvent + UnreliableRemoteEvent for high-frequency; ProfileStore for player data
Build the world	references/world-building.md	Greybox in Parts first; 1 stud ≈ 0.28 m; StreamingEnabled = true; Unified Lighting LightingStyle = Realistic + PrioritizeLightingQuality (the old Technology enum is deprecated)
Performance & traps	references/performance-and-traps.md	Anchor static parts; transparency 0 or 1 only; disconnect every connection; UpdateAsync + session lock + BindToClose; WaitForChild in LocalScripts
Discovery, economy, policy	references/discovery-economy-policy.md	Design for RFY's 28-day, 3-phase retention model (Day 1 / Day 2–7 / Day 8–28; rewritten Jun 2026 — the old 7-day qPTR model is superseded); complete the maturity questionnaire; design sinks for every source; never trust the client for economy
AI-assisted creation	references/setup-and-toolchain.md#ai-assisted-creation	Studio Assistant (planning mode), Material Generator (GA), Code Assist, Studio MCP server for external LLMs — real and shipping; Texture Generator still Beta

World Creation Workflow

The durable spine. Each step names its verification check inline — do not advance from a state you cannot describe back.

1. Scope the world to a testable first playable → verify: one sentence — "a player spawns, can perform the core verb, and has a reason to return tomorrow." If you can't write it, stop and get it.
2. Set up the toolchain and place structure → verify: rojo serve (or Script Sync) round-trips an edit Studio ↔ disk; default.project.json maps src/ to the right services. See references/setup-and-toolchain.md.
3. Greybox the world in Parts only — no meshes, textures, or scripts → verify: you can walk the whole space, sightlines and player flow read clearly at player scale (1 stud ≈ 0.28 m). See references/world-building.md.
4. Stand up the architecture skeleton — server-authoritative state, one RemoteEvent path, ProfileStore-backed save, CollectionService tags for repeated objects → verify: a value changed on the server replicates; a value changed only on a client does not (FilteringEnabled is permanently on). See references/luau-and-architecture.md.
5. Reach First Playable — working spawn/respawn, one lighting pass, the core loop is playable end to end → verify: Team Test with a second client; the loop is completable without programmer intervention.
6. Detail pass — modular kits replace greybox, PBR/SurfaceAppearance, atmosphere, sound zones → verify: part count and draw calls still inside budget on a real low-end Android, not just the Studio emulator. See references/world-building.md and references/performance-and-traps.md.
7. Harden — rate-limit and type-validate every OnServerEvent; serialize economy remotes; disconnect every connection; BindToClose save; session locking on data → verify: walk references/performance-and-traps.md Known Traps as a checklist; MicroProfiler shows no runaway frame peaks.
8. Soft-launch under real concurrency — release to a capped audience (private server, limited region, or throttled ad spend) before wide release → verify: watch real per-server-instance CPU and experience-wide DataStore budget (shared across all servers since the 2026 per-experience model) with 50–200 concurrent players, not a 2–4-client Studio Team Test — the burst-join DataStore exhaustion, physics-step cost, and remote flood only appear at real concurrency. Fix what surfaces before RFY sends volume.
9. Ship and tune for discovery — complete the maturity questionnaire (mandatory), set access and game settings, publish, then design the FTUE and loops around the RFY signals → verify: experience is rated (since Sep 30 2025 an unrated experience is fully unplayable platform-wide for users — not merely hidden; you can still playtest it unrated in Studio); first-session core-loop comprehension is real. See references/discovery-economy-policy.md.

Verify every volatile number (part/draw budgets, DataStore limits, DevEx rates, fees, maturity ages) against current primary sources before quoting it. The platform changes these without warning. Each reference labels volatile facts as of Jul 2026 — verify.

ASCII Flow

Scope -> "first playable" sentence
  -> Toolchain + place structure (Rojo/Script Sync + default.project.json)
  -> Greybox in Parts (validate scale + flow)
  -> Architecture skeleton (server-authority + ProfileStore + tags)
  -> FIRST PLAYABLE (Team Test the core loop)
  -> Detail (modular kits, Unified Lighting, PBR, sound)
  -> Harden (validate + serialize remotes, disconnect leaks, BindToClose, session lock)
  -> Soft-launch (capped audience -> watch CPU + DataStore budget at real concurrency)
  -> Ship (maturity questionnaire -> publish -> FTUE + loops for RFY signals)

Patterns (durable)

• Server is the single source of truth. Clients request; the server decides. FilteringEnabled cannot be turned off — design as if every client is hostile.
• task library, always. task.wait/spawn/delay/defer and signal:Once(). The legacy wait()/spawn()/delay() globals are deprecated and drift under load.
• Set properties before parenting. Instance.new("Part"), configure, then set .Parent last — one replication event, not several.
• Stream the world. StreamingEnabled = true; access Workspace objects from LocalScripts via WaitForChild(name, timeout); keep ReplicatedStorage/ReplicatedFirst lean (they never stream).
• Atomic, session-locked saves. UpdateAsync (never SetAsync for shared keys) + a session lock keyed on game.JobId + BindToClose + ProfileStore. Save on cadence and on critical events, not on every stat change.
• One script for many things. CollectionService tags + a single manager script for repeated objects (doors, spawns, traps), not a Script per instance.
• Client does pixels, server does truth — but "truth" means adversarial state, not everything. Validate what a cheater profits from (currency, damage, hit-reg, item grants); leave non-adversarial state (camera shake, footstep particles, ragdoll poses) client-authoritative. Over-validating cosmetic state burns server CPU for zero security benefit. See references/luau-and-architecture.md.
• Network ownership is the physics-feel lever. part:SetNetworkOwner(player) makes their own vehicle/tool physics simulate locally (lag-free); SetNetworkOwner(nil) forces server ownership for contested/exploitable physics. This — not RemoteEvents — is why "my car lags for the driver."
• Serialize economy remotes. Two fires of a spend/grant remote can land in one frame before the first write commits (the dupe race). Process economy-affecting remotes through a per-player serial queue, not independent handlers.
• Design for retention signals, not raw volume. RFY (rewritten Jun 2026) scores Day 1, Day 2–7, and Day 8–28 separately and deliberately ignores lifetime totals — a strong new experience can outrank a large declining one, but a strong first session with no mid-game hook now shows up as a visible Day-8–28 weakness instead of being averaged away.
• Every currency/item source needs a sink. Before shipping a new way to earn, decide what removes it from the economy — otherwise you get inflation and an economy that only rewards early adopters. See references/discovery-economy-policy.md#economy-design-judgment-sinks-sources-and-exploit-economics.
• Roblox isn't always the right call. Sexual/gambling content, full payment-stack control, frame-perfect competitive netcode, non-Roblox-client distribution, and adult-first products fit poorly on this platform — recognize the mismatch before scoping the build. See references/discovery-economy-policy.md#when-roblox-is-the-wrong-platform.

Anti-Patterns

• Changing currency, health, or inventory in a LocalScript and expecting the server (or other players) to see it.
• Trusting numeric arguments from OnServerEvent for economy or stat changes instead of computing on authoritative server state.
• SetAsync on a shared key from multiple servers (race → data loss); no BindToClose (lose the last autosave on shutdown).
• Partial transparency (0.01–0.99) or RenderFidelity = Precise on background geometry; unanchored static parts; per-instance Scripts where one tagged manager would do.
• Connecting events per-respawn without disconnecting (the most common silent memory leak); busy-wait while ... do wait() end loops.
• Setting the deprecated Lighting.Technology enum in a new project instead of LightingStyle + PrioritizeLightingQuality.
• Shipping unrated (skipping the maturity questionnaire) → fully unplayable platform-wide for users since Sep 30 2025 (stronger than the old "hidden from search" penalty), and absent from top charts.
• Quoting a DevEx rate, fee, part budget, or DataStore limit from memory without re-verifying — every one of these has changed and is dated in the references.

Known Traps

• wait() drift — legacy scheduler resumes on ~1/30s minimum and accumulates drift; use task.wait.
• Replication timing — a Workspace object that exists on the server may not have replicated/streamed to a given client yet; LocalScripts must WaitForChild with a timeout.
• Humanoid race — Humanoid/HumanoidRootPart are not all present the instant CharacterAdded fires; :WaitForChild them.
• DataStore throttling — request/storage budget is now per-experience (2026 change), shared across every running server, not per-server; a burst on one server can starve all of them. Wrap in pcall + logging; use ProfileStore.
• RemoteFunction:InvokeClient() from the server — a malicious client can yield forever and hang the thread; never call it.
• Emulator ≠ device — Studio's device emulator tests layout only, not CPU/GPU; most players are mobile, so test on a real 3–4 year old Android before shipping.
• New Type Solver footguns (2026) — the current type solver has open issues (as of mid-2026 — verify fixed): stale Parent/Model type narrowing after reparenting or reassignment, and high Studio memory use. If strict-typed code reports impossible type errors after moving instances, suspect the solver, not your code.
• Script Sync edge cases (2026) — even post-full-release, Script Sync has reported "ghost instances" in Team Create and silently skips scripts nested under non-Folder/non-Script ancestors. Confirm every script actually round-trips; don't assume a clean sync.

Frameworks (Jul 2026 status — verify before adopting)

Need	Pick	Status
Player data persistence	ProfileStore	Active community standard; successor to ProfileService (deprecated)
Tag/component architecture	CollectionService (optionally Stamp wrapper)	Built-in; idiomatic
Typed networking	Jolt (community) or ByteNet	Emerging community options; no official typed networking API yet; verify package activity before adopting
ECS	Matter (matter-ecs)	Dormant — no confirmed 2026 activity on the canonical or community-fork repos; do not adopt for new production ECS without independent confirmation of maintenance
Module framework	Modular OOP, or ECS if needed	Knit is no longer maintained — do not start new projects on it
Build automation / CI	Lune + Wally + Rokit	Git-native production stack

Navigation

Resources:

• references/setup-and-toolchain.md — Studio, Rojo/Script Sync/Azul, Rokit/Wally/Lune, project structure, and AI-assisted creation
• references/luau-and-architecture.md — Luau 2026 (strict types, task, native, buffer), client-server model, network ownership, client-vs-server authority judgment, remotes + anti-exploit (dupe races, speed hacks), data persistence (ProfileStore lease traps, DataStore budget bursts, schema migration), Parallel Luau/Actors, MessagingService, module patterns
• references/world-building.md — Scale, greyboxing, modular kits, Unified Lighting, terrain/mesh/PBR, sound, streaming, publishing and testing
• references/performance-and-traps.md — Performance budgets, profiling, memory-leak patterns, and the full Known Traps catalog with fixes
• references/discovery-economy-policy.md — RFY discovery signals, monetization mix, retention/FTUE design, content maturity and safety policy, UGC economy
• data/sources.json — Primary sources to verify volatile facts against

Related skills (same family only):

• ../software-mobile/SKILL.md — Mobile-platform constraints and store flows
• ../software-performance/SKILL.md — General performance profiling discipline
• ../software-ui-ux-design/SKILL.md — Onboarding and flow design that transfers to FTUE

Learnings Loop

Before applying this skill on a non-trivial task, read learnings.consolidated.md in this directory (and learnings.md if present).

After applying it, if you encountered a pattern worth remembering, a mistake worth preventing, or a domain fact that surprised you, append one dated bullet to learnings.md via agents-skills-feedback-loop/scripts/append_learning.py. Do not modify SKILL.md itself.

Fact-Checking

• Roblox platform facts are high-drift. Treat every rate, fee, percentage, numeric limit, maturity age, and recently renamed API as volatile and verify against current primary sources (create.roblox.com, devforum.roblox.com, luau.org, about.roblox.com) before quoting.
• The references separate DURABLE principles (build order, server authority, save discipline) from VOLATILE facts (budgets, rates, API names) and date the volatile ones as of Jul 2026.
• Items announced on the roadmap but not confirmed shipped (e.g. CSG-on-meshes, enhanced voxel terrain, Android native codegen) are marked as such — confirm shipping status before depending on them.
• If web access is unavailable, state the limitation and mark any volatile platform claim as unverified rather than asserting it as current.