> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/vibe-coding.md).

# Vibe Coding con IA

Crea escenas de Decentraland con asistentes de IA usando Creator Hub y las SDK Skills oficiales de Decentraland (npx skills add decentraland/sdk-skills).

Crea Scenes de Decentraland describiendo lo que quieres. Un asistente de IA se encarga por ti del código de SDK7, la arquitectura ECS y la estructura del proyecto.

Tanto si eres un creador que empieza como si eres un desarrollador con experiencia, la «programación por intuición» asistida por IA te permite pasar de una idea a una Scene en funcionamiento en minutos, en lugar de horas.

{% hint style="info" %}
**💡 Consejo**: No necesitas saber TypeScript para empezar. Los asistentes de IA pueden generar código funcional para una Scene a partir de descripciones en lenguaje natural.
{% endhint %}

## ¿Qué es la programación por intuición?

La programación por intuición consiste en crear Scenes conversando con un asistente de IA, en lugar de escribir a mano cada línea de código. Describes lo que quieres —«una taberna medieval con puertas en las que se pueda hacer clic y música de fondo»— y la IA escribe código correcto y listo para implementar con SDK7.

Este enfoque funciona con cualquier nivel de experiencia:

* **Principiantes y personas que no desarrollan** — Pasa de cero a una Scene funcional sin escribir código manualmente.
* **Desarrolladores con experiencia** — Evita el código repetitivo. Deja que la IA se encargue de la sincronización multijugador, la estructura inicial de la UI y la configuración de implementación mientras tú te centras en las decisiones creativas.
* **Equipos y estudios** — Crea prototipos de conceptos de Scenes rápidamente antes de dedicar recursos de desarrollo a fondo.

## Usa el asistente de IA en Creator Hub

La forma más rápida de empezar es con el [Asistente de IA](https://docs.decentraland.org/creator/content-creator-es/scene-editor/extender-con-codigo/ai-assistant.md) integrado en Creator Hub. Puede ver la Scene que tienes abierta, editar Entities, Components, Smart items y código por ti, y ejecutar el Preview para revisar su propio trabajo. Instala automáticamente en tu proyecto las Skills que aparecen a continuación, así que no tienes que configurar nada más que iniciar sesión en una CLI de programación.

Es una función experimental que está desactivada de forma predeterminada.

## Combina un editor de código con IA

Usa un editor de código de IA de propósito general, como [Cursor](https://www.cursor.com/) o VS Code con GitHub Copilot o Claude AI. Decentraland proporciona una carpeta de contexto para que estas herramientas entiendan el SDK.

1. Abre Creator Hub y crea o abre una Scene.
2. Haz clic en el botón **< > CODE** para abrir tu editor de código.
3. Usa el asistente de IA integrado en el editor (el chat de Cursor, Copilot, etc.) para generar o modificar código.

## Instala Skills para cualquier agente de IA

Las Skills son conjuntos de instrucciones listas para usar que enseñan a tu agente de IA a trabajar con el SDK de Decentraland. Cada Skill abarca un tema específico, como crear Scenes, añadir modelos 3D o configurar el modo multijugador. Así, la IA ya conoce los patrones, las API y las limitaciones adecuadas, sin que tengas que explicárselos. Instalar Skills reduce los errores y mejora los resultados desde el primer prompt.

```bash
# Elige qué skills de Decentraland instalar mediante un selector interactivo
npx skills add decentraland/sdk-skills

# O instala todas las skills de Decentraland
npx skills add decentraland/sdk-skills --all

# O elige skills específicas
npx skills add decentraland/sdk-skills --skill create-scene

# Instala globalmente (disponibles en todos los proyectos)
npx skills add decentraland/sdk-skills -g
```

Esto copia los archivos de las Skills en la configuración de tu agente para que conozca los patrones y las limitaciones de Decentraland.

## Actualizar Skills

Se añaden nuevas Skills con el tiempo y se mejoran las existentes. Para obtener las versiones más recientes, vuelve a ejecutar el comando de instalación con `--all`:

```bash
# Actualiza todas las skills instaladas y descarga las nuevas
npx skills add decentraland/sdk-skills --all
```

Ejecutar `add` de nuevo vuelve a descargar el repositorio, por lo que actualiza las Skills que ya tienes e instala las que se hayan añadido desde la primera instalación. Si instalaste Skills globalmente, añade `-g` también a este comando.

{% hint style="warning" %}
**📔 Nota**: No uses `npx skills update` para esto. Solo actualiza las skills que ya están en tu equipo, por lo que las skills que se hayan añadido al repositorio después de la última instalación se omiten sin aviso. Usa siempre `npx skills add decentraland/sdk-skills --all` en su lugar.
{% endhint %}

## Depurar una Scene multijugador desplegada

La skill `authoritative-server` actualizada puede buscar en los logs persistentes del servidor, seguir los logs durante un periodo limitado y obtener métricas de CPU, memoria y otros recursos cuando le pides que investigue una Scene desplegada. Actualiza tus skills y el `auth-server` de la Scene primero; consulta [Scene Insights](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/depuracion/scene-insights.md) para conocer la configuración, los permisos y los límites.

Por ejemplo, pregunta:

> Investiga los errores y el aumento del uso de CPU o memoria en mi Scene multijugador desplegada durante las últimas dos horas. Usa Scene Insights y relaciona los logs y las métricas con el código fuente.

Tú apruebas el inicio de sesión con Wallet en el navegador. Después, el asistente puede reutilizar la sesión de solo lectura; no necesita tu clave privada ni el archivo de sesión.

## Skills de IA disponibles

Al instalar skills en tu agente, estarán disponibles las siguientes capacidades:

| Skill                  | Qué hace                                                                              |
| ---------------------- | ------------------------------------------------------------------------------------- |
| `sdk-scenes`           | Punto de entrada con pautas para agentes e índice de todas las skills temáticas       |
| `create-scene`         | Crear desde cero la estructura de un nuevo proyecto de Scene con SDK7                 |
| `migrate-sdk6-to-sdk7` | Migrar una Scene heredada de SDK6 a SDK7                                              |
| `add-3d-models`        | Añadir modelos 3D (`.glb`/`.gltf`) con posicionamiento, escalado y Colliders          |
| `add-interactivity`    | Pointer Events, Triggers y Raycasts                                                   |
| `build-ui`             | UI 2D en el espacio de pantalla con React-ECS: HUDs, menús y cuadros de diálogo       |
| `animations-tweens`    | Animaciones de modelos GLTF con Animator y Tweens del SDK                             |
| `multiplayer-sync`     | Multijugador entre pares mediante redes CRDT                                          |
| `authoritative-server` | Servidor multijugador sin interfaz para Scenes validadas por el servidor (BETA)       |
| `audio-video`          | Efectos de sonido, música, streaming de audio y reproductores de video                |
| `audio-analysis`       | Datos de amplitud y frecuencia en tiempo real para Scenes que reaccionan al audio     |
| `deploy-scene`         | Desplegar Scenes en Genesis City (basadas en LAND)                                    |
| `deploy-worlds`        | Desplegar Scenes en Worlds (espacios 3D personales)                                   |
| `optimize-scene`       | Optimización del rendimiento, límites de las Scenes y prácticas recomendadas          |
| `camera-control`       | Detección del modo de cámara, cámara cinematográfica, cámaras virtuales               |
| `composites`           | Referencia del formato de archivo Composite para contenido de escenas estáticas       |
| `lighting-environment` | Iluminación dinámica, sombras, skybox, niebla, ajustes del entorno                    |
| `particle-system`      | Efectos de partículas: fuego, humo, chispas, nieve, fuegos artificiales               |
| `npcs`                 | Personajes no jugadores: biblioteca NPC Toolkit y métodos manuales                    |
| `player-avatar`        | Posición del jugador, perfil, personalización del Avatar, accesorios                  |
| `player-physics`       | Fuerzas físicas: impulsos, retroceso, fuerzas continuas                               |
| `nft-blockchain`       | Visualización de NFT e interacciones con blockchain/cripto                            |
| `advanced-rendering`   | Billboard, TextShape, materiales PBR, materiales de video                             |
| `advanced-input`       | Lectura de entrada a nivel de sistema y control del movimiento del jugador            |
| `scene-runtime`        | API de runtime transversales: tareas asíncronas, HTTP, mensajería                     |
| `script-components`    | Clases de componentes de script para Creator Hub                                      |
| `game-design`          | Patrones de diseño de juegos, límites de escenas, presupuestos de rendimiento         |
| `unity-explorer-mcp`   | Controla un Explorer en ejecución para probar y verificar una escena dentro del mundo |

Nota: Algunas de estas habilidades implican obtener modelos 3D u otros recursos de catálogos gratuitos. El agente de IA siempre debe pedir confirmación al usuario antes de descargar nuevos recursos en un proyecto de escena.

## Permite que la IA vea tu escena dentro del mundo

Normalmente, la IA escribe código y *tú* ejecutas la vista previa, la revisas e informas de lo que está mal. El cliente de escritorio de Decentraland puede cerrar ese ciclo: incluye un servidor opcional **MCP** que permite a un agente de IA ver y controlar directamente el Explorer en ejecución. El agente toma sus propias capturas de pantalla, lee la salida de la consola de la escena, mueve al jugador, hace clic en los objetos y comprueba si la escena realmente hace lo que se le pidió que creara; luego corrige lo que encuentra y vuelve a revisarla.

Esto convierte la programación por intuición en un ciclo que el agente puede ejecutar casi por su cuenta, en lugar de «describir, esperar y revisar».

{% hint style="info" %}
**💡 Consejo**: Instala la habilidad `unity-explorer-mcp` antes de probar esto. Enseña al agente todo el flujo de trabajo: cómo iniciar el cliente, cómo encuadrar capturas de pantalla útiles, cómo contrastar lo que ve con el estado real de la escena y cómo recuperarse cuando la escena deja de cargar.

```bash
npx skills add decentraland/sdk-skills --skill unity-explorer-mcp
```

{% endhint %}

### Qué necesitas

* El **cliente de escritorio de Decentraland** instalado (el mismo que Creator Hub inicia para las vistas previas).
* Un agente de IA que pueda conectarse a servidores MCP mediante HTTP: Claude Code, Cursor, Cline, VS Code con una extensión compatible con MCP, entre otros.
* Un SDK actualizado en tu escena: ejecuta `npm i @dcl/sdk@latest` si se rechaza la opción `--mcp` de abajo por ser una opción desconocida.

### 1. Inicia la escena con el servidor MCP habilitado

Desde la carpeta de la escena:

```bash
npm run start -- --mcp
```

Esto hace lo que `npm run start` hace siempre: sirve la escena en `http://127.0.0.1:8000` y la recarga automáticamente cada vez que guardas un archivo; además, inicia el cliente de escritorio con el servidor MCP escuchando en `http://127.0.0.1:8123/unity-explorer-mcp`.

Inicia sesión cuando se abra el cliente. El agente no podrá empezar a trabajar hasta que hayas pasado la pantalla de inicio de sesión y se haya cargado el mundo.

### 2. Conecta tu agente de IA al servidor

En **Claude Code**, regístralo una sola vez:

```bash
claude mcp add --transport http --scope user explorer http://127.0.0.1:8123/unity-explorer-mcp
```

En **cualquier otro cliente MCP**, añade el servidor siguiendo las instrucciones de ese cliente y usando estos datos:

| Configuración | Valor                                                                                                              |
| ------------- | ------------------------------------------------------------------------------------------------------------------ |
| Transporte    | HTTP transmitible (no stdio: no hay ningún comando que ejecutar; el servidor se ejecuta dentro del cliente activo) |
| URL           | `http://127.0.0.1:8123/unity-explorer-mcp`                                                                         |
| Autenticación | Ninguna                                                                                                            |
| Nombre        | `explorer`                                                                                                         |

Muchos clientes usan un archivo de configuración JSON para esto (`.cursor/mcp.json`, `mcp.json`y otros similares; consulta la documentación de tu cliente para conocer los nombres exactos de las claves):

```json
{
  "mcpServers": {
    "explorer": {
      "type": "http",
      "url": "http://127.0.0.1:8123/unity-explorer-mcp"
    }
  }
}
```

Reinicia o vuelve a cargar tu cliente de IA después de registrar el servidor para que detecte la conexión. Si el agente indica que las herramientas de Explorer no están disponibles, la causa más habitual es que el cliente no estaba en ejecución cuando se inició el agente. Vuelve a conectar el servidor (en Claude Code, ejecuta `/mcp`) con Explorer abierto.

{% hint style="info" %}
**¿Es seguro?** El servidor solo se ejecuta cuando inicias el cliente con `--mcp`, solo acepta conexiones desde tu propio equipo (`127.0.0.1`) y rechaza las solicitudes procedentes de páginas web. No se expone nada a Internet y permanece completamente desactivado cuando se inicia el cliente de forma normal.
{% endhint %}

### 3. Pide lo que quieras y deja que lo verifique

Con el servidor conectado, pide lo que necesites como lo harías normalmente; la diferencia es que ahora el agente puede comprobar sus propios resultados:

> «Añade un cofre del tesoro en el centro del parcel que se abra al hacer clic y luego acércate y haz clic en él para confirmar que la tapa se anima».

> «El letrero de neón se ve demasiado tenue. Haz una captura de pantalla, ajusta la intensidad emisiva y muéstrame el antes y el después».

> «Algo no funciona con el ascensor. Súbete a la plataforma, revisa los registros y dime por qué no se mueve».

En segundo plano, el agente puede:

* **Ver** — tomar capturas de pantalla, leer la salida de `console.log` y los errores de la escena, comprobar si se cargó o se bloqueó, enumerar sus entidades e inspeccionar sus componentes, y leer la posición del jugador y de la cámara.
* **Controlar** — mover y teletransportar al jugador, caminar en una dirección teniendo en cuenta las colisiones reales, apuntar la cámara, colocar una cámara libre para una toma específica, cambiar de modo de cámara, hacer clic en los objetos de la escena, enviar mensajes de chat y `/commands`, activar emotes y volver a cargar la escena.
* **Medir** — consultar en tiempo real los recuentos del contenido de la escena (triángulos, entidades, texturas, materiales y más) y compararlos con los límites de Decentraland, determinar qué modelos 3D contribuyen más a esa carga desde cualquier punto de vista y medir la velocidad de fotogramas real que experimenta el jugador en cualquier lugar.

### Úsalo para optimizar tu escena

Como el agente puede medir además de observar, puedes asignarle directamente tareas de rendimiento. Puede comprobar tu escena con respecto a las [limitaciones de la escena](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/optimizacion/scene-limitations.md), identificar qué modelos 3D son los más pesados, medir la velocidad de fotogramas en lugares específicos y, lo más importante, volver a medir después de hacer cambios para demostrar que dieron resultado:

> «Comprueba si mi escena está dentro de los límites de contenido de Decentraland e indícame qué presupuesto está más cerca del límite»

> «La escena se entrecorta cerca de la fuente. Ve hasta allí, mide la velocidad de fotogramas e indícame qué modelos consumen más recursos desde ese lugar»

> «Optimiza la escena: encuentra qué está reduciendo la velocidad de fotogramas, corrígelo y muéstrame las mediciones de antes y después»

Para obtener los mejores resultados, instala la `optimize-scene` skill junto con `unity-explorer-mcp`, para que el agente también conozca las prácticas recomendadas de optimización de Decentraland. Consulta [Optimización del rendimiento](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/optimizacion/performance-optimization.md#optimize-with-ai) para obtener más información sobre este flujo de trabajo, incluido cómo combinarlo con el servidor Blender MCP para automatizar las correcciones en los propios modelos 3D.

### Consejos

* **Pide pruebas, no afirmaciones.** Pedir «Verifícalo con una captura de pantalla» o «Confírmalo en los registros» es lo que hace que este flujo de trabajo valga la pena. Un buen agente comprueba ambas cosas: la imagen puede parecer correcta mientras el estado subyacente está dañado, y también puede ocurrir lo contrario.
* **Las capturas de pantalla consumen tokens.** Cada captura de pantalla que el agente examina consume parte de su contexto. Si quieres hacer una revisión visual prolongada —una animación a lo largo del tiempo o un recorrido por muchos lugares—, pídele que guarde fotogramas en archivos y que solo lea los que importan. La skill `unity-explorer-mcp` incluye un script que hace exactamente eso.
* **Guarda una vez, no cinco veces seguidas.** Guardar varias veces seguidas y rápidamente puede hacer que el cliente cargue un paquete escrito a medias y descarte por completo la escena; para recuperarla, hay que reiniciar el cliente. Pídele al agente que agrupe sus cambios en un solo guardado.
* **Mantén el cliente abierto.** Si lo cierras, se interrumpe la conexión y el agente se queda sin poder ver. Volver a iniciarlo con el mismo comando restablece la conexión.
* **Los teletransportes funcionan de manera distinta durante el desarrollo local de escenas.** En ese entorno, no se permite moverse entre parcelas con `/goto` , así que el agente debe cambiar la posición del jugador dentro de la escena en vez de teletransportarlo.

## Consejos para escribir prompts eficaces

Para obtener los mejores resultados de la IA, escribe prompts claros y específicos. Aquí tienes algunos consejos:

### Especifica lo que quieres

En lugar de:

> «Mejora mi escena»

Prueba con:

> «Añade una puerta en la posición (8, 0, 8) que se abra con una animación de rotación al hacer clic y reproduzca un efecto de sonido chirriante»

### Haz referencia a elementos existentes

> «Haz que el botón rojo de la mesa active el ascensor para que suba»

### Pide una cosa a la vez

Divide las solicitudes complejas en pasos:

1. «Añade una UI de marcador en la esquina superior derecha»
2. "Añade un contador que aumente cuando el jugador haga clic en el objetivo"
3. "Muestra el valor del contador en el marcador"

### Itera y perfecciona

Después de cada cambio:

1. Previsualiza la Scene (haz clic en **Play** en Creator Hub, o ejecuta `npm run start` en la línea de comandos)
2. Comprueba qué funciona y qué no
3. Dile a la IA qué debe ajustar: "Mueve al NPC 2 metros a la izquierda y haz que mire al jugador"

### Ejemplos de prompts

Para ejecutarse en un clon limpio de [sdk7-scene-template](https://github.com/decentraland/sdk7-scene-template/).

#### Ejemplo de prompt 1

```
Quiero que descartes el código actual de la escena y crees un juego de laberinto pequeño y sencillo en un solo Parcel. Las paredes pueden ser cubos y deben tener colisión.

El juego debe empezar cuando el jugador entre realmente al laberinto por el punto A y terminar cuando salga por el punto B (la única salida del laberinto).

Quiero que añadas 3 puertas diferentes al laberinto, con las que se pueda interactuar usando la acción de apuntar para abrirlas y pasar.

Debes verificar que el jugador realmente pueda jugar y ganar
```

#### Ejemplo de prompt 2

```
Quiero que descartes el código actual de la escena y crees un juego de plataformas sencillo.

Debes verificar que se pueda ganar el juego antes de considerarlo terminado.
```

## En qué puede ayudar la IA

* Crear la estructura inicial de nuevas Scenes a partir de una descripción
* Añadir y posicionar modelos 3D
* Escribir controladores de clic e interactividad
* Crear UI (HUD, menús y diálogos)
* Configurar la sincronización del modo Multiplayer
* Configurar el Multiplayer Server para evitar trampas
* Añadir audio, video y streaming
* Crear animaciones y tweens
* Optimizar el rendimiento de la Scene
* Preparar Scenes para el Deploy
* Depurar problemas en el código existente
* Probar y verificar visualmente una Scene en un Explorer en ejecución (consulta [Permite que la IA vea tu Scene dentro del mundo](#let-the-ai-see-your-scene-in-world))

## Limitaciones

Aunque las herramientas de IA son potentes, ten en cuenta lo siguiente:

* **Previsualiza siempre** — Es posible que el código generado por IA no se vea exactamente como esperas. Ejecuta una Preview para verificarlo.
* **Los límites de las Scenes siguen vigentes** — La IA no puede eludir las [limitaciones de las Scenes](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/optimizacion/scene-limitations.md) de Decentraland (cantidad de triángulos, tamaño de los archivos y límites de los Parcels).
* **Lógica de juego compleja** — Para mecánicas de juego complejas, quizá tengas que guiar a la IA paso a paso o perfeccionar manualmente el resultado.
* **Modelos 3D personalizados** — La IA puede hacer referencia a Assets gratuitos existentes o cargar modelos que proporciones, pero no puede crear modelos 3D desde cero (a menos que también uses otras herramientas, como el servidor MCP oficial de Blender).

## Próximos pasos

* [Inicio rápido del SDK](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/sdk-101.md) — Aprende los fundamentos de SDK7
* [Combinar con código](https://docs.decentraland.org/creator/content-creator-es/scene-editor/extender-con-codigo/overview.md) — Combina la edición visual con código
* [Servidor multijugador](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/networking/authoritative-servers.md) — Multijugador con autoridad del servidor
* [Ejemplos de escenas](https://docs.decentraland.org/creator/content-creator-es/tutoriales-y-ejemplos/examples.md) — Explora mecánicas de escenas reutilizables y repositorios
* [Recursos útiles](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/useful-resources.md) — Más herramientas de IA, bibliotecas de recursos y complementos para agilizar tu flujo de trabajo


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/vibe-coding.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
