Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/brockmartin/roblox-game-skill/llms.txt

Use this file to discover all available pages before exploring further.

The fastest path from idea to running Roblox game is a single sentence. Describe what you want to build, and the skill takes over: it detects your genre, loads the matching template, scaffolds a complete service architecture, and generates the core systems with production-ready Luau code — all while adapting to whatever Studio connection (or lack thereof) you have available.

Step 1: Describe Your Game

Start a Claude Code session and describe your game in plain language. You don’t need to know Roblox’s API, service hierarchy, or scripting conventions — just tell Claude what you want to build. Example prompts that work great:
Build me a pet simulator with 3 zones and a prestige system.
I want to make a tycoon game where players build and run a pizza restaurant.
Create a horror game — players explore a haunted mansion and try to escape a monster.
Make an obby with 50 stages, a timer, and a leaderboard for fastest completions.
Build a battle royale game for up to 20 players with a shrinking storm.
The more detail you provide — number of zones, specific mechanics, monetization ideas — the more tailored the output will be. But even a single sentence is enough to get a complete scaffold.

Step 2: Genre Auto-Detection

The skill automatically scans your message for genre keywords before doing anything else. If it finds a match, it confirms with you and proceeds. If no genre is detected, it presents a multiple-choice menu.

Keyword Matching Table

GenreTrigger Keywords
Simulatorsimulator, sim, clicking, rebirth, prestige, idle, grind, farm
Tycoontycoon, factory, build, base, dropper, conveyor, empire
Obbyobby, obstacle, parkour, jump, platformer, tower, stages
RPGrpg, quest, adventure, dungeon, story, level up, class, mmorpg, open world
Horrorhorror, scary, escape, survive, monster, fear, dark, haunted
Battle Royalebattle royale, pvp, arena, fight, last standing, deathmatch, shooter, fps
When a genre is detected, Claude confirms before continuing:
I detected Simulator from your description. I’ll use the Simulator template to structure your game. Does that sound right, or would you prefer a different genre?
If you have something that doesn’t fit a predefined genre, answer Custom and describe your concept — the skill will use the universal game-scaffold.md template and adapt to your requirements.

Step 3: Scaffolding — MCP or Offline

After genre detection, the skill checks what MCP tools are available and scaffolds accordingly.
With the boshyxd/robloxstudio-mcp server running, Claude will:
  1. Call get_file_tree to inspect your current Studio project structure
  2. Create all required service folders (ServerScriptService/Services/, ReplicatedStorage/Remotes/, etc.)
  3. Write each generated script directly into your project using create_build
  4. Execute initialization code with execute_luau and read the console output to verify it ran correctly
You’ll see your Studio project populate in real time as Claude builds it autonomously.

Step 4: Core System Generation

Once the scaffold is in place, Claude generates the core systems for your genre. For a Simulator, this includes:
  • CollectionService — Resource node spawning, collection logic, multiplier application
  • PetService — Egg hatching, pet inventory, equip/unequip, leveling, merging
  • ZoneService — Zone unlock checks, zone gates, zone-specific resource tables
  • UpgradeService — Permanent upgrade purchases, multiplier calculations
  • PrestigeService — Rebirth logic, requirement checks, permanent multiplier grants
  • DataService — Player data persistence via ProfileService/ProfileStore
  • ShopService — GamePass and DevProduct handling with server-side validation
Every system uses proper client-server separation. RemoteEvents live in ReplicatedStorage, server authority lives in ServerScriptService, and clients are treated as display layers only.

Example: RemoteEvent Communication

Here is the standard pattern used throughout every generated system for safe client-to-server communication:
-- SERVER: Listen for client requests (in a Script inside ServerScriptService)
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectRemote = ReplicatedStorage.Remotes.CollectResource

CollectRemote.OnServerEvent:Connect(function(player, nodeId)
    -- ALWAYS validate on the server — never trust the client
    if typeof(nodeId) ~= "string" then return end
    -- Process the collection authoritatively
    CollectionService:HandleCollect(player, nodeId)
end)

-- CLIENT: Fire the server when the player interacts (in a LocalScript)
local CollectRemote = game:GetService("ReplicatedStorage").Remotes.CollectResource
CollectRemote:FireServer(node.Name)

-- SERVER → CLIENT: Replicate the updated value back for display
CollectRemote:FireClient(player, newCoinTotal)

Example: DataStore Persistence

Player data is always wrapped in a pcall to prevent data loss from transient API errors:
local DataStoreService = game:GetService("DataStoreService")
local store = DataStoreService:GetDataStore("PlayerData")

-- Reading data safely
local success, data = pcall(function()
    return store:GetAsync("Player_" .. player.UserId)
end)

if success and data then
    -- Apply saved data to the player session
    applyData(player, data)
else
    -- Fall back to defaults if load fails — never leave a player with nil data
    applyData(player, getDefaultData())
end

-- Writing data safely
local saveSuccess, saveErr = pcall(function()
    store:SetAsync("Player_" .. player.UserId, playerData)
end)

if not saveSuccess then
    warn("DataStore save failed for", player.Name, saveErr)
end
The Golden Rule: Never trust the client. Every RemoteEvent payload is attacker-controlled. No matter how your client-side code behaves, always validate the type, range, ownership, and cooldown of every incoming request on the server. Client-side currency, health, or inventory changes that aren’t re-validated server-side are the single most common exploitable vulnerability in Roblox games.

Next Steps

You now have a fully scaffolded, production-ready game architecture with core systems in place. Here is where to go from here:

Full 8-Step New Game Workflow

Walk through the complete guided workflow — genre selection, scoping, architecture review, scaffold, core systems, integration testing, and a final summary with specific next steps tailored to your game.

Connect MCP Studio

Set up Full or Standard MCP mode to let Claude build, test, and iterate inside Roblox Studio autonomously — reading the console, fixing errors in a loop, and inserting assets directly.

Build docs developers (and LLMs) love