iOS desde la Terminal: Workflow CLI-First con Claude Code

Puedes compilar, testear y enviar una app iOS a la App Store sin abrir la interfaz de Xcode. Con Claude Code como orquestador y XcodeBuildMCP como puente al toolchain de Apple, todo el ciclo de desarrollo cabe en la terminal. Esta guía cubre la configuración, el ciclo build-test-fix y el envío a producción.

Por qué el desarrollo iOS CLI-first tiene sentido en 2026

Xcode consume entre 4 y 8 GB de RAM solo por estar abierta. Para corregir un layout en SwiftUI o ajustar una llamada a API, arrancar esa interfaz completa es desproporcionado. Las herramientas de línea de comandos de Apple (xcodebuild, xcrun simctl, xcresulttool) siempre han existido, pero usarlas requería memorizar decenas de flags y parsear output sin estructura.

Lo que ha cambiado es la capa de abstracción. XcodeBuildMCP, adquirido por Sentry en febrero de 2026, expone más de 78 herramientas que cubren compilación, tests, simuladores, dispositivos físicos, debugging con LLDB y automatización de interfaz. Claude Code las consume como cualquier otro servidor MCP, y de pronto tienes un agente que compila, detecta errores, los corrige y vuelve a compilar sin intervención manual.

El resultado es un workflow donde escribes código en tu editor preferido, delegas compilación y testing al agente, y solo abres Xcode cuando necesitas el Interface Builder o firmar manualmente la app. Si vienes del mundo del desarrollo con agentes de terminal, el salto conceptual es mínimo.

¿Qué es XcodeBuildMCP?

XcodeBuildMCP es un servidor MCP y CLI que permite a agentes de IA compilar, ejecutar, testear y depurar apps iOS, macOS, watchOS y visionOS desde la terminal sin necesidad de tener Xcode abierto. Funciona en dos modos: como servidor MCP para agentes (Claude Code, Cursor, Codex) y como CLI independiente para scripts y CI/CD.

A diferencia de ejecutar xcodebuild directamente, XcodeBuildMCP devuelve output estructurado en JSON. Donde xcodebuild produce miles de líneas de log intercaladas, XcodeBuildMCP categoriza errores por archivo y severidad en campos estructurados. Para un agente de IA que necesita interpretar resultados de compilación, esa diferencia es la que separa un ciclo de corrección automática de un agente perdido en texto plano.

Entre sus capacidades destacan: scaffolding de proyectos desde plantillas, builds incrementales, ejecución de tests con filtrado, control de simuladores, deployment a dispositivos físicos vía USB o Wi-Fi, debugging con LLDB (breakpoints, inspección de variables) y automatización de UI (tap, swipe, capturas de pantalla). Si ya trabajas con servidores MCP para dar contexto visual a tus agentes, XcodeBuildMCP sigue el mismo patrón pero especializado en el toolchain de Apple.

Herramientas del ecosistema CLI-first para iOS

No todas las herramientas resuelven lo mismo. Esta tabla resume las opciones disponibles a marzo de 2026:

Herramienta	Enfoque	Pros	Contras
XcodeBuildMCP	MCP + CLI para Xcode nativo	78+ tools, LLDB, UI automation, JSON output, dynamic loading	Requiere Xcode instalado, solo macOS
FlowDeck	CLI wrapper sobre xcodebuild	Modo interactivo con atajos de teclado, extensión VS Code/Cursor	No es MCP, menos integración con agentes IA
Apple MCP (Xcode 26.3)	MCP nativo de Apple	20 tools, SwiftUI previews, REPL Swift, diagnósticos en tiempo real	Requiere proceso de Xcode ejecutándose en background
Expo + EAS	React Native cross-platform	Build en la nube, submit automático, funciona en Linux/Windows	No es nativo, limitaciones de acceso a APIs de sistema

La combinación más potente para desarrollo nativo es XcodeBuildMCP + Apple MCP: el primero compila sin necesitar Xcode abierto, el segundo aporta previews y documentación en tiempo real. Para proyectos React Native, Expo con EAS permite compilar y enviar desde cualquier sistema operativo.

Configuración paso a paso

1. Instalar XcodeBuildMCP

Dos opciones de instalación. Con Homebrew:

# Instalación vía Homebrew
brew tap getsentry/xcodebuildmcp
brew install xcodebuildmcp

# Verificar instalación
xcodebuildmcp --version

O directamente con npx si prefieres no instalar globalmente:

# Uso directo sin instalación global
npx -y xcodebuildmcp@latest --version

2. Añadir el servidor MCP a Claude Code

# Registrar XcodeBuildMCP como servidor MCP
claude mcp add --transport stdio XcodeBuildMCP -- \
  npx -y xcodebuildmcp@latest mcp

Para reducir el consumo de tokens en el contexto inicial, activa la carga dinámica de herramientas. En lugar de registrar las 78+ tools de golpe, solo carga las esenciales y añade el resto bajo demanda:

# Con carga dinámica de herramientas
claude mcp add --transport stdio \
  -e XCODEBUILDMCP_DYNAMIC_TOOLS=true \
  -e INCREMENTAL_BUILDS_ENABLED=true \
  XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp

3. Configurar permisos en Claude Code

Permite que el agente compile y testee sin pedir confirmación en cada paso. En .claude/settings.json:

{
  "permissions": {
    "allow": [
      "Bash(swift build)",
      "Bash(swift test)",
      "Bash(xcodebuild -scheme * build)",
      "Bash(xcrun simctl *)",
      "mcp__XcodeBuildMCP__*"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force *)"
    ]
  }
}

Operaciones no destructivas (compilar, testear, gestionar simuladores) pasan sin confirmación. Las destructivas quedan bloqueadas. En escenarios donde cada miembro del equipo usa un agente distinto, esta configuración es portable porque XcodeBuildMCP funciona con cualquier cliente MCP.

4. Preparar el CLAUDE.md del proyecto

El archivo CLAUDE.md define las reglas del proyecto para el agente. Para iOS, hay una regla que no puedes saltarte:

# Reglas del Proyecto iOS

## Restricciones
- NUNCA modificar archivos .pbxproj manualmente
- Compilar después de cada cambio para detectar errores
- Usar Plan Mode antes de refactors que toquen 3+ archivos
- Assets solo via Asset Catalog

## Stack
- Swift 6.1, SwiftUI, iOS 18+
- Arquitectura: MVVM con async/await
- Tests: XCTest + Swift Testing

## Workflow
- Compilar con XcodeBuildMCP tras cada cambio
- Tomar screenshot del simulador para verificar UI
- Ejecutar tests antes de dar por bueno un cambio

La regla sobre .pbxproj es la más importante. Ese archivo gestiona la estructura del proyecto Xcode. Un agente de IA que lo modifique directamente puede corromper todo el proyecto. Es el equivalente a dejar que edite tu package-lock.json a mano.

5. El ciclo build-test-fix en acción

Con todo configurado, el flujo es directo:

# Iniciar Claude Code en el directorio del proyecto
claude

> Añade una pantalla de perfil de usuario con avatar,
> nombre y botón de edición. Usa async/await para
> cargar los datos del API en /api/v1/profile.

Claude Code escribe el código SwiftUI, compila con XcodeBuildMCP, detecta errores de tipos o imports faltantes, los corrige y vuelve a compilar. Si el build es exitoso, instala la app en el simulador y toma capturas de pantalla para verificar el layout. El ciclo completo ocurre sin que cambies de ventana.

6. Envío a la App Store

Para proyectos Expo/React Native, EAS Submit automatiza todo el proceso:

# Build + envío automático a TestFlight
eas build --platform ios --profile production --auto-submit

# Enviar un build existente
eas submit --platform ios --latest

Para proyectos nativos Swift, el proceso requiere encadenar comandos de archivado y subida:

# 1. Archivar para distribución
xcodebuild archive -scheme MiApp \
  -archivePath ./build/MiApp.xcarchive

# 2. Exportar IPA
xcodebuild -exportArchive \
  -archivePath ./build/MiApp.xcarchive \
  -exportOptionsPlist ExportOptions.plist \
  -exportPath ./build/

# 3. Subir a App Store Connect
xcrun altool --upload-app \
  -f ./build/MiApp.ipa \
  -t ios \
  -u "$APPLE_ID" \
  -p "$APP_SPECIFIC_PASSWORD"

Refactors multi-archivo sin salir de la CLI

Uno de los puntos donde el workflow CLI-first destaca es en refactors que tocan múltiples archivos. En Xcode, renombrar un protocolo implica navegar por cada archivo que lo implementa. Con Claude Code, describes el cambio y el agente lo ejecuta en todos los archivos, compilando después de cada modificación para asegurar que nada se rompe.

La clave es usar el modo planificación para cambios grandes:

claude

> /plan Migra el networking de URLSession con callbacks
> a async/await en todos los servicios.
> No toques los tests todavía.

Claude Code analiza todos los archivos, propone un plan de migración archivo por archivo, y solo ejecuta cuando confirmas. Este patrón de "cambio incremental con verificación" es lo que hace viable los refactors grandes desde la terminal. En escenarios con agentes en modo autónomo, la regla de oro es: cuanto más acotado sea el prompt, mejor el resultado.

En Producción

El workflow CLI-first funciona para el desarrollo diario, pero hay escenarios donde Xcode sigue siendo necesario:

Storyboards y XIBs: si tu proyecto los usa, necesitas el Interface Builder. Un proyecto SwiftUI puro elimina esta dependencia.
Signing y capabilities: añadir push notifications, HealthKit o entitlements requiere la interfaz de Xcode al menos una vez para la configuración inicial.
Profiling avanzado: Instruments sigue sin tener equivalente CLI completo para análisis de memory leaks o CPU profiling detallado.
Debugging visual: el View Debugger 3D de Xcode para inspeccionar jerarquías de vistas no tiene reemplazo en terminal.

En cuanto a costes, el workflow añade la suscripción a Claude (Pro desde unos 20 €/mes, Max desde unos 100 €/mes) sobre la cuenta de Apple Developer (99 €/año). XcodeBuildMCP y FlowDeck son gratuitos y open source. Para un desarrollador independiente, el coste adicional real está entre 20 y 50 €/mes dependiendo de la intensidad de uso.

Respecto a rendimiento, compilar vía MCP añade un overhead inferior a 1 segundo sobre xcodebuild directo. El cuello de botella real son los tokens: un proyecto Swift mediano genera entre 5.000 y 15.000 tokens de contexto por compilación. Activa XCODEBUILDMCP_DYNAMIC_TOOLS=true para que el servidor solo registre las herramientas que necesita en cada momento, e INCREMENTAL_BUILDS_ENABLED=true para que el output se limite a los cambios incrementales. Si necesitas racionalizar tu stack de herramientas IA, este es uno de los ajustes con mayor impacto.

Errores comunes y depuración

Error: Unable to find a destination matching the provided destination specifier
Causa: el simulador especificado no existe o no está disponible.
Solución: ejecuta xcrun simctl list devices available para ver los dispositivos instalados y usa un nombre exacto.

Error: Claude Code modifica .pbxproj y el proyecto deja de abrir en Xcode.
Causa: el agente intentó añadir archivos editando la estructura del proyecto directamente.
Solución: revierte con git checkout -- *.pbxproj y añade la restricción en CLAUDE.md.

Error: build exitoso pero la app no aparece en el simulador.
Causa: xcodebuild build compila pero no instala. Es un paso separado.
Solución: usa la herramienta simulator/build-and-run de XcodeBuildMCP en lugar de solo simulator/build.

Error: Code Signing Error: No profiles for 'com.example.app' were found
Causa: perfiles de provisión no configurados o expirados.
Solución: abre Xcode una vez, activa "Automatically manage signing" en Signing & Capabilities, y vuelve a la terminal.

Preguntas frecuentes

¿Necesito macOS para este workflow?

Para desarrollo nativo con Swift/SwiftUI, sí. El toolchain de Apple solo funciona en macOS, y tanto xcodebuild como los simuladores iOS requieren un Mac. La excepción es Expo con EAS Build, que compila en la nube y permite enviar a la App Store desde Linux o Windows.

¿Puedo usar Cursor o Copilot en lugar de Claude Code?

XcodeBuildMCP es compatible con cualquier cliente MCP: Cursor, Claude Code, VS Code con Copilot, Windsurf e incluso Xcode 26.3 de forma nativa. El workflow es el mismo independientemente del agente. FlowDeck tiene además una extensión específica para VS Code y Cursor.

¿XcodeBuildMCP reemplaza a Fastlane?

No directamente. XcodeBuildMCP cubre build, test, simuladores y debugging, pero no gestiona signing automatizado, screenshots para la App Store ni distribución a testers. Fastlane sigue siendo la referencia para pipelines CI/CD de iOS. Son complementarias: XcodeBuildMCP para el ciclo de desarrollo local con agentes IA, Fastlane para la automatización de releases.

El desarrollo iOS desde la terminal ha pasado de ser un ejercicio con flags incomprensibles de xcodebuild a un workflow productivo con agentes IA que compilan, corrigen y verifican por ti. La combinación de Claude Code con XcodeBuildMCP cubre el 80% de las tareas diarias sin abrir la interfaz de Xcode. El 20% restante (signing, profiling, debugging visual avanzado) sigue justificando tener Xcode instalado, pero ya no necesita estar siempre abierto.

¿Has probado a desarrollar iOS sin abrir Xcode? Cuéntame tu experiencia en Twitter @sergiomarquezp_. En los próximos posts exploraremos cómo optimizar el consumo de tokens cuando tu agente interactúa con herramientas de build pesadas.