Cómo usar OpenCode desde el primer prompt hasta el App Store: la guía de 2026 sobre planes de programación, Ollama, servidores MCP y skills

En algún punto entre el primer prompt y el primer correo de App Review, un agente de programación con IA deja de ser un juguete y se convierte en una herramienta con la que publicas. Esta guía trata de cómo usar OpenCode para pasar de uno a otro: instalarlo en un Mac limpio, elegir por qué pagar por el modelo que piensa, ejecutar modelos en tu propia máquina con Ollama, darle al agente manos de verdad con servidores MCP, enseñarle tus hábitos con skills y, después, llevar una app de iPhone por TestFlight y App Review sin perder una semana en papeleo.

Yo no vengo del mundo de la programación. Llevo una pequeña empresa de informática en Alemania y construyo software con agentes de IA. Dos de los resultados se publicaron en el App Store este otoño: Stash, que recuerda dónde dejas las cosas, y PingAtlas, que mide la latencia de red desde tu propio dispositivo. Aparecen en esta guía donde de verdad son útiles como ejemplos, y en ningún otro sitio.

Todo lo que sigue se comprobó con la documentación oficial, las notas de versión, las páginas de precios y el propio App Store el 7 November 2026. La programación con IA va deprisa: OpenCode publicó al menos diez versiones 2 solo entre el 20 y el 30 de octubre, Ollama y MiniMax han reestructurado sus planes desde finales de agosto y Apple reescribió partes de sus directrices de revisión al menos dos veces este año. Los datos volátiles van señalados donde aparecen. Compruébalos antes de comprar nada.

Aviso: Stash y PingAtlas son apps mías, publicadas por mi empresa, Graham Miranda UG (haftungsbeschränkt). Las dos son gratuitas y no muestran anuncios. Este artículo contiene un enlace de afiliado: el enlace al Z.ai GLM Coding Plan de la parte 2 te da un 10 % de descuento y me paga una comisión si te suscribes. El equipo de OpenCode en Anomaly, Ollama, Apple, Expo, Z.ai y todas las demás empresas mencionadas aquí no han patrocinado, revisado ni aprobado este artículo.

---

Resumen — todo el recorrido en diez puntos

• OpenCode es un agente de programación gratuito y de código abierto (MIT) que funciona con casi cualquier modelo: suscripciones en la nube, API de pago por token o modelos que se ejecutan en tu propio Mac. Va por la versión 2.2.6 (6 de noviembre de 2026), con una app de terminal, una app de escritorio, una interfaz web y para móvil, y un modo ACP que se ejecuta dentro de Xcode 27.
• Pagas por el modelo, no por el agente. Los “planes de programación” son suscripciones mensuales a tarifa plana por tiempo de modelo. Para la mayoría de la gente que empieza, OpenCode Go ($10 al mes) más Ollama (gratis en local, $20 al mes por los créditos de nube Pro) es la configuración que recomiendo: barata, independiente del modelo, con retención cero por defecto en la mayoría de los modelos y sin zonas grises en los términos de servicio de nadie.
• Las alternativas son reales. ChatGPT Plus y Pro, GitHub Copilot y el Z.ai GLM Coding Plan se conectan a OpenCode mediante proveedores integrados. Las suscripciones de Claude vuelven a funcionar a través del nuevo proveedor Claude Agent de OpenCode 2.2.3, pero Anthropic no ha respaldado esa vía públicamente, así que lee la parte 2 antes de fiarte de ella.
• Ollama es un solo motor para modelos locales y en la nube. ollama launch opencode los conecta entre sí, los modelos locales necesitan al menos una ventana de contexto de 64K y un Mac de 32 GB puede ejecutar modelos de programación solventes como qwen3.8:27b (una descarga de 18 GB).
• Los servidores MCP le dan manos al agente. Para trabajar con apps, la lista corta es el propio puente MCP de Xcode (xcrun mcpbridge), XcodeBuildMCP, el servidor MCP de Expo, Context7 para documentación al día y Sentry para las caídas. Añade solo lo que uses: cada servidor cuesta contexto.
• Las skills le dan al agente tu manual de procedimientos. Una skill es una carpeta con un archivo SKILL.md . OpenCode las lee de .opencode/skills y también de .claude/skills y .agents/skills, así que las skills escritas para otros agentes también funcionan. Expo publica 23 oficiales, y la CLI de App Store Connect (asc) viene con más de veinte.
• Deja que el agente haga el papeleo, nunca el envío. El asc La CLI y sus skills pueden subir compilaciones, gestionar TestFlight, sincronizar metadatos y capturas de pantalla, y consultar el estado de la revisión. Deniega el comando de envío en los permisos de OpenCode y pulsa tú el botón.
• Las normas de Apple para 2026 importan en las apps hechas con IA. Las apps clones en categorías saturadas ahora se rechazan (directriz 4.3(b), junio), las funciones ocultas o inactivas están prohibidas (nueva 2.5.19, octubre), las compilaciones necesitan Xcode 26 o posterior y, desde abril de 2027, las apps creadas con el SDK de iOS 27.1 necesitan capturas de pantalla para iPhone Duo.
• Coste del primer año: $99 si lo ejecutas todo en local y solo pagas a Apple, unos $419 con la configuración que recomiendo (Apple + OpenCode Go + Ollama Pro con facturación anual), y alrededor de $1,779 para una configuración potente. Los precios no incluyen IVA.
• La regla más importante: “hecho” es una afirmación, no un hecho. Pruébalo en un iPhone real, en modo avión, en modo oscuro, con el tamaño de texto más grande y con VoiceOver activado. Entonces créetelo.

---

El recorrido de un vistazo

Fase	Lo que haces	Lo que hace OpenCode	Herramientas
1. Configurar	Instala, elige un plan de programación y conecta modelos	Nada aún	OpenCode, OpenCode Go, Ollama
2. Enseñar	Escribe AGENTS.md, añade skills y conecta servidores MCP	Los lee en cada sesión	AGENTS.md, skills, MCP
3. Planificar	Escribe el brief, discute con el plan	Convierte el brief en un plan y una hoja de ruta	plan agente, /goal
4. Construir	Revisa cada diff, prueba en un dispositivo	Escribe código en fragmentos pequeños, compila, ejecuta pruebas y hace capturas de pantalla	construir agente, Xcode MCP, XcodeBuildMCP o Expo MCP
5. Beta	Invita a probadores, lee los comentarios	Archiva, sube y gestiona grupos de TestFlight	Xcode, asc o EAS
6. Papeleo	Responde con honestidad a las preguntas legales y de privacidad	Redacta metadatos, audita flujos de datos y redimensiona capturas de pantalla	asc competencias
7. Enviar	Usted pulsa “Submit for Review”	Comprueba el estado de la revisión y clasifica los rechazos	App Store Connect
8. Lanzar	Responde a los usuarios, planifica las actualizaciones	Traduce, escribe las notas de la versión y clasifica los fallos	asc, Sentry, tu sitio web

---

Índice

• Parte 1 — Qué es OpenCode en noviembre de 2026 y por qué lo recomiendo
• Parte 2 — Los planes de programación, explicados (y los dos que recomiendo)
• Parte 3 — Ollama: un motor para modelos locales y en la nube
• Parte 4 — Cómo usar OpenCode: instálalo y conecta tus modelos, paso a paso
• Parte 5 — Agentes, comandos, permisos y modo Goal: haz tuyo OpenCode
• Parte 6 — Servidores MCP: darle manos al agente
• Parte 7 — Skills: escribe tu manual una sola vez
• Parte 8 — Construir la app: de la idea a una compilación en la que confías
• Parte 9 — Publicar en el App Store: deja que OpenCode haga el papeleo y pulsa Enviar tú mismo
• Parte 10 — Lanzamiento: la ficha, las capturas, el ASO y la vida tras la aprobación
• Parte 11 — Cuánto cuesta: cuatro presupuestos para el primer año
• Parte 12 — Quince errores que evitar
• Parte 13 — ¿Qué configuración deberías elegir? Seis escenarios
• Preguntas frecuentes
• Conclusión

---

Parte 1 — Qué es OpenCode en noviembre de 2026 y por qué lo recomiendo

OpenCode es un agente de programación con IA de código abierto. Lo inicias en la carpeta de un proyecto, describes lo que quieres y trabaja como lo haría un desarrollador: lee tus archivos, hace un plan, edita código, ejecuta comandos, lee los errores y sigue adelante hasta que el trabajo está hecho o te necesita. Está publicado bajo la licencia MIT por Anomaly, el equipo que está detrás, y le da igual qué modelo le des.

La página de inicio del proyecto afirma tener más de 220.000 estrellas en GitHub, 1.089 colaboradores y 22 millones de desarrolladores mensuales. Son cifras del propio proyecto y cambian cada semana, pero explican por qué OpenCode se ha convertido en la alternativa agnóstica de modelo más conocida frente a los agentes de los propios fabricantes de modelos, Claude Code y Codex.

Dónde se ejecuta

OpenCode ya no es una sola aplicación. Desde la reescritura 2.0, un servicio en segundo plano se ejecuta en tu máquina y todas las interfaces hablan con él, así que una sesión que empiezas en un sitio aparece en los demás.

Interfaz	Qué es	Ideal para
Terminal (TUI)	La clásica aplicación de terminal a pantalla completa	Trabajo rápido con teclado, sesiones SSH, servidores
Aplicación de escritorio	Una aplicación Electron para macOS (Apple silicon e Intel), Windows (x64 y ARM64) y Linux (.deb, .rpm, AppImage), con pestañas, diffs, terminales y un navegador integrado	Quien no vive en una terminal
Web y móvil	opencode pair imprime un enlace de un solo uso (caduca a los cinco minutos) que abre tus sesiones locales en un navegador; la 2.2.6 añadió un compositor adaptado a móvil y tableta	Comprobar una tarea larga desde el sofá
Dentro de Xcode 27	OpenCode habla el Agent Client Protocol, así que opencode acp se puede añadir como agente en los ajustes de Intelligence de Xcode	Desarrolladores de Swift nativo que quieren quedarse en Xcode
SDK y scripts	opencode run para tareas puntuales, además de un SDK de JavaScript	Automatización y CI

Qué ha cambiado desde la 2.0

OpenCode 2.0 fue una reconstrucción desde cero: según el anuncio del equipo en julio, el runtime pasó de Bun a Node.js para reducir el consumo de memoria, la aplicación de escritorio pasó de Tauri a Electron, la API se rediseñó y OpenCode empezó a funcionar como servicio de forma predeterminada. La versión 2.0.0 salió el 11 de septiembre de 2026. Las versiones publicadas desde entonces han añadido sobre todo las funciones que importan en proyectos largos y reales:

Versión	Fecha	Qué añadió
2.2.0	27 oct	Plugins de escritorio experimentales, una aplicación de escritorio renovada, APIs de imagen y de decisión para plugins
2.2.1	29 oct	Modo de objetivos (/goal <objective>, con pausa, reanudar y borrar), opcional prompts programados, generación de imágenes
2.2.2	29 oct	Generación de imágenes activada de forma predeterminada cuando el proveedor conectado la admite; un selector de worktree desde la rama de Git
2.2.3	30 oct	El Claude Agent como proveedor (más sobre eso en la parte 2)
2.2.4	30 oct	Configuración guiada de Claude Agent, programaciones que se ejecutan bajo opencode serve, terminales de escritorio persistentes
2.2.5	30 oct	Atajos de worktree y de modo shell, un búfer de compactación basado en porcentajes
2.2.6	6 nov	opencode run --worktree para ejecuciones con scripts, un dock de compositor móvil, conexiones MCP compartidas

Fuente: el changelog de OpenCode, consultado el 7 de noviembre de 2026. Cuando leas esto, lo más probable es que ya haya una versión más reciente.

Por qué es el agente que recomiendo

1. No es leal a ningún modelo. OpenCode se conecta a suscripciones, APIs de pago por token y modelos locales mediante un solo /connect comando. Cuando el mes que viene salga un modelo mejor, cambias una línea de un archivo de configuración, no todo tu flujo de trabajo.
2. Sus permisos funcionan como un cortafuegos. Cada acción (leer, editar, ejecutar un comando de shell, cargar una skill, llamar a una herramienta MCP) pasa por una lista ordenada de allow, preguntar y deny reglas en las que gana la última coincidencia. “Nunca ejecutes git push” y “nunca enviar a la App Store” ocupan una línea cada una.
3. Habla los formatos de todo el mundo. Dice así: AGENTS.md (y recurre a CLAUDE.md), carga las skills desde .claude/skills y .agents/skills así como sus propias carpetas, y se conecta a cualquier servidor MCP. El ecosistema que han creado otros agentes también funciona aquí.
4. Va donde estés. Terminal en un servidor, app de escritorio en un Mac, un navegador en tu teléfono o dentro de Xcode.
5. No cuesta nada. OpenCode es gratis e incluso incluye un conjunto rotativo de modelos gratuitos que puedes usar sin cuenta.

Donde no es la mejor opción

Primero, sinceridad: OpenCode no es el que más puntúa en las clasificaciones de programación, porque no es un solo modelo. Los harness que encabezan esas listas son parejas de proveedor: Claude Code con el mejor modelo de Anthropic, Codex con el de OpenAI. Están ajustados en conjunto y son excelentes. Comparé veintiocho de ellos en mi comparativa de harness de programación con IA, y si ya pagas una de esas suscripciones y te encanta, nada en esta guía te obliga a cambiar.

También hay asperezas. OpenCode publica versiones casi a diario, así que las cosas se mueven bajo tus pies. La documentación antigua de la versión 1 sigue existiendo en docs.opencode.ai (con un banner que apunta a la v2), y muchas guías de terceros, incluida la propia página de OpenCode de Ollama, todavía muestran la dirección del instalador de la v1. Varias de las funciones más recientes están marcadas como experimentales. Y los gestores de paquetes de Windows no son compatibles con la herramienta de línea de comandos v2; los usuarios de Windows tienen la app de escritorio o un zip independiente.

---

Parte 2 — Los planes de programación, explicados (y los dos que recomiendo)

OpenCode es gratis. El modelo que piensa no lo es. Hay tres formas de pagarlo, y la mayor parte de la confusión sobre los “planes de programación con IA” viene de mezclarlas.

1. Ejecútalo tú mismo. Modelos de pesos abiertos en tu propio Mac con Ollama. Pagas con hardware y paciencia, no con dinero. Tu código nunca sale de la máquina.
2. Suscríbete a un plan de programación. Una cuota mensual fija compra un límite de uso, normalmente medido en ventanas de cinco horas y semanales. Aquí están OpenCode Go, Ollama Pro, el GLM Coding Plan y las suscripciones de ChatGPT y Claude.
3. Paga por token. Trae una clave API de cualquier proveedor y paga exactamente lo que uses. Ideal para el problema difícil ocasional; peligroso para una sesión larga de depuración sin una alerta de presupuesto.

Los planes de programación que funcionan en OpenCode (noviembre de 2026)

Plan	Precio mensual (USD)	Qué obtienes	Cómo se conecta a OpenCode
Modelos gratuitos de OpenCode	$0	Un conjunto rotativo de modelos gratuitos por tiempo limitado	Integrado, sin necesidad de cuenta
Ollama, local	$0	Cualquier modelo de pesos abiertos que tu Mac pueda alojar	Detectado automáticamente, o ollama launch opencode
OpenCode Go ⭐	$10 · Go Plus $40 · Go Teams $20 por miembro	32 modelos abiertos, incluidos GLM-5.3, GLM-5.3-Flash, Kimi K3 y K3.1 Pro, MiniMax M3.1 Flash, DeepSeek V4.1 Flash y Qwen3.8 Max	/connect → OpenCode Go → pega tu clave
Ollama Pro / Max ⭐	$20 ($200 al año) · Max $100	$60 (Pro) o $300 (Max) de créditos de modelos en la nube al mes, más uso local ilimitado	Igual que Ollama local; los modelos en la nube aparecen junto a los locales
Plan de codificación GLM (Z.ai)	Lite $18 · Pro $80 · Max $168 (20 % de descuento al trimestral, 30 % al anual)	GLM-5.3 y GLM-5.3-Flash, ambos con contexto de 1 M de tokens	/connect → el proveedor Z.AI Coding Plan
Plan MiniMax M	Go $22 · Explore $55 · Build $132 (dos meses gratis con facturación anual)	MiniMax M3.1 Flash, más modelos de imagen, audio y (desde Explore) de vídeo	El proveedor del plan de programación de MiniMax, con una clave M Plan
ChatGPT	Plus $20 · Pro desde $100	La familia GPT-6 de OpenAI mediante tu plan de ChatGPT	/connect → OpenAI → “Iniciar sesión con ChatGPT”
GitHub Copilot	Pro $10 · Pro+ $39 · Max $100	El conjunto de modelos de Copilot, medido en créditos de IA de GitHub	/connect → GitHub Copilot → inicio de sesión en el dispositivo
Claude	Pro 20 $ · Max desde 100 $	Los modelos de Anthropic a través de Claude Code	/connect → Claude Agent (OpenCode 2.2.3+, Claude Code instalado); consulta la advertencia de abajo
Pago por token	Lo que usas	La API de cualquier proveedor, incluida la pasarela de pago por uso de OpenCode	/connect → el proveedor → clave de API

Precios de tarifa a 7 de noviembre de 2026, sin IVA. ⭐ = lo que recomienda esta guía. Los precios, las cuotas y las listas de modelos cambian constantemente, así que revisa la página de cada proveedor antes de suscribirte. Los precios de GLM son de una instantánea del 24 de septiembre y del titular “planes desde 18 $” de Z.ai; la membresía de Kimi (desde 19 $) queda fuera porque no pude confirmar una vía oficial de OpenCode para ella.

Cómo funcionan realmente los límites

El precio del titular te dice muy poco. Con lo que convives es con la asignación.

• OpenCode Go da a cada modelo su propia asignación mensual en dólares, y puedes gastar el 20 % de ella en cualquier ventana de cinco horas y el 50 % en cualquier semana. En el plan de 10 $, por ejemplo, GLM-5.3-Flash recibe 60 $ al mes, DeepSeek V4.1 Flash 100 $ y Kimi K3 15 $, así que los modelos baratos y eficientes cunden mucho más que los pesados. Cuando alcanzas un límite, las solicitudes se bloquean salvo que hayas activado Extra Usage, que recurre al crédito de pago por uso. Los modelos gratuitos siguen funcionando en cualquier caso.
• Ollama pasó a créditos: Pro incluye 60 $ de uso en la nube al mes y Max 300 $, ambos facturados a tarifas por token, y el crédito no usado no se acumula. Pro permite tres solicitudes a la vez y Max diez. Los precios bajan fuera de las 12:00 a las 18:00 UTC de lunes a viernes y todo el fin de semana, lo que encaja muy bien con las tardes europeas. Los modelos locales son ilimitados en todos los planes, incluido el gratuito.
• El GLM Coding Plan usa créditos por ventana de cinco horas y semanal, y el uso fuera de hora punta (fuera de las 14:00 a las 18:00, hora de China, de lunes a viernes) cuesta la mitad de créditos.
• ChatGPT y Copilot miden con sus propios sistemas: ChatGPT en estimaciones de mensajes por cinco horas y por modelo, Copilot en AI Credits. Dentro de OpenCode, los inicios de sesión de ChatGPT no muestran coste por solicitud porque el uso va contra tu plan, y OpenCode limita por defecto la ventana de contexto de entrada para ellos (500.000 tokens en los modelos GPT más recientes).

Privacidad y retención de datos

Tus prompts contienen tu código. Importa adónde van, sobre todo en trabajos para clientes sujetos a las normas europeas de protección de datos.

• OpenCode Go bloquea por defecto los endpoints de pago que entrenan con tus datos. La mayoría de los modelos (GLM, Kimi, MiniMax, Qwen, MiMo y otros) se sirven con retención cero; unos pocos (Grok, los modelos GPT Luna, Claude Haiku y dos modelos promocionales gratuitos) guardan registros durante 30 días. Los modelos “Contributor” con descuento sí entrenan con tus prompts y hay que activarlos a propósito. Las regiones por defecto son Europa y Estados Unidos, y los modelos de DeepSeek exigen activar el enrutamiento global, con un acuerdo de retención cero vigente hasta el 30 de noviembre de 2026.
• Nube de Ollama lo dice claramente: “Los datos de prompts o respuestas nunca se registran ni se usan para entrenar.” Los modelos se ejecutan principalmente en Estados Unidos, y la capacidad de desbordamiento podría enrutarse a Europa.
• Los modelos gratuitos de OpenCode son otro cantar: la documentación señala que algunos modelos gratuitos pueden usar tus datos para mejorar el modelo. Vale para experimentos, no para código de clientes. Configura OPENCODE_DISABLE_FREE_MODELS=1 para ocultarlos.
• Modelos locales nunca salen de tu máquina. Para cualquier cosa bajo un acuerdo estricto de tratamiento de datos, esa sigue siendo la respuesta más limpia.

La cuestión de Claude

Las suscripciones de Claude han tenido un año accidentado en herramientas de terceros. En enero, Anthropic endureció sus comprobaciones y los inicios de sesión de Claude Pro y Max dejaron de funcionar en harness como OpenCode, y en marzo OpenCode eliminó su opción de inicio de sesión a petición de Anthropic. El 30 de octubre, OpenCode 2.2.3 devolvió las suscripciones por otra vía: un Claude Agent proveedor integrado que controla tu Claude Code instalado localmente (versión 2.1.248 o posterior) mediante el Agent SDK oficial de Anthropic, después de iniciar sesión con claude auth login.

Los datos que necesitas antes de usarlo:

• OpenCode no lee el inicio de sesión guardado de Claude Code; el verdadero claude programa es el que envía las solicitudes.
• Las herramientas, la configuración, los CLAUDE.md archivos, los hooks, los servidores MCP y las skills propias de Claude Code están desactivados. Claude trabaja en su lugar con las herramientas y los avisos de permiso de OpenCode.
• La documentación del Agent SDK de Anthropic dice que los desarrolladores de terceros no pueden ofrecer el inicio de sesión de claude.ai ni los límites de suscripción en sus productos salvo que Anthropic lo haya aprobado. En el momento de escribir esto, Anthropic no se había pronunciado públicamente sobre el proveedor de OpenCode, y nadie puede decirte con certeza si pone tu cuenta en riesgo.

Mi consejo: si ya pagas por Claude y quieres probarlo, úsalo en proyectos personales y estate atento a un comunicado oficial. Para trabajo profesional, usa una clave de API de Anthropic, la única vía que menciona la documentación de Anthropic.

Lo que recomiendo, y por qué

Empieza con OpenCode Go y Ollama. Este es el razonamiento:

• Precio. 10 $ al mes te dan acceso a 32 modelos abiertos potentes. Añade Ollama Pro por 20 $ si quieres más margen en la nube; sáltatelo si tu Mac ejecuta bien los modelos locales.
• Elección sin ataduras. Go y Ollama Cloud ofrecen las mismas familias de pesos abiertos (GLM, Kimi, MiniMax, DeepSeek y otras), así que puedes comparar modelos en tu propio proyecto en vez de fiarte de una clasificación.
• Privacidad por defecto. Retención cero para la mayoría de los modelos de Go, una política de no registro en Ollama y la opción de ir totalmente local para trabajos sensibles.
• Sin zonas grises. Ambos están diseñados exactamente para este uso, dentro de OpenCode.
• La alternativa local es gratis. Cuando la ventana de cinco horas se agota a las 23:00, un modelo local en Ollama te mantiene avanzando con las tareas pequeñas.

Cuándo elegir otra cosa. Si ya pagas ChatGPT Plus o Copilot, conéctalo primero; no te cuesta nada extra. Si GLM va a ser tu herramienta de cada día, la cuota del GLM Coding Plan’s puede tener más sentido que los límites por modelo de Go’s, y puedes obtener un 10% de descuento en el GLM Coding Plan con mi enlace de afiliado (enlace de afiliado, consulta la divulgación al principio). Las claves del Coding Plan y las claves estándar de la API de Z.ai no son intercambiables, así que elige el proveedor Coding Plan en /connect. Y si tu trabajo necesita lo más alto de la clasificación, un modelo frontera por clave de API para las tareas más difíciles es dinero bien invertido.

---

Parte 3 — Ollama: un motor para modelos locales y en la nube

Ollama ejecuta modelos de pesos abiertos en tu propio ordenador y los sirve a través de una API local sencilla. Desde el año pasado también ejecuta modelos más grandes en su propia nube, con la misma app y la misma API, así que para OpenCode un modelo en la nube parece exactamente igual que uno local. Ese es todo el atractivo: un solo motor, una sola configuración y un cambio entre “privado y gratis” y “grande y rápido” que es solo un nombre de modelo.

Instalar Ollama (paso a paso)

1. Descárgalo de ollama.com/download. En un Mac, abre la descarga y arrastra Ollama a Aplicaciones. En Windows, ejecuta el instalador. En Linux, el comando oficial de una línea es:

   curl -fsSL https://ollama.com/install.sh | sh

2. Inícialo. Abre la app o escribe ollama en un terminal. Desde la versión 0.40.15 (principios de noviembre), ejecutar ollama sin argumentos abre un lanzador de bienvenida.
3. Inicia sesión si quieres modelos en la nube. La app te lo pide durante la configuración. Los modelos locales funcionan sin cuenta; tu uso de la nube está en ollama.com/settings/usage.
4. Descarga un modelo para comprobar que todo funciona:

   ollama pull qwen3.8:27b
   ollama run qwen3.8:27b "Di hola en Swift"

Conecta Ollama con OpenCode

Tienes tres opciones, de la más sencilla a la más flexible.

Opción 1: deja que OpenCode lo encuentre. OpenCode v2 comprueba la dirección local predeterminada de Ollama al arrancar y añade todos los modelos que pueden escribir texto a /models. Sin cuenta, sin configuración. Los modelos solo de embeddings se omiten.

Opción 2: deja que Ollama lo configure.

ollama launch opencode            # configura OpenCode para Ollama y lo inicia
ollama launch opencode --config   # solo configura, no inicia una sesión

ollama launch funciona con OpenCode v2 desde Ollama 0.40.12 (27 de octubre). No sobrescribe tu ~/.config/opencode/opencode.json, así que tus propios ajustes siguen aplicándose. Una curiosidad: los modelos que hayas definido solo en la configuración de OpenCode no aparecen en el selector de lanzamiento de Ollama.

Opción 3: apunta OpenCode a un servidor Ollama en otro sitio. Si Ollama se ejecuta en un Mac mini en el armario o en un servidor, añádelo como proveedor con su dirección. El /v1 del final importa:

{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "ollama": {
      "settings": {
        "baseURL": "https://ollama.example.com/v1",
        "apiKey": "{env:OLLAMA_API_KEY}"   // optional, sent as a bearer token
      }
    }
  }
}

El ajuste que rompe la mayoría de configuraciones locales: la longitud de contexto

Las preguntas frecuentes de Ollama indican que su ventana de contexto predeterminada es de 4.096 tokens. La propia guía de Ollama para OpenCode pide al menos 64K, porque el prompt de sistema de un agente, las definiciones de herramientas y el contenido de los archivos llenan una ventana pequeña antes de que ocurra ningún trabajo. Ajusta esto en el servidor de Ollama, no en OpenCode:

# Si inicias el servidor tú mismo:
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# Si usas la app de Mac: define la variable para launchd, luego cierra y vuelve a abrir Ollama
launchctl setenv OLLAMA_CONTEXT_LENGTH 65536

Luego comprueba que ha surtido efecto: ollama ps muestra el tamaño de contexto de cada modelo cargado y si se ejecuta en la GPU. Una ventana más grande usa más memoria, así que en un Mac de 32 GB, 64K es un techo razonable para un modelo de 27.000 millones de parámetros.

Qué modelo local encaja con tu Mac

Una regla práctica útil de las clasificaciones de noviembre de BenchLM: un modelo necesita aproximadamente su tamaño de descarga más un 20% para el contexto, y un Mac puede dar alrededor de tres cuartas partes de su memoria unificada a la GPU. En la práctica, mantén la descarga por debajo de aproximadamente el 60% de la memoria de tu Mac.

La memoria de tu Mac	Modelo para probar primero	Descargar	Contexto	Ideal para
16 GB	gemma4:12b o gemma4:e4b	7.7 GB / 6.6 GB	256K / 128K	Explicaciones, pequeños cambios, mensajes de commit. Demasiado pequeño para sesiones largas de agente; usa modelos en la nube para construir
24-32 GB	qwen3.8:27b (también como 27b-mlx para Apple silicon)	18 GB	256 K	El punto óptimo local para programar con un agente
24-32 GB	qwen3-coder:30b	19 GB	256 K	Un modelo de mezcla de expertos para programar con solo unos 3000 millones de parámetros activos, así que es rápido
24-32 GB	gpt-oss:20b	14 GB	128 K	El modelo de pesos abiertos más pequeño de OpenAI; deja más margen
64 GB	Los mismos modelos con mayor precisión, como qwen3.8:27b-q8_0	30 GB	256 K	Mejores respuestas, espacio para un contexto grande
96–128 GB	gpt-oss:120b o devstral-2:123b	65 GB / 75 GB	128K / 256K	Calidad de modelo grande sin la nube

Tamaños y ventanas de contexto de la biblioteca de Ollama el 7 de noviembre de 2026. La velocidad depende tanto del ancho de banda de memoria de tu chip como del tamaño de esa memoria. Para la parte de hardware, consulta mi guía de MacBook para LLM locales.

Ollama Cloud: los modelos que tu Mac no puede alojar

Los modelos de programación de pesos abiertos más potentes de hoy son demasiado grandes para un portátil. Ollama Cloud los ejecuta por ti. En la app o en la CLI llevan una :cloud etiqueta y no descargan nada:

ollama run glm-5.3:cloud
ollama run minimax-m3.1-flash:cloud

La parte del catálogo en la nube relevante para programar el 7 de noviembre:

Modelo	Fabricante	Contexto	La valoración de uso de Ollama	Notas
glm-5.3	Z.ai	1 millón	Alta	El modelo estrella de Z.ai; potente en tareas agénticas largas
glm-5.3-flash	Z.ai	1 millón	Medio	Multimodal nativo, 18B de parámetros activos; un gran modelo de construcción predeterminado
kimi-k3.1-pro	Moonshot AI	1 millón	Extra alta	La entrada más reciente (actualizada el 4 de noviembre), multimodal, el modelo más capaz de Moonshot
kimi-k2.7-code	Moonshot AI	256 K	Alta	Ajustado para programar y más ligero en tokens de razonamiento
minimax-m3.1-flash	MiniMax	976K	Medio	Lee imágenes; 0,15 $ de entrada y 0,60 $ de salida por millón de tokens
deepseek-v4.1-flash	DeepSeek	1 millón	Medio	Diseñado para velocidad y rendimiento; lee imágenes
mistral-large-4	Mistral	1 millón	Alta	Laboratorio europeo, pesos abiertos
gemma4	Google	256 K	Bajo	Lo bastante barato para ayudantes y subagentes

La calificación es la forma abreviada de Ollama para indicar con qué rapidez un modelo gasta tus créditos. Si quieres comparar bien los grandes, mis Kimi K3 frente a Fable 5.1 frente a GLM-5.3 y GLM-5.3-Flash frente a MiniMax M3 comparativas profundizan más.

El patrón de enrutamiento que copiaría

No tienes que elegir un solo modelo. Da a cada tipo de trabajo el modelo más barato que lo haga bien:

• Planificación (aquí ocurren los errores más caros): tu modelo más potente.
• Construcción: un modelo rápido y capaz como GLM-5.3-Flash o MiniMax M3.1 Flash.
• Buscar en el código, leer documentación, escribir tests y mensajes de commit: un modelo local. No cuesta nada y tu código se queda donde está.

La parte 4 muestra exactamente cómo configurar esto en la configuración de OpenCode.

Modo solo local para proyectos sensibles

Si un proyecto no debe tocar nunca un modelo en la nube, haz que eso sea un ajuste y no una promesa. Ollama puede desactivar por completo sus funciones en la nube (añade "disable_ollama_cloud": true a ~/.ollama/server.json, o define OLLAMA_NO_CLOUD=1, y luego reinícialo), y los modelos gratuitos en la nube de OpenCode se pueden ocultar con OPENCODE_DISABLE_FREE_MODELS=1. Después conecta solo proveedores locales en ese proyecto.

Advertencias honestas sobre Ollama

• Los modelos locales son más lentos y más flojos en el uso prolongado de herramientas en varios pasos que los grandes modelos en la nube. Destacan en tareas acotadas.
• La nube sigue siendo el ordenador de otra persona. La política de no registrar nada de Ollama es buena, pero tu código sigue saliendo de tu máquina, sobre todo hacia Estados Unidos.
• Los créditos se acaban. $60 de crédito Pro cunden mucho con GLM-5.3-Flash y mucho menos con un modelo valorado como “extra alto”.
• Una respuesta lenta no siempre es culpa del modelo. Cada petición a la nube hace antes un viaje de ida y vuelta por tu Wi-Fi, tu router e internet en general. Si las respuestas van lentas, comprueba la conexión antes de culpar al modelo: mi propia app PingAtlas mide los tiempos de ida y vuelta desde tu iPhone, iPad o Mac hasta ciudades y hasta servicios como GitHub, y expliqué el resto del recorrido en lo que ocurre dentro de su router.

---

Parte 4 — Cómo usar OpenCode: instálalo y conecta tus modelos, paso a paso

Esta es la configuración que le daría a un amigo. Lleva unos veinte minutos, la mayor parte descargas.

Paso 0 — Lo que necesitas antes de nada

• Un Mac con Apple Silicon, si quieres crear apps para iPhone de forma nativa. Xcode 27.1 (publicado el 15 de octubre, con Swift 6.4 y el SDK de iOS 27.1) necesita macOS Tahoe 26.6 o posterior. Si compilas con Expo, su servicio en la nube puede compilar apps para iOS desde Windows o Linux, pero aun así querrás un iPhone para probar.
• Xcode desde el Mac App Store, ábrelo una vez para que instale sus componentes.
• Git. Tu verdadero botón de deshacer.
• Node.js, solo si vas a usar Expo: el SDK 58 necesita Node 22.13 o posterior, 24.3 o posterior, o 26 y posteriores (las versiones impares como la 23 y la 25 no son compatibles).
• Un plan de programación de la parte 2, u Ollama de la parte 3.

Paso 1 — Instalar OpenCode

En macOS o Linux:

curl -fsSL https://opencode.ai/v2/install | bash

¿Prefieres una app? Descarga la versión de escritorio para macOS, Windows o Linux desde opencode.ai/download. Las apps de terminal y de escritorio comparten el mismo servicio en segundo plano y las mismas sesiones. En Windows, usa la app de escritorio o el zip independiente; los gestores de paquetes de Windows no son compatibles con la v2.

Dos trampas que conviene conocer:

• Las guías antiguas usan el instalador antiguo. opencode.ai/install (sin /v2/) sigue apareciendo en muchos tutoriales, incluida documentación oficial de algunos socios. Usa la /v2/install dirección de arriba.
• usuarios de mise necesitan mise 2026.10.9 o posterior, o tendrán OpenCode 1.

Paso 2 — Conectar tus modelos

Inicia OpenCode en una carpeta de proyecto y ejecuta /connect:

mkdir -p ~/code/my-first-app && cd ~/code/my-first-app
git init
opencode

Luego, según lo que pagues:

Tienes	En /connect, elige	Entonces
OpenCode Go	OpenCode Go	Pega la clave API de la OpenCode Console
Ollama	Nada; los modelos locales aparecen solos	O ejecuta ollama launch opencode
ChatGPT Plus o Pro	OpenAI → Iniciar sesión con ChatGPT	Inicia sesión en el navegador
GitHub Copilot	GitHub Copilot	Completa el inicio de sesión del dispositivo
Claude Pro o Max	Claude Agent (no “Anthropic”, que es para claves API)	Correr claude auth login primero en una terminal; lee la advertencia de la Parte 2
Plan de codificación GLM	El proveedor Z.AI Coding Plan	Pega tu clave del Coding Plan, no una clave API estándar
Una clave API	El nombre del proveedor	Pega la clave

Paso 3 — Elige tus modelos

Correr /models y elige. Los modelos de OpenCode Go se llaman opencode-go/<model-id>; los modelos locales de Ollama aparecen bajo el proveedor Ollama. Copia los IDs exactos de /models en tu configuración, porque los nombres y las etiquetas cambian.

Paso 4 — Añadir una configuración de proyecto

Los valores por defecto funcionan, pero un proyecto de app merece un archivo de configuración que haga tres cosas: dirigir cada agente al modelo correcto, mantener al agente lejos de todo lo irreversible y conectar tus servidores MCP. Guarda esto como opencode.jsonc en la raíz del proyecto, y sustituye los IDs de modelo /models te muestra:

{
  "$schema": "https://opencode.ai/config.json",

  // The model new sessions start with
  "model": "opencode-go/glm-5.3-flash",

  "agents": {
    // Planning: your strongest model, because a bad plan costs the most later
    "plan":    { "model": "opencode-go/glm-5.3" },
    // Building: fast and capable
    "build":   { "model": "opencode-go/glm-5.3-flash" },
    // Read-only exploring: local, free, private
    "explore": { "model": "ollama/qwen3.8:27b" }
  },

  // Rules are checked in order and the LAST match wins
  "permissions": [
    { "action": "shell", "resource": "*",                     "effect": "ask"   },
    { "action": "shell", "resource": "git status *",          "effect": "allow" },
    { "action": "shell", "resource": "git diff *",            "effect": "allow" },
    { "action": "shell", "resource": "git log *",             "effect": "allow" },
    { "action": "shell", "resource": "xcodebuild -list *",    "effect": "allow" },
    { "action": "shell", "resource": "asc * list *",          "effect": "allow" },
    { "action": "shell", "resource": "asc review status *",   "effect": "allow" },
    { "action": "shell", "resource": "git push *",            "effect": "deny"  },
    { "action": "shell", "resource": "asc publish appstore *","effect": "deny"  },
    { "action": "shell", "resource": "* --submit *",          "effect": "deny"  },
    { "action": "shell", "resource": "* --confirm *",         "effect": "deny"  }
  ],

  "mcp": {
    "servers": {
      // Apple's bridge to the Xcode project you have open (Part 6)
      "xcode": { "type": "local", "command": ["xcrun", "mcpbridge"] },
      // Headless builds, simulator control and screenshots (Part 6)
      "XcodeBuildMCP": { "type": "local", "command": ["npx", "-y", "xcodebuildmcp@latest", "mcp"] },
      // Up-to-date library documentation
      "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" }
    }
  }
}

Lo que estás pegando, en palabras sencillas:

• Todos los comandos de shell preguntan primero, excepto unos pocos de solo lectura. Las consultas de solo lectura asc (todo lo que lista, además del estado de revisión) están permitidas, para que el agente pueda comprobar las compilaciones y el progreso de la revisión sin molestarte.
• Algunas cosas están bloqueadas directamente: subir código, publicar o enviar una app a revisión y confirmar acciones destructivas en App Store Connect. Eso lo haces tú, a propósito. Subir una compilación a TestFlight sigue permitido (después de preguntar), porque no envía nada a revisión.
• Los valores por defecto de OpenCode ya preguntan antes de leer .env del entorno. Déjalo activado.
• Los permisos son barandillas, no un sandbox. Un modelo decidido puede encontrar otra forma de hacer algo. Mantén las credenciales de producción, las claves de firma y tu clave Admin de App Store Connect lejos de la máquina donde los agentes se ejecutan sin supervisión.

Paso 5 — Escribe un AGENTS.md antes de escribir código

OpenCode dice: AGENTS.md en la raíz de tu proyecto al inicio de cada sesión, más uno personal en ~/.config/opencode/AGENTS.md si lo creas. El /init comando puede redactar uno escaneando tu repositorio. Es el hábito más eficaz del desarrollo asistido por IA, y escribí sobre todo el sistema en mi Guía de programación de Vibe. Para una app de iPhone, debería contener las reglas del producto además de los comandos:

# Notas para agentes de programación

## Qué es esta app
Una frase. Si un cambio no sirve a eso, no tiene sitio.

## Innegociables
- Funciona sin conexión. Las funciones de red se degradan con elegancia.
- Sin analíticas, anuncios ni SDK de seguimiento. Pregunta antes de añadir CUALQUIER dependencia.
- Sin secretos en el paquete de la app. Las claves que cuestan dinero viven en un servidor.
- Sin funciones ocultas, inactivas o solo de depuración en las compilaciones de lanzamiento
  (directriz 2.5.19 de App Review). Los menús de depuración se compilan fuera de Release.
- Nunca envíes datos personales a un servicio de IA de terceros sin
  una pantalla de consentimiento explícita dentro de la app (directriz 5.1.2(i)).
- Accesibilidad: Dynamic Type, etiquetas de VoiceOver, objetivos táctiles de 44 x 44 pt,
  modo claro y oscuro en todas las pantallas.
- Cada cadena visible para el usuario está localizada, incluidos los widgets,
  las notificaciones y los avisos de permisos.

## Comandos
- Compilar y ejecutar: usa las herramientas de XcodeBuildMCP (build_run_sim), esquema "MyApp"
- Pruebas: test_sim
- Nunca ejecutes asc publish ni nada con --submit.

## Definición de terminado
- Compila sin advertencias, las pruebas pasan
- Comprobado con screenshot + snapshot_ui en el simulador
- Funciona en modo avión, modo oscuro y con el tamaño de texto más grande

Paso 6 — Tu primera sesión real

1. Empieza en modo plan. Cambia al plan agente (no puede editar los archivos de tu proyecto) y pídele que discuta con tu brief: “Lee AGENTS.md y BRIEF.md. Enumera los flujos de usuario, los casos límite en los que no he pensado y las pantallas que me faltan. Luego dime qué recortar.”
2. Guarda el plan como una hoja de ruta. Pídele que lo escriba ROADMAP.md como una lista de comprobación de fragmentos pequeños, de extremo a extremo.
3. Construye un fragmento cada vez con el construir agente. Una pantalla, una función, que funcione de extremo a extremo.
4. Revisa el diff, ejecútalo y haz commit. Cada fragmento termina con un commit. Si un paso sale mal, /undo revierte el último paso del agente a partir de las instantáneas de OpenCode; Git es la red de seguridad más importante.
5. Empieza una sesión nueva para el siguiente fragmento. Una sesión limpia que vuelve a leer AGENTS.md y ROADMAP.md suele ser más lista que una larga llena de suposiciones obsoletas.

---

Parte 5 — Agentes, comandos, permisos y modo Goal: haz tuyo OpenCode

Cuando lo básico funciona, cuatro funciones convierten OpenCode de un chat con una terminal en un taller que encaja con tu proyecto.

Los agentes integrados

Agente	Tipo	Para qué sirve
construir	Primary	El predeterminado. Edita archivos, ejecuta comandos, hace el trabajo
plan	Primary	Explora y planifica sin editar los archivos de tu proyecto (puede escribir sus propios archivos de plan)
general	Subagente	Trabajos de investigación y de varios pasos; no puede lanzar más subagentes
explorar	Subagente	Busca y lee código o páginas web; no puede editar nada

Los agentes primarios son aquellos con los que hablas. Los subagentes los lanza un agente primario para una tarea concreta, así que el contexto de la sesión principal se mantiene limpio.

Escribe tu propio subagente: un escéptico de App Review

Los agentes personalizados son archivos Markdown en .opencode/agents/ (o ~/.config/opencode/agents/ para cada proyecto). El front matter configura el agente y el cuerpo se convierte en sus instrucciones. Este revisa tu app como lo hará App Review y no puede cambiar nada mientras lo hace:

---
description: Revisa la app y sus metadatos contra las Directrices de App Review de Apple antes de un envío
mode: subagent
model: opencode-go/glm-5.3
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

Eres un especialista escéptico en App Review. Revisa el código actual y los
archivos de metadata/ y enumera los problemas, del más grave al menos, con archivo y línea:

- Cierres inesperados, textos de relleno, enlaces muertos, cuenta de demostración ausente (2.1)
- Cualquier cosa que parezca una copia de una categoría de apps saturada (4.3(b))
- Funciones ocultas, inactivas o sin documentar, menús de depuración, feature flags (2.5.19)
- Datos que salen del dispositivo y no figuran en la política de privacidad ni en la etiqueta de privacidad
- Datos personales enviados a cualquier servicio de IA sin consentimiento explícito (5.1.2(i))
- Creación de cuenta sin eliminación de la cuenta dentro de la app (5.1.1(v))
- Capturas de pantalla o descripciones que prometen funciones que la compilación no tiene

No arregles nada. Solo informa.

Guárdalo como .opencode/agents/appstore-reviewer.md, y luego pregunta: “Usa el subagente appstore-reviewer para revisar todo lo que ha cambiado desde la última etiqueta de versión.”

Comandos personalizados para las tareas que repites

Los comandos son plantillas de prompt que ejecutas con una barra. Ponlos en .opencode/commands/; $ARGUMENTS se sustituye por lo que escribas después del comando, y ` !command ` inserta la salida de un comando de shell antes de enviar el prompt. Este redacta las notas de la versión para el App Store:

---
description: Redacta las notas "What's New" del App Store a partir de los commits desde la última etiqueta
agent: build
---

Aquí están los commits desde la última versión:

!`git log $(git describe --tags --abbrev=0)..HEAD --oneline`

Escribe las notas "What's New" de la versión $ARGUMENTS en un inglés sencillo y cercano,
con menos de 400 caracteres y solo cambios visibles para el usuario. Guárdalas en
metadata/en-US/release_notes.txt y muéstrame el texto.

Guárdalo como .opencode/commands/whats-new.md y ejecútalo con /whats-new 1.2.0. Merece la pena repetir una advertencia de la documentación de OpenCode: esos ! bloques se ejecutan fuera del sistema de permisos del agente, así que solo pon en ellos comandos en los que confíes.

Un recetario de permisos para proyectos de apps

La configuración de la Parte 4 es un buen punto de partida. Algunas reglas más que conviene conocer:

• Reglas por agente van bajo agents.<id>.permissions y se añaden después de las globales, así que puedes, por ejemplo, dejar que solo el construir agente ejecute xcodebuild.
• Las herramientas MCP también son acciones, llamadas <server>_<tool>. Una regla como { "action": "XcodeBuildMCP_*", "resource": "*", "effect": "ask" } hace que cada llamada de XcodeBuildMCP pregunte primero.
• Las skills se pueden restringir con el skill action: allow anuncia y carga una skill libremente, preguntar la anuncia pero pregunta antes de cargarla, deny la oculta por completo.
• Cuando se comprueban varios recursos a la vez, cualquier deny gana, luego cualquier preguntar.

Modo Goal, worktrees y programaciones

Tres funciones más recientes cambian la percepción de lo largos que se hacen los trabajos:

• Modo de objetivos (2.2.1): /goal Haz que cada pantalla pase una auditoría de VoiceOver y corrige lo que falle mantiene la sesión trabajando hacia el objetivo hasta que se revisa, con pause, resume y clear. Perfecto para los trabajos grandes y aburridos: pasadas de accesibilidad, localización, cobertura de pruebas.
• Worktrees: inicia una sesión en un worktree de Git aparte desde la pantalla de nueva sesión (o ⌘⌥O en la app de escritorio), así un experimento no puede tocar tu rama principal. Las ejecuciones por script usan opencode run --worktree=<name> desde la 2.2.6. Tira el worktree si el experimento falla.
• Prompts programados (opcional, experimental): /schedule ejecuta un prompt según un horario mientras opencode serve está en marcha, como un “ejecuta las pruebas y resume los fallos” nocturno.

---

Parte 6 — Servidores MCP: darle manos al agente

Por sí solo, un agente de programación puede leer archivos y ejecutar comandos de shell. MCP, el Model Context Protocol, es la forma estándar de darle más: un proyecto Xcode en ejecución, un simulador en el que puede tocar y hacer capturas, tus informes de fallos, documentación actual, tu servicio de compilación. Cada servidor MCP expone un conjunto de herramientas, y el agente decide cuándo llamarlas.

Hay un coste, y la documentación de OpenCode lo dice sin rodeos: “Las herramientas MCP consumen contexto del modelo, así que añade solo los servidores que necesites.” Cada servidor conectado añade descripciones de herramientas a cada petición. Diez servidores que apenas usas hacen que cada respuesta sea más lenta y menos centrada.

La lista corta del desarrollador de apps

Servidor	Qué le aporta al agente	Añádelo a OpenCode	Conviene saber
Xcode (Apple)	Tu proyecto Xcode abierto: compilar, probar y más, a través del propio Xcode	opencode mcp add xcode -- xcrun mcpbridge	En Xcode → Ajustes → Intelligence, activa Permitir que agentes externos usen las herramientas de Xcode a Siempre o Mientras Xcode está abierto. Abre el proyecto en Xcode antes de escribir el prompt; Xcode muestra cuándo se conecta un agente
XcodeBuildMCP	Compilaciones sin interfaz, ejecuciones en simulador y dispositivo, capturas de pantalla, toques y deslizamientos, instantáneas de accesibilidad, pruebas, depuración con LLDB	opencode mcp add XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp	Código abierto (MIT), mantenido por Sentry desde que adquirió el proyecto en febrero. Requiere macOS 14.5+, Xcode 16+ y Node 18+. Solo las herramientas de simulador están activadas por defecto
Expo	Compilaciones, flujos de trabajo y envíos de EAS, documentación de Expo, simuladores en la nube, datos de fallos y comentarios de TestFlight y de las tiendas	opencode mcp add expo --url https://mcp.expo.dev/mcp, entonces opencode mcp auth expo	Requiere una cuenta de Expo y el SDK más reciente. Algunas herramientas necesitan un plan de pago de Expo. Las herramientas de simulador local necesitan npx expo install expo-mcp --dev y SDK 54+
Context7	Documentación actual y específica de cada versión para bibliotecas y frameworks	opencode mcp add context7 --url https://mcp.context7.com/mcp	Evita que el modelo invente APIs que cambiaron el mes pasado
Sentry	Tus fallos y errores reales	opencode mcp add sentry --url https://mcp.sentry.dev/mcp, entonces opencode mcp auth sentry	Inicio de sesión con OAuth
Playwright	Un navegador real que el agente puede controlar	opencode mcp add playwright -- npx @playwright/mcp@latest	Para la versión web de tu app y tu landing page
Firebase	Tu proyecto de Firebase, las reglas de seguridad y la configuración	opencode mcp add firebase -- npx -y firebase-tools@latest mcp	Pregunta antes de cambiar cualquier cosa en tu proyecto

Comprueba qué está conectado con Lista de MCP de OpenCode, y activa o desactiva servidores para una sesión con /mcps.

Si diseñas en Figma, su servidor MCP también puede pasar frames y variables al agente. Expliqué el detalle específico de OpenCode (servidor remoto frente a servidor de escritorio) en mi guía para crear una app desde cero con IA.

El puente MCP de Xcode frente a XcodeBuildMCP

Se solapan, y funcionan bien juntos:

• El servidor propio de Xcode (xcrun mcpbridge) funciona a través de la app Xcode que tengas abierta. Es de Apple, entiende tu proyecto igual que Xcode y necesita que Xcode esté en marcha.
• XcodeBuildMCP envuelve las herramientas de línea de comandos de Apple (xcodebuild, simctl, devicectl), así que se ejecuta sin interfaz. Su verdadera fuerza es el bucle de verificación: build_run_sim para compilar y lanzar, screenshot para mirar, snapshot_ui para leer el árbol de accesibilidad, tap y type_text para usar la app, y test_sim para ejecutar las pruebas. Ejecuta xcodebuildmcp init una vez en tu proyecto para instalar sus dos skills complementarias.

En el archivo de configuración

Los mismos servidores pueden vivir en opencode.jsonc (la parte 4 tiene un ejemplo completo), que es mejor para un equipo porque la configuración viaja con el repositorio:

"mcp": {
  "servers": {
    "expo":   { "type": "remote", "url": "https://mcp.expo.dev/mcp" },
    "sentry": { "type": "remote", "url": "https://mcp.sentry.dev/mcp" },
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "headers": { "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}" }
    },
    "playwright": { "type": "local", "command": ["npx", "@playwright/mcp@latest"], "disabled": true }
  }
}

Dos detalles de la documentación de MCP de OpenCode: los secretos se introducen como {env:NAME} (un simple $NAME no se expande), y "disabled": true mantiene un servidor configurado sin conectarlo.

Cuándo una herramienta de línea de comandos supera a un servidor MCP

Mi regla: si existe una buena herramienta de línea de comandos, pruébala con una skill antes de añadir un servidor. El agente ya sabe ejecutar comandos, una CLI no cuesta contexto hasta que se usa, y su salida se puede filtrar antes de que llegue al modelo. Para el trabajo con apps, tres CLI cubren mucho terreno:

• gh para GitHub: issues, pull requests, releases.
• asc para App Store Connect: compilaciones, TestFlight, metadatos, capturas de pantalla y estado de revisión (parte 9).
• eas para el servicio de compilación y envío de Expo.

La seguridad de MCP en cuatro reglas

1. Instala servidores de sus creadores o de proyectos que puedas leer. Un servidor es código que se ejecuta en tu máquina con tus permisos.
2. Trata la salida de las herramientas como no fiable. Una página web, un comentario en una issue o un informe de fallos puede contener instrucciones dirigidas a tu agente. Mantén las acciones de riesgo en preguntar.
3. Controla las herramientas por nombre. Cada herramienta de MCP es una acción de permiso llamada <server>_<tool>, así que puedes permitir las de solo lectura y hacer que las demás pregunten.
4. Elimina lo que no uses. Cuesta contexto, y es una cosa menos que puede salir mal.

---

Parte 7 — Skills: escribe tu manual una sola vez

AGENTS.md le dice al agente qué es tu proyecto. Skills le enseñan cómo haces tareas concretas: publicar una compilación, escribir una migración, preparar capturas de pantalla, auditar la privacidad. Una skill es una carpeta que contiene un SKILL.md archivo con una descripción breve arriba y las instrucciones debajo, además de los scripts o archivos de referencia que necesite. El formato es un estándar abierto que comparten OpenCode, Claude Code, Codex y otros, por eso una skill escrita para un agente suele funcionar en los demás.

Cómo usa OpenCode una skill

1. En cada paso, OpenCode muestra al modelo una lista de las skills que puede usar: solo el ID, el nombre y la descripción de cada una. Las instrucciones en sí no se cargan, así que cien skills no cuestan casi nada.
2. Cuando una tarea coincide, el modelo llama a la skill herramienta con el ID de la skill, y OpenCode comprueba tus permisos.
3. OpenCode añade las instrucciones a la conversación, con la ruta de la carpeta de la skill y una lista de hasta diez de sus archivos de apoyo.
4. Los archivos de apoyo solo se cargan cuando las instrucciones los piden. Una lista de comprobación larga o un script se quedan en disco hasta que hacen falta.

También puedes cargar una tú mismo si la mencionas en un prompt: @app-store-release.

Dónde busca OpenCode

Alcance	Carpeta
Tu proyecto	.opencode/habilidades/
Tu proyecto (compartido con otros agentes)	.claude/skills/ y .agents/skills/
Todos los proyectos de tu máquina	~/.config/opencode/skills/
Todos los proyectos (compartido)	~/.agents/skills/ y ~/.agents/skills/
Cualquier otro sitio	Rutas o catálogos HTTP indicados en un competencias array en opencode.jsonc

El ID de una skill viene del nombre de su carpeta, no del nombre que figura en su front matter, y distingue mayúsculas y minúsculas: .opencode/skills/app-store-release/SKILL.md tiene el ID app-store-release. Cuando dos fuentes definen el mismo ID, gana la que aparece después en este orden: las integradas, .claude/skills, .agents/skills, tu carpeta global, la de tu proyecto .opencode/skills, luego las entradas explícitas de configuración. Una skill sin descripción no se anuncia al modelo en absoluto.

Escribe tu primera skill: una lista de comprobación para publicar en el App Store

Crea .opencode/skills/app-store-release/SKILL.md:

---
name: Publicación en el App Store
description: Prepara una publicación de iOS. Sube la versión y el número de build, ejecuta la lista de comprobación de publicación, archiva, sube a TestFlight con asc y redacta las notas de Novedades. Úsala cuando te pidan "publicar", "lanzar" o "enviar a TestFlight".
---

# Publicación en el App Store

1. Comprueba `git status`. Si el árbol de trabajo no está limpio, para y dilo.
2. Sube la versión de marketing y el número de build (pregunta qué versión si no se indica).
3. Recorre references/release-checklist.md. Cada punto debe pasar.
4. Archiva y exporta el IPA con scripts/archive.sh.
5. Sube: `asc builds upload --app "$ASC_APP_ID" --ipa build/MyApp.ipa`
6. Redacta las notas de Novedades a partir de los commits desde la última etiqueta y guárdalas
   en metadata/en-US/release_notes.txt.
7. NUNCA envíes a revisión. Informa de que el build ya está subido y para.

Pon la lista de comprobación en references/release-checklist.md y el script de archivo en scripts/archive.sh junto a ella. La próxima vez que digas “publica la 1.2.0 en TestFlight”, el agente encuentra la skill por su descripción y sigue tus pasos en lugar de improvisar.

Skills que merece la pena instalar para trabajar con apps

Conjunto de skills	¿Qué contiene?	Instalar
Skills de Expo (oficiales)	23 skills: 16 para el SDK de Expo (Router, UI nativa, @expo/ui, sistemas de diseño, actualizaciones, módulos nativos y más) y 7 para los servicios de Expo, incluida eas-app-stores para compilar y enviar a TestFlight, el App Store y Google Play	npx skills add expo/skills
Skills de la CLI de App Store Connect	Más de veinte asc skills: flujo de publicación, orquestación de TestFlight, sincronización de metadatos con comprobación de límites de caracteres, traducción de fichas, flujos de capturas de pantalla, configuración de firma, estado del envío, triaje de fallos, auditorías de ASO	asc install-skillso npx skills add rorkai/app-store-connect-cli-skills
Skills de XcodeBuildMCP	Dos skills que enseñan al agente las herramientas y la CLI de XcodeBuildMCP	xcodebuildmcp init
skills.sh	El directorio abierto de skills de la comunidad de Vercel; incluye OpenCode entre los agentes compatibles	npx skills add <owner/repo>

Si OpenCode no muestra una skill que has instalado, comprueba dónde la puso el instalador con respecto a las carpetas de arriba, o copia la carpeta de la skill en .opencode/habilidades/.

Seguridad de las skills

Una skill son instrucciones y, a menudo, scripts que el agente ejecutará. Lee una skill de terceros antes de instalarla, igual que leerías un script de shell de internet. Prefiere las skills de quienes hacen la herramienta (Expo para Expo, los asc mantenedores de asc), mantén las skills desconocidas en preguntar con una regla de permisos, y recuerda que deny oculta una skill al modelo por completo.

---

Parte 8 — Construir la app: de la idea a una compilación en la que confías

Las herramientas están listas. Ahora llega la parte que decide si alguien descarga el resultado.

Elige una idea que pase la revisión de App Review

La IA ha abaratado la creación de apps, y Apple se ha dado cuenta. El 9 de junio reescribió la directriz 4.3(b), su norma contra el spam: las apps que son esencialmente lo mismo que ya abunda en la tienda ahora se rechazan, y Apple nombra las apps de citas, linterna, fondos de pantalla, temporizador y adivinación como categorías en las que necesitas una experiencia significativamente distinta o mejor. Las apps novedad de bajo esfuerzo se pueden eliminar, las apps ya existentes en esas categorías se pueden retirar si no se mejoran o no atraen usuarios, y los envíos repetidos de este tipo pueden costarte la membresía de desarrollador.

Así que antes del primer prompt, una prueba: ¿puedes decir en una frase qué hace tu app que no hagan los primeros resultados de su término de búsqueda principal? Si no puedes, el agente lo construirá de maravilla y App Review te lo devolverá.

Pequeño y específico gana a grande y genérico. Mis dos apps son deliberadamente limitadas:

• Stash recuerda dónde guardaste las cosas: fotografía el sitio, elige la habitación, guarda y luego busca por nombre, habitación o una nota de voz transcrita.
• PingAtlas mide los tiempos de ida y vuelta de red desde tu propio iPhone, iPad o Mac hasta 202 ciudades, 278 destinos públicos, 109 juegos y 32 servicios online, sin cuenta y sin servicio de medición remoto.

Un trabajo cada una. Eso es lo que hace que una sola persona con un agente pueda construirlas y que se expliquen en una frase en una página de la App Store.

Elige tu stack

	SwiftUI + Xcode 27.1	Expo SDK 58 (React Native 0.88)
Funciona con	iPhone, iPad, Mac, Apple Watch, Vision Pro	iPhone, iPad, Android y la web desde un solo código base
Idioma	Swift 6.4	TypeScript
¿Necesitas un Mac?	Sí	No para compilar ni enviar (la nube de Expo lo hace); sí para herramientas locales del simulador de iOS
Herramientas para agentes	el puente MCP de Xcode, XcodeBuildMCP, OpenCode dentro de Xcode mediante ACP	el servidor MCP de Expo, 23 skills oficiales, una experimental @expo/agent-cli y legible por máquina expo command:ps de salida para agentes
Novedades este otoño	SDK de iOS 27.1, un simulador de iPhone Duo (con algunas limitaciones en las extensiones)	Compilado con el SDK de iOS 27; las apps pasan al ciclo de vida de escenas de UIKit, listas para iPhone Duo; compatibilidad con App Intents en alfa; macOS no es compatible con el SDK 58
Lo mejor para	apps solo para Apple que quieren las funciones más nuevas de la plataforma	una persona publicando para iPhone y Android, con una versión web

Si te gusta publicar primero una versión web (a mí sí), la salida web de Expo te permite poner una demo funcional delante de la gente antes de que exista la versión de la App Store. La web de Stash hace algo parecido con un demostración en el navegador montado alrededor de un hogar de ejemplo: la gente puede probar la idea antes de instalar nada.

El ciclo de desarrollo que funciona

El agente escribe rápido. Lo que mantiene fiable el resultado es el ciclo que lo rodea:

1. Brief. Un BRIEF.md: la promesa en una frase, tres historias de usuario y la lista de pantallas.
2. Plan. El plan el agente lo convierte en ROADMAP.md: porciones verticales pequeñas, cada una con una función que funciona de principio a fin.
3. Construye una porción. El construir el agente la implementa y escribe las pruebas.
4. Verifica como un usuario. Con XcodeBuildMCP el agente puede compilar y lanzar la app en el simulador, hacer una captura de pantalla, leer el árbol de accesibilidad con snapshot_ui, recorrer el flujo pulsando y ejecutar las pruebas. Con Expo, las herramientas MCP locales hacen lo mismo para el simulador. Pídele que compare lo que ve con lo que le pediste.
5. Revisa como App Review. Ejecuta el appstore-reviewer subagente de la parte 5.
6. Lee tú mismo el diff. Todas las líneas que se van a enviar.
7. Haz commit, marca la casilla y empieza una sesión nueva.

Para las grandes pasadas mecánicas (añadir etiquetas de accesibilidad por todas partes, traducir cada cadena, subir la cobertura de pruebas), usa el modo objetivo: /goal Traduce al alemán cada cadena visible para el usuario, incluidos widgets, notificaciones y avisos de permisos.

Tres plantillas de prompt que merece la pena adaptar:

Una porción: Implementa la porción 4 de ROADMAP.md (búsqueda). Lee AGENTS.md primero. Escribe primero las pruebas unitarias y luego el código. Compílalo y ejecútalo en el simulador, haz una captura de la pantalla de resultados y compárala con el brief. Muéstrame el diff y enumera todas las suposiciones que hiciste.

Un error: En un iPhone con el tamaño de texto dinámico más grande, el teclado tapa el botón Guardar de la pantalla Añadir. Repróducelo en el simulador, haz una captura, explica la causa en dos frases, corrígelo y comprueba si el mismo problema aparece en los demás formularios.

Una revisión antes del commit: Revisa todo lo hecho desde el último commit como un revisor sénior de iOS escéptico: cierres inesperados, pérdida de datos, filtraciones de privacidad, etiquetas de accesibilidad que faltan, cadenas y colores codificados a mano, cualquier cosa que rompa el uso sin conexión. Lista numerada, lo más grave primero. Todavía no arregles nada.

Lecciones de dos apps pequeñas

Stash y la localización. Stash 1.1.0 (28 de octubre) añadió diez idiomas al inglés: español, francés, alemán, italiano, portugués de Brasil, neerlandés, polaco, japonés, coreano y chino simplificado. La app escoge uno según el dispositivo y te deja cambiarlo en Ajustes → Idioma, y las notas de la versión señalan que también se tradujeron los widgets, los recordatorios y los avisos de permiso del sistema. Ese último detalle es la lección: la localización es un trabajo ideal para un agente, pero las cadenas que los agentes olvidan viven fuera de las pantallas principales: en los widgets, las notificaciones, los textos de propósito de los permisos y el formato de las fechas. Nómbralos en AGENTS.md y se hacen.

PingAtlas y las promesas honestas. La descripción de PingAtlas en el App Store hace promesas concretas: una respuesta que falta aparece como “Sin respuesta”, nunca como 0 ms; no hay GPS ni permiso de ubicación; no hay anuncios, ni analíticas, ni cuenta; los resultados se quedan en el dispositivo a menos que los exportes; y las comprobaciones de sitios web usan solo peticiones HEAD. Promesas así deben estar en AGENTS.md como condiciones no negociables, porque también son lo que dice tu etiqueta de privacidad. La etiqueta de PingAtlas dice “Datos no recopilados”, y eso solo es cierto mientras el código esté de acuerdo. El subagente revisor está ahí para darse cuenta del día en que deje de estarlo.

El alcance es una función. PingAtlas pesa 1,9 MB. Stash, con fotos, notas de voz, sincronización y widgets, ronda los 65 MB. Más funciones significan más cosas que probar, más que explicar en la política de privacidad y más sobre lo que App Review puede preguntar. Empieza por la versión más pequeña que cumpla la promesa.

Accesibilidad desde el primer día

Las etiquetas de nutrición de accesibilidad de Apple te permiten declarar compatibilidad con nueve funciones en la página de tu app en el App Store: VoiceOver, Control por voz, Texto más grande, Interfaz oscura, Diferenciar sin depender solo del color, Contraste suficiente, Reducir movimiento, Subtítulos y descripciones de audio. Hoy son voluntarias, pero Apple dice que con el tiempo tendrás que proporcionarlas para enviar apps nuevas y actualizaciones. Solo puedes declarar una función si con ella se pueden completar todas las tareas habituales de tu app, incluido el primer arranque, el inicio de sesión, las compras y los ajustes.

Ninguna de mis propias fichas declara ninguna todavía, que es justo el tipo de hueco que esta guía pretende detectar. El agente puede hacer la mayor parte de la auditoría: el servidor MCP de XcodeBuildMCP snapshot_ui lee el árbol de accesibilidad, así que /goal Haz que cada pantalla sea totalmente usable con VoiceOver y con el tamaño de texto más grande, y enumera todo lo que no puedas arreglar es un trabajo realista para una tarde.

---

Parte 9 — Publicar en el App Store: deja que OpenCode haga el papeleo y pulsa Enviar tú mismo

Construir es la parte divertida. Publicar es un proyecto en sí mismo, y es donde los desarrolladores primerizos pierden una semana. La buena noticia para 2026: casi todo se puede automatizar con scripts, lo que significa que un agente puede teclear mientras tú tomas las decisiones.

Qué cambió en Apple en 2026

Cuándo	¿Qué ha cambiado?	Qué hacer
31 ene 2026	Las nuevas preguntas sobre la clasificación por edad pasaron a ser obligatorias para las actualizaciones	Respóndelas para cada app antes de enviar
28 abr 2026	Los archivos subidos deben haberse compilado con Xcode 26 o posterior y los SDK 26	Usa Xcode 26 o 27
9 jun 2026	Directriz 4.3(b) reescrita: las apps copiadas y de bajo esfuerzo se rechazan o se eliminan	Diferénciate (parte 8)
9 sep 2026	Las subidas deben apuntar a iOS 13 o posterior	Nada, para ninguna app nueva
15 oct 2026	Xcode 27.1 (Swift 6.4, SDK de iOS 27.1; requiere macOS Tahoe 26.6+) y Expo SDK 58	Actualiza tu cadena de herramientas
16 oct 2026	Nueva directriz 2.5.19 prohíbe las funciones ocultas, inactivas o no documentadas; reglas más duras para las apps que esconden su propósito durante la revisión	Compila los menús de depuración y los feature flags fuera de las compilaciones de publicación
En vigor	Directriz 5.1.2(i): informa a las personas y obtén su permiso antes de compartir datos personales con IA de terceros (añadido en noviembre de 2025)	Añade una pantalla de consentimiento si tu app llama a un servicio de IA
Ahora	Capturas de pantalla: un conjunto para iPhone con Dynamic Island (pantalla mediana) es obligatorio, más un iPad de 13 pulgadas si tu app funciona en iPad	Planifica los tamaños de tus capturas de pantalla (Parte 10)
Abril de 2027	iPhone Duo capturas de pantalla obligatorias para las apps compiladas con el SDK de iOS 27.1 o posterior	Empieza ya a diseñar para la segunda pantalla
Voluntario, por ahora	de nutrición de accesibilidad de Apple	Declara lo que realmente soportas

La nueva 2.5.19 es la que más afecta a las apps creadas con IA. A los agentes les encantan los extras útiles: una pantalla de depuración oculta, un feature flag que se queda desactivado, un menú de pruebas tras una pulsación larga. La nueva redacción de Apple es contundente: “No incluyas funciones ocultas, inactivas o no documentadas en tu app.” Según el informe de 9to5Mac sobre el cambio, intentar ocultar esas funciones, por ejemplo mediante ofuscación del código, puede provocar la retirada de la app y la cancelación de tu cuenta de desarrollador. Incluye la regla en AGENTS.md y pide al subagente revisor que la busque antes de cada envío.

El flujo de trabajo, paso a paso

1. Inscríbete en el Apple Developer Program. Cuesta 99 $ al año (99 € en Alemania). Las empresas se inscriben como organización, lo que requiere un número D-U-N-S. Empieza pronto; la verificación puede tardar días. Inscríbete aquí.
2. Declara tu condición de comerciante en la UE. Según el Reglamento de Servicios Digitales de la UE, todo desarrollador debe indicar si es un comerciante. Si publicas como empresa, tu dirección, tu número de teléfono y tu correo electrónico aparecen en la página de tu producto en todos los países de la UE. Apple retiró miles de apps de las tiendas de la UE en febrero de 2025 por no cumplir este requisito.
3. Crea una clave de API de App Store Connect. En App Store Connect, ve a Usuarios y acceso → Integraciones → API de App Store Connect y genera una clave de equipo. Solo el titular de la cuenta puede solicitar acceso a la API en primer lugar. Asigna a la clave el rol menos potente que sirva para la tarea (la descripción general de los roles muestra lo que puede hacer cada uno), descarga el .p8 una sola vez y guárdalo en un lugar seguro, fuera de tu repositorio.
4. Instala la CLI de App Store Connect e inicia sesión. asc es una herramienta de línea de comandos de código abierto (MIT) para la API de App Store Connect, pensada para scripts y agentes: imprime tablas en una terminal y JSON cuando otro programa lee su salida.

brew install asc        # or: curl -fsSL https://asccli.sh/install | bash

asc auth login --name "MyApp" --key-id "ABC123" --issuer-id "DEF456" \
  --private-key ~/keys/AuthKey_ABC123.p8 --network
asc auth status --validate

Luego instala sus skills (asc install-skills) para que OpenCode sepa cómo usarla.

5. Crea el registro de la app. En App Store Connect, elige Apps → + → Nueva app, y elige con cuidado tu bundle ID, porque nunca cambia (el de Stash es network.grahammiranda.stash, el de PingAtlas network.grahammiranda.pingatlas). Las asc skills incluyen una que hace esto mediante automatización del navegador, pero es un trabajo de dos minutos que merece la pena hacer a mano una vez.
6. Resuelve la firma. Para una app nativa, la firma automática de Xcode gestiona los certificados y los perfiles. Para Expo, EAS gestiona las credenciales por ti. La asc-signing-setup skill cubre los bundle IDs, las capacidades, los certificados y los perfiles si prefieres hacerlo con scripts.
7. Compila y sube. Nativa: archiva en Xcode (o deja que el agente lo haga con la asc-xcode-build skill) y luego sube:

asc builds upload --app "123456789" --ipa build/MyApp.ipa

Exposición: eas build --platform ios, entonces eas submit -p ios, que sube la compilación a App Store Connect (no la envía a revisión). Puedes delegar la subida sin problema; el envío a revisión, no.

8. Prueba primero con TestFlight. Los probadores internos (hasta 100 personas de tu equipo) reciben las compilaciones sin revisión. Los probadores externos (hasta 10.000, por correo electrónico o enlace público) necesitan una breve revisión Beta App Review para la primera compilación. Las compilaciones se pueden probar durante 90 días. El agente puede gestionar los grupos con asc testflight groups list --app "123456789" y el asc-testflight-orchestration skill. Da la app a cinco personas con iPhones distintos durante una semana; encontrarán el fallo que tú no encontraste.
9. Escribe los metadatos y luego deja que el agente los revise. Mantén tu ficha en archivos dentro del repositorio (metadata/en-US/…) y aplícala primero con una prueba en seco:

asc metadata apply --app "123456789" --version "1.0.0" --dir ./metadata --dry-run

El asc-metadata-sync skill comprueba los límites de caracteres de Apple antes de subir nada. La parte 10 explica qué escribir.

10. Haz las capturas de pantalla. Al menos una, hasta diez, por cada tamaño requerido, en PNG o JPEG sin transparencia. El asc-shots-pipeline skill puede capturarlas desde el simulador, enmarcarlas y subirlas con asc screenshots upload. La parte 10 tiene los tamaños.
11. Responde con sinceridad a las preguntas sobre privacidad, clasificación por edad y cumplimiento. Esta es la parte que no debes delegar a ciegas:

• La etiqueta de privacidad. Según los términos de Apple, los datos cuentan como recogidos cuando salen del dispositivo y se conservan durante más tiempo del necesario para atender la solicitud. Los datos procesados solo en el dispositivo no cuentan. Sincronizar el contenido de los usuarios con tu servidor sí cuenta, aunque solo ellos puedan verlo. Pide al agente que audite cada llamada de red y cada SDK, y luego rellena tú mismo la etiqueta a partir de su tabla.
• La política de privacidad debe estar enlazada en App Store Connect y y ser accesible dentro de la app, y debe describir esta app, no solo tu empresa.
• IA de terceros (directriz 5.1.2(i)): si los datos personales van a un servicio de IA, dilo y pide permiso primero.
• Eliminación de la cuenta (directriz 5.1.1(v)): si las personas pueden crear una cuenta, deben poder eliminarla dentro de la app.
• Clasificación por edad, cumplimiento de exportación y las Accessibility Nutrition Labels. Si tu app solo usa el cifrado integrado en iOS, como HTTPS, configura ITSAppUtilizaCifradoNoExento en tu Info.plist después de consultar las indicaciones de Apple, para que no te pregunten en cada subida.

12. Envía tú mismo. Añade la versión para revisión y envíala en la página de la app en App Store Connect, o ejecuta asc publish appstore … --submit --confirm desde tu propio terminal (las reglas de permisos de la parte 4 impiden que el agente lo ejecute). Luego deja que el agente vigile: asc review status --app "123456789".

Revisión: qué esperar

Apple dice que, de media, el 90 % de los envíos se revisan en menos de 24 horas, y que más del 40 % de los problemas no resueltos provienen de la directriz 2.1, App Completeness: fallos, contenido de relleno, información incompleta y enlaces rotos. Si te rechazan, lee el mensaje dos veces, corrige el problema real y responde en App Store Connect. El asc-submission-health skill ayuda a diagnosticar los bloqueos, y el agente es bueno redactando una respuesta tranquila y concreta. Envíala tú mismo.

---

Parte 10 — Lanzamiento: la ficha, las capturas, el ASO y la vida tras la aprobación

Una app aprobada con una ficha floja es una tienda sin cartel. Aquí está el resto del trabajo.

La ficha, campo por campo

Campo	Límite	Qué funciona
Nombre de la app	30 caracteres	Marca más beneficio. “Stash — Find It Fast” le dice a un desconocido para qué sirve la app
Subtítulo	30 caracteres	El beneficio en palabras llanas. PingAtlas usa “Ping cities, games & services”
Palabras clave	100 caracteres	Separadas por comas, sin espacios. No repitas palabras que ya estén en el nombre o el subtítulo; cuentan igualmente
Texto promocional	170 caracteres	Cambia sin una nueva revisión, así que úsalo para temporadas y noticias
Descripción	4.000 caracteres	Qué hace, para quién es y qué no hace con los datos de las personas. Claro y concreto
Novedades	Por versión	Cambios reales contados en lenguaje humano; el /whats-new comando de la parte 5 lo redacta
Capturas de pantalla	De 1 a 10 por tamaño	Cuenta la historia en orden; la mayoría nunca pasa de las tres primeras

Dos reglas para dejar que un agente escriba algo de esto: dile que use solo funciones que existan en el código (y que nombre el archivo donde vive cada una), y guarda el resultado en tu repositorio para que cada cambio se revise como código. El asc-aso-audit skill puede entonces comprobar los huecos de palabras clave sin conexión antes de que nada se publique.

Tamaños de capturas de pantalla en noviembre de 2026

Dispositivo	¿Obligatorio?	Tamaños verticales (píxeles)
iPhone con Dynamic Island, pantalla mediana	Sí	1179 × 2556 o 1206 × 2622
iPhone con Dynamic Island, pantalla grande	Opcional	1260 × 2736, 1290 × 2796 o 1320 × 2868
iPad, pantalla de 13 pulgadas	Sí, si tu app funciona en iPad	2064 × 2752 o 2048 × 2732
iPhone Duo (pantalla exterior / interior)	Desde Abril de 2027, para apps creadas con el SDK de iOS 27.1 o posterior	1398 × 2034 / 2007 × 2853

Si tu interfaz se ve igual en todos los tamaños e idiomas, solo necesitas la resolución más alta requerida; App Store Connect la reduce para los dispositivos más pequeños. Las capturas de pantalla no pueden contener transparencia.

Localiza la ficha, no solo la app

Si la app habla varios idiomas, la ficha también debería. El asc-localize-metadata skill traduce el texto de la ficha y asc-metadata-sync comprueba cada idioma contra los límites de caracteres de Apple, que es justo donde suelen fallar los subtítulos alemanes traducidos a mano. Haz que un hablante nativo lea el resultado; la traducción automática es excelente hoy en día, pero los textos de la App Store son marketing, y el marketing necesita oído humano.

Después de la aprobación

• Pide valoraciones en un momento en el que estés de buen humor. El aviso de valoración del sistema de Apple aparece como máximo tres veces al año por persona, así que no lo desperdicies en el primer arranque. Pídelo justo después de que algo haya salido bien.
• Usa el texto promocional para el momento. Temporada de mudanzas, limpieza de primavera, un fin de semana de gaming. Cambia sin revisión.
• Vigila los cierres inesperados desde el primer día. El asc-crash-triage skill revisa los cierres inesperados y los comentarios de TestFlight; el servidor MCP de Expo puede obtener cierres, comentarios y reseñas (las respuestas necesitan tu confirmación); el servidor MCP de Sentry trae los errores de producción.
• Publica actualizaciones pequeñas a menudo. Stash se lanzó el 23 de septiembre, sacó un rediseño el 2 de octubre y añadió diez idiomas en la versión 1.1.0 el 28 de octubre. Publica la versión que funciona y luego mejórala en público.
• Dale a la app un hogar en la web. Una página sencilla con una demo, una política de privacidad escrita para la app y, si estás en Alemania, un Impressum. Mi app-from-scratch guide cubre las páginas legales para desarrolladores alemanes y de la UE.

---

Parte 11 — Cuánto cuesta: cuatro presupuestos para el primer año

OpenCode es gratis. Ollama es gratis en tu propio hardware. El único coste que no puedes evitar para una app de iPhone es la membresía de Apple; todo lo demás depende de cuánto tiempo de modelo quieras comprar.

Presupuesto	¿Qué contiene?	Primer año (USD)
Solo local	Apple Developer Program; OpenCode; Ollama con modelos locales en un Mac que ya tengas (32 GB o más)	$99
Inicial	Solo local + OpenCode Go ($10 al mes)	$219
Recomendado	Starter + Ollama Pro con facturación anual ($200)	$419
Potencia	Apple + OpenCode Go Plus ($40 al mes) + Ollama Max ($100 al mes)	$1,779

Precios de tarifa el 7 de noviembre de 2026, sin IVA y sin descuentos promocionales. Cambia lo que quieras por tus propias opciones: un GLM Coding Plan Lite en lugar de Go cuesta $216 al año con facturación mensual (unos $151 con facturación anual) en vez de $120; ChatGPT Plus cuesta $240 al año. Extras opcionales: la tarifa única de $25 de Google Play si publicas en Android, los planes de pago de Expo si te quedas corto con el plan gratuito y lo que te cueste tu web.

El coste real no está en la lista, eso sí: son tus tardes. La IA acorta la escritura, no el pensamiento, y el pensamiento es la mayor parte del trabajo.

---

Parte 12 — Quince errores que evitar

1. Dejar que el agente envíe la app a revisión. Deníegalo en los permisos. Tú pulsas el botón.
2. Guardar una clave Admin API donde los agentes se ejecutan sin supervisión. Usa el rol menos potente que funcione y guarda las claves de firma y las credenciales de producción en otro sitio.
3. Construir una copia de algo que ya existe. La directriz 4.3(b) ahora nombra categorías enteras. Encuentra primero tu diferencia en una frase.
4. Publicar extras ocultos. Las pantallas de depuración, los indicadores de funciones inactivos y los menús de prueba incumplen la directriz 2.5.19. Compílalos fuera de las compilaciones de lanzamiento.
5. Una etiqueta de privacidad que resulta verosímil, pero no precisa. Si los datos salen del dispositivo y se quedan en un servidor, se recopilan, aunque solo los pueda ver el usuario.
6. Enviar datos personales a un servicio de IA sin preguntar. La directriz 5.1.2(i) exige informar y pedir permiso.
7. Secretos en el paquete de la app. Todo lo que hay dentro de una app se puede extraer. Las claves que cuestan dinero viven en un servidor.
8. Conectar todos los servidores MCP que encuentres. Cada uno consume contexto en cada petición. Añade solo lo que uses.
9. Instalar habilidades y servidores que no has leído. Son instrucciones y código que se ejecuta con tus permisos.
10. Creer que “ya está hecho”. Pruébalo en un iPhone real, sin conexión, en modo oscuro, con el tamaño de texto más grande y con VoiceOver activado.
11. Usar modelos promocionales gratuitos para el código de clientes. Algunos pueden usar tus datos para mejorar el modelo. Desactívalos en los proyectos de clientes.
12. Olvidar la longitud de contexto de Ollama. Con el valor por defecto, un agente se queda sin espacio antes de empezar. Pon 64K en el servidor.
13. Dejar que se acumulen las dependencias. Cada paquete es código que no has leído y una actualización que tendrás que gestionar. Haz que el agente pregunte.
14. Sesiones largas y descontroladas. Empieza de cero en cada porción y usa worktrees para los experimentos.
15. Te prometo tu hoja de ruta. Las capturas y las descripciones muestran lo que hace esta compilación. Las ideas van en tu web, etiquetadas como ideas.

---

Parte 13 — ¿Qué configuración deberías elegir? Seis escenarios

1. “Nunca he escrito código y tengo un Mac.”

La app de escritorio de OpenCode, OpenCode Go y Ollama para los trabajos pequeños. Expo si también quieres Android; SwiftUI si solo te importa el iPhone. Mantén los comandos de shell en preguntar, haz commit después de cada paso que funcione y empieza con una app que haga una sola cosa.

2. “Mi código no debe salir nunca de mi máquina.”

OpenCode solo con Ollama local. Desactiva las funciones en la nube de Ollama, configura OPENCODE_DISABLE_FREE_MODELS=1, y no conectes ningún proveedor en la nube en ese proyecto. Espera una ayuda más lenta y sencilla, y dale al agente tareas más pequeñas. Un Mac con 64 GB o más hace esto mucho más cómodo.

3. “Ya pago ChatGPT, Copilot o Claude.”

Conecta primero lo que ya tienes. ChatGPT Plus y Pro y GitHub Copilot funcionan con los inicios de sesión integrados sin coste adicional. Claude funciona a través del proveedor Claude Agent; lee la parte 2 antes de depender de él para trabajo de empresa. Añade OpenCode Go más adelante si quieres modelos abiertos además.

4. “Quiero iPhone y Android con un solo código base.”

Expo SDK 58, el servidor MCP de Expo, las habilidades oficiales de Expo y EAS para compilaciones y subidas en la nube. Puedes compilar y subir apps iOS sin un Mac, aunque seguirás queriendo uno (y un iPhone) para las pruebas.

5. “Solo me interesan las plataformas de Apple y quiero que todo sea nativo.”

SwiftUI en Xcode 27.1, con OpenCode dentro de Xcode mediante ACP (Xcode → Ajustes → Inteligencia → Añadir un agente…, ejecutable opencode, argumento acp) o en tu terminal con el puente MCP de Xcode y XcodeBuildMCP. Una limitación de la ruta dentro de Xcode: no hay selector de modelo, así que configura tu modelo predeterminado en opencode.jsonc Primero.

6. “Quiero ir rápido y pagaré por ello.”

OpenCode Go Plus y Ollama Max, worktrees para experimentos en paralelo, el modo goal para los trabajos largos y mecánicos, y un modelo de frontera por clave API para los problemas realmente difíciles. Vigila tu gasto cada semana. Para ejecutar varios agentes en paralelo, mi comparativa de harness cubre las opciones.

---

Preguntas frecuentes

---

Conclusión

Aprendizaje cómo usar OpenCode bien no consiste en memorizar comandos. Consiste en construir un pequeño sistema alrededor del agente: un plan de codificación que encaje en tu presupuesto, Ollama para el trabajo que debe quedarse en tu máquina, un puñado de servidores MCP que dejan al agente ver lo que construye, skills que guardan tu manual de juego y permisos que mantienen contigo las decisiones irreversibles.

Mi recomendación se mantiene: OpenCode con OpenCode Go y Ollama es la manera más barata, más flexible y con menos riesgo de quedarse atado a un proveedor de crear una app con IA a finales de 2026. Añade una suscripción que ya pagues, o un modelo de frontera mediante clave de API, cuando una tarea lo merezca. Después usa también el agente para el papeleo y quédate tú con el botón “Enviar”.

Si quieres ver qué produce este tipo de proceso a pequeña escala, mis dos apps son gratuitas: Stash — Encuéntralo rápido para las cosas que guardas, y PingAtlas para comprobar lo cerca que está realmente internet de donde estás sentado. Ahora ve y construye la tuya.

---

¿Construyes con OpenCode? Me gustaría saber por qué plan de codificación te decidiste, qué modelo local se ganó un sitio en tu Mac y qué servidor MCP o skill no podrías dejar de usar. Las correcciones y las pruebas en contra son bienvenidas; este artículo se actualiza cuando cambia el panorama.

Aviso: Stash y PingAtlas son apps mías, publicadas por mi empresa, Graham Miranda UG (haftungsbeschränkt). Ambas son gratuitas y no muestran anuncios. Este artículo contiene un enlace de afiliado, al GLM Coding Plan de Z.ai en la parte 2; si te suscribes a través de él obtienes un 10 % de descuento y yo recibo una comisión. Ninguna empresa mencionada aquí patrocinó, revisó ni aprobó este artículo.

Última actualización: 7 de noviembre de 2026.