New Game Workflow: Build a Roblox Game from Scratch

The New Game workflow is the primary entry point for building a complete Roblox game with Claude. Starting from nothing but a short description, it walks you through genre selection, scope definition, architecture approval, live scaffolding, core system code generation, and an automated integration test — ending with a working, playable project and a clear list of next steps. Use this workflow whenever you want to start a fresh game, not when iterating on an existing one. Trigger phrases: “build me a game”, “create a game”, “start a project”, or any description of a game concept. Prerequisites: MCP mode is detected automatically (Full, Standard, or Offline). Each step below notes how behavior differs per mode. See MCP Overview for mode details.

Workflow Steps

Genre Detection

Claude first tries to detect the game genre automatically from your message by scanning for keywords (case-insensitive). The first matching genre wins.

Genre	Trigger Keywords
Simulator	simulator, sim, clicking, rebirth, prestige, idle, grind, farm
Tycoon	tycoon, factory, build, base, dropper, conveyor, empire
Obby	obby, obstacle, parkour, jump, platformer, tower, stages
RPG	rpg, quest, adventure, dungeon, story, level up, class, mmorpg, open world
Horror	horror, scary, escape, survive, monster, fear, dark, haunted
Battle Royale	battle royale, pvp, arena, fight, last standing, deathmatch, shooter, fps

If a genre is detected, Claude confirms before continuing:

I detected from your description. I will use the template to structure your game. Does that sound right, or would you prefer a different genre?

If no genre matches, Claude presents a multiple-choice prompt offering all six genres plus a Custom option. Choosing Custom skips genre-specific templates and uses only the universal scaffold — you’ll be asked for a short concept description to inform architecture decisions.

Load Genre Template

Claude loads the right template files based on the confirmed genre.The universal base scaffold (templates/game-scaffold.md) is always loaded first. It provides the folder hierarchy, DataManager boilerplate, RemoteEvent setup, loading screen, and core configuration module that every game needs. See Templates Overview for the full template library.Genre-specific templates are layered on top:

Genre	Template
Simulator	`templates/genre-simulator.md`
Tycoon	`templates/genre-tycoon.md`
Obby	`templates/genre-obby.md`
RPG	`templates/genre-rpg.md`
Horror	`templates/genre-horror.md`
Battle Royale	`templates/genre-battle-royale.md`
Custom	Universal scaffold only

From the loaded templates, Claude extracts the core systems, required RemoteEvents, player data schema, UI screens, and Workspace layout requirements.

Scope Definition

Claude asks you to choose between two build scopes before writing any code.MVP (Minimum Viable Product) — Core gameplay loop only. Builds the 3–5 essential systems that make the game playable: DataManager, 1–2 genre-defining systems, a basic HUD, RemoteEvent wiring, and minimal Workspace setup. No monetization, minimal UI polish. Great for prototyping.Full Vision — A shippable game with all genre systems, MonetizationManager (game passes, developer products, receipt processing), a complete UI suite (shop, settings, inventory, leaderboards), mobile input support, a loading screen with asset preloading, sound/music system, and anti-cheat basics.The scope choice is stored and applied throughout Steps 4–6.

Architecture Generation

Claude generates a complete project architecture document — folder hierarchy, script manifest, RemoteEvent list, and player data schema — and presents it for your approval before writing any code.

=== PROJECT ARCHITECTURE: Simulator Game (MVP) ===

FOLDER STRUCTURE:
game
+-- ServerScriptService
|   +-- Main (Script) -- bootstrapper, requires and inits all server modules
|   +-- Services/
|       +-- DataManager (ModuleScript) -- save/load player data
|       +-- ClickService (ModuleScript) -- handle click actions, earnings
|       +-- RebirthService (ModuleScript) -- prestige/rebirth logic
+-- ReplicatedStorage
|   +-- Remotes/
|   |   +-- ClickAction (RemoteEvent)  -- client -> server: player clicked
|   |   +-- RebirthRequest (RemoteEvent) -- client -> server: rebirth request
|   |   +-- UpdateStats (RemoteEvent)  -- server -> client: updated stats
|   +-- Modules/
|       +-- Constants (ModuleScript) -- shared game constants
|       +-- Types (ModuleScript) -- shared type definitions
+-- StarterGui
|   +-- HUD (ScreenGui)
|       +-- HUDController (LocalScript)
+-- StarterPlayer
|   +-- StarterPlayerScripts
|       +-- ClientMain (LocalScript)
+-- Workspace
    +-- SpawnLocation
    +-- ClickArea (Part)

DATA SCHEMA:
{ clicks: number, currency: number, rebirths: number,
  multiplier: number, lastSave: number }

You can respond with Proceed, Add (describe what), Remove (name which script/system), or Modify scope. Claude will not begin scaffolding until you approve.

Scaffold

Claude creates the full Instance tree in your project using the appropriate method for your MCP mode.

Full Mode
Standard Mode
Offline Mode

Uses execute_luau to run a single comprehensive script that creates all Folders, Scripts, LocalScripts, ModuleScripts, RemoteEvents, and Workspace layout parts. After execution, get_file_tree or search_objects verifies the structure matches the plan.

game:GetService("ChangeHistoryService"):SetWaypoint("Before: Game Scaffold")

local function ensureFolder(parent, name)
    local folder = parent:FindFirstChild(name)
    if not folder then
        folder = Instance.new("Folder")
        folder.Name = name
        folder.Parent = parent
    end
    return folder
end

local SSS = game:GetService("ServerScriptService")
local RS  = game:GetService("ReplicatedStorage")

local services = ensureFolder(SSS, "Services")
local remotes  = ensureFolder(RS,  "Remotes")
local modules  = ensureFolder(RS,  "Modules")

local function createScript(className, name, parent, source)
    local s = Instance.new(className)
    s.Name   = name
    s.Source = source or ("-- TODO: " .. name)
    s.Parent = parent
    return s
end

Uses run_code with the same Instance-creation pattern. After creation, Claude runs a tree-print verification script and reads get_console_output to confirm the hierarchy matches the plan.

-- Verification script
local function printTree(instance, indent)
    indent = indent or 0
    print(string.rep("  ", indent) .. instance.ClassName .. ": " .. instance.Name)
    for _, child in ipairs(instance:GetChildren()) do
        printTree(child, indent + 1)
    end
end
printTree(game:GetService("ServerScriptService"))
printTree(game:GetService("ReplicatedStorage"))

Claude outputs explicit placement instructions — a numbered hierarchy showing each Instance type and parent — followed by a note that code will come in the next step. Example:

1. ServerScriptService
   +-- Services (Folder)
       +-- DataManager (ModuleScript)
       +-- ClickService (ModuleScript)
   +-- Main (Script)

2. ReplicatedStorage
   +-- Remotes (Folder)
       +-- ClickAction (RemoteEvent)
       +-- UpdateStats (RemoteEvent)
   +-- Modules (Folder)
       +-- Constants (ModuleScript)

Core System Generation

Claude generates each system in dependency order and injects the source, one module at a time.Generation order:

Constants / Types (no dependencies)
DataManager (depends on Constants)
Genre-specific systems (depend on DataManager)
Client scripts (depend on Remotes and shared modules)
UI controllers (depend on Remotes and client infrastructure)
Main bootstrapper (requires and initializes all server modules)

Every generated system must follow these rules:

Never trust the client — all validation server-side
Use pcall for DataStore operations — handle failures gracefully
Use the task library — task.wait(), task.spawn(), task.delay() (never deprecated wait())
Disconnect events on cleanup — store connections, disconnect on PlayerRemoving
Type annotations — Luau types on all function signatures
Rate limiting — server-side cooldowns on every OnServerEvent handler
No circular dependencies — use the init() pattern if modules need cross-references

In MCP Full/Standard modes, Claude applies each script’s source directly via execute_luau or run_code and checks for errors before moving to the next system. In Offline mode, each system is output as a complete copy-paste-ready block with a placement header.

Integration Test

After all systems are built, Claude runs an automated test loop (max 5 attempts).

Full Mode
Standard Mode
Offline Mode

start_playtest
Wait 5–10 seconds for initialization
get_playtest_output — scan for: attempt to index nil, Infinite yield possible, is not a valid member, script-level error traces
stop_playtest

On error: identify the failing script and line, read its source, generate and apply a fix, then retry. After 5 failed attempts Claude reports each iteration’s hypothesis and remaining theories.

Same loop using start_stop_play, get_console_output, and run_code to apply fixes.

Claude provides a manual checklist:

[ ] Game starts without errors in the Output window
[ ] Player data initializes (check Output for DataManager logs)
[ ] Core gameplay loop works end-to-end
[ ] Currency/stats update on screen
[ ] Rejoin test: data persists correctly
[ ] No "Infinite yield possible" warnings
[ ] No "attempt to index nil" errors

COMMON FIXES:
"X is not a valid member" → Use WaitForChild() instead of direct indexing
"attempt to index nil with 'Connect'" → RemoteEvent is missing from Remotes folder
"Infinite yield" → Instance name mismatch — check spelling and capitalization
Data not saving → Enable Studio Access to API Services in Game Settings > Security

Summary and Next Steps

On success, Claude presents a complete build summary:

=== BUILD COMPLETE: {Genre} Game ({Scope}) ===

SYSTEMS BUILT:
1. DataManager       -- Player data persistence with session locking
2. {System2}         -- {one-line description}
3. {System3}         -- {one-line description}

SCRIPTS CREATED: {count}
- Server Scripts:  {count}
- Client Scripts:  {count}
- Shared Modules:  {count}

REMOTE EVENTS: {count}
- {name}: {direction} — {purpose}

DATA SCHEMA:
{ clicks, currency, rebirths, multiplier, lastSave }

FEATURES WORKING:
- {list of verified features}

Claude then suggests 4–6 tailored next steps based on your scope. For MVP builds: add monetization, polish UI, add a leaderboard, add sound. For Full Vision builds: optimize for mobile, add analytics, run a Security Audit, or work through the Publish Checklist.You can continue in the same session with: “Add a shop system”, “Debug an error”, “Review security”, “Optimize performance”, or “Prepare to publish”.

Mode Reference

Step	Full Mode	Standard Mode	Offline Mode
1. Genre	Conversation	Conversation	Conversation
2. Templates	Read template files	Read template files	Read template files
3. Scope	Conversation	Conversation	Conversation
4. Architecture	Conversation	Conversation	Conversation
5. Scaffold	`execute_luau` + `get_file_tree`	`run_code` + `get_console_output`	Placement instructions
6. Core Systems	`execute_luau` per script	`run_code` per script	Code blocks
7. Test	`start_playtest` + `get_playtest_output`	`start_stop_play` + `get_console_output`	Manual checklist
8. Summary	Conversation	Conversation	Conversation

If you select Custom genre, Claude skips genre-specific templates and builds from the universal scaffold only. Give as much detail as possible about your concept so the architecture reflects your vision.

Get Started

MCP Studio Integration

Workflows

Genre Templates

New Game Workflow: Build a Roblox Game from Scratch

Workflow Steps

Mode Reference

Build docs developers (and LLMs) love

Get Started

MCP Studio Integration

Workflows

Genre Templates

Documentation Index

​Workflow Steps

​Mode Reference

Build docs developers (and LLMs) love

Workflow Steps

Mode Reference