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.

Full Mode activates when the skill detects the community MCP server (boshyxd/robloxstudio-mcp) running alongside Roblox Studio. With 39 tools spanning project exploration, instance building, playtesting, Creator Store access, bulk operations, and history management, Full Mode is the highest-capability configuration available. Claude can inspect your entire place file, write and edit scripts directly inside Studio, search for bugs across every script, insert assets, and iterate through errors automatically — all in a single conversation.

Detection

The skill enters Full Mode when any of these tool names are found in the active MCP tool list:
Probe ToolSignificance
execute_luauPrimary build and execution workhorse
get_file_treeFull instance hierarchy access
grep_scriptsCross-script pattern search
create_buildStructured instance scaffolding
search_objectsInstance-tree search by name or class
get_instance_propertiesProperty inspection for any instance
get_script_sourceFull source read for any script
A single matching tool is sufficient to activate Full Mode. In practice, all 39 tools will be available once the community server is running.

Tool Reference

Exploration Tools

Use these tools to understand any project before touching a single line of code.
ToolPurposeWhen to Use
get_file_treeReturns the full instance hierarchy of the placeFirst step in any project exploration; understanding overall structure
get_project_structureReturns a higher-level structural overviewQuick orientation before diving into specifics
search_objectsFind instances by name or class across the treeLocating specific parts, models, scripts, or UI elements
get_instance_propertiesRead all properties of a specific instanceInspecting configuration, checking values before modification
get_instance_childrenList direct children of an instanceNavigating the hierarchy incrementally
grep_scriptsSearch across all scripts for a patternFinding references, tracing function calls, locating bugs
get_script_sourceRead the full source of a specific scriptUnderstanding implementation before editing
search_by_propertyFind instances matching a property valueLocating all anchored parts, all red-colored bricks, etc.
get_class_infoGet Roblox API info for a classChecking available properties and methods before writing code
get_selectionGet the currently selected instance(s) in StudioContext-aware operations on what the user has selected

Building Tools

The building tools turn a plan into real Studio instances. execute_luau is the primary workhorse for nearly every create, modify, and wire-up operation.
ToolPurposeWhen to Use
execute_luauRun arbitrary Luau code inside StudioCreating instances, modifying properties, wiring events — the core build primitive
create_buildGenerate a structured build from a specificationScaffolding rooms, maps, or complex instance trees from a plan
import_buildImport a previously exported buildRestoring saved structures or applying templates
export_buildExport a subtree to a reusable formatSaving work for reuse, creating templates, backing up before changes
import_sceneImport a complete scene definitionLoading pre-built environments or level layouts

Testing Tools

Run, observe, and stop playtests without leaving the conversation.
ToolPurposeWhen to Use
start_playtestBegin a playtest session in StudioValidating changes, testing gameplay, triggering runtime behavior
stop_playtestEnd the current playtest sessionAfter gathering output or when done testing
get_playtest_outputRead console/output from the playtestChecking for errors, reading print statements, validating behavior

Assets Tools (Creator Store)

Search, preview, and insert assets from the Creator Store directly into your place.
ToolPurposeWhen to Use
Creator Store searchSearch the Creator Store for models, audio, etc.Finding assets to populate a scene
Creator Store detailsGet metadata for a specific assetChecking asset info before insertion
Creator Store thumbnailGet the thumbnail/preview image of an assetVisual verification before inserting
Creator Store insertInsert an asset from the Creator Store into the placeAdding models, meshes, audio, images, etc.
Creator Store previewPreview an asset before committing to insertionEvaluating suitability

History Tools

Undo and redo operations are first-class citizens in Full Mode, making experimental changes safe.
ToolPurposeWhen to Use
undoUndo the last change via ChangeHistoryServiceRolling back a mistake, reverting after a failed experiment
redoRedo a previously undone changeRe-applying a reverted change

Bulk Operations

Large-scale reads and writes across many instances at once.
ToolPurposeWhen to Use
mass_get_propertyRead a property from many instances at onceAuditing values across the place (e.g., all part sizes)
Batch operationsExecute multiple related changes in sequenceBulk renaming, bulk property updates, mass restructuring

Scripting Tools

Full Mode surfaces direct script authoring through execute_luau combined with the exploration tools above. The typical scripting workflow is:
  1. get_script_source — read the existing implementation
  2. Analyze and generate updated code
  3. execute_luau — write the new source back into the Script instance
  4. start_playtest + get_playtest_output — verify at runtime
Full Mode is the recommended configuration for autonomous game scaffolding. Claude can read your place’s structure, generate all server scripts, client controllers, and shared modules, insert them via execute_luau, run a playtest, read errors from get_playtest_output, patch the offending scripts, and repeat — all without manual copy-pasting.

Autonomous Build Sequence

The following example shows how Claude uses execute_luau as the backbone of a complete build cycle, from an empty place to a working game system.
1. SCAFFOLD
   ├── get_file_tree          →  understand current place state
   ├── get_project_structure  →  high-level layout
   └── create_build           →  create folder structure and placeholder instances

2. GENERATE CORE SYSTEMS
   ├── For each system (combat, inventory, UI…):
   │   ├── execute_luau  →  create Script in ServerScriptService, set .Source
   │   ├── execute_luau  →  create LocalScript in StarterPlayerScripts, set .Source
   │   └── execute_luau  →  create ModuleScript in ReplicatedStorage, set .Source
   └── execute_luau  →  wire RemoteEvents and RemoteFunctions

3. INSERT ASSETS
   ├── Creator Store search  →  find relevant models / audio
   └── Creator Store insert  →  place assets in Workspace with correct transforms

4. TEST
   ├── start_playtest
   ├── get_playtest_output  →  read console for errors
   └── stop_playtest

5. FIX & ITERATE  (max 5 attempts)
   ├── grep_scripts       →  locate error source
   ├── get_script_source  →  read the problematic script
   ├── execute_luau       →  apply the fix
   └── Return to step 4
Here is what a single autonomous fix step looks like using execute_luau:
-- Example: create a CombatSystem ModuleScript in ReplicatedStorage
local rs = game:GetService("ReplicatedStorage")

-- Create the module
local module = Instance.new("ModuleScript")
module.Name = "CombatSystem"
module.Parent = rs

-- Write the source
module.Source = [[
local CombatSystem = {}

local DAMAGE_VALUES = {
    sword   = 25,
    bow     = 15,
    default = 10,
}

function CombatSystem.getDamage(weaponType: string): number
    return DAMAGE_VALUES[weaponType] or DAMAGE_VALUES.default
end

return CombatSystem
]]

print("CombatSystem created at", module:GetFullName())
Always create a ChangeHistoryService waypoint via execute_luau before any bulk or destructive operation so the user can undo the entire change as a single action:
game:GetService("ChangeHistoryService"):SetWaypoint("Before: Add CombatSystem")

Build docs developers (and LLMs) love