Cómo crear juegos de Roblox con IA usando MCP y Claude Code

El Model Context Protocol (MCP) permite que asistentes de IA como Claude Code se comuniquen directamente con Roblox Studio: pueden leer tu escena, escribir scripts, insertar objetos y ejecutar código en tiempo real. En lugar de copiar y pegar fragmentos de un lado a otro, tienes un puente bidireccional en vivo entre la IA y tu juego.

Este artículo te guía desde cero hasta un nivel avanzado: primero configurarás la conexión y luego crearás funciones cada vez más complejas con Claude Code como tu compañero de desarrollo.

Cómo funciona el puente MCP

Claude Code  ──stdio──►  MCP Server (local binary)  ──HTTP poll──►  Roblox Studio Plugin
                                                                      │
                                                                      └── reads/writes your Place

El servidor MCP se ejecuta en tu máquina. Un plugin de Studio consulta continuamente el servidor mediante long polling para recibir comandos. Cuando Claude llama a una herramienta (por ejemplo, run_code), el plugin la ejecuta dentro de Studio y devuelve el resultado. Nada sale de tu máquina excepto los prompts que envías a Claude.

Configuración

1. Instala el servidor MCP

Roblox ahora incluye un servidor MCP integrado en Studio (desde febrero de 2026). Es la opción recomendada y no requiere instalar el toolchain de Rust.

Abre Roblox Studio → File → Studio Settings → Beta Features → activa MCP Server.

Por defecto, Studio comenzará a escuchar en localhost:3004.

Para consultar el servidor independiente de código abierto (versión anterior), visita el repositorio studio-rust-mcp-server. Ya no se actualiza activamente, pero sirve como referencia.

2. Regístralo en Claude Code

claude mcp add roblox-studio --transport http http://localhost:3004/mcp

O, si usas el binario independiente en macOS:

claude mcp add --transport stdio roblox_studio \
  -- '/Applications/RobloxStudioMCP.app/Contents/MacOS/rbx-studio-mcp' --stdio

Verifica que las herramientas estén disponibles:

claude mcp list
# roblox-studio  ✓  tools: run_code, insert_model, get_console_output, ...

3. Abre un lugar en Studio

Los comandos MCP operan sobre el lugar abierto actualmente. Abre cualquier baseplate y mantén Studio visible: verás los cambios en vivo mientras Claude trabaja.

Principiante: crear objetos y ejecutar scripts

Crea una pieza de color

Dile a Claude:

“En Roblox Studio, crea una pieza tipo ladrillo de color rojo brillante en la posición (0, 5, 0) con un tamaño de (4, 4, 4).”

Claude llama a run_code con:

local part = Instance.new("Part")
part.Size = Vector3.new(4, 4, 4)
part.Position = Vector3.new(0, 5, 0)
part.BrickColor = BrickColor.new("Bright red")
part.Anchored = true
part.Parent = workspace

La pieza aparece al instante en Studio.

Imprime el contenido del workspace

“Lista todos los objetos que están actualmente en Workspace.”

for _, obj in ipairs(workspace:GetChildren()) do
    print(obj.Name, obj.ClassName)
end

Después, Claude llama a get_console_output para leer el resultado y te muestra la lista directamente en el chat.

Inserta un modelo gratuito

“Inserta un SpawnLocation desde la Creator Store.”

Claude llama a insert_model con el ID del asset. El modelo aparece en tu escena sin que tengas que buscarlo manualmente en la caja de herramientas.

Intermedio: crear sistemas de juego

Sistema básico para recoger monedas

“Crea un sistema para recoger monedas. Las monedas deben ser esferas amarillas distribuidas en posiciones aleatorias. Cuando un jugador toque una, debe desaparecer e imprimir un mensaje.”

Claude escribe e inserta dos scripts:

ServerScript (dentro de ServerScriptService):

local function createCoin(position)
    local coin = Instance.new("Part")
    coin.Name = "Coin"
    coin.Shape = Enum.PartType.Ball
    coin.Size = Vector3.new(1, 1, 1)
    coin.BrickColor = BrickColor.new("Bright yellow")
    coin.Material = Enum.Material.Neon
    coin.Position = position
    coin.Anchored = true
    coin.Parent = workspace

    coin.Touched:Connect(function(hit)
        local character = hit.Parent
        local player = game.Players:GetPlayerFromCharacter(character)
        if player then
            print(player.Name .. " collected a coin!")
            coin:Destroy()
        end
    end)
end

-- Spawn 10 coins at random positions
for i = 1, 10 do
    local x = math.random(-20, 20)
    local z = math.random(-20, 20)
    createCoin(Vector3.new(x, 2, z))
end

Luego le pides a Claude que lo pruebe:

“Inicia el modo de juego y dime si las monedas aparecieron correctamente.”

Claude llama a start_stop_play, espera y luego lee get_console_output para informarte del resultado.

Tabla de clasificación con puntos

“Agrega una tabla de clasificación que registre la cantidad de monedas de cada jugador. Incrementa el conteo cuando recojan una moneda.”

Claude actualiza el script para usar leaderstats:

game.Players.PlayerAdded:Connect(function(player)
    local leaderstats = Instance.new("Folder")
    leaderstats.Name = "leaderstats"
    leaderstats.Parent = player

    local coins = Instance.new("IntValue")
    coins.Name = "Coins"
    coins.Value = 0
    coins.Parent = leaderstats
end)

Y modifica el manejador de contacto:

local player = game.Players:GetPlayerFromCharacter(character)
if player then
    player.leaderstats.Coins.Value += 1
    coin:Destroy()
end

Avanzado: flujos de trabajo con agentes

En este nivel dejas de darle instrucciones individuales a Claude y empiezas a darle objetivos. Claude planifica, ejecuta varias llamadas a herramientas, lee los resultados e itera, igual que lo haría un desarrollador júnior.

Genera un circuito de obstáculos completo

“Diseña un circuito de obstáculos de 10 etapas que vaya de fácil a difícil. Cada etapa debe tener una mecánica diferente: plataformas móviles, pisos de lava y caminos que se estrechan. Agrega puntos de control entre las etapas.”

Claude lo divide en pasos automáticamente:

Llama a run_code para limpiar el estado inicial del workspace
Genera cada etapa en un bucle, con distintas configuraciones de piezas para cada una
Inserta puntos de control SpawnPart con hooks de TeleportService
Inicia el modo de juego mediante start_stop_play para verificar que el recorrido se pueda completar
Lee get_console_output para detectar errores
Corrige las etapas con problemas y vuelve a probarlas

Un solo prompt no se encarga de todo esto: Claude encadena llamadas a herramientas hasta que considera satisfactorio el resultado.

Encuentra y corrige API obsoletas

“Examina cada Script y LocalScript del juego. Lista los que usen API obsoletas de Roblox y reescríbelos para que usen sus equivalentes actuales.”

-- Claude uses run_code to enumerate scripts:
local function scanScripts(parent, results)
    for _, obj in ipairs(parent:GetDescendants()) do
        if obj:IsA("Script") or obj:IsA("LocalScript") then
            table.insert(results, {name = obj:GetFullName(), source = obj.Source})
        end
    end
end

local results = {}
scanScripts(game, results)
for _, s in ipairs(results) do
    print("===", s.name)
    print(s.source)
end

Claude lee la salida de la consola, identifica usos como game.Players.LocalPlayer.Character.Humanoid.Health (un patrón obsoleto) y reescribe cada script en su lugar con una llamada posterior a run_code.

Comportamiento de NPC controlado por IA

“Crea un NPC que patrulle entre 3 puntos de ruta. Si un jugador se acerca a menos de 10 studs, el NPC lo persigue. Si el jugador se aleja hasta 30 studs, el NPC vuelve a patrullar.”

Claude genera un script completo de máquina de estados:

local NPC = workspace.NPC  -- Claude inserts the NPC model first
local humanoid = NPC:FindFirstChild("Humanoid")
local rootPart = NPC:FindFirstChild("HumanoidRootPart")

local waypoints = {
    Vector3.new(0, 0, 0),
    Vector3.new(20, 0, 0),
    Vector3.new(20, 0, 20),
}
local currentWaypoint = 1
local state = "patrol"  -- "patrol" | "chase"
local CHASE_RANGE = 10
local ESCAPE_RANGE = 30

local function getNearestPlayer()
    local nearest, dist = nil, math.huge
    for _, p in ipairs(game.Players:GetPlayers()) do
        local char = p.Character
        if char and char:FindFirstChild("HumanoidRootPart") then
            local d = (char.HumanoidRootPart.Position - rootPart.Position).Magnitude
            if d < dist then nearest, dist = p, d end
        end
    end
    return nearest, dist
end

game:GetService("RunService").Heartbeat:Connect(function()
    local player, dist = getNearestPlayer()

    if state == "patrol" then
        if dist <= CHASE_RANGE then
            state = "chase"
        else
            humanoid:MoveTo(waypoints[currentWaypoint])
            if (rootPart.Position - waypoints[currentWaypoint]).Magnitude < 3 then
                currentWaypoint = (currentWaypoint % #waypoints) + 1
            end
        end
    elseif state == "chase" then
        if dist > ESCAPE_RANGE then
            state = "patrol"
        elseif player.Character then
            humanoid:MoveTo(player.Character.HumanoidRootPart.Position)
        end
    end
end)

Después de insertar el script, Claude inicia el modo de juego, lee la consola e informa si el NPC se mueve correctamente.

Referencia de prompts útiles

Objetivo	Prompt
Inspeccionar la escena	”Lista todos los objetos en Workspace con su clase y posición.”
Crear un prototipo rápido	”Crea una puerta funcional que se abra cuando un jugador toque un botón.”
Depurar errores	”Ejecuta el juego, recopila los errores de la consola y corrígelos.”
Hacer cambios masivos	”Cambia el nombre de cada Part llamado ‘Block’ a ‘Platform’ en todo el juego.”
Auditar el rendimiento	”Encuentra scripts que usen bucles sin `task.wait()` y agrega pausas apropiadas.”
Insertar assets	”Inserta un modelo de árbol desde la Creator Store y coloca 20 copias en posiciones aleatorias.”

Consideraciones de seguridad

El servidor MCP se ejecuta localmente: ningún dato del juego sale de tu máquina hacia Roblox.
Tus prompts sí se envían a los servidores de Anthropic (la API de Claude). Evita incluir contraseñas, claves de API o datos privados de usuarios en los prompts.
Conecta únicamente clientes MCP de confianza (versiones oficiales de Claude, Cursor). El servidor otorga acceso de escritura programático al lugar que tienes abierto.
El servidor MCP integrado de Roblox respeta el historial de deshacer de Studio: puedes usar Ctrl+Z para revertir los cambios que haga Claude.

Cómo crear juegos de Roblox con IA usando MCP