Cómo configurar VS Code con opencode, GPT-5.5, Codex 5.3, skills y MCPs

El stack moderno para programar con IA ya no es solo “abrir un chat y pedir código”. Cada vez más equipos trabajan con un entorno agentic: un modelo principal, agentes especializados, skills reutilizables, MCPs para herramientas externas y permisos para evitar que la IA toque más de la cuenta.

Esta guía explica cómo pensar y configurar un flujo con VS Code + opencode, usando modelos como GPT-5.5 para razonamiento/orquestación y Codex 5.3 para implementación, siempre que tu proveedor o cuenta los tenga disponibles.

Antes de empezar: nombres de modelos y acceso

Los nombres exactos de modelos cambian según proveedor, cuenta, región y producto. En opencode el formato habitual es:

provider/model-id

Por ejemplo, si tu proveedor expone esos modelos, podrías ver identificadores como:

openai/gpt-5.5
Si esos IDs no existen en tu cuenta, opencode no podrá usarlos aunque estén en una guía. Comprueba siempre la lista real de modelos disponibles en tu proveedor.

Qué papel cumple cada pieza

VS Code: editor, terminal integrada, Git, extensiones y navegación por el proyecto.
opencode: interfaz agentic para trabajar con modelos, agentes, permisos, skills y MCPs.
GPT-5.5: buen candidato para planificación, análisis, arquitectura, revisión y decisiones con contexto amplio.
Codex 5.3: buen candidato para implementación, edición de código, tests y resolución de errores, si está disponible.
Claude Code: otra superficie agentic popular para desarrollo; útil compararla con opencode según permisos, agentes, costes y flujo.
Hermes Agent: enfoque de agente/orquestador para ejecutar flujos más largos o especializados.
Skills: instrucciones reutilizables para tareas concretas: SEO, WordPress, seguridad, testing, diseño, etc.
MCPs: conectores que dan acceso controlado a herramientas externas: navegador, GitHub, bases de datos, documentación, archivos o APIs.


Instalar y usar opencode desde VS Code
La forma más sencilla de trabajar es abrir el proyecto en VS Code y usar la terminal integrada.

Abre la carpeta del proyecto en VS Code.
Abre la terminal integrada.
Ejecuta opencode desde la raíz del repositorio.
Deja el archivo de configuración en el proyecto o en tu configuración global.

El archivo de proyecto suele estar en:
./opencode.json
La configuración global suele vivir en:
~/.config/opencode/opencode.json
Config base para GPT-5.5 y Codex 5.3
Ejemplo mínimo de opencode.json:
{
  "$schema": "https://opencode.ai/config.json",
  "model": "openai/gpt-5.5",
  "small_model": "openai/codex-5.3",
  "default_agent": "build",
  "share": "disabled",
  "permission": {
    "edit": "ask",
    "bash": {
      "*": "ask",
      "git status": "allow",
      "git diff*": "allow",
      "rm *": "deny"
    },
    "external_directory": {
      "*": "ask",
      "~/secrets/**": "deny"
    }
  }
}
Este ejemplo no incluye claves API. No conviene guardar secretos directamente en el repositorio. Usa variables de entorno o el método seguro que recomiende tu proveedor.
Separar planificación e implementación
Un flujo práctico es usar un modelo fuerte para pensar y otro optimizado para código. En opencode puedes definir agentes distintos.
{
  "$schema": "https://opencode.ai/config.json",
  "model": "openai/gpt-5.5",
  "agent": {
    "architect": {
      "description": "Planifica arquitectura, riesgos y decisiones antes de implementar.",
      "mode": "subagent",
      "model": "openai/gpt-5.5",
      "permission": {
        "edit": "deny",
        "bash": "ask"
      }
    },
    "codex-implementer": {
      "description": "Implementa cambios de código y tests siguiendo un plan concreto.",
      "mode": "subagent",
      "model": "openai/codex-5.3",
      "permission": {
        "edit": "ask",
        "bash": "ask"
      }
    }
  }
}
La idea es sencilla: no dejes que el mismo agente piense, escriba, ejecute y apruebe todo sin revisión. Separa roles.
Skills: instrucciones que se reutilizan
Una skill es una carpeta con un archivo SKILL.md. Sirve para cargar instrucciones específicas cuando una tarea lo necesita.
.opencode/skills/wordpress-seo/SKILL.md
Ejemplo de cabecera:
---
name: wordpress-seo
description: Use when improving WordPress SEO, internal links, metadata, sitemaps or content hubs.
---

# WordPress SEO

Check canonical URLs, indexability, internal links and page intent before editing.
Las skills evitan repetir instrucciones en cada prompt. También reducen errores porque el agente carga un procedimiento más concreto.
MCPs: herramientas externas con control
MCP significa Model Context Protocol. En la práctica, permite conectar el agente con herramientas externas de forma estructurada.
Ejemplo de MCP local para navegador:
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "playwright": {
      "type": "local",
      "command": ["npx", "-y", "@playwright/mcp"],
      "enabled": true,
      "timeout": 30000
    }
  }
}
Ejemplo de MCP remoto:
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "docs": {
      "type": "remote",
      "url": "https://example.com/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer ${DOCS_MCP_TOKEN}"
      }
    }
  }
}
No metas tokens reales en artículos, repositorios públicos ni capturas. Usa variables de entorno.
Claude Code, opencode y Hermes Agent: cómo elegir
No hace falta elegir una sola herramienta para siempre. Puedes pensar en ellas como superficies diferentes:
Claude Code: muy útil para desarrollo agentic integrado con el flujo de Claude y proyectos grandes.
opencode: interesante si quieres configuración abierta, varios proveedores, agents, skills, permisos y MCPs en un archivo controlable.
Hermes Agent: útil como patrón de agente/orquestador para flujos más largos, tareas recurrentes o pipelines personalizados.
La mejor opción depende de tu equipo, coste, modelos disponibles, permisos y nivel de automatización que quieras permitir.
Config recomendada para trabajar seguro
Plan mode sin edición: un agente que solo investigue y proponga.
Implementador con permisos “ask”: que pida confirmación antes de editar o ejecutar comandos.
MCPs mínimos: conecta solo lo necesario.
Sin secretos en archivos: usa variables de entorno.
Git siempre visible: revisa git diff antes de aceptar cambios.
Tests antes de confiar: que el agente ejecute pruebas, pero revisa los resultados.
Flujo práctico en VS Code
Abre el repositorio.
Comprueba que opencode.json tiene $schema.
Configura modelo principal y agentes.
Añade skills por dominio: testing, seguridad, WordPress, backend, frontend.
Añade MCPs solo si aportan valor claro.
Ejecuta opencode desde la terminal integrada.
Pide primero plan, después implementación.
Revisa diff, pruebas y resultados antes de publicar.
Errores frecuentes
Usar el modelo más caro para todo.
Dar permisos de edición y bash sin límites.
Conectar demasiados MCPs y aumentar superficie de riesgo.
No reiniciar opencode tras cambiar configuración.
Guardar claves API en opencode.json.
Dejar que el agente implemente sin tests ni revisión humana.
Checklist final
¿El modelo existe en tu proveedor?
¿El archivo tiene $schema?
¿Los permisos son restrictivos por defecto?
¿Las skills tienen descripción clara?
¿Los MCPs son necesarios y tienen tokens fuera del repo?
¿Has reiniciado opencode tras cambiar la configuración?
Un buen entorno agentic no es el que tiene más modelos o conectores. Es el que reparte bien responsabilidades, limita permisos y deja trazabilidad suficiente para revisar lo que la IA ha hecho.