How to use Claude Code with Roblox Studio

What you need before you start

Which Claude Code to use

Claude Code runs in several places. Anthropic says they all share the same engine, so your CLAUDE.md, settings and MCP servers work across them. What matters for Studio is where the session runs: Roblox's MCP server is a local process on your computer, so the session has to be on your computer too.

Step 1: Install Claude Code and sign in

Anthropic's recommended install is one command in a terminal. These are the commands its setup page gave on 9 October 2026; check Anthropic's setup page for the current ones.

curl -fsSL https://claude.ai/install.sh | bash

irm https://claude.ai/install.ps1 | iex

1. Open a new terminal window and run claude --version. A version number means it worked. If the command is not found, the install folder is not on your PATH yet, and Anthropic's install troubleshooting page has the fix.
2. Go to your project folder and run claude. On first launch it opens a browser window to sign in. If the browser does not open, press c to copy the sign-in link.
3. Sign in with your Claude account. A Pro or Max sign-in uses your plan's included usage.

On Windows, Anthropic recommends installing Git for Windows so Claude Code can use its Bash tool; without it, Claude Code runs commands in PowerShell. Install Claude Code on Windows itself rather than inside WSL for this setup: Roblox's Windows configuration runs cmd.exe with a %LOCALAPPDATA% path, and Roblox does not document WSL.

Prefer an editor panel? In VS Code or Cursor, open Extensions (Ctrl+Shift+X, or Cmd+Shift+X on Mac), search for Claude Code, install it, and sign in from the Claude panel. This is the setup Roblox's coding harness guide uses.

Step 2: Connect Claude Code to Studio

Turn the server on first. In Studio, open Assistant, click … > Manage MCP Servers, and turn on Enable Studio as MCP server. The Studio MCP guide covers this step in more detail.

Quick connect

1. In the same panel (Assistant Settings > MCP Servers), expand the Quick connect drop-down. It lists the supported clients installed on your computer.
2. Turn on Claude Code. If it is missing, install Claude Code and restart Studio.
3. Restart Claude Code: end the session and run claude again, or start a new conversation in the extension. Roblox says a client needs a restart to pick up a new configuration.

Roblox does not say which Claude Code file quick connect writes to, or what it names the server. Type /mcp in Claude Code to see the name. You need it for the permission rules in Step 3.

Using the Claude Code extension in VS Code or Cursor? Turn on Claude Code here too. Roblox's coding harness guide switches on Cursor or Visual Studio Code, but Anthropic documents the extension sharing its MCP configuration with the terminal version of Claude Code, and does not say it reads the editor's own MCP settings.

Manual setup with a .mcp.json file

If quick connect does not work for you, add Studio yourself. Claude Code reads project MCP servers from a file named .mcp.json in your project folder, in the same mcpServers format Roblox documents, and it treats an entry with no type as a local stdio server. So Roblox's configuration works as it is. Save the one for your system as .mcp.json in the folder where you run claude:

{
  "mcpServers": {
    "Roblox_Studio": {
      "command": "cmd.exe",
      "args": [
        "/c",
        "%LOCALAPPDATA%\\Roblox\\mcp.bat"
      ]
    }
  }
}

{
  "mcpServers": {
    "Roblox_Studio": {
      "command": "/Applications/RobloxStudio.app/Contents/MacOS/StudioMCP"
    }
  }
}

The next time you run claude in that folder, it asks you to approve the server: Anthropic shows this prompt for every server that comes from a .mcp.json file. Anthropic designed the file to be committed so a team shares it, but the Windows and macOS paths differ. If your team uses both, keep the file out of the repository and let each person add Studio for themselves.

On macOS you can add Studio with one command instead. --scope user makes it available in every project on your computer; leave it out and the server loads only in the current folder. The -- separates Claude Code's own options from the command that starts the server.

claude mcp add --transport stdio --scope user Roblox_Studio -- /Applications/RobloxStudio.app/Contents/MacOS/StudioMCP

On Windows, the JSON file is the simpler route, because PowerShell and CMD treat %LOCALAPPDATA% differently on a command line.

Check the connection

• In a terminal, claude mcp list shows each server and its status. claude mcp get Roblox_Studio shows more, including an Issue: line if the server failed to connect.
• Inside Claude Code, type /mcp. Connected servers show a tool count next to their name.
• In Studio, Assistant > … > Manage MCP Servers shows a green indicator with the number of connected clients.

Step 3: Decide what Claude may do without asking

Set this before Claude touches your place. According to Anthropic's permission modes page, since Claude Code v2.1.283 interactive terminal and VS Code sessions start in auto mode by default whenever it is available, and in auto mode a background classifier reviews actions instead of you. An MCP call that edits a script or runs Luau in Studio can then go ahead without a prompt.

You have two ways to keep each change in your hands:

• Start in Manual mode. Run claude --permission-mode default. In Manual mode only reads run without asking. Press Shift+Tab during a session to cycle modes.
• Add ask rules for the Studio tools that change things. Anthropic says no mode auto-approves a tool matched by an explicit ask rule, not even bypass mode.

{
  "permissions": {
    "allow": [
      "mcp__Roblox_Studio__list_roblox_studios",
      "mcp__Roblox_Studio__get_studio_state",
      "mcp__Roblox_Studio__search_game_tree",
      "mcp__Roblox_Studio__inspect_instance",
      "mcp__Roblox_Studio__script_read",
      "mcp__Roblox_Studio__script_search",
      "mcp__Roblox_Studio__script_grep",
      "mcp__Roblox_Studio__get_console_output"
    ],
    "ask": [
      "mcp__Roblox_Studio__multi_edit",
      "mcp__Roblox_Studio__execute_luau",
      "mcp__Roblox_Studio__start_stop_play",
      "mcp__Roblox_Studio__subagent",
      "mcp__Roblox_Studio__insert_asset",
      "mcp__Roblox_Studio__upload_image",
      "mcp__Roblox_Studio__generate_mesh",
      "mcp__Roblox_Studio__generate_material",
      "mcp__Roblox_Studio__generate_procedural_model"
    ]
  }
}

MCP rules take the form mcp__<server>__<tool>, using the server name as Claude Code has it. Replace Roblox_Studio with the name /mcp shows. Allow rules in a project's .claude/settings.json apply only after you accept the workspace trust dialog for that folder. For rules that are just for you, use .claude/settings.local.json instead.

The allow list covers tools that only read: the game tree, properties, scripts, the Output and the list of open Studio windows. The ask list covers tools that change your place, run code, start playtests, bring in outside assets or send images to Roblox. Tools in neither list, such as screen_capture and the input tools, follow your permission mode. The full tool list, with what each one does, is in the Studio MCP guide.

Step 4: Start with a request that only reads

Open the place you want to work on and close any you do not. Then give Claude a first request that cannot change anything:

Use the Roblox Studio MCP tools. Call list_roblox_studios and tell me which place you are connected to, then list what is in Workspace. Do not change anything.

On a fresh Baseplate, Roblox's coding harness guide expects the answer to list the default Camera, Terrain, Baseplate and SpawnLocation. Asking for list_roblox_studios first is a good habit: one client can reach every Studio window you have open, and every tool call names its target window with a studio_id.

For anything bigger than one script, ask for a plan first. In plan mode (press Shift+Tab, or start a prompt with /plan) Claude researches and proposes without editing your files. Anthropic describes plan mode in terms of file edits and shell commands, so keep your ask rules for the Studio tools as well.

Step 5: Work on scripts as files with Script Sync or Rojo

Claude Code is built around files in a folder. It edits them with its own tools, Git keeps their history, and /rewind can restore them. Putting your scripts on disk lets you use all of that, and leaves the MCP tools for the parts of a place that are not scripts, such as GUIs in StarterGui, RemoteEvents and parts. Roblox documents two ways to do it.

The same file name can mean different things

Both tools pick the script type from the file name, and the suffixes do not line up. A .client file is a LocalScript in Rojo but a Script with a Client run context in Script Sync. Tell Claude which tool your project uses; the CLAUDE.md example below does.

Set up Script Sync for Claude Code

1. Make a project folder with one folder for each service you want on disk, for example ServerScriptService, ReplicatedStorage and StarterPlayerScripts, and run git init in it.
2. If Script Sync does not appear when you right-click a service, turn it on under File > Beta Features, click Save and restart Studio.
3. In the Explorer, right-click ServerScriptService, choose Script Sync > Sync to, and pick the top-level project folder, not a folder inside it. Repeat for the other services.
4. Run claude in that folder. Claude now edits .luau files, and Studio picks up each change.
5. Commit before each session, so you always have a clean point to go back to.

git add .
git commit -m "Before Claude session"

Two Script Sync rules matter more with an agent. Do not sync scripts that have attributes or tags: Script Sync ignores them, and Roblox warns that this can lead to data loss. And if files change while Studio is closed, Studio asks how to resolve it when you reopen the place, listing what Keep Studio and Keep Disk would add, change or delete. Read that list before you choose.

With Script Sync on, a file edit reaches Studio as soon as it is saved. Accepting an edit in Claude Code is accepting it into your place, so review before you accept, especially in modes that accept edits automatically.

For autocomplete and type errors in your editor, Roblox recommends the Luau Language Server extension with its companion Studio plugin. In VS Code, the Claude Code extension can read the Problems panel through a built-in tool, so Claude sees the same warnings you do.

Step 6: Give Claude your Roblox rules in CLAUDE.md

Every Claude Code session starts with a fresh context. A CLAUDE.md file in your project folder is read at the start of each session, so it is where your conventions go. Run /init to have Claude draft one, or write it yourself. Anthropic's advice is to keep it under 200 lines, write rules specific enough to check, and run /context to confirm it loaded.

This example was written for this guide, for a project that uses Script Sync. Change the names to match your game and cut what you do not need.

# Roblox project rules (example: edit to fit your game)

## Project
- Roblox game "Wave Survival". The place open in Studio is named WaveSurvival.
- Scripts sync to Studio with Script Sync:
  - ServerScriptService/ holds server game logic
  - ReplicatedStorage/ holds ModuleScripts shared by server and client
  - StarterPlayerScripts/ holds client code
- File names set the script type (Script Sync rules):
  - name.server.luau = Script with Server run context
  - name.local.luau = LocalScript
  - name.luau = ModuleScript
  - Do not use name.client.luau unless I ask. In Script Sync it makes a Script with Client run context, not a LocalScript.
- Never add attributes or tags to synced scripts. Script Sync ignores them.

## Roblox Studio MCP
- Call list_roblox_studios first. Work only in the place named WaveSurvival.
- Edit synced scripts as files, not with multi_edit.
- Use the MCP tools only for what is not a synced script: GUIs in StarterGui, RemoteEvents, parts, attributes.
- Never use insert_asset, upload_image or the generate tools unless I ask in this session.
- Ask before deleting any instance you did not create in this session.

## Luau
- Use task.wait, task.spawn and task.delay. Never wait, spawn or delay.
- Get services with game:GetService.
- The server decides coins, health, inventory and rewards. A LocalScript only asks.
- Every OnServerEvent handler checks the type and size of each argument and limits how often each player can call it.
- Wrap DataStore and HttpService calls in pcall and handle the failure.
- Remove per-player table entries in Players.PlayerRemoving.
- Never put API keys, webhook URLs or passwords in scripts or in this repository.

## Before you say a task is done
- List every script and instance you changed.
- Read the Output with get_console_output and report any errors.
- Tell me what to playtest by hand.

Some lines are there because of how the tools work. The file name rules exist because .client.luau is not a LocalScript in Script Sync. The list_roblox_studios line exists because the server can reach every open window. The asset line exists because insert_asset brings outside content into your place and upload_image sends images to Roblox's asset server. The wait line follows Roblox's API reference, which marks wait, spawn and delay as deprecated in favour of the task library.

If your project already has an AGENTS.md for other coding agents, Claude Code can read it as its project instructions, so you can keep one file for both. Anthropic's memory page explains which file wins when both exist.

What those rules look like in code

Here is a server script that follows the Luau rules above. It was written by hand for this guide, not generated by Claude. Use it as a yardstick when you review what Claude hands back. A LocalScript asks for a tool with RequestTool:FireServer("Sword"), and the server checks everything.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

local COOLDOWN_SECONDS = 1
local MAX_NAME_LENGTH = 50
local toolsFolder = ServerStorage:WaitForChild("Tools")

-- Script Sync only syncs scripts and folders, so the server makes its own remote.
local function getRemote(name: string): RemoteEvent
	local existing = ReplicatedStorage:FindFirstChild(name)
	if existing and existing:IsA("RemoteEvent") then
		return existing
	end
	local remote = Instance.new("RemoteEvent")
	remote.Name = name
	remote.Parent = ReplicatedStorage
	return remote
end

local requestTool = getRemote("RequestTool")
local lastRequest: { [Player]: number } = {}

local function onRequestTool(player: Player, toolName: unknown)
	-- Ignore a request that arrives after the player has left.
	if player.Parent ~= Players then
		return
	end

	-- 1. Check the argument: a client can send anything.
	if typeof(toolName) ~= "string" or #toolName == 0 or #toolName > MAX_NAME_LENGTH then
		return
	end

	-- 2. Limit how often one player can ask.
	local now = os.clock()
	local last = lastRequest[player]
	if last ~= nil and now - last < COOLDOWN_SECONDS then
		return
	end
	lastRequest[player] = now

	-- 3. The server decides. Add your own ownership check here (a game pass, a purchase record).
	local template = toolsFolder:FindFirstChild(toolName)
	if not (template and template:IsA("Tool")) then
		return
	end
	local backpack = player:FindFirstChildOfClass("Backpack")
	local character = player.Character
	if not backpack or backpack:FindFirstChild(toolName) then
		return
	end
	if character and character:FindFirstChild(toolName) then
		return
	end

	template:Clone().Parent = backpack
end

requestTool.OnServerEvent:Connect(onRequestTool)

-- 4. Per-player cleanup.
Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)

Look for the same things in any remote handler Claude writes: it checks the type and size of what the client sent, it limits how often one player can call it, the server makes the decision, and it removes the player's entry when they leave. The RemoteEvents guide explains why each one matters.

A safe way to work: checkpoint, review, playtest

1. Checkpoint both sides. Commit your files in Git, and save a version of the place in Studio with File > Save to Roblox with Notes. The Studio MCP guide shows how to restore one from Version History.
2. Ask for a plan for anything bigger than one script, and read it before you approve it.
3. Review the diff. For files, read git diff or the extension's inline diffs before you accept. For changes made in Studio, read the scripts Claude touched and check the Explorer for objects that appeared or disappeared.
4. Playtest it yourself. Claude can start a playtest and read the Output, but it only checks what it chose to check. Play the feature as a player would before you commit or publish.
5. Commit once it works, with a message that says what changed.

What /rewind can and cannot undo

Claude Code saves a checkpoint before each prompt, and /rewind (or Esc twice) restores files Claude changed with its file editing tools. Anthropic lists what it does not track, including changes made by shell commands. Changes made in Studio through MCP tools are not file edits, so do not expect /rewind to undo them, and Roblox's MCP page does not say whether they land in Studio's undo history. With Script Sync, a file that /rewind restores syncs back into Studio like any other change on disk. For everything else, your saved version is the way back.

Keep secrets and live data out of reach

• Do not paste API keys, Open Cloud keys, webhook URLs or passwords into a prompt or into CLAUDE.md. Both are text Claude reads, and CLAUDE.md is usually committed to your repository.
• Do not hard-code them in scripts either. Roblox has a secrets store for each game: create secrets in the Creator Dashboard and read them in a server script with HttpService:GetSecret(). For local playtests, add local secrets under File > Experience Settings > Security.
• Keep personal settings in .claude/settings.local.json and CLAUDE.local.md, which are meant to stay out of Git. Add CLAUDE.local.md to .gitignore yourself.
• Turn on Enable Studio Access to API Services only in a separate test copy of your game. Roblox warns that Studio uses the same data stores as the live game, so a playtest Claude starts there could overwrite real player data.
• Read a third-party skill before you install it. Skill directories list Roblox skills for Claude Code, and Anthropic notes that a skill can grant itself broad tool access through its allowed-tools field.

What Claude Code costs for Roblox work

The Studio side has no documented price: the MCP server is part of Studio, and Roblox's MCP page mentions no charge. The cost is Claude Code's, and Anthropic offers two ways to pay (as of 9 October 2026):

• A Claude subscription. Claude Code is included in Pro, Max, Team and Enterprise, not Free. It draws on the same usage as Claude on the web, desktop and mobile. Limits reset on a rolling five-hour window, and paid plans have weekly limits on top. When you reach one, you can wait, move to a higher plan, or turn on usage credits.
• A Claude Console account. You pay for API use by the token. Anthropic's costs page says spending varies widely with model choice, codebase size and how you use it.

Current prices are on claude.com/pricing. This guide does not repeat them because they change. Inside Claude Code, /usage shows plan usage bars for subscribers and an estimated session cost for API users.

What makes a Roblox session use more

• Context size. Token use grows with what Claude has in context. Use /clear between unrelated tasks.
• Large tool results. Walking the whole game tree of a big place or reading long scripts in full returns a lot of text. Claude Code warns when an MCP tool result passes 10,000 tokens and limits it to 25,000 by default. Ask for one folder, a depth limit or a line range instead: search_game_tree and script_read both support that.
• Model choice. Anthropic says Sonnet handles most coding tasks well and costs less than Opus. Switch with /model.

Troubleshooting Claude Code and Studio

Roblox's own checklist is short: restart Studio and the client, check that the command path exists, and check the JSON. These are the cases specific to Claude Code.

Or use a plugin agent instead: RoCode

Claude Code with MCP suits people who are comfortable in a terminal or code editor. RoCode (RoCode.app) is a different route: an independent AI agent for Roblox Studio, with a web chat at rocode.app and a free plugin from the Creator Store that carries out the steps in the place you have open. It is not an MCP product and does not use Studio's MCP server, so there is no command line, config file or MCP server to set up. You pair the chat and the plugin once with the 8-character code shown in the plugin panel.

What to know before you switch. RoCode cannot connect a Claude or Claude Code subscription. It runs third-party models through OpenRouter, including Claude Sonnet 5.5 on Pro and up and Claude Opus 5.5 on Studio and up, and the free Starter plan gives 3 credits a day on DeepSeek V4 Flash or GPT-OSS 120B. It works in edit mode only: it does not start playtests, run code, insert Creator Store models or generate meshes, all of which the Studio MCP tools can do. Its Ask mode answers questions about your place with read-only tools and changes nothing. Accounts are for ages 13 and up, with a parent or guardian's permission under 18.

Press Play yourself to test the result: RoCode does not start playtests. The prompt is an example written by us; the steps use the real tool names. How the plugin and pairing work. RoCode is an independent product, not affiliated with, endorsed by or sponsored by Roblox Corporation.

Questions

Sources and further reading

• Roblox Creator Docs: Connect to the Roblox Studio MCP server. enabling the server, quick connect, JSON and CLI setup, the tools, several Studio windows and troubleshooting
• Roblox Creator Docs: Build with a coding harness. Claude Code in VS Code, Script Sync, MCP and Git together
• Roblox Creator Docs: Script Sync. what syncs, file naming rules, conflicts and the language server
• Roblox Creator Docs: Third-party tools. Rojo with Rokit and version control
• Roblox Creator Docs: Secrets stores. keeping API keys out of scripts
• Roblox Creator Docs: Data stores. why Studio access to API services belongs on a test copy
• Rojo documentation (v7). installation and how file names map to instances
• Claude Code Docs: Overview. the surfaces share one engine, and the desktop app needs a paid subscription
• Claude Code Docs: Advanced setup. system requirements and install commands
• Claude Code Docs: Authentication. signing in and the account types that work
• Claude Code Docs: Connect Claude Code to tools via MCP. stdio servers, .mcp.json, scopes and server status
• Claude Code Docs: Configure permissions. allow, ask and deny rules, including MCP tools
• Claude Code Docs: Choose a permission mode. auto mode as the starting mode, Manual mode and plan mode
• Claude Code Docs: How Claude remembers your project. CLAUDE.md, /init and AGENTS.md
• Claude Code Docs: Checkpointing. what /rewind restores and what it does not track
• Claude Code Docs: Manage costs effectively. /usage, context size and model choice
• Claude Code Docs: Use Claude Code in the cloud. why cloud sessions do not run on your machine
• Claude Code Docs: Use Claude Code in VS Code. requirements, the PATH note, shared MCP configuration and the Problems panel
• Claude Code Docs: Extend Claude with skills. what a skill's allowed-tools field grants
• Claude pricing. which plans include Claude Code, and usage limits
• Claude Help Center: Use Claude Code with your Pro or Max plan. shared limits and the ANTHROPIC_API_KEY warning
• Anthropic: Consumer Terms of Service. minimum age

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 9 October 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.