Como usar o OpenCode do primeiro prompt à App Store: o guia de 2026 para planos de codificação, Ollama, servidores MCP e skills

Em algum ponto entre o primeiro prompt e o primeiro e-mail da App Review, um agente de codificação com IA deixa de ser um brinquedo e se torna uma ferramenta com a qual você entrega software. Este guia trata de como usar o OpenCode para ir de um ponto ao outro: instalá-lo em um Mac limpo, escolher o que pagar pelo modelo que faz o raciocínio, rodar modelos na sua própria máquina com Ollama, dar mãos de verdade ao agente com servidores MCP, ensinar ao agente os seus hábitos com skills e então levar um aplicativo de iPhone pelo TestFlight e pela App Review sem perder uma semana com burocracia.

Eu não venho de uma formação em programação. Administro uma pequena empresa de TI na Alemanha e construo software com agentes de IA. Dois dos resultados entraram no ar na App Store neste outono: Stash, que lembra onde você guardou as coisas, e PingAtlas, que mede a latência de rede a partir do seu próprio aparelho. Eles aparecem neste guia onde são realmente úteis como exemplos, e em nenhum outro lugar.

Tudo abaixo foi verificado com base na documentação oficial, nas notas de versão, nas páginas de preços e na própria App Store em 7 de novembro de 2026. A codificação com IA anda rápido: o OpenCode lançou pelo menos dez lançamentos da versão 2 só entre 20 e 30 de outubro, Ollama e MiniMax refizeram seus planos desde o fim de agosto, e a Apple reescreveu partes de suas diretrizes de revisão pelo menos duas vezes neste ano. Números voláteis são sinalizados onde aparecem. Confira-os antes de comprar qualquer coisa.

Divulgação: Stash e PingAtlas são aplicativos meus, publicados pela minha empresa, Graham Miranda UG (haftungsbeschränkt). Ambos são gratuitos e não mostram anúncios. Este artigo contém um link de afiliado: o link do Z.ai GLM Coding Plan na Parte 2 concede 10% de desconto e me paga uma comissão se você assinar. A equipe do OpenCode na Anomaly, Ollama, Apple, Expo, Z.ai e todas as outras empresas mencionadas aqui não patrocinaram, revisaram nem aprovaram este artigo.

---

Resumo — A jornada inteira em dez tópicos

• O OpenCode é um agente de codificação gratuito e de código aberto (MIT) que funciona com quase qualquer modelo: assinaturas na nuvem, APIs com pagamento por token ou modelos rodando no seu próprio Mac. Está na versão 2.2.6 (6 de novembro de 2026), com um aplicativo de terminal, um aplicativo de desktop, uma interface web e para celular, e um modo ACP que roda dentro do Xcode 27.
• Você paga pelo modelo, não pelo agente. “Planos de codificação” são assinaturas mensais de valor fixo por tempo de modelo. Para a maioria das pessoas que está começando, OpenCode Go (US$ 10 por mês) mais Ollama (gratuito localmente, US$ 20 por mês pelos créditos de nuvem do Pro) é a configuração que recomendo: barata, independente de modelo, sem retenção por padrão para a maioria dos modelos e sem zonas cinzentas nos termos de serviço de ninguém.
• As alternativas são reais. ChatGPT Plus e Pro, GitHub Copilot e o Z.ai GLM Coding Plan se conectam ao OpenCode por meio de provedores integrados. As assinaturas do Claude voltaram a funcionar pelo novo provedor Claude Agent do OpenCode 2.2.3, mas a Anthropic não endossou publicamente esse caminho, então leia a Parte 2 antes de contar com ele.
• O Ollama é um único motor para modelos locais e na nuvem. ollama launch opencode conecta os dois, modelos locais precisam de uma janela de contexto de pelo menos 64K, e um Mac de 32 GB roda modelos de codificação sólidos como qwen3.8:27b (um download de 18 GB).
• Servidores MCP dão mãos ao agente. Para trabalho com aplicativos, a lista curta é a própria ponte MCP do Xcode (xcrun mcpbridge), o XcodeBuildMCP, o servidor MCP do Expo, o Context7 para documentação atual e o Sentry para travamentos. Adicione apenas o que você usa: cada servidor custa contexto.
• As skills dão ao agente o seu playbook. Uma skill é uma pasta com um SKILL.md arquivo. O OpenCode as lê de .opencode/skills e também de .claude/skills e .agents/skills, então skills escritas para outros agentes também funcionam. A Expo publica 23 oficiais, e a CLI do App Store Connect (asc) vem com mais de vinte.
• Deixe o agente fazer a papelada, nunca o envio. O asc A CLI e suas skills podem enviar builds, gerenciar o TestFlight, sincronizar metadados e capturas de tela e verificar o status da revisão. Negue o comando de envio nas permissões do OpenCode e aperte o botão você mesmo.
• As regras de 2026 da Apple importam para aplicativos feitos com IA. Aplicativos clones em categorias saturadas agora são rejeitados (diretriz 4.3(b), junho), recursos ocultos ou dormentes são proibidos (nova 2.5.19, outubro), os builds precisam do Xcode 26 ou mais recente e, a partir de abril de 2027, aplicativos feitos com o SDK do iOS 27.1 precisam de capturas de tela do iPhone Duo.
• Custo do primeiro ano: US$ 99 se você rodar tudo localmente e pagar apenas à Apple, cerca de US$ 419 na configuração que recomendo (Apple + OpenCode Go + Ollama Pro na cobrança anual), e cerca de US$ 1.779 para uma configuração potente. Todos os preços excluem impostos.
• A regra que mais importa: “pronto” é uma alegação, não um fato. Rode no seu iPhone de verdade, em modo avião, no modo escuro, no maior tamanho de texto, com o VoiceOver ligado. Só então acredite.

---

A jornada em resumo

Etapa	O que você faz	O que o OpenCode faz	Ferramentas
1. Configurar	Instale, escolha um plano de codificação, conecte modelos	Nada ainda	OpenCode, OpenCode Go, Ollama
2. Ensinar	Escreva o AGENTS.md, adicione skills, conecte servidores MCP	Lê tudo a cada sessão	AGENTS.md, skills, MCP
3. Planejar	Escreva o briefing, discuta com o plano	Transforma o briefing em um plano e um roteiro	plan agente, /goal
4. Construir	Revise cada diff, teste em um dispositivo	Escreve código em pequenos blocos, compila, roda testes, tira capturas de tela	build agente, Xcode MCP, XcodeBuildMCP ou Expo MCP
5. Beta	Convide testadores, leia o feedback	Arquiva, envia, gerencia grupos do TestFlight	Xcode, asc ou EAS
6. Documentação	Responda com honestidade às perguntas legais e de privacidade	Redige metadados, audita fluxos de dados, redimensiona capturas de tela	asc skills
7. Enviar	Você pressione “Enviar para revisão”	Verifica o status da revisão, faz a triagem das rejeições	App Store Connect
8. Lançar	Responda aos usuários, planeje atualizações	Localiza, escreve notas de versão, faz a triagem de falhas	asc, Sentry, seu site

---

Índice

• Parte 1 — O que é o OpenCode em novembro de 2026, e por que eu o recomendo
• Parte 2 — Planos de codificação, explicados (e os dois que eu recomendo)
• Parte 3 — Ollama: um motor para modelos locais e na nuvem
• Parte 4 — Como usar o OpenCode: instale e conecte seus modelos, passo a passo
• Parte 5 — Agentes, comandos, permissões e modo Goal: tornando o OpenCode seu
• Parte 6 — Servidores MCP: dando mãos ao agente
• Parte 7 — Skills: escreva seu playbook uma vez
• Parte 8 — Construindo o aplicativo: da ideia a uma compilação em que você confia
• Parte 9 — Publicando na App Store: deixe o OpenCode cuidar da documentação e pressione Enviar você mesmo
• Parte 10 — Lançamento: a listagem, as capturas de tela, o ASO e a vida depois da aprovação
• Parte 11 — Quanto custa: quatro orçamentos para o primeiro ano
• Parte 12 — Quinze erros a evitar
• Parte 13 — Qual configuração você deve escolher? Seis cenários
• Perguntas frequentes
• A conclusão

---

Parte 1 — O que é o OpenCode em novembro de 2026, e por que eu o recomendo

O OpenCode é um agente de codificação com IA de código aberto. Você o inicia em uma pasta de projeto, descreve o que quer, e ele trabalha como um desenvolvedor: lê seus arquivos, faz um plano, edita o código, executa comandos, lê os erros e continua até o trabalho terminar ou até precisar de você. É publicado sob a licença MIT pela Anomaly, a equipe por trás do projeto, e não se importa com o modelo que você usa.

A página inicial do projeto afirma ter mais de 220.000 estrelas no GitHub, 1.089 colaboradores e 22 milhões de desenvolvedores mensais. São números do próprio projeto e mudam toda semana, mas explicam por que o OpenCode se tornou a alternativa mais conhecida, independente de modelo, aos agentes das próprias criadoras de modelos, Claude Code e Codex.

Onde ele roda

O OpenCode não é mais um único aplicativo. Desde a reescrita da versão 2.0, um serviço em segundo plano roda na sua máquina e todas as interfaces falam com ele, então uma sessão que você inicia em um lugar aparece nos outros.

Interface	O que é	Bom para
Terminal (TUI)	O clássico aplicativo de terminal em tela cheia	Trabalho rápido pelo teclado, sessões SSH, servidores
Aplicativo para desktop	Um aplicativo Electron para macOS (Apple silicon e Intel), Windows (x64 e ARM64) e Linux (.deb, .rpm, AppImage), com abas, diffs, terminais e um navegador integrado	Pessoas que não vivem no terminal
Web e celular	opencode pair imprime um link de uso único (ele expira após cinco minutos) que abre suas sessões locais em um navegador; a 2.2.6 adicionou um compositor adaptado a celulares e tablets	Acompanhar uma tarefa longa do sofá
Dentro do Xcode 27	O OpenCode fala o Agent Client Protocol, então opencode acp pode ser adicionado como agente nas configurações de Inteligência do Xcode	Desenvolvedores de Swift nativo que querem ficar no Xcode
SDK e scripts	opencode run para tarefas pontuais, além de um SDK JavaScript	Automação e CI

O que mudou desde a 2.0

O OpenCode 2.0 foi uma reconstrução do zero: segundo o anúncio da equipe em julho, o runtime passou de Bun para Node.js para reduzir o uso de memória, o aplicativo para desktop passou de Tauri para Electron, a API foi redesenhada e o OpenCode começou a rodar como serviço por padrão. A versão 2.0.0 foi lançada em 11 de setembro de 2026. As versões desde então acrescentaram principalmente os recursos que importam para projetos longos e reais:

Versão	Data	O que foi adicionado
2.2.0	27 de out	Plugins experimentais para desktop, um aplicativo para desktop renovado, APIs de imagem e de decisão para plugins
2.2.1	29 de out	Modo objetivo (/goal <objective>, com pausa, retomada e limpeza), adesão opcional prompts agendados, geração de imagens
2.2.2	29 de out	Geração de imagens ativada por padrão quando um provedor conectado oferece suporte; um seletor de worktree a partir do branch do Git
2.2.3	30 de out	O Claude Agent provedor (mais sobre isso na Parte 2)
2.2.4	30 de out	Configuração guiada do Claude Agent, agendamentos que rodam sob opencode serve, terminais persistentes no desktop
2.2.5	30 de out	Atalhos de worktree e de modo shell, um buffer de compactação baseado em porcentagem
2.2.6	6 de nov	opencode run --worktree para execuções via script, um dock de compositor para celular, conexões MCP compartilhadas

Fonte: changelog do OpenCode, verificado em 7 de novembro de 2026. Espere uma versão mais nova quando você ler isto.

Por que é o agente que eu recomendo

1. Ele não é leal a nenhum modelo. O OpenCode se conecta a assinaturas, APIs pagas por token e modelos locais por meio de um único /connect comando. Quando um modelo melhor for lançado no mês que vem, você muda uma linha em um arquivo de configuração, não todo o seu fluxo de trabalho.
2. Suas permissões funcionam como um firewall. Toda ação (ler, editar, executar um comando de shell, carregar uma skill, chamar uma ferramenta MCP) passa por uma lista ordenada de allow, perguntar e deny regras em que a última correspondência vence. “Nunca execute git push” e “nunca enviar para a App Store” são uma linha cada.
3. Ele fala os formatos de todo mundo. Ele lê AGENTS.md (e recorre a CLAUDE.md), carrega skills de .claude/skills e .agents/skills assim como das próprias pastas, e se conecta a qualquer servidor MCP. O ecossistema que outros agentes construíram também funciona aqui.
4. Ele vai onde você está. Terminal em um servidor, aplicativo de desktop em um Mac, um navegador no seu celular ou dentro do Xcode.
5. Não custa nada. O OpenCode é gratuito e ainda inclui um conjunto rotativo de modelos gratuitos que você pode usar sem conta.

Onde ele não é a melhor escolha

Honestidade antes de tudo: o OpenCode não é o maior pontuador nos rankings de programação, porque não é um modelo. Os harnesses que lideram são pares de fornecedor: Claude Code com o melhor modelo da Anthropic, Codex com o da OpenAI. Eles são ajustados juntos e são excelentes. Comparei vinte e oito deles no meu comparativo de harness de codificação com IA, e se você já paga por uma dessas assinaturas e adora, nada neste guia exige que você mude.

Também há arestas. O OpenCode lança versões quase todos os dias, então as coisas mudam sob seus pés. A documentação antiga da versão 1 ainda existe em docs.opencode.ai (com um banner apontando para a v2), e muitos guias de terceiros, incluindo a própria página do OpenCode da Ollama, ainda mostram o endereço do instalador v1. Vários dos recursos mais novos estão marcados como experimentais. E os gerenciadores de pacotes do Windows não são compatíveis com a ferramenta de linha de comando v2; usuários do Windows recebem o aplicativo de desktop ou um zip independente.

---

Parte 2 — Planos de codificação, explicados (e os dois que eu recomendo)

O OpenCode é gratuito. O modelo que pensa não é. Há três formas de pagar por ele, e a maior parte da confusão sobre “planos de codificação com IA” vem de misturá-las.

1. Rode você mesmo. Modelos de pesos abertos no seu próprio Mac via Ollama. Você paga com hardware e paciência, não com dinheiro. Seu código nunca sai da máquina.
2. Assine um plano de codificação. Uma mensalidade fixa compra uma franquia de uso, geralmente medida em janelas de cinco horas e semanais. É aqui que ficam OpenCode Go, Ollama Pro, o GLM Coding Plan e as assinaturas do ChatGPT e do Claude.
3. Pague por token. Traga uma chave de API de qualquer provedor e pague exatamente pelo que usar. Ideal para o problema difícil ocasional; perigoso para uma sessão longa de depuração sem alerta de orçamento.

Os planos de codificação que funcionam no OpenCode (novembro de 2026)

Plano	Preço mensal (USD)	O que você recebe	Como ele se conecta ao OpenCode
Modelos gratuitos do OpenCode	US$ 0	Um conjunto rotativo de modelos gratuitos por tempo limitado	Integrado, sem necessidade de conta
Ollama, local	US$ 0	Qualquer modelo de pesos abertos que seu Mac suporte	Detectado automaticamente, ou ollama launch opencode
OpenCode Go ⭐	US$ 10 · Go Plus $40 · Go Teams $20 por membro	32 modelos abertos, incluindo GLM-5.3, GLM-5.3-Flash, Kimi K3 e K3.1 Pro, MiniMax M3.1 Flash, DeepSeek V4.1 Flash e Qwen3.8 Max	/connect → OpenCode Go → cole sua chave
Ollama Pro / Max ⭐	US$ 20 ($200 por ano) · Max $100	$60 (Pro) ou $300 (Max) em créditos de modelos na nuvem por mês, mais uso local ilimitado	Igual ao Ollama local; modelos na nuvem aparecem junto com os locais
GLM Coding Plan (Z.ai)	Lite $18 · Pro $80 · Max $168 (20% de desconto no trimestral, 30% no anual)	GLM-5.3 e GLM-5.3-Flash, ambos com contexto de 1M de tokens	/connect → o provedor Z.AI Coding Plan
MiniMax M Plan	Go $22 · Explore $55 · Build $132 (dois meses grátis na cobrança anual)	MiniMax M3.1 Flash, além de modelos de imagem, áudio e (a partir do Explore) de vídeo	O provedor do plano de codificação da MiniMax, com uma chave M Plan
ChatGPT	Plus $20 · Pro a partir de $100	A família GPT-6 da OpenAI por meio do seu plano ChatGPT	/connect → OpenAI → “Entrar com ChatGPT”
GitHub Copilot	Pro $10 · Pro+ $39 · Max $100	O conjunto de modelos do Copilot, medido em GitHub AI Credits	/connect → GitHub Copilot → login por dispositivo
Claude	Pro $20 · Max a partir de $100	Modelos da Anthropic via Claude Code	/connect → Claude Agent (OpenCode 2.2.3+, Claude Code instalado); veja a ressalva abaixo
Pague por token	O que você usa	A API de qualquer provedor, incluindo o gateway de pagamento por uso do próprio OpenCode	/connect → o provedor → chave de API

Preços de tabela em 7 de novembro de 2026, sem impostos. ⭐ = o que este guia recomenda. Preços, cotas e listas de modelos mudam o tempo todo, então confira a página de cada fornecedor antes de assinar. Os preços do GLM vêm de um instantâneo de 24 de setembro e da manchete da Z.ai de “planos a partir de US$ 18”; a assinatura do Kimi (a partir de US$ 19) fica de fora porque não consegui confirmar uma rota oficial no OpenCode para ele.

Como os limites funcionam de verdade

O preço de manchete diz muito pouco. O que vale é a cota com que você convive.

• OpenCode Go dá a cada modelo sua própria cota mensal em dólares, e você pode gastar 20% dela em qualquer janela de cinco horas e 50% em qualquer semana. No plano de US$ 10, por exemplo, o GLM-5.3-Flash recebe US$ 60 por mês, o DeepSeek V4.1 Flash US$ 100 e o Kimi K3 US$ 15, então modelos baratos e eficientes rendem muito mais do que os pesados. Quando você atinge um limite, as solicitações são bloqueadas, a menos que você tenha ativado o Extra Usage, que recorre a crédito por uso. Os modelos gratuitos continuam funcionando de qualquer forma.
• Ollama passou a créditos: o Pro inclui $60 de uso na nuvem por mês e o Max $300, ambos cobrados por token, e o crédito não usado não acumula. O Pro permite três requisições ao mesmo tempo, o Max dez. Os preços caem fora da faixa de 12:00 a 18:00 UTC em dias úteis e durante todo o fim de semana, o que cai bem nas noites europeias. Modelos locais são ilimitados em todos os planos, inclusive no gratuito.
• O GLM Coding Plan usa créditos por janela de cinco horas e semanal, e o uso fora de pico (fora de 14:00 a 18:00 no horário da China em dias úteis) custa metade dos créditos.
• ChatGPT e Copilot medem pelos próprios sistemas: o ChatGPT em estimativas de mensagens por cinco horas e por modelo, o Copilot em AI Credits. Dentro do OpenCode, os logins do ChatGPT não mostram custo por requisição porque o uso conta na sua assinatura, e o OpenCode limita por padrão a janela de contexto de entrada deles (500.000 tokens nos modelos GPT mais novos).

Privacidade e retenção de dados

Seus prompts contêm seu código. Para onde eles vão importa, especialmente em trabalhos para clientes sob as regras de proteção de dados da UE.

• OpenCode Go bloqueia endpoints pagos que treinam com seus dados por padrão. A maioria dos modelos (GLM, Kimi, MiniMax, Qwen, MiMo e mais) é servida com retenção zero; alguns (Grok, modelos GPT Luna, Claude Haiku e dois modelos promocionais gratuitos) mantêm registros por 30 dias. Os modelos “Contributor” com desconto treinam com seus prompts e precisam ser ativados de propósito. As regiões padrão são a Europa e os Estados Unidos, e os modelos da DeepSeek exigem adesão ao roteamento global, com um acordo de retenção zero válido até 30 de novembro de 2026.
• Ollama Cloud diz sem rodeios: “Dados de prompt ou de resposta nunca são registrados nem usados para treinamento.” Os modelos rodam principalmente nos Estados Unidos, com a capacidade excedente possivelmente encaminhada para a Europa.
• Os modelos gratuitos do OpenCode são outro caso: a documentação observa que alguns modelos gratuitos podem usar seus dados para melhorar o modelo. Ótimo para experimentos, não para código de cliente. Defina OPENCODE_DISABLE_FREE_MODELS=1 para ocultá-los.
• Modelos locais nunca saem da sua máquina. Para qualquer coisa sob um acordo rígido de processamento de dados, essa ainda é a resposta mais limpa.

A questão do Claude

As assinaturas do Claude tiveram um ano acidentado em ferramentas de terceiros. Em janeiro, a Anthropic apertou as verificações e os logins do Claude Pro e Max pararam de funcionar em harnesses como o OpenCode; em março, o OpenCode removeu a opção de login a pedido da Anthropic. Em 30 de outubro, o OpenCode 2.2.3 trouxe as assinaturas de volta por outro caminho: um provedor integrado Claude Agent que conduz o Claude Code instalado localmente (versão 2.1.248 ou posterior) pelo Agent SDK oficial da Anthropic, depois que você entra com claude auth login.

Os fatos que você precisa saber antes de usar:

• O OpenCode não lê o login salvo do Claude Code; o verdadeiro claude programa é quem envia as requisições.
• As ferramentas, configurações, CLAUDE.md arquivos, hooks, servidores MCP e skills do próprio Claude Code ficam desativados. Em vez disso, o Claude trabalha com as ferramentas e os pedidos de permissão do OpenCode.
• A documentação do Agent SDK da Anthropic diz que desenvolvedores terceiros não podem oferecer login do claude.ai nem limites de assinatura em seus produtos sem que a Anthropic tenha aprovado. Na data em que escrevo, a Anthropic não havia se manifestado publicamente sobre o provedor do OpenCode, e ninguém pode dizer com certeza se ele coloca sua conta em risco.

Meu conselho: se você já paga pelo Claude e quer testar, use em projetos pessoais e fique de olho em um comunicado oficial. Para trabalho profissional, use uma chave de API da Anthropic, o único caminho que a documentação da Anthropic cita.

O que eu recomendo, e por quê

Comece com o OpenCode Go e o Ollama. O raciocínio é este:

• Preço. $10 por mês dão acesso a 32 modelos abertos fortes. Acrescente o Ollama Pro por $20 se quiser mais folga na nuvem; pule se seu Mac roda bem modelos locais.
• Escolha sem ficar preso a um fornecedor. O Go e o Ollama Cloud oferecem as mesmas famílias de pesos abertos (GLM, Kimi, MiniMax, DeepSeek e mais), então você pode comparar modelos no seu próprio projeto em vez de confiar em um ranking.
• Privacidade por padrão. Retenção zero para a maioria dos modelos do Go, uma política de não registro no Ollama e a opção de rodar tudo localmente em trabalhos sensíveis.
• Sem zonas cinzentas. Ambos foram feitos exatamente para esse uso, dentro do OpenCode.
• A alternativa local é gratuita. Quando a janela de cinco horas se esgota às 23h, um modelo local no Ollama mantém você avançando nas tarefas pequenas.

Quando escolher outra coisa. Se você já paga pelo ChatGPT Plus ou pelo Copilot, conecte-o primeiro; não custa nada a mais. Se o GLM vai ser seu principal do dia a dia, a franquia do GLM Coding Plan pode fazer mais sentido do que os limites por modelo do Go, e você pode ganhar 10% de desconto no GLM Coding Plan pelo meu link de afiliado (link de afiliado, veja o aviso no início). As chaves do Coding Plan e as chaves padrão da API do Z.ai não são intercambiáveis, então escolha o provedor Coding Plan em /connect. E se o seu trabalho precisa do topo absoluto da tabela de classificação, um modelo de fronteira via chave de API para as tarefas mais difíceis é dinheiro bem gasto.

---

Parte 3 — Ollama: um motor para modelos locais e na nuvem

O Ollama roda modelos de pesos abertos no seu próprio computador e os serve por uma API local simples. Desde o ano passado ele também roda modelos maiores na própria nuvem, pelo mesmo aplicativo e pela mesma API, então para o OpenCode um modelo de nuvem parece exatamente um modelo local. É todo o atrativo: um único motor, uma única configuração, e uma troca entre “privado e grátis” e “grande e rápido” que é só um nome de modelo.

Instalar o Ollama (passo a passo)

1. Baixe de ollama.com/download. No Mac, abra o download e arraste o Ollama para Aplicativos. No Windows, execute o instalador. No Linux, o comando oficial de uma linha é:

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

2. Inicie. Abra o aplicativo, ou digite ollama em um terminal. Desde a versão 0.40.15 (início de novembro), executar ollama sem argumentos abre um launcher de boas-vindas.
3. Entre na sua conta se quiser modelos na nuvem. O aplicativo pede isso durante a configuração. Modelos locais funcionam sem conta; seu uso da nuvem fica em ollama.com/settings/usage.
4. Baixe um modelo para verificar se tudo funciona:

   ollama pull qwen3.8:27b
   ollama run qwen3.8:27b "Say hello in Swift"

Conecte o Ollama ao OpenCode

Você tem três opções, da mais fácil à mais flexível.

Opção 1: deixe o OpenCode encontrá-lo. O OpenCode v2 verifica o endereço local padrão do Ollama na inicialização e adiciona todo modelo capaz de escrever texto a /models. Sem conta, sem configuração. Modelos apenas de embedding são ignorados.

Opção 2: deixe o Ollama configurar.

ollama launch opencode            # configure OpenCode for Ollama and start it
ollama launch opencode --config   # configure only, don't start a session

ollama launch funciona com o OpenCode v2 desde o Ollama 0.40.12 (27 de outubro). Ele não sobrescreve seu ~/.config/opencode/opencode.json, então suas próprias configurações continuam valendo. Uma peculiaridade: modelos definidos apenas na configuração do OpenCode não aparecem no seletor de inicialização do Ollama.

Opção 3: aponte o OpenCode para um servidor Ollama em outro lugar. Se o Ollama roda em um Mac mini no armário ou em um servidor, adicione-o como provedor com o endereço dele. O /v1 no final faz diferença:

{
  "$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
      }
    }
  }
}

A configuração que quebra a maioria das instalações locais: o tamanho da janela de contexto

O FAQ do Ollama informa sua janela de contexto padrão como 4.096 tokens. O próprio guia do Ollama para o OpenCode pede pelo menos 64K, porque o prompt de sistema de um agente, as definições de ferramentas e o conteúdo dos arquivos enchem uma janela pequena antes de qualquer trabalho acontecer. Defina isso no servidor Ollama, não no OpenCode:

# Se você inicia o servidor por conta própria:
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# Se usa o aplicativo para Mac: defina a variável para o launchd, depois feche e reabra o Ollama
launchctl setenv OLLAMA_CONTEXT_LENGTH 65536

Depois confira se funcionou: ollama ps mostra o tamanho do contexto de cada modelo carregado e se ele está rodando na GPU. Uma janela maior usa mais memória, então em um Mac de 32 GB, 64K é um teto sensato para um modelo de 27 bilhões de parâmetros.

Qual modelo local cabe no seu Mac

Uma regra prática útil do ranking de novembro do BenchLM: um modelo precisa de mais ou menos o tamanho do download mais 20% para o contexto, e um Mac pode dar cerca de três quartos da sua memória unificada à GPU. Na prática, mantenha o download abaixo de cerca de 60% da memória do seu Mac.

Memória do seu Mac	Modelo para testar primeiro	Download	Contexto	Bom para
16 GB	gemma4:12b ou gemma4:e4b	7,7 GB / 6,6 GB	256K / 128K	Explicações, pequenas edições, mensagens de commit. Pequeno demais para sessões longas de agente; use modelos na nuvem para construir
24–32 GB	qwen3.8:27b (também como 27b-mlx para Apple silicon)	18 GB	256K	O ponto ideal no local para programar com um agente
24–32 GB	qwen3-coder:30b	19 GB	256K	Um coder de mistura de especialistas com apenas cerca de 3 bilhões de parâmetros ativos, então é rápido
24–32 GB	gpt-oss:20b	14 GB	128K	O modelo de pesos abertos menor da OpenAI; deixa mais folga
64 GB	Os mesmos modelos em precisão maior, como qwen3.8:27b-q8_0	30 GB	256K	Respostas melhores, espaço para um contexto grande
96–128 GB	gpt-oss:120b ou devstral-2:123b	65 GB / 75 GB	128K / 256K	Qualidade de modelo grande sem a nuvem

Tamanhos e janelas de contexto da biblioteca do Ollama em 7 de novembro de 2026. A velocidade depende da largura de banda de memória do seu chip tanto quanto do tamanho da memória. Para o lado do hardware, veja meu guia de MacBook para LLMs locais.

Ollama Cloud: os modelos que seu Mac não comporta

Os modelos de código de pesos abertos mais fortes hoje são grandes demais para um notebook. O Ollama Cloud os executa para você. No aplicativo ou na CLI, eles usam a :cloud tag e não baixam nada:

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

A parte relevante para código do catálogo na nuvem em 7 de novembro:

Modelo	Fabricante	Contexto	A classificação de uso do Ollama	Notas
glm-5.3	Z.ai	1M	Alto	O carro-chefe da Z.ai; forte em tarefas agênticas longas
glm-5.3-flash	Z.ai	1M	Médio	Nativamente multimodal, 18B de parâmetros ativos; um ótimo modelo padrão para construir
kimi-k3.1-pro	Moonshot AI	1M	Extremamente alto	A entrada mais recente (atualizada em 4 de novembro), multimodal, o modelo mais capaz da Moonshot
kimi-k2.7-code	Moonshot AI	256K	Alto	Ajustado para código e mais leve em tokens de raciocínio
minimax-m3.1-flash	MiniMax	976K	Médio	Lê imagens; $0,15 de entrada e $0,60 de saída por milhão de tokens
deepseek-v4.1-flash	DeepSeek	1M	Médio	Feito para velocidade e taxa de transferência; lê imagens
mistral-large-4	Mistral	1M	Alto	Laboratório europeu, pesos abertos
gemma4	Google	256K	Baixo	Barato o suficiente para auxiliares e subagentes

A classificação é a abreviação da Ollama para a rapidez com que um modelo gasta seus créditos. Se você quer comparar os grandes de verdade, minhas Kimi K3 vs Fable 5.1 vs GLM-5.3 e GLM-5.3-Flash vs MiniMax M3 comparações vão mais fundo.

O padrão de roteamento que eu copiaria

Você não precisa escolher um modelo só. Dê a cada tipo de trabalho o modelo mais barato que o faça bem:

• Planejamento (os erros mais caros acontecem aqui): seu modelo mais forte.
• Desenvolvimento: um modelo rápido e capaz, como GLM-5.3-Flash ou MiniMax M3.1 Flash.
• Buscar no código, ler documentação, escrever testes e mensagens de commit: um modelo local. Não custa nada e seu código fica onde está.

A Parte 4 mostra exatamente como configurar isso no arquivo de configuração do OpenCode.

Modo somente local para projetos sensíveis

Se um projeto nunca pode tocar em um modelo na nuvem, transforme isso em configuração, não em promessa. A Ollama consegue desligar totalmente os recursos de nuvem (adicione "disable_ollama_cloud": true a ~/.ollama/server.json, ou defina OLLAMA_NO_CLOUD=1, depois reinicie), e os modelos gratuitos na nuvem do OpenCode podem ser ocultados com OPENCODE_DISABLE_FREE_MODELS=1. Depois, conecte apenas provedores locais nesse projeto.

Ressalvas honestas sobre a Ollama

• Modelos locais são mais lentos e mais fracos no uso de ferramentas longo e com várias etapas do que os grandes modelos na nuvem. Eles brilham em tarefas contidas.
• A nuvem ainda é o computador de outra pessoa. A política de não registrar dados da Ollama é boa, mas seu código ainda sai da sua máquina, principalmente para os Estados Unidos.
• Os créditos acabam. US$ 60 de crédito Pro rendem bastante no GLM-5.3-Flash e muito menos em um modelo classificado como “extra high”.
• Uma resposta lenta nem sempre é culpa do modelo. Toda requisição à nuvem faz primeiro uma viagem de ida e volta pelo seu Wi-Fi, seu roteador e a internet em geral. Se as respostas parecerem lentas, verifique a conexão antes de culpar o modelo: meu próprio app PingAtlas mede os tempos de ida e volta do seu iPhone, iPad ou Mac até cidades e até serviços como o GitHub, e eu expliquei o resto do caminho em o que acontece dentro do seu roteador.

---

Parte 4 — Como usar o OpenCode: instale e conecte seus modelos, passo a passo

Esta é a configuração que eu daria a um amigo. Leva uns vinte minutos, a maior parte em downloads.

Passo 0 — O que você precisa primeiro

• Um Mac com Apple silicon, se você quer criar apps para iPhone nativamente. O Xcode 27.1 (lançado em 15 de outubro, com Swift 6.4 e o SDK do iOS 27.1) precisa de macOS Tahoe 26.6 ou mais recente. Se você constrói com o Expo, o serviço de nuvem dele consegue compilar apps iOS a partir do Windows ou do Linux, mas você ainda vai querer um iPhone para testar.
• Xcode na Mac App Store, aberto uma vez para instalar os componentes dele.
• Git. Seu verdadeiro botão de desfazer.
• Node.js, apenas se você for usar o Expo: o SDK 58 exige Node 22.13 ou mais recente, 24.3 ou mais recente, ou 26 e posteriores (versões ímpares como 23 e 25 não são suportadas).
• Um plano de codificação da Parte 2, ou a Ollama da Parte 3.

Passo 1 — Instalar o OpenCode

No macOS ou Linux:

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

Prefere um app? Baixe a versão desktop para macOS, Windows ou Linux em opencode.ai/download. Os apps de terminal e de desktop compartilham o mesmo serviço em segundo plano e as mesmas sessões. No Windows, use o app de desktop ou o zip autônomo; gerenciadores de pacotes do Windows não são suportados na v2.

Duas armadilhas que vale conhecer:

• Guias antigos usam o instalador antigo. opencode.ai/install (sem /v2/) ainda aparece em muitos tutoriais, inclusive em alguns documentos oficiais de parceiros. Use o /v2/install endereço acima.
• usuários do mise precisam do mise 2026.10.9 ou mais recente, ou vão receber o OpenCode 1.

Passo 2 — Conectar seus modelos

Inicie o OpenCode em uma pasta de projeto e execute /connect:

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

Depois, dependendo do que você paga:

Você tem	Em /connect, escolha	Depois
OpenCode Go	OpenCode Go	Cole a chave de API do OpenCode Console
Ollama	Nada; os modelos locais aparecem sozinhos	Ou execute ollama launch opencode
ChatGPT Plus ou Pro	OpenAI → Entrar com o ChatGPT	Faça login no navegador
GitHub Copilot	GitHub Copilot	Conclua o login no dispositivo
Claude Pro ou Max	Claude Agent (não “Anthropic”, que é para chaves de API)	Executar claude auth login primeiro em um terminal; leia a ressalva da Parte 2
GLM Coding Plan	O provedor Z.AI Coding Plan	Cole sua chave do Coding Plan, não uma chave de API padrão
Uma chave de API	O nome do provedor	Cole a chave

Passo 3 — Escolha seus modelos

Executar /models e escolha. Os modelos do OpenCode Go são nomeados opencode-go/<model-id>; os modelos locais do Ollama aparecem no provedor Ollama. Copie os IDs exatos de /models para sua configuração, porque nomes e tags mudam.

Passo 4 — Adicionar uma configuração de projeto

Os padrões funcionam, mas um projeto de aplicativo merece um arquivo de configuração que faz três coisas: encaminhar cada agente para o modelo certo, manter o agente longe de qualquer coisa irreversível e conectar seus servidores MCP. Salve isto como opencode.jsonc na raiz do projeto e substitua pelos IDs dos modelos /models mostra a você:

{
  "$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" }
    }
  }
}

O que você está colando, em palavras simples:

• , exceto alguns poucos somente leitura. Somente leituraconsultas (qualquer coisa que liste, além do status de revisão) são permitidas, para que o agente possa verificar builds e o andamento da revisão sem incomodar você. asc consultas (qualquer coisa que liste, além do status de revisão) são permitidas, para que o agente possa verificar builds e o andamento da revisão sem incomodar você.
• Algumas coisas são bloqueadas de imediato: enviar código, publicar ou submeter um aplicativo para revisão, e confirmar ações destrutivas no App Store Connect. Você faz isso sozinho, de propósito. O upload de um build para o TestFlight continua permitido (depois de pedir permissão), porque não envia nada para revisão.
• Os padrões do OpenCode já pedem confirmação antes de ler .env arquivos. Deixe isso ativado.
• As permissões são grades de proteção, não um sandbox. Um modelo determinado pode encontrar outro caminho para fazer alguma coisa. Mantenha credenciais de produção, chaves de assinatura e sua chave Admin do App Store Connect longe da máquina onde os agentes rodam sem supervisão.

Passo 5 — Escreva um AGENTS.md antes de qualquer código

O OpenCode lê o AGENTS.md na raiz do seu projeto no início de cada sessão, além de um pessoal em ~/.config/opencode/AGENTS.md se você criá-lo. O /init comando pode rascunhar um examinando seu repositório. É o hábito isolado mais eficaz no desenvolvimento assistido por IA, e eu escrevi sobre o sistema inteiro no meu guia de vibe coding. Para um aplicativo de iPhone, ele deve conter as regras do produto, bem como os comandos:

# Notas para agentes de codificação

## O que este aplicativo é
Uma frase. Se uma mudança não serve a isso, ela não tem lugar.

## Inegociáveis
- Funciona offline. Os recursos de rede degradam com elegância.
- Sem analytics, anúncios ou SDKs de rastreamento. Pergunte antes de adicionar QUALQUER dependência.
- Sem segredos no pacote do aplicativo. Chaves que custam dinheiro ficam em um servidor.
- Sem recursos ocultos, dormentes ou apenas de depuração nos builds de release
  (diretriz 2.5.19 da App Review). Os menus de depuração são compilados fora do Release.
- Nunca envie dados pessoais a um serviço de IA de terceiros sem
  uma tela de consentimento explícita no aplicativo (diretriz 5.1.2(i)).
- Acessibilidade: Dynamic Type, rótulos do VoiceOver, alvos de toque de 44 x 44 pt,
  modo claro e escuro em todas as telas.
- Toda string visível ao usuário é localizada, incluindo widgets,
  notificações e avisos de permissão.

## Comandos
- Compilar e executar: use as ferramentas do XcodeBuildMCP (build_run_sim), esquema "MyApp"
- Testes: test_sim
- Nunca execute asc publish nem nada com --submit.

## Definição de concluído
- Compila sem avisos, os testes passam
- Verificado com screenshot + snapshot_ui no simulador
- Funciona em modo avião, modo escuro e no maior tamanho de texto

Passo 6 — Sua primeira sessão de verdade

1. Comece no modo plan. Mude para o plan agent (ele não consegue editar os arquivos do seu projeto) e peça que ele conteste seu briefing: “Leia o AGENTS.md e o BRIEF.md. Liste os fluxos do usuário, os casos extremos que eu não considerei e as telas que estão faltando. Depois me diga o que cortar.”
2. Salve o plano como um roteiro. Peça a ele para escrever ROADMAP.md como uma checklist de fatias pequenas, de ponta a ponta.
3. Construa uma fatia de cada vez com o build agente. Uma tela, um recurso, funcionando de ponta a ponta.
4. Revise o diff, execute, faça o commit. Cada fatia termina com um commit. Se um passo der errado, /undo desfaz o último passo do agente a partir dos snapshots do OpenCode; o Git é a rede de segurança maior.
5. Comece uma sessão nova para a próxima fatia. Uma sessão limpa, que relê o AGENTS.md e o ROADMAP.md, costuma ser mais inteligente do que uma sessão longa cheia de suposições desatualizadas.

---

Parte 5 — Agentes, comandos, permissões e modo Goal: tornando o OpenCode seu

Depois que o básico funciona, quatro recursos transformam o OpenCode de um chat com terminal em uma oficina que se encaixa no seu projeto.

Os agentes integrados

Agente	Tipo	O que ele faz
build	Primário	O padrão. Edita arquivos, executa comandos, faz o trabalho
plan	Primário	Explora e planeja sem editar os arquivos do seu projeto (pode criar os próprios arquivos de plano)
general	Subagente	Pesquisa e tarefas de várias etapas; não pode iniciar outros subagentes
explore	Subagente	Pesquisa e lê código ou páginas web; não pode editar nada

Os agentes primários são aqueles com quem você conversa. Os subagentes são iniciados por um agente primário para uma tarefa específica, então o contexto da sessão principal continua limpo.

Escreva seu próprio subagente: um cético da App Review

Agentes personalizados são arquivos Markdown em .opencode/agents/ (ou ~/.config/opencode/agents/ para todos os projetos). O front matter configura o agente e o corpo se torna as instruções dele. Este revisa seu app do mesmo jeito que a App Review vai revisar, e não pode mudar nada enquanto faz isso:

---
description: Reviews the app and its metadata against Apple's App Review Guidelines before a submission
mode: subagent
model: opencode-go/glm-5.3
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

You are a sceptical App Review specialist. Review the current code and the
files in metadata/ and list problems, most serious first, with file and line:

- Crashes, placeholder text, dead links, missing demo account (2.1)
- Anything that looks like a copy of a saturated app category (4.3(b))
- Hidden, dormant or undocumented features, debug menus, feature flags (2.5.19)
- Data that leaves the device and isn't in the privacy policy or privacy label
- Personal data sent to any AI service without explicit consent (5.1.2(i))
- Account creation without in-app account deletion (5.1.1(v))
- Screenshots or descriptions promising features the build doesn't have

Don't fix anything. Report only.

Salve como .opencode/agents/appstore-reviewer.md, depois pergunte: “Use o subagente appstore-reviewer para revisar tudo desde a última tag de release.”

Comandos personalizados para as tarefas que você repete

Comandos são modelos de prompt que você executa com uma barra. Coloque-os em .opencode/commands/; $ARGUMENTS é substituído pelo que você digitar depois do comando, e ` !command ` insere a saída de um comando de shell antes de o prompt ser enviado. Este aqui rascunha as notas de versão da App Store:

---
description: Draft App Store "What's New" notes from the commits since the last tag
agent: build
---

Here are the commits since the last release:

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

Write "What's New" notes for version $ARGUMENTS in plain, friendly English,
under 400 characters, user-facing changes only. Save them to
metadata/en-US/release_notes.txt and show me the text.

Salve como .opencode/commands/whats-new.md e execute com /whats-new 1.2.0. Um aviso da documentação do OpenCode vale repetir: esses ! blocos rodam fora do sistema de permissões do agente, então só coloque neles comandos em que você confia.

Um guia de permissões para projetos de app

A configuração da Parte 4 é um bom começo. Mais algumas regras que vale conhecer:

• Regras por agente ficam em agents.<id>.permissions e são adicionadas depois das globais, então você pode, por exemplo, deixar apenas o agente build rodar xcodebuild.
• Ferramentas MCP também são ações, chamado <server>_<tool>. Uma regra como { "action": "XcodeBuildMCP_*", "resource": "*", "effect": "ask" } faz com que toda chamada ao XcodeBuildMCP peça confirmação primeiro.
• Skills podem ser restringidas com o skill action: allow anuncia e carrega uma skill livremente, perguntar anuncia, mas pergunta antes de carregar, deny a esconde por completo.
• Quando vários recursos são verificados ao mesmo tempo, qualquer deny vence, depois qualquer perguntar.

Modo Goal, worktrees e agendamentos

Três recursos mais recentes mudam como a duração dos trabalhos é percebida:

• Modo objetivo (2.2.1): /goal Faça cada tela passar por uma auditoria de VoiceOver e corrija o que falhar mantém a sessão trabalhando rumo ao objetivo até que ele seja revisado, com pause, resume e clear. Perfeito para os trabalhos grandes e chatos: revisões de acessibilidade, localização, cobertura de testes.
• Worktrees: inicie uma sessão em um worktree Git separado na tela de nova sessão (ou ⌘⌥O no aplicativo de desktop), para que um experimento não toque no seu branch principal. Execuções com script usam opencode run --worktree=<name> desde a 2.2.6. Descarte o worktree se o experimento falhar.
• Prompts agendados (opcional, experimental): /schedule executa um prompt em um horário programado enquanto opencode serve está em execução, como um “rodar os testes e resumir as falhas” noturno.

---

Parte 6 — Servidores MCP: dando mãos ao agente

Sozinho, um agente de codificação consegue ler arquivos e executar comandos de shell. MCP, o Model Context Protocol, é a forma padrão de dar mais a ele: um projeto Xcode em execução, um simulador em que ele pode tocar e tirar capturas de tela, seus relatórios de falhas, documentação atualizada, seu serviço de build. Cada servidor MCP expõe um conjunto de ferramentas, e o agente decide quando chamá-las.

Há um custo, e a documentação do OpenCode diz isso sem rodeios: “As ferramentas MCP consomem contexto do modelo, então adicione apenas os servidores de que você precisa.” Cada servidor conectado adiciona descrições de ferramentas a cada requisição. Dez servidores que você raramente usa deixam cada resposta mais lenta e menos focada.

A lista curta do desenvolvedor de aplicativos

Servidor	O que ele dá ao agente	Adicionar ao OpenCode	Vale saber
Xcode (Apple)	Seu projeto Xcode aberto: build, testes e mais, pelo próprio Xcode	opencode mcp add xcode -- xcrun mcpbridge	No Xcode → Settings → Intelligence, defina Allow External Agents to Use Xcode Tools a Sempre ou While Xcode is Open. Abra o projeto no Xcode antes de enviar o prompt; o Xcode mostra quando um agente se conecta
XcodeBuildMCP	Builds headless, execuções em simulador e dispositivo, capturas de tela, toques e deslizes, snapshots de acessibilidade, testes, depuração com LLDB	opencode mcp add XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp	Código aberto (MIT), mantido pela Sentry desde que ela comprou o projeto em fevereiro. Requer macOS 14.5+, Xcode 16+ e Node 18+. Só as ferramentas de simulador ficam ativas por padrão
Expo	Builds, fluxos de trabalho e envios do EAS, documentação do Expo, simuladores na nuvem, dados de crashes e feedback do TestFlight e das lojas	opencode mcp add expo --url https://mcp.expo.dev/mcp, depois opencode mcp auth expo	Requer uma conta Expo e o SDK mais recente. Algumas ferramentas exigem um plano Expo pago. As ferramentas de simulador local precisam de npx expo install expo-mcp --dev e SDK 54+
Context7	Documentação atual e específica para cada versão de bibliotecas e frameworks	opencode mcp add context7 --url https://mcp.context7.com/mcp	Impede que o modelo invente APIs que mudaram no mês passado
Sentry	Seus crashes e erros reais	opencode mcp add sentry --url https://mcp.sentry.dev/mcp, depois opencode mcp auth sentry	Login via OAuth
Playwright	Um navegador de verdade que o agente pode controlar	opencode mcp add playwright -- npx @playwright/mcp@latest	Para a versão web do seu app e a sua landing page
Firebase	Seu projeto Firebase, regras de segurança e configuração	opencode mcp add firebase -- npx -y firebase-tools@latest mcp	Pergunta antes de alterar qualquer coisa no seu projeto

Veja o que está conectado com opencode mcp list, e ative ou desative servidores para uma sessão com /mcps.

Se você desenha no Figma, o servidor MCP dele também pode passar frames e variáveis para o agente. Cobri a pegadinha específica do OpenCode (servidor remoto versus servidor desktop) no meu guia de criar um app do zero com IA.

A ponte MCP do Xcode vs XcodeBuildMCP

Eles se sobrepõem e funcionam bem juntos:

• O servidor próprio do Xcode (xcrun mcpbridge) funciona através do app Xcode que você tem aberto. É da Apple, entende o seu projeto do jeito que o Xcode entende, e precisa do Xcode rodando.
• XcodeBuildMCP envolve as ferramentas de linha de comando da Apple (xcodebuild, simctl, devicectl), então roda sem interface gráfica. A força de verdade dele é o ciclo de verificação: build_run_sim para compilar e iniciar, screenshot para olhar, snapshot_ui para ler a árvore de acessibilidade, tap e type_text para usar o app, e test_sim para rodar os testes. Rode xcodebuildmcp init uma vez no seu projeto para instalar as duas skills complementares dele.

No arquivo de configuração

Os mesmos servidores podem ficar em opencode.jsonc (A Parte 4 tem um exemplo completo), o que é melhor para uma equipe porque a configuração acompanha o repositório:

"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 }
  }
}

Dois detalhes da documentação de MCP do OpenCode: segredos entram como {env:NAME} (um $NAME simples não é expandido), e "disabled": true mantém um servidor configurado sem conectá-lo.

Quando uma ferramenta de linha de comando vence um servidor MCP

Minha regra: se existe uma boa ferramenta de linha de comando, teste-a com uma skill antes de adicionar um servidor. O agente já sabe executar comandos, uma CLI não custa contexto até ser usada, e a saída dela pode ser filtrada antes de chegar ao modelo. Para trabalho com aplicativos, três CLIs cobrem muita coisa:

• gh para o GitHub: issues, pull requests, releases.
• asc para o App Store Connect: builds, TestFlight, metadados, capturas de tela, status de revisão (Parte 9).
• eas para o serviço de build e envio do Expo.

Segurança de MCP em quatro regras

1. Instale servidores dos próprios criadores ou de projetos que você consegue ler. Um servidor é código rodando na sua máquina com as suas permissões.
2. Trate a saída das ferramentas como não confiável. Uma página web, um comentário de issue ou um relatório de falha podem conter instruções destinadas ao seu agente. Mantenha as ações de risco em perguntar.
3. Controle ferramentas por nome. Cada ferramenta MCP é uma ação de permissão chamada <server>_<tool>, então você pode permitir as somente leitura e fazer as demais pedirem autorização.
4. Remova o que você não usa. Custa contexto, e é uma coisa a menos que pode dar errado.

---

Parte 7 — Skills: escreva seu playbook uma vez

O AGENTS.md diz ao agente o que é o seu projeto. Skills ensinam como você faz trabalhos específicos: lançar uma build, escrever uma migração, preparar capturas de tela, auditar privacidade. Uma skill é uma pasta contendo um SKILL.md arquivo com uma descrição curta no topo e instruções abaixo, além de quaisquer scripts ou arquivos de referência de que precise. O formato é um padrão aberto compartilhado pelo OpenCode, Claude Code, Codex e outros, e é por isso que uma skill escrita para um agente costuma funcionar nos demais.

Como o OpenCode usa uma skill

1. A cada passo, o OpenCode mostra ao modelo uma lista das skills que ele pode usar: apenas o ID, o nome e a descrição de cada skill. As instruções em si não são carregadas, então cem skills custam quase nada.
2. Quando uma tarefa corresponde, o modelo chama a skill ferramenta com o ID da skill, e o OpenCode verifica suas permissões.
3. O OpenCode adiciona as instruções à conversa, com o caminho da pasta da skill e uma lista de até dez dos seus arquivos de apoio.
4. Os arquivos de apoio só carregam quando as instruções pedem por eles. Uma lista de verificação longa ou um script fica no disco até ser necessário.

Você também pode carregar uma você mesmo mencionando-a em um prompt: @app-store-release.

Onde o OpenCode procura

Escopo	Pasta
Seu projeto	.opencode/skills/
Seu projeto (compartilhado com outros agentes)	.claude/skills/ e .agents/skills/
Todos os projetos na sua máquina	~/.config/opencode/skills/
Todos os projetos (compartilhado)	~/.agents/skills/ e ~/.agents/skills/
Em qualquer outro lugar	Caminhos ou catálogos HTTP listados em um skills array em opencode.jsonc

O ID de uma skill vem do nome da pasta dela, não do nomear no front matter dela, e diferencia maiúsculas de minúsculas: .opencode/skills/app-store-release/SKILL.md tem o ID app-store-release. Quando duas fontes definem o mesmo ID, a que vem depois nesta ordem vence: embutida, .claude/skills, .agents/skills, sua pasta global, a do seu projeto .opencode/skills, depois entradas explícitas de configuração. Uma skill sem um descrição não é anunciada ao modelo de jeito nenhum.

Escreva sua primeira skill: uma checklist de lançamento na App Store

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

---
name: App Store release
description: Prepara um lançamento de iOS. Aumenta a versão e o número de build, executa a checklist de lançamento, arquiva e envia para o TestFlight com o asc, e redige as notas do What's New. Use quando pedirem para "enviar", "lançar" ou "mandar para o TestFlight".
---

# Lançamento na App Store

1. Verifique `git status`. Se a árvore de trabalho não estiver limpa, pare e avise.
2. Aumente a versão de marketing e o número de build (pergunte qual versão se ela não for informada).
3. Percorra references/release-checklist.md. Todos os itens precisam passar.
4. Arquive e exporte o IPA com scripts/archive.sh.
5. Envie: `asc builds upload --app "$ASC_APP_ID" --ipa build/MyApp.ipa`
6. Redija as notas do What's New a partir dos commits desde a última tag e salve-as
   em metadata/en-US/release_notes.txt.
7. NUNCA envie para revisão. Informe que o build foi enviado e pare.

Coloque a checklist em references/release-checklist.md e o script de arquivamento em scripts/archive.sh ao lado dela. Da próxima vez que você disser “envie a 1.2.0 para o TestFlight”, o agente encontra a skill pela descrição e segue os seus passos em vez de improvisar.

Skills que valem a pena instalar para trabalhar com apps

Conjunto de skills	O que está incluído	Instale
Skills do Expo (oficiais)	23 skills: 16 para o Expo SDK (Router, interface nativa, @expo/ui, sistemas de design, atualizações, módulos nativos e mais) e 7 para os serviços do Expo, incluindo eas-app-stores para compilar e enviar ao TestFlight, à App Store e ao Google Play	npx skills add expo/skills
Skills da CLI do App Store Connect	Mais de vinte asc skills: fluxo de lançamento, orquestração do TestFlight, sincronização de metadados com verificação de limite de caracteres, tradução de listagem, pipelines de capturas de tela, configuração de assinatura, saúde do envio, triagem de travamentos, auditorias de ASO	asc install-skills, ou npx skills add rorkai/app-store-connect-cli-skills
Skills do XcodeBuildMCP	Duas skills que ensinam ao agente as ferramentas e a CLI do XcodeBuildMCP	xcodebuildmcp init
skills.sh	O diretório aberto de skills da comunidade da Vercel; ele lista o OpenCode entre os agentes suportados	npx skills add <owner/repo>

Se o OpenCode não mostrar uma skill que você instalou, verifique onde o instalador a colocou em relação às pastas acima, ou copie a pasta da skill para .opencode/skills/.

Segurança de skills

Uma skill são instruções e, muitas vezes, scripts que o agente vai executar. Leia uma skill de terceiros antes de instalá-la, do mesmo jeito que você leria um script de shell vindo da internet. Prefira skills de quem faz a ferramenta (Expo para o Expo, os asc mantenedores do asc), mantenha skills desconhecidas em perguntar com uma regra de permissão, e lembre-se de que deny esconde uma skill do modelo por completo.

---

Parte 8 — Construindo o aplicativo: da ideia a uma compilação em que você confia

As ferramentas estão prontas. Agora vem a parte que decide se alguém vai baixar o resultado.

Escolha uma ideia que a App Review vai deixar passar

A IA barateou a criação de apps, e a Apple percebeu. Em 9 de junho ela reescreveu a diretriz 4.3(b), a regra antispam dela: apps que são essencialmente iguais ao que já existe em abundância na loja agora são rejeitados, e a Apple cita apps de namoro, lanterna, papel de parede, timer e adivinhação como categorias em que você precisa de uma experiência significativamente diferente ou melhor. Apps de novidade de baixo esforço podem ser removidos, apps existentes nessas categorias podem ser retirados se não forem melhorados ou não atraírem usuários, e envios repetidos desse tipo podem custar sua assinatura de desenvolvedor.

Então, antes do primeiro prompt, um teste: você consegue dizer em uma frase o que o seu app faz que os primeiros resultados do termo principal de busca dele não fazem? Se você não conseguir, o agente vai construir tudo lindamente e a App Review vai devolver.

Pequeno e específico vence grande e genérico. Meus dois aplicativos são deliberadamente estreitos:

• Stash lembra onde você guardou as coisas: fotografe o local, escolha o ambiente, salve e depois busque por nome, ambiente ou uma nota de voz transcrita.
• PingAtlas mede os tempos de ida e volta da rede do seu próprio iPhone, iPad ou Mac até 202 cidades, 278 destinos públicos, 109 jogos e 32 serviços online, sem conta e sem serviço de medição remoto.

Um trabalho cada. É isso que torna possível uma única pessoa construí-los com um agente, e explicá-los em uma frase na página da App Store.

Escolha sua stack

	SwiftUI + Xcode 27.1	Expo SDK 58 (React Native 0.88)
Roda em	iPhone, iPad, Mac, Apple Watch, Vision Pro	iPhone, iPad, Android e a web a partir de um único código-base
Linguagem	Swift 6.4	TypeScript
Precisa de um Mac?	Sim	Não para compilar ou enviar (a nuvem da Expo faz isso); sim para ferramentas locais do simulador iOS
Ferramentas do agente	A ponte MCP do Xcode, XcodeBuildMCP, OpenCode dentro do Xcode via ACP	O servidor MCP da Expo, 23 skills oficiais, um experimental @expo/agent-cli e legível por máquina expo command:ps saída para agentes
Novidades deste outono	iOS 27.1 SDK, um simulador de iPhone Duo (com alguns limites nas extensões)	Compilado com o SDK do iOS 27; os apps migram para o ciclo de vida de cena do UIKit, prontos para o iPhone Duo; suporte a App Intents em alfa; macOS não é suportado no SDK 58
Melhor para	Apps exclusivos para Apple que querem os recursos mais recentes da plataforma	Uma pessoa publicando para iPhone e Android, com uma versão web

Se você gosta de publicar primeiro uma versão web (eu gosto), a saída web da Expo permite colocar uma demonstração funcional na frente das pessoas antes de existir a versão da App Store. O site do Stash faz algo parecido com uma demonstração no navegador construída em torno de uma casa de exemplo: as pessoas podem experimentar a ideia antes de instalar qualquer coisa.

O ciclo de build que funciona

O agente escreve rápido. O que mantém o resultado confiável é o ciclo em volta dele:

1. Briefing. Um BRIEF.mdde uma página: a promessa em uma frase, três histórias de usuário, a lista de telas.
2. Plano. O plan o agente transforma isso em ROADMAP.md: fatias verticais pequenas, cada uma com um recurso funcionando de ponta a ponta.
3. Construa uma fatia. O build o agente implementa e escreve os testes.
4. Verifique como um usuário. Com o XcodeBuildMCP, o agente pode compilar e iniciar o app no simulador, tirar uma captura de tela, ler a árvore de acessibilidade com snapshot_ui, percorrer o fluxo tocando na tela e executar os testes. Com a Expo, as ferramentas MCP locais fazem o mesmo para o simulador. Peça que ele compare o que vê com o que você pediu.
5. Revise como a App Review. Execute o appstore-reviewer subagente da Parte 5.
6. Leia o diff você mesmo. Cada linha que vai para produção.
7. Faça o commit, marque a caixa, inicie uma sessão nova.

Para as grandes passagens mecânicas (adicionar rótulos de acessibilidade em todo lugar, traduzir cada string, aumentar a cobertura de testes), use o modo goal: /goal Traduza cada string visível ao usuário para o alemão, incluindo widgets, notificações e avisos de permissão.

Três modelos de prompt que valem adaptação:

Uma fatia: Implemente a fatia 4 do ROADMAP.md (busca). Leia o AGENTS.md primeiro. Escreva os testes unitários primeiro, depois o código. Compile e execute no simulador, tire uma captura de tela da tela de resultados e confira com o brief. Mostre o diff e liste cada suposição que você fez.

Um bug: Em um iPhone no maior tamanho do Dynamic Type, o teclado cobre o botão Salvar na tela Adicionar. Reproduza no simulador, tire uma captura de tela, explique a causa em duas frases, corrija e verifique todos os outros formulários para o mesmo problema.

Uma revisão antes do commit: Revise tudo desde o último commit como um revisor sênior de iOS cético: travamentos, perda de dados, vazamentos de privacidade, rótulos de acessibilidade ausentes, strings e cores fixas no código, qualquer coisa que quebre o uso offline. Lista numerada, do mais grave primeiro. Não corrija nada ainda.

Lições de dois aplicativos pequenos

Stash e localização. O Stash 1.1.0 (28 de outubro) adicionou dez idiomas ao inglês: espanhol, francês, alemão, italiano, português do Brasil, holandês, polonês, japonês, coreano e chinês simplificado. O aplicativo escolhe um deles a partir do dispositivo e permite trocar em Ajustes → Idioma, e as notas de versão destacam que widgets, lembretes e as solicitações de permissão do sistema também foram traduzidos. Esse último detalhe é a lição: a localização é um trabalho ideal para um agente, mas as strings que os agentes esquecem ficam fora das telas principais, em widgets, notificações, textos de finalidade das permissões e formatação de datas. Nomeie-as no AGENTS.md e elas serão feitas.

PingAtlas e promessas honestas. A descrição do PingAtlas na App Store faz promessas específicas: uma resposta ausente aparece como “Sem resposta”, nunca como 0 ms; não há GPS nem permissão de localização; não há anúncios, análises nem conta; os resultados ficam no dispositivo a menos que você os exporte; e as verificações de sites usam apenas requisições HEAD. Promessas assim pertencem ao AGENTS.md como inegociáveis, porque também são o que o seu rótulo de privacidade diz. O rótulo do PingAtlas diz “Dados Não Coletados”, e isso só é verdade enquanto o código concordar. O subagente revisor existe para perceber o dia em que não concordar.

Escopo é um recurso. O PingAtlas é um download de 1,9 MB. O Stash, com fotos, notas de voz, sincronização e widgets, tem cerca de 65 MB. Mais recursos significam mais coisa para testar, mais coisa para explicar na política de privacidade e mais coisa para a App Review questionar. Comece com a menor versão que cumpre a promessa.

Acessibilidade desde o primeiro dia

Os Rótulos Nutricionais de Acessibilidade da Apple permitem que você declare suporte a nove recursos na página do seu aplicativo na App Store: VoiceOver, Controle por Voz, Texto Maior, Interface Escura, Diferenciar Sem Apenas Cor, Contraste Suficiente, Reduzir Movimento, Legendas e Descrições de Áudio. Eles são voluntários por enquanto, mas a Apple diz que, com o tempo, você terá que fornecê-los para enviar novos aplicativos e atualizações. Você só pode declarar um recurso se as pessoas conseguirem concluir todas as tarefas comuns do seu aplicativo com ele, incluindo a primeira inicialização, o login, as compras e os ajustes.

Nenhuma das minhas próprias listagens declara nenhum deles ainda, o que é exatamente o tipo de lacuna que este guia pretende pegar. O agente pode fazer a maior parte da auditoria: o XcodeBuildMCP snapshot_ui lê a árvore de acessibilidade, então /goal Torne todas as telas totalmente utilizáveis com o VoiceOver e no maior tamanho de texto, e liste tudo o que você não conseguir corrigir é um trabalho realista para uma tarde.

---

Parte 9 — Publicando na App Store: deixe o OpenCode cuidar da documentação e pressione Enviar você mesmo

Construir é a parte divertida. Publicar é um projeto à parte, e é onde desenvolvedores de primeira viagem perdem uma semana. A boa notícia para 2026: quase tudo isso agora pode ser automatizado por script, o que significa que um agente pode fazer a digitação enquanto você toma as decisões.

O que mudou na Apple em 2026

Quando	O que mudou	O que fazer
31 jan 2026	Novas perguntas de classificação etária passaram a ser obrigatórias para atualizações	Responda a elas para cada aplicativo antes de enviar
28 abr 2026	Os envios precisam ser compilados com Xcode 26 ou mais recente e os SDKs 26	Use o Xcode 26 ou 27
9 jun 2026	Diretriz 4.3(b) reescrita: aplicativos copiados e de baixo esforço rejeitados ou removidos	Diferencie-se (Parte 8)
9 set 2026	Os uploads precisam ter como alvo iOS 13 ou mais recente	Nada, para qualquer aplicativo novo
15 out 2026	Xcode 27.1 (Swift 6.4, SDK do iOS 27.1; exige macOS Tahoe 26.6+) e Expo SDK 58	Atualize sua toolchain
16 out 2026	Nova diretriz 2.5.19 proíbe recursos ocultos, inativos ou não documentados; regras mais rígidas para aplicativos que escondem sua finalidade durante a análise	Compile as builds de lançamento sem menus de depuração nem feature flags
Em vigor	Diretriz 5.1.2(i): informe as pessoas e obtenha a permissão delas antes de compartilhar dados pessoais com IA de terceiros (adicionado em novembro de 2025)	Adicione uma tela de consentimento se o seu aplicativo chamar um serviço de IA
Agora	Capturas de tela: um conjunto para iPhone com Dynamic Island (tela média) é obrigatório, além de um iPad de 13 polegadas se o seu aplicativo roda no iPad	Planeje os tamanhos das capturas de tela (Parte 10)
Abril de 2027	iPhone Duo capturas de tela exigidas para apps criados com o SDK iOS 27.1 ou mais recente	Comece já a projetar para a segunda tela
Voluntário, por enquanto	Rótulos Nutricionais de Acessibilidade da Apple	Declare o que você realmente oferece suporte

A nova 2.5.19 é a que atinge os apps feitos com IA. Os agentes adoram extras úteis: uma tela de depuração oculta, uma feature flag deixada desligada, um menu de teste atrás de um toque longo. A nova redação da Apple é direta: “Não inclua recursos ocultos, inativos ou não documentados no seu app.” Segundo a reportagem do 9to5Mac sobre a mudança, tentar esconder esses recursos, por exemplo com ofuscação de código, pode levar à remoção do app e ao encerramento da sua conta de desenvolvedor. Coloque a regra no AGENTS.md e peça ao subagente revisor que procure por ela antes de cada envio.

O fluxo de trabalho, passo a passo

1. Inscreva-se no Apple Developer Program. Custa $99 por ano (€99 na Alemanha). Empresas se inscrevem como organização, o que exige um número D-U-N-S. Comece cedo; a verificação pode levar dias. Inscreva-se aqui.
2. Declare seu status de comerciante na UE. Pela Lei de Serviços Digitais da UE, todo desenvolvedor precisa declarar se é um comerciante. Se você publica como empresa, seu endereço, telefone e e-mail aparecem na página do produto em todos os países da UE. A Apple removeu milhares de apps das lojas da UE em fevereiro de 2025 por falta dessa declaração.
3. Crie uma chave de API do App Store Connect. No App Store Connect, vá para Usuários e Acesso → Integrações → App Store Connect API e gere uma chave de equipe. Só o titular da conta pode solicitar acesso à API. Dê à chave o cargo menos poderoso que dê conta do trabalho (a visão geral de cargos mostra o que cada um pode fazer), baixe o .p8 arquivo uma única vez e guarde-o em um lugar seguro, fora do seu repositório.
4. Instale a CLI do App Store Connect e faça login. asc é uma ferramenta de linha de comando de código aberto (MIT) para a API do App Store Connect, feita para scripts e agentes: ela imprime tabelas em um terminal e JSON quando outro programa lê a saída.

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

Depois instale as skills dela (asc install-skills) para que o OpenCode saiba como usá-la.

5. Crie o registro do app. No App Store Connect, escolha Apps → + → Novo App, e escolha seu bundle ID com cuidado, porque ele nunca muda (o da Stash é network.grahammiranda.stash, o da PingAtlas network.grahammiranda.pingatlas). As asc skills incluem uma que faz isso por automação de navegador, mas é um trabalho de dois minutos que vale a pena fazer à mão uma vez.
6. Resolva a assinatura de código. Para um app nativo, a assinatura automática do Xcode cuida dos certificados e perfis. No Expo, o EAS gerencia as credenciais para você. A asc-signing-setup skill cobre bundle IDs, capacidades, certificados e perfis, caso você prefira fazer por script.
7. Compile e envie. Nativo: arquive no Xcode (ou deixe o agente fazer isso com a asc-xcode-build skill) e depois envie:

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

Expo: eas build --platform ios, depois eas submit -p ios, que envia o build para o App Store Connect (ele não o manda para revisão). Enviar o upload é seguro para delegar; submeter para revisão não é.

8. Teste primeiro com o TestFlight. Testadores internos (até 100 pessoas da sua equipe) recebem builds sem revisão. Testadores externos (até 10.000, por e-mail ou link público) precisam de uma breve Beta App Review para o primeiro build. Os builds ficam testáveis por 90 dias. O agente pode gerenciar grupos com asc testflight groups list --app "123456789" e o asc-testflight-orchestration skill. Entregue o app a cinco pessoas com iPhones diferentes por uma semana; elas vão encontrar o crash que você não encontrou.
9. Escreva os metadados e depois deixe o agente verificar. Mantenha o anúncio do app em arquivos no repositório (metadata/en-US/…) e aplique primeiro com um dry run:

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

O asc-metadata-sync skill verifica os limites de caracteres da Apple antes de qualquer envio. A Parte 10 mostra o que escrever.

10. Faça as capturas de tela. Pelo menos uma, até dez, por tamanho exigido, em PNG ou JPEG sem transparência. O asc-shots-pipeline skill consegue capturá-las do simulador, aplicar as molduras e enviá-las com asc screenshots upload. A Parte 10 traz os tamanhos.
11. Responda com honestidade às perguntas de privacidade, classificação etária e conformidade. Esta é a parte que você não pode delegar às cegas:

• O rótulo de privacidade. Nos termos da Apple, um dado conta como coletado quando sai do dispositivo e é mantido por mais tempo do que leva para atender à solicitação. Dados processados apenas no dispositivo não contam. Sincronizar o conteúdo das pessoas com o seu servidor conta, mesmo que só elas possam vê-lo. Peça ao agente que audite cada chamada de rede e cada SDK, depois preencha o rótulo você mesmo a partir da tabela que ele montar.
• A política de privacidade precisa estar vinculada no App Store Connect e e acessível dentro do app, e ela deve descrever este app, não apenas a sua empresa.
• IA de terceiros (diretriz 5.1.2(i)): se dados pessoais vão para um serviço de IA, diga isso e peça permissão antes.
• Exclusão de conta (diretriz 5.1.1(v)): se as pessoas podem criar uma conta, elas precisam poder excluí-la dentro do app.
• Classificação etária, conformidade de exportação e os Accessibility Nutrition Labels. Se o seu app usa apenas a criptografia embutida no iOS, como HTTPS, defina ITSAppUsesNonExemptEncryption no seu Info.plist depois de conferir as orientações da Apple, para não ser questionado a cada envio.

12. Envie você mesmo. Adicione a versão para revisão e envie na página do app no App Store Connect, ou execute asc publish appstore … --submit --confirm no seu próprio terminal (as regras de permissão da Parte 4 impedem o agente de executar isso). Depois deixe o agente acompanhar: asc review status --app "123456789".

Revisão: o que esperar

A Apple diz que, em média, 90% dos envios são revisados em menos de 24 horas, e que mais de 40% dos problemas não resolvidos vêm da diretriz 2.1, App Completeness: crashes, conteúdo provisório, informações incompletas e links quebrados. Se você for rejeitado, leia a mensagem duas vezes, corrija o problema de verdade e responda no App Store Connect. O asc-submission-health skill ajuda a diagnosticar os bloqueios, e o agente é bom em redigir uma resposta calma e específica. Envie você mesmo.

---

Parte 10 — Lançamento: a listagem, as capturas de tela, o ASO e a vida depois da aprovação

Um app aprovado com um anúncio fraco é uma loja sem placa. Aqui está o resto do trabalho.

O anúncio, campo por campo

Campo	Limite	O que funciona
Nome do app	30 caracteres	Marca mais benefício. “Stash — Encontre Rápido” diz a um estranho para que serve o app
Subtítulo	30 caracteres	O benefício em palavras simples. O PingAtlas usa “Ping cidades, jogos & serviços”
Palavras-chave	100 caracteres	Separadas por vírgula, sem espaços. Não repita palavras que já estão no nome ou no subtítulo; elas contam de qualquer forma
Texto promocional	170 caracteres	Muda sem uma nova revisão, então use para temporadas e novidades
Descrição	4.000 caracteres	O que ele faz, para quem é, o que ele não faz com os dados das pessoas. Claro e específico
Novidades	Por versão	Mudanças reais em palavras humanas; o /whats-new comando da Parte 5 rascunha isso
Capturas de tela	1 a 10 por tamanho	Conte a história em ordem; a maioria das pessoas nunca rola além das três primeiras

Duas regras para deixar um agente escrever qualquer parte disso: mande ele usar apenas recursos que existem no código (e nomear o arquivo onde cada um fica), e mantenha o resultado no seu repositório para que toda mudança seja revisada como código. A asc-aso-audit skill pode então verificar lacunas de palavras-chave offline antes que qualquer coisa entre no ar.

Tamanhos de captura de tela em novembro de 2026

Dispositivo	Obrigatório?	Tamanhos em retrato (pixels)
iPhone com Dynamic Island, tela média	Sim	1179 × 2556 ou 1206 × 2622
iPhone com Dynamic Island, tela grande	Opcional	1260 × 2736, 1290 × 2796 ou 1320 × 2868
iPad, tela de 13 polegadas	Sim, se seu aplicativo roda no iPad	2064 × 2752 ou 2048 × 2732
iPhone Duo (tela externa / interna)	A partir de Abril de 2027, para aplicativos criados com o SDK do iOS 27.1 ou posterior	1398 × 2034 / 2007 × 2853

Se sua interface é igual em todos os tamanhos e idiomas, você só precisa da maior resolução exigida; o App Store Connect reduz para dispositivos menores. Capturas de tela não podem conter transparência.

Localize a ficha, não só o aplicativo

Se o aplicativo fala vários idiomas, a ficha também deve falar. A asc-localize-metadata skill traduz o texto da ficha e asc-metadata-sync confere cada idioma com os limites de caracteres da Apple, que é onde os subtítulos em alemão traduzidos à mão costumam falhar. Peça a um falante nativo para ler o resultado; a tradução automática está excelente hoje, mas o texto de loja de aplicativos é marketing, e marketing precisa de um ouvido humano.

Depois da aprovação

• Peça avaliações em um momento feliz. O pedido de avaliação do sistema da Apple aparece no máximo três vezes por ano por pessoa, então não desperdice na primeira abertura. Peça logo depois que algo tiver dado certo.
• Use o texto promocional para marcar o momento. Temporada de mudança, faxina de primavera, um fim de semana de games. Muda sem revisão.
• Fique de olho nas falhas desde o primeiro dia. O asc-crash-triage skill revisa falhas e feedback do TestFlight; o servidor MCP do Expo pode buscar falhas, feedback e avaliações (as respostas precisam da sua confirmação); o servidor MCP do Sentry traz erros de produção.
• Publique atualizações pequenas com frequência. Stash entrou no ar em 23 de setembro, ganhou um redesign em 2 de outubro e adicionou dez idiomas na versão 1.1.0 em 28 de outubro. Publique a versão que funciona e depois melhore em público.
• Dê ao aplicativo uma casa na web. Uma página simples com uma demo, uma política de privacidade escrita para o aplicativo e, se você estiver na Alemanha, um Impressum. Meu guia de app do zero cobre as páginas legais para desenvolvedores alemães e da UE.

---

Parte 11 — Quanto custa: quatro orçamentos para o primeiro ano

O OpenCode é grátis. O Ollama é grátis no seu próprio hardware. O único custo que você não pode evitar para um app de iPhone é a assinatura da Apple; todo o resto depende de quanto tempo de modelo você quer comprar.

Orçamento	O que está incluído	Primeiro ano (USD)
Somente local	Apple Developer Program; OpenCode; Ollama com modelos locais em um Mac que você já tem (32 GB ou mais)	US$ 99
Inicial	Somente local + OpenCode Go ($10 por mês)	US$ 219
Recomendado	Starter + Ollama Pro na cobrança anual ($200)	US$ 419
Power	Apple + OpenCode Go Plus ($40 por mês) + Ollama Max ($100 por mês)	US$ 1.779

Preços de tabela em 7 de novembro de 2026, sem impostos e sem descontos promocionais. Troque pelas suas próprias escolhas: um GLM Coding Plan Lite em vez do Go custa US$ 216 por ano na cobrança mensal (cerca de US$ 151 na cobrança anual), em vez de US$ 120; o ChatGPT Plus custa US$ 240 por ano. Extras opcionais: a taxa única de US$ 25 do Google Play, se você publicar no Android, os planos pagos do Expo, se o nível gratuito ficar pequeno para você, e o que custar o seu site.

O custo real não está na lista, porém: são as suas noites. A IA encurta a digitação, não o raciocínio, e o raciocínio é a maior parte do trabalho.

---

Parte 12 — Quinze erros a evitar

1. Deixar o agente enviar para revisão. Negue isso nas permissões. Você aperta o botão.
2. Manter uma chave de Admin API onde agentes rodam sem supervisão. Use o papel menos poderoso que funcione e guarde chaves de assinatura e credenciais de produção em outro lugar.
3. Construir uma cópia de algo que já existe. A diretriz 4.3(b) agora cita categorias inteiras. Encontre primeiro a sua diferença em uma frase.
4. Publicar extras escondidos. Telas de depuração, flags de funcionalidades inativas e menus de teste violam a diretriz 2.5.19. Compile-os fora das versões de lançamento.
5. Um rótulo de privacidade plausível em vez de exato. Se os dados saem do dispositivo e ficam em um servidor, eles são coletados, mesmo que só o usuário possa vê-los.
6. Enviar dados pessoais para um serviço de IA sem pedir. A diretriz 5.1.2(i) exige divulgação e permissão.
7. Segredos no pacote do app. Qualquer coisa dentro de um app pode ser extraída. Chaves que custam dinheiro ficam em um servidor.
8. Conectar todos os servidores MCP que você encontrar. Cada um custa contexto em cada requisição. Adicione o que você usa.
9. Instalar skills e servidores que você não leu. São instruções e código rodando com as suas permissões.
10. Acreditar no “pronto”. Rode no seu iPhone real, offline, no modo escuro, no maior tamanho de texto, com o VoiceOver ativado.
11. Usar modelos promocionais gratuitos para código de cliente. Alguns podem usar seus dados para melhorar o modelo. Desative-os em projetos de cliente.
12. Esquecer o comprimento de contexto do Ollama. No padrão, um agente fica sem espaço antes de começar. Defina 64K no servidor.
13. Deixar as dependências se acumularem. Cada pacote é código que você não leu e uma atualização que você terá de gerenciar. Faça o agente pedir permissão.
14. Sessões longas e extensas. Comece do zero a cada etapa e use worktrees para experimentos.
15. Prometer o seu roadmap. Capturas de tela e descrições mostram o que esta versão faz. Ideias pertencem ao seu site, rotuladas como ideias.

---

Parte 13 — Qual configuração você deve escolher? Seis cenários

1. “Nunca escrevi código e tenho um Mac.”

O app de desktop do OpenCode, o OpenCode Go e o Ollama para as tarefas pequenas. Expo se você também quer Android; SwiftUI se você só se importa com iPhone. Mantenha os comandos de shell em perguntar, faça commit depois de cada passo que funcionar e comece com um app que faça uma coisa só.

2. “Meu código nunca pode sair da minha máquina.”

OpenCode só com Ollama local. Desative os recursos de nuvem do Ollama, defina OPENCODE_DISABLE_FREE_MODELS=1, e não conecte nenhum provedor de nuvem nesse projeto. Espere uma ajuda mais lenta e mais simples, e dê ao agente tarefas menores. Um Mac com 64 GB ou mais torna isso bem mais confortável.

3. “Eu já pago por ChatGPT, Copilot ou Claude.”

Conecte primeiro o que você já tem. ChatGPT Plus e Pro e o GitHub Copilot funcionam por logins integrados sem custo extra. O Claude funciona pelo provedor Claude Agent; leia a Parte 2 antes de depender dele para trabalho de negócios. Adicione o OpenCode Go depois, se quiser modelos abertos ao lado.

4. “Quero iPhone e Android a partir de uma única base de código.”

Expo SDK 58, o servidor MCP da Expo, as skills oficiais da Expo e o EAS para builds e envios na nuvem. Você pode compilar e enviar apps iOS sem um Mac, embora ainda vá querer um (e um iPhone) para testar.

5. “Só me importo com plataformas Apple e quero tudo nativo.”

SwiftUI no Xcode 27.1, com o OpenCode dentro do Xcode via ACP (Xcode → Ajustes → Intelligence → Adicionar um agente…, executável opencode, argumento acp) ou no seu terminal com a ponte MCP do Xcode e o XcodeBuildMCP. Uma limitação do caminho dentro do Xcode: não existe seletor de modelo, então defina seu modelo padrão em opencode.jsonc primeiro.

6. “Quero ir rápido e vou pagar por isso.”

OpenCode Go Plus e Ollama Max, worktrees para experimentos em paralelo, modo goal para os trabalhos longos e mecânicos, e um modelo de fronteira por chave de API para os problemas realmente difíceis. Acompanhe seus gastos semanalmente. Para rodar vários agentes lado a lado, minha comparação de harnesses cobre as opções.

---

Perguntas frequentes

---

A conclusão

Aprendizado como usar o OpenCode bem não se resume a memorizar comandos. Trata-se de montar um pequeno sistema em torno do agente: um plano de codificação que caiba no seu orçamento, o Ollama para o trabalho que deve ficar na sua máquina, um punhado de servidores MCP que deixam o agente ver o que ele constrói, skills que guardam o seu playbook e permissões que mantêm as decisões irreversíveis com você.

Minha recomendação continua: OpenCode com OpenCode Go e Ollama é a forma mais barata, mais flexível e com menos aprisionamento a fornecedor de criar um aplicativo com IA no final de 2026. Adicione uma assinatura que você já paga, ou um modelo de ponta por chave de API, quando uma tarefa merecer. Depois, use o agente também para a papelada e guarde o botão “Enviar” para você.

Se você quiser ver o que esse tipo de processo produz em pequena escala, meus dois aplicativos são gratuitos: Stash — Find It Fast para as coisas que você guarda, e PingAtlas para verificar o quão perto a internet realmente está de onde você está sentado. Depois, vá construir o seu.

---

Está construindo com o OpenCode? Quero saber em qual plano de codificação você ficou, qual modelo local conquistou um lugar no seu Mac e qual servidor MCP ou skill você não conseguiria dispensar. Correções e contraprovas são bem-vindas; este artigo é atualizado quando o cenário muda.

Divulgação: Stash e PingAtlas são aplicativos meus, publicados pela minha empresa, Graham Miranda UG (haftungsbeschränkt). Ambos são gratuitos e não têm anúncios. Este artigo contém um link de afiliado, para o GLM Coding Plan da Z.ai na Parte 2; se você assinar por ele, ganha 10% de desconto e eu recebo uma comissão. Nenhuma empresa mencionada aqui patrocinou, revisou ou aprovou este artigo.

Última atualização: 7 de novembro de 2026.