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 Tool | Significance |
|---|
execute_luau | Primary build and execution workhorse |
get_file_tree | Full instance hierarchy access |
grep_scripts | Cross-script pattern search |
create_build | Structured instance scaffolding |
search_objects | Instance-tree search by name or class |
get_instance_properties | Property inspection for any instance |
get_script_source | Full 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.
Use these tools to understand any project before touching a single line of code.
| Tool | Purpose | When to Use |
|---|
get_file_tree | Returns the full instance hierarchy of the place | First step in any project exploration; understanding overall structure |
get_project_structure | Returns a higher-level structural overview | Quick orientation before diving into specifics |
search_objects | Find instances by name or class across the tree | Locating specific parts, models, scripts, or UI elements |
get_instance_properties | Read all properties of a specific instance | Inspecting configuration, checking values before modification |
get_instance_children | List direct children of an instance | Navigating the hierarchy incrementally |
grep_scripts | Search across all scripts for a pattern | Finding references, tracing function calls, locating bugs |
get_script_source | Read the full source of a specific script | Understanding implementation before editing |
search_by_property | Find instances matching a property value | Locating all anchored parts, all red-colored bricks, etc. |
get_class_info | Get Roblox API info for a class | Checking available properties and methods before writing code |
get_selection | Get the currently selected instance(s) in Studio | Context-aware operations on what the user has selected |
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.
| Tool | Purpose | When to Use |
|---|
execute_luau | Run arbitrary Luau code inside Studio | Creating instances, modifying properties, wiring events — the core build primitive |
create_build | Generate a structured build from a specification | Scaffolding rooms, maps, or complex instance trees from a plan |
import_build | Import a previously exported build | Restoring saved structures or applying templates |
export_build | Export a subtree to a reusable format | Saving work for reuse, creating templates, backing up before changes |
import_scene | Import a complete scene definition | Loading pre-built environments or level layouts |
Run, observe, and stop playtests without leaving the conversation.
| Tool | Purpose | When to Use |
|---|
start_playtest | Begin a playtest session in Studio | Validating changes, testing gameplay, triggering runtime behavior |
stop_playtest | End the current playtest session | After gathering output or when done testing |
get_playtest_output | Read console/output from the playtest | Checking for errors, reading print statements, validating behavior |
Search, preview, and insert assets from the Creator Store directly into your place.
| Tool | Purpose | When to Use |
|---|
Creator Store search | Search the Creator Store for models, audio, etc. | Finding assets to populate a scene |
Creator Store details | Get metadata for a specific asset | Checking asset info before insertion |
Creator Store thumbnail | Get the thumbnail/preview image of an asset | Visual verification before inserting |
Creator Store insert | Insert an asset from the Creator Store into the place | Adding models, meshes, audio, images, etc. |
Creator Store preview | Preview an asset before committing to insertion | Evaluating suitability |
History Tools
Undo and redo operations are first-class citizens in Full Mode, making experimental changes safe.
| Tool | Purpose | When to Use |
|---|
undo | Undo the last change via ChangeHistoryService | Rolling back a mistake, reverting after a failed experiment |
redo | Redo a previously undone change | Re-applying a reverted change |
Bulk Operations
Large-scale reads and writes across many instances at once.
| Tool | Purpose | When to Use |
|---|
mass_get_property | Read a property from many instances at once | Auditing values across the place (e.g., all part sizes) |
| Batch operations | Execute multiple related changes in sequence | Bulk renaming, bulk property updates, mass restructuring |
Full Mode surfaces direct script authoring through execute_luau combined with the exploration tools above. The typical scripting workflow is:
get_script_source — read the existing implementation
- Analyze and generate updated code
execute_luau — write the new source back into the Script instance
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")