Come usare OpenCode dal primo prompt all'App Store: la guida 2026 ai piani di coding, Ollama, server MCP e skill

Da qualche parte tra il primo prompt e la prima email di App Review, un agente di coding IA smette di essere un giocattolo e diventa uno strumento con cui rilasci. Questa guida parla di come usare OpenCode come passare dall'uno all'altro: installarlo su un Mac pulito, scegliere cosa pagare per il modello che pensa, eseguire modelli sulla tua macchina con Ollama, dare all'agente mani vere con i server MCP, insegnargli le tue abitudini con le skill e poi accompagnare un'app iPhone attraverso TestFlight e App Review senza perdere una settimana in pratiche burocratiche.

Non vengo da un background di programmazione. Gestisco una piccola azienda IT in Germania e costruisco software con agenti IA. Due dei risultati sono arrivati sull’App Store questo autunno: Stash, che ricorda dove metti le cose, e PingAtlas, che misura la latenza di rete dal tuo dispositivo. Compaiono in questa guida dove sono davvero utili come esempi, e da nessun’altra parte.

Tutto ciò che segue è stato verificato con la documentazione ufficiale, le note di rilascio, le pagine dei prezzi e l'App Store stesso il 7 novembre 2026. Il coding IA corre veloce: OpenCode ha pubblicato almeno dieci release della versione 2 solo tra il 20 e il 30 ottobre, Ollama e MiniMax hanno entrambi rifatto i loro piani dalla fine di agosto, e Apple ha riscritto almeno due volte quest'anno parti delle sue linee guida per la revisione. I numeri volatili sono segnalati dove compaiono. Controllali prima di comprare qualsiasi cosa.

Informativa: Stash e PingAtlas sono app mie, pubblicate dalla mia azienda, Graham Miranda UG (haftungsbeschränkt). Entrambe sono gratuite e non mostrano annunci. Questo articolo contiene un link affiliato: il link al piano Z.ai GLM Coding Plan nella Parte 2 ti dà il 10% di sconto e mi paga una commissione se ti abboni. Il team di OpenCode presso Anomaly, Ollama, Apple, Expo, Z.ai e ogni altra azienda menzionata qui non hanno sponsorizzato, revisionato o approvato quest’articolo.

---

TL;DR — Tutto il percorso in dieci punti

• OpenCode è un agente di coding gratuito e open source (MIT) che funziona con quasi qualsiasi modello: abbonamenti cloud, API a pagamento per token o modelli in esecuzione sul tuo Mac. È alla versione 2.2.6 (6 novembre 2026), con un'app per terminale, un'app desktop, un’interfaccia web e per telefono e una modalità ACP che gira dentro Xcode 27.
• Paghi il modello, non l'agente. I “piani di coding” sono abbonamenti mensili a prezzo fisso per l'utilizzo del modello. Per la maggior parte di chi inizia, OpenCode Go ($10 al mese) più Ollama (gratuito in locale, $20 al mese per i crediti cloud Pro) è la configurazione che consiglio: economica, indipendente dal modello, con conservazione zero per impostazione predefinita per la maggior parte dei modelli e nessun’area grigia nei termini di servizio di chiunque.
• Le alternative sono reali. ChatGPT Plus e Pro, GitHub Copilot e il piano Z.ai GLM Coding Plan si collegano tutti a OpenCode tramite provider integrati. Gli abbonamenti Claude ora funzionano di nuovo tramite il nuovo provider Claude Agent di OpenCode 2.2.3, ma Anthropic non ha dato l’approvazione pubblica a questa strada, quindi leggi la Parte 2 prima di affidarti all’approccio.
• Ollama è un unico motore per modelli locali e cloud. ollama launch opencode li collega tra loro, i modelli locali richiedono almeno una finestra di contesto da 64K e un Mac da 32 GB può eseguire validi modelli di coding come qwen3.8:27b (un download da 18 GB).
• I server MCP danno all'agente delle mani. Per il lavoro sull’app, la lista ristretta è il bridge MCP nativo di Xcode (xcrun mcpbridge), XcodeBuildMCP, il server MCP di Expo, Context7 per la documentazione aggiornata e Sentry per i crash. Aggiungi solo quello che usi: ogni server costa contesto.
• Le skill danno all'agente il tuo manuale operativo. Una skill è una cartella con un SKILL.md file. OpenCode le legge da .opencode/skills e anche da .claude/skills e .agents/skills, così funzionano anche le skill scritte per altri agenti. Expo ne pubblica 23 ufficiali, e la CLI di App Store Connect (asc) ne include più di venti.
• Lascia che l'agente faccia le pratiche, mai l'invio. L’ asc La CLI e le sue skill possono caricare build, gestire TestFlight, sincronizzare metadati e screenshot e controllare lo stato della revisione. Nega il comando di invio all’interno dei permessi di OpenCode e premi tu il pulsante.
• Le regole di Apple per il 2026 sono importanti per le app create con l’IA. Le app imitatrici in categorie sature ora vengono rifiutate (linea guida 4.3(b), giugno), le funzionalità nascoste o latenti sono vietate (nuova 2.5.19, ottobre), le build richiedono Xcode 26 o successivo e, da aprile 2027, le app create con l'SDK iOS 27.1 richiedono screenshot per iPhone Duo.
• Costo del primo anno: $99 se esegui tutto in locale e paghi solo Apple, circa $419 con la configurazione che consiglio (Apple + OpenCode Go + Ollama Pro con fatturazione annuale), e circa $1,779 per una configurazione di fascia alta. Tutti i prezzi escludono l'IVA.
• La regola più importante: “fatto” è un'affermazione, non un fatto. Provala su un iPhone vero, in modalità aereo, in modalità scura, con il testo alla dimensione più grande, con VoiceOver attivo. Poi credici.

---

Il percorso in sintesi

Fase	Cosa fai	Cosa fa OpenCode	Strumenti
1. Configura	Installa, scegli un piano di coding, collega i modelli	Ancora niente	OpenCode, OpenCode Go, Ollama
2. Insegna	Scrivi AGENTS.md, aggiungi skill, collega server MCP	Li legge a ogni sessione	AGENTS.md, skill, MCP
3. Pianifica	Scrivi il brief, contesta il piano	Trasforma il brief in un piano e una roadmap	plan agent, /goal
4. Crea	Rivedi ogni diff, prova su un dispositivo	Scrive codice a piccoli blocchi, compila, esegue i test, fa screenshot	build agent, Xcode MCP, XcodeBuildMCP o Expo MCP
5. Beta	Invita i tester, leggi il feedback	Archivia, carica, gestisce i gruppi TestFlight	Xcode, asc o EAS
6. Burocrazia	Rispondi con onestà alle domande legali e sulla privacy	Prepara le bozze dei metadati, controlla i flussi di dati, ridimensiona gli screenshot	asc competenze
7. Invia	Tu premi “Invia per la revisione”	Controlla lo stato della revisione, smista le bocciature	App Store Connect
8. Lancia	Rispondi agli utenti, pianifica gli aggiornamenti	Localizza, scrive le note di rilascio, smista i crash	asc, Sentry, il tuo sito

---

Indice

• Parte 1 — Cos’è OpenCode a novembre 2026 e perché lo consiglio
• Parte 2 — I piani di coding spiegati (e i due che consiglio)
• Parte 3 — Ollama: un solo motore per modelli locali e cloud
• Parte 4 — Come usare OpenCode: installarlo e collegare i tuoi modelli, passo dopo passo
• Parte 5 — Agenti, comandi, permessi e modalità Goal: OpenCode su misura per te
• Parte 6 — Server MCP: dare delle mani all’agente
• Parte 7 — Skill: scrivi il tuo playbook una volta sola
• Parte 8 — Costruire l’app: dall’idea a una build di cui fidarti
• Parte 9 — Pubblicare sull’App Store: lascia che OpenCode si occupi della burocrazia, poi premi Invia da solo
• Parte 10 — Lancio: la scheda, gli screenshot, l’ASO e la vita dopo l’approvazione
• Parte 11 — Quanto costa: quattro budget per il primo anno
• Parte 12 — Quindici errori da evitare
• Parte 13 — Quale configurazione scegliere? Sei scenari
• Domande frequenti
• In sintesi

---

Parte 1 — Cos’è OpenCode a novembre 2026 e perché lo consiglio

OpenCode è un agente di coding IA open source. Lo avvii in una cartella di progetto, descrivi cosa vuoi e lui lavora come lavora uno sviluppatore: legge i tuoi file, fa un piano, modifica il codice, esegue comandi, legge gli errori e va avanti finché il lavoro non è finito o finché non ha bisogno di te. È pubblicato con licenza MIT da Anomaly, il team che lo ha creato, e non gli importa quale modello gli dai.

La homepage del progetto dichiara più di 220.000 stelle GitHub, 1.089 contributori e 22 milioni di sviluppatori al mese. Sono numeri del progetto stesso e cambiano ogni settimana, ma spiegano perché OpenCode sia diventato l’alternativa indipendente dal modello più conosciuta agli agenti degli stessi produttori di modelli, Claude Code e Codex.

Dove gira

OpenCode non è più una sola app. Dalla riscrittura 2.0, un servizio in background gira sulla tua macchina e ogni interfaccia comunica con lui, così una sessione che avvii in un punto compare anche negli altri.

Interfaccia	Che cos'è	Adatto a
Terminale (TUI)	La classica app da terminale a schermo intero	Lavoro veloce da tastiera, sessioni SSH, server
App desktop	Un’app Electron per macOS (Apple silicon e Intel), Windows (x64 e ARM64) e Linux (.deb, .rpm, AppImage), con schede, diff, terminali e un browser integrato	Chi non vive in un terminale
Web e telefono	opencode pair stampa un link monouso (scade dopo cinque minuti) che apre le tue sessioni locali in un browser; la 2.2.6 ha aggiunto un compositore adatto a telefono e tablet	Controllare un’attività lunga dal divano
Dentro Xcode 27	OpenCode parla l’Agent Client Protocol, quindi opencode acp può essere aggiunto come agente nelle impostazioni Intelligence di Xcode	Sviluppatori Swift nativi che vogliono restare in Xcode
SDK e script	opencode run per attività una tantum, più un SDK JavaScript	Automazione e CI

Cosa è cambiato dalla 2.0

OpenCode 2.0 è stata una riscrittura da zero: secondo l’annuncio del team a luglio, il runtime è passato da Bun a Node.js per ridurre l’uso di memoria, l’app desktop è passata da Tauri a Electron, l’API è stata ridisegnata e OpenCode ha iniziato a girare come servizio per impostazione predefinita. La versione 2.0.0 è uscita l’11 settembre 2026. Le release successive hanno soprattutto aggiunto le funzioni che contano per progetti lunghi e reali:

Versione	Data	Cosa ha aggiunto
2.2.0	27 ott	Plugin desktop sperimentali, un’app desktop rinnovata, API per immagini e decisioni per i plugin
2.2.1	29 ott	Modalità obiettivo (/goal <objective>, con pausa, ripresa e azzeramento), su attivazione esplicita prompt pianificati, generazione di immagini
2.2.2	29 ott	Generazione di immagini attiva per impostazione predefinita quando un provider collegato la supporta; un selettore di worktree dal branch Git
2.2.3	30 ott	L’ Claude Agent come provider (ne parlo meglio nella Parte 2)
2.2.4	30 ott	Configurazione guidata di Claude Agent, pianificazioni che girano sotto opencode serve, terminali desktop persistenti
2.2.5	30 ott	Scorciatoie per worktree e modalità shell, un buffer di compattazione basato su percentuale
2.2.6	6 nov	opencode run --worktree per esecuzioni scriptate, un dock del compositore mobile, connessioni MCP condivise

Fonte: il changelog di OpenCode, verificato il 7 novembre 2026. Aspettati una versione più recente quando leggerai queste righe.

Perché è l’agente che consiglio

1. Non è fedele a nessun modello. OpenCode si collega ad abbonamenti, API a pagamento per token e modelli locali con un solo /connect comando. Quando il mese prossimo esce un modello migliore, cambi una riga in un file di configurazione, non tutto il tuo flusso di lavoro.
2. I suoi permessi funzionano come un firewall. Ogni azione (leggere, modificare, eseguire un comando shell, caricare una skill, chiamare uno strumento MCP) passa attraverso un elenco ordinato di allow, ask e deny regole in cui vince l’ultima corrispondenza. “Non eseguire mai git push” e “non inviare mai all'App Store” sono una riga ciascuno.
3. Parla i formati di tutti. Si legge AGENTS.md (e ripiega su CLAUDE.md), carica le skill da .claude/skills e .agents/skills oltre che dalle proprie cartelle, e si collega a qualsiasi server MCP. Anche l’ecosistema costruito dagli altri agenti funziona qui.
4. Va dove sei tu. Terminale su un server, app desktop su un Mac, un browser sul telefono oppure dentro Xcode.
5. Non costa niente. OpenCode è gratuito e include persino una serie a rotazione di modelli gratuiti che puoi usare senza account.

Dove non è la scelta migliore

Prima l’onestà: OpenCode non è il primo nelle leaderboard del coding, perché non è un modello. Gli harness che stanno in cima sono accoppiate di produttori: Claude Code con il miglior modello di Anthropic, Codex con quello di OpenAI. Sono messi a punto insieme e sono eccellenti. Ne ho confrontati ventotto nel mio confronto tra harness di coding IA, e se già paghi uno di quegli abbonamenti e ti trovi bene, niente in questa guida ti obbliga a cambiare.

Ci sono anche degli spigoli. OpenCode pubblica release quasi ogni giorno, quindi le cose si muovono sotto i piedi. La vecchia documentazione della versione 1 esiste ancora su docs.opencode.ai (con un banner che rimanda alla v2), e molte guide di terzi, compresa la pagina OpenCode di Ollama stesso, mostrano ancora l’indirizzo dell’installer v1. Diverse delle funzionalità più recenti sono contrassegnate come sperimentali. E i gestori di pacchetti di Windows non sono supportati per lo strumento da riga di comando v2; gli utenti Windows hanno l’app desktop o uno zip autonomo.

---

Parte 2 — I piani di coding spiegati (e i due che consiglio)

OpenCode è gratuito. Il modello che pensa no. Ci sono tre modi per pagarlo, e la maggior parte della confusione sui “piani di coding IA” nasce dal confonderli.

1. Lo esegui tu. Modelli a pesi aperti sul tuo Mac tramite Ollama. Paghi in hardware e pazienza, non in denaro. Il tuo codice non lascia mai la macchina.
2. Abbonati a un piano di coding. Un canone mensile fisso compra una quota di utilizzo, di solito misurata in finestre di cinque ore e settimanali. Qui vivono OpenCode Go, Ollama Pro, il GLM Coding Plan e gli abbonamenti ChatGPT e Claude.
3. Paghi a token. Porti una chiave API da qualsiasi fornitore e paghi esattamente quello che usi. Ideale per il problema difficile occasionale; pericoloso per una lunga sessione di debug senza un avviso di budget.

I piani di coding che funzionano in OpenCode (novembre 2026)

Piano	Prezzo mensile (USD)	Cosa ottieni	Come si collega a OpenCode
Modelli gratuiti di OpenCode	$0	Una serie a rotazione di modelli gratuiti a tempo limitato	Integrato, nessun account necessario
Ollama, locale	$0	Qualsiasi modello a pesi aperti che il tuo Mac riesce a reggere	Rilevato automaticamente, oppure ollama launch opencode
OpenCode Go ⭐	$10 · Go Plus $40 · Go Teams $20 per membro	32 modelli aperti, tra cui 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 → incolla la tua chiave
Ollama Pro / Max ⭐	$20 ($200 all’anno) · Max $100	$60 (Pro) o $300 (Max) di crediti per modelli cloud al mese, più uso locale illimitato	Come Ollama locale; i modelli cloud compaiono accanto a quelli locali
Piano di codifica GLM (Z.ai)	Lite $18 · Pro $80 · Max $168 (sconto del 20% con fatturazione trimestrale, del 30% con quella annuale)	GLM-5.3 e GLM-5.3-Flash, entrambi con finestra di contesto da 1M token	/connect → il provider Z.AI Coding Plan
MiniMax M Plan	Go $22 · Explore $55 · Build $132 (due mesi gratis con fatturazione annuale)	MiniMax M3.1 Flash, più modelli per immagini, audio e (da Explore) video	il provider del piano di coding di MiniMax, con una chiave M Plan
ChatGPT	Plus $20 · Pro da $100	la famiglia GPT-6 di OpenAI tramite il tuo piano ChatGPT	/connect → OpenAI → “Accedi con ChatGPT”
GitHub Copilot	Pro $10 · Pro+ $39 · Max $100	il pool di modelli di Copilot, misurato in GitHub AI Credits	/connect → GitHub Copilot → accesso tramite dispositivo
Claude	Pro $20 · Max da $100	I modelli di Anthropic tramite Claude Code	/connect → Claude Agent (OpenCode 2.2.3+, con Claude Code installato); vedi l'avvertenza qui sotto
Pagamento per token	Cosa usi	L'API di qualsiasi provider, incluso il gateway pay-as-you-go di OpenCode	/connect → il provider → chiave API

Prezzi di listino al 7 novembre 2026, IVA esclusa. ⭐ = ciò che consiglia questa guida. Prezzi, quote e roster di modelli cambiano continuamente, quindi controlla la pagina di ogni fornitore prima di abbonarti. I prezzi GLM vengono da uno snapshot del 24 settembre e dal titolo di Z.ai “piani da $18”; l'abbonamento Kimi (da $19) è escluso perché non sono riuscito a confermare un percorso ufficiale OpenCode per usarlo.

Come funzionano davvero i limiti

Il prezzo di copertina ti dice molto poco. La quota è quella con cui convivi.

• OpenCode Go assegna a ogni modello una propria quota mensile in dollari, e puoi spenderne il 20% in qualsiasi finestra di cinque ore e il 50% in qualsiasi settimana. Sul piano da $10, per esempio, GLM-5.3-Flash riceve $60 al mese, DeepSeek V4.1 Flash $100 e Kimi K3 $15, così i modelli economici ed efficienti durano molto più a lungo di quelli pesanti. Quando raggiungi un limite, le richieste vengono bloccate a meno che tu non abbia attivato Extra Usage, che ripiega sul credito pay-as-you-go. I modelli gratuiti continuano a funzionare in ogni caso.
• Ollama è passata a un sistema di crediti: Pro include $60 di utilizzo cloud al mese e Max $300, entrambi fatturati a tariffa per token, e il credito non usato non si accumula. Pro consente tre richieste contemporanee, Max dieci. I prezzi scendono fuori dalla fascia 12:00-18:00 UTC nei giorni feriali e per tutto il fine settimana, il che si adatta bene alle serate europee. I modelli locali sono illimitati su ogni piano, incluso quello gratuito.
• Il piano GLM Coding usa crediti per ogni finestra di cinque ore e settimanale, e l'uso fuori orario di punta (al di fuori delle 14:00-18:00 ora cinese nei giorni feriali) costa metà dei crediti.
• ChatGPT e Copilot si misurano tramite i propri sistemi: ChatGPT in stime di messaggi ogni cinque ore per modello, Copilot in AI Credits. Dentro OpenCode, gli accessi ChatGPT non mostrano alcun costo per richiesta, perché l'uso viene conteggiato sul tuo piano, e OpenCode limita loro la finestra di contesto in input per impostazione predefinita (500.000 token sui modelli GPT più recenti).

Privacy e conservazione dei dati

I tuoi prompt contengono il tuo codice. Conta dove finiscono, soprattutto per il lavoro per i clienti soggetto alle norme UE sulla protezione dei dati.

• OpenCode Go blocca per impostazione predefinita gli endpoint a pagamento che si addestrano sui tuoi dati. La maggior parte dei modelli (GLM, Kimi, MiniMax, Qwen, MiMo e altri) viene servita con conservazione zero; alcuni (Grok, i modelli GPT Luna, Claude Haiku e due modelli promozionali gratuiti) conservano i log per 30 giorni. I modelli scontati “Contributor” si addestrano davvero sui tuoi prompt e devono essere attivati deliberatamente. Le regioni predefinite sono l'Europa e gli Stati Uniti, e i modelli di DeepSeek richiedono di attivare il routing globale, con un accordo di conservazione zero valido fino al 30 novembre 2026.
• Nuvola di Ollama dice chiaramente: “I dati dei prompt o delle risposte non vengono mai registrati né usati per l'addestramento.” I modelli girano principalmente negli Stati Uniti, con la capacità in eccesso che può essere instradata verso l'Europa.
• I modelli gratuiti di OpenCode sono un'altra storia: la documentazione nota che alcuni modelli gratuiti possono usare i tuoi dati per migliorare il modello. Va bene per gli esperimenti, non per il codice dei clienti. Imposta OPENCODE_DISABLE_FREE_MODELS=1 per nasconderli.
• Modelli locali non lasciano mai la tua macchina. Per qualsiasi cosa soggetta a un accordo rigoroso sul trattamento dei dati, resta comunque la risposta più pulita.

La questione Claude

Gli abbonamenti Claude hanno avuto un anno turbolento negli strumenti di terze parti. A gennaio Anthropic ha stretto i suoi controlli, così gli accessi Claude Pro e Max hanno smesso di funzionare in harness come OpenCode, e a marzo OpenCode ha rimosso la sua opzione di accesso su richiesta di Anthropic. Il 30 ottobre OpenCode 2.2.3 ha riportato gli abbonamenti attraverso una strada diversa: un Claude Agent provider integrato che pilota il tuo Claude Code installato localmente (versione 2.1.248 o successiva) tramite l'Agent SDK ufficiale di Anthropic, dopo che hai effettuato l'accesso con claude auth login.

I fatti che devi conoscere prima di usarlo:

• OpenCode non legge il login salvato di Claude Code; è il vero claude programma che invia le richieste.
• gli strumenti, le impostazioni, CLAUDE.md i file, gli hook, i server MCP e le skill di Claude Code sono disattivati. Claude lavora invece tramite gli strumenti e le richieste di autorizzazione di OpenCode.
• La documentazione dell'Agent SDK di Anthropic afferma che gli sviluppatori di terze parti non possono offrire l'accesso a claude.ai o i limiti degli abbonamenti nei propri prodotti senza l'approvazione di Anthropic. Al momento di scrivere, Anthropic non aveva commentato pubblicamente il provider di OpenCode, e nessuno può dirti con certezza se mette a rischio il tuo account.

Il mio consiglio: se già paghi per Claude e vuoi provarlo, usalo per progetti personali e tieni d'occhio una dichiarazione ufficiale. Per il lavoro professionale, usa una chiave API di Anthropic, l'unica strada che la documentazione di Anthropic cita.

Cosa consiglio, e perché

Inizia con OpenCode Go e Ollama. Ecco il ragionamento:

• Prezzo. $10 al mese ti danno accesso a 32 modelli aperti validi. Aggiungi Ollama Pro a $20 se vuoi più margine nel cloud; saltalo se il tuo Mac esegue bene i modelli locali.
• Scelta senza vincoli. Go e Ollama Cloud offrono le stesse famiglie di modelli a pesi aperti (GLM, Kimi, MiniMax, DeepSeek e altri), così puoi confrontare i modelli sul tuo progetto invece di fidarti di una classifica.
• Privacy per impostazione predefinita. Conservazione zero per la maggior parte dei modelli Go, una politica di non registrazione dei log su Ollama e la possibilità di passare completamente in locale per il lavoro sensibile.
• Nessuna zona grigia. Entrambi sono progettati esattamente per questo uso, dentro OpenCode.
• Il fallback locale è gratuito. Quando la finestra di cinque ore si esaurisce alle 23:00, un modello locale su Ollama ti tiene in movimento sui lavori piccoli.

Quando scegliere qualcos'altro. Se paghi già ChatGPT Plus o Copilot, collegalo per primo; non ti costa nulla in più. Se GLM sarà il tuo strumento quotidiano, la quota del GLM Coding Plan può avere più senso dei limiti per modello di Go, e puoi ottenere il 10% di sconto sul GLM Coding Plan tramite il mio link affiliato (link affiliato, vedi l'informativa in alto). Le chiavi del Coding Plan e le chiavi API standard di Z.ai non sono intercambiabili, quindi scegli il provider Coding Plan in /connect. E se il tuo lavoro richiede la vetta assoluta della classifica, un modello di frontiera via chiave API per i compiti più difficili è denaro ben speso.

---

Parte 3 — Ollama: un solo motore per modelli locali e cloud

Ollama esegue modelli con pesi aperti sul tuo computer e li serve tramite una semplice API locale. Dall'anno scorso esegue anche modelli più grandi nel proprio cloud, attraverso la stessa app e la stessa API, così per OpenCode un modello cloud è identico a uno locale. È tutto qui il fascino: un solo motore, una sola configurazione e un passaggio tra “privato e gratuito” e “grande e veloce” che è solo un nome di modello.

Installare Ollama (passo dopo passo)

1. Scaricalo da ollama.com/download. Su Mac, apri il download e trascina Ollama in Applicazioni. Su Windows, esegui l'installer. Su Linux, la riga ufficiale è:

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

2. Avvialo. Apri l'app, oppure digita ollama in un terminale. Dalla versione 0.40.15 (inizio novembre), eseguire ollama senza argomenti apre un launcher di benvenuto.
3. Accedi se vuoi i modelli cloud. L'app te lo chiede durante la configurazione. I modelli locali funzionano senza account; il tuo utilizzo cloud è su ollama.com/settings/usage.
4. Scarica un modello per verificare che tutto funzioni:

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

Collegare Ollama a OpenCode

Hai tre opzioni, dalla più semplice alla più flessibile.

Opzione 1: lascia che OpenCode lo trovi. OpenCode v2 controlla all'avvio l'indirizzo locale predefinito di Ollama e aggiunge ogni modello che sa scrivere testo a /models. Nessun account, nessuna configurazione. I modelli solo di embedding vengono saltati.

Opzione 2: lascia che Ollama lo configuri.

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

ollama launch funziona con OpenCode v2 da Ollama 0.40.12 (27 ottobre). Non sovrascrive il tuo ~/.config/opencode/opencode.json, quindi le tue impostazioni restano valide. Una stranezza: i modelli che hai definito solo nella configurazione di OpenCode non compaiono nel selettore di avvio di Ollama.

Opzione 3: punta OpenCode a un server Ollama altrove. Se Ollama gira su un Mac mini nell'armadio o su un server, aggiungilo come provider con il suo indirizzo. Il /v1 alla fine è importante:

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

L'impostazione che rovina la maggior parte delle configurazioni locali: la lunghezza del contesto

Le FAQ di Ollama indicano una finestra di contesto predefinita di 4.096 token. La guida OpenCode di Ollama stessa chiede almeno 64K, perché il prompt di sistema di un agente, le definizioni degli strumenti e il contenuto dei file riempiono una finestra piccola prima ancora che inizi il lavoro. Impostala sul server Ollama, non in OpenCode:

# Se avvii il server da solo:
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# Se usi l'app per Mac: imposta la variabile per launchd, poi chiudi e riapri Ollama
launchctl setenv OLLAMA_CONTEXT_LENGTH 65536

Poi verifica che abbia avuto effetto: ollama ps mostra la dimensione del contesto di ogni modello caricato e se è in esecuzione sulla GPU. Una finestra più grande usa più memoria, quindi su un Mac da 32 GB, 64K è un tetto ragionevole per un modello da 27 miliardi di parametri.

Quale modello locale si adatta al tuo Mac

Una regola pratica utile dalle classifiche di novembre di BenchLM: un modello ha bisogno all'incirca della sua dimensione di download più il 20% per il contesto, e un Mac può dare circa tre quarti della sua memoria unificata alla GPU. In pratica, tieni il download sotto circa il 60% della memoria del tuo Mac.

La memoria del tuo Mac	Modello da provare per primo	Scarica	Contesto	Adatto a
16 GB	gemma4:12b o gemma4:e4b	7.7 GB / 6.6 GB	256K / 128K	Spiegazioni, piccole modifiche, messaggi di commit. Troppo piccolo per sessioni agentiche lunghe; usa i modelli cloud per lo sviluppo
24–32 GB	qwen3.8:27b (anche come 27b-mlx per Apple silicon)	18 GB	256K	Il punto ottimale in locale per programmare con un agente
24–32 GB	qwen3-coder:30b	19 GB	256K	Un coder mixture-of-experts con solo circa 3 miliardi di parametri attivi, per cui l’esecuzione è rapida
24–32 GB	gpt-oss:20b	14 GB	128K	Il modello open-weight più piccolo di OpenAI; l’opzione che lascia più margine
64 GB	Gli stessi modelli a precisione superiore, come qwen3.8:27b-q8_0	30 GB	256K	Risposte migliori, spazio per un contesto ampio
96–128 GB	gpt-oss:120b o devstral-2:123b	65 GB / 75 GB	128K / 256K	Qualità da modello grande senza il cloud

Dimensioni e finestre di contesto dalla libreria Ollama al 7 novembre 2026. La velocità dipende dall’ampiezza di banda della memoria del tuo chip tanto quanto dalla sua capacità. Per la parte hardware, vedi la mia guida al MacBook per LLM locali.

Ollama Cloud: i modelli che il tuo Mac non può ospitare

I modelli open-weight per la programmazione più potenti di oggi sono troppo grandi per un portatile. Ollama Cloud li esegue per te. Nell’app o nella CLI portano un :cloud tag e non scaricano nulla:

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

La parte del catalogo cloud rilevante per la programmazione al 7 novembre:

Modello	Produttore	Contesto	La valutazione d’uso di Ollama	Note
glm-5.3	Z.ai	1 milione	Alto	Il fiore all’occhiello di Z.ai; forte sui compiti agentici lunghi
glm-5.3-flash	Z.ai	1 milione	Medio	Multimodale nativo, 18B parametri attivi; un ottimo modello predefinito per lo sviluppo
kimi-k3.1-pro	Moonshot AI	1 milione	Molto alto	L’ultima voce (aggiornata il 4 novembre), multimodale, il modello più capace di Moonshot
kimi-k2.7-code	Moonshot AI	256K	Alto	Ottimizzato per la programmazione e più leggero sui token di ragionamento
minimax-m3.1-flash	MiniMax	976K	Medio	Legge le immagini; 0,15 $ in input e 0,60 $ in output per milione di token
deepseek-v4.1-flash	DeepSeek	1 milione	Medio	Progettato per velocità e throughput; legge le immagini
mistral-large-4	Mistral	1 milione	Alto	Laboratorio europeo, pesi aperti
gemma4	Google	256K	Basso	Abbastanza economico per gli helper e i subagenti

Il rating è l’abbreviazione di Ollama per indicare quanto in fretta un modello consuma i tuoi crediti. Se vuoi confrontare davvero i modelli più grandi, i miei Kimi K3 vs Fable 5.1 vs GLM-5.3 e GLM-5.3-Flash vs MiniMax M3 confronti vanno più a fondo.

L’approccio di instradamento che copierei

Non c’è bisogno di scegliere un solo modello. A ogni tipo di lavoro assegna il modello più economico che lo svolge bene:

• Pianificazione (qui si fanno gli errori più costosi): il tuo modello più forte.
• Sviluppo: un modello veloce e capace come GLM-5.3-Flash o MiniMax M3.1 Flash.
• Cercare nel codice sorgente, leggere la documentazione, scrivere test e messaggi di commit: un modello locale. Non costa nulla e il tuo codice resta dov’è.

La parte 4 mostra esattamente come impostarlo nella config di OpenCode.

Modalità solo locale per i progetti sensibili

Se un progetto non deve mai toccare un modello cloud, rendilo un’impostazione invece di una promessa. Ollama può disattivare del tutto le sue funzioni cloud (aggiungi "disable_ollama_cloud": true a ~/.ollama/server.json, oppure imposta OLLAMA_NO_CLOUD=1, poi riavvialo), e i modelli cloud gratuiti di OpenCode si possono nascondere con OPENCODE_DISABLE_FREE_MODELS=1. Poi collega solo provider locali in quel progetto.

Avvertenze oneste su Ollama

• I modelli locali sono più lenti e più deboli nell’uso prolungato degli strumenti in più passaggi rispetto ai grandi modelli cloud. Danno il meglio sui compiti contenuti.
• Il cloud resta pur sempre il computer di qualcun altro. La politica di non registrazione di Ollama è buona, ma il tuo codice lascia comunque la tua macchina, per lo più diretto verso gli Stati Uniti.
• I crediti finiscono. 60 $ di credito Pro durano molto con GLM-5.3-Flash e molto meno con un modello classificato “extra alto”.
• Una risposta lenta non è sempre colpa del modello. Ogni richiesta cloud fa prima un viaggio di andata e ritorno sul tuo Wi-Fi, sul tuo router e sulla rete internet. Se le risposte sembrano lente, controlla la connessione prima di dare la colpa al modello: la mia app PingAtlas misura i tempi di andata e ritorno dal tuo iPhone, iPad o Mac verso le città e verso servizi come GitHub, e il resto del percorso l’ho spiegato in cosa succede all'interno del router.

---

Parte 4 — Come usare OpenCode: installarlo e collegare i tuoi modelli, passo dopo passo

Questa è la configurazione che consiglierei a un amico. Ci vogliono circa venti minuti, per lo più di download.

Fase 0 — Cosa ti serve prima di tutto

• Un Mac con Apple Silicon, se vuoi sviluppare app per iPhone in modo nativo. Xcode 27.1 (uscito il 15 ottobre, con Swift 6.4 e l’SDK iOS 27.1) richiede macOS Tahoe 26.6 o successivo. Se sviluppi con Expo, il suo servizio cloud può compilare app iOS da Windows o Linux, ma ti servirà comunque un iPhone su cui fare i test.
• Xcode dal Mac App Store, aperto una volta così può installare i suoi componenti.
• Git. Il tuo vero pulsante di annulla.
• Node.js, solo se userai Expo: l’SDK 58 richiede Node 22.13 o successivo, 24.3 o successivo, oppure 26 e successivi (le versioni con numero dispari come la 23 e la 25 non sono supportate).
• Un piano di coding dalla parte 2, oppure Ollama dalla parte 3.

Passo 1 — Installa OpenCode

Su macOS o Linux:

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

Preferisci un’app? Scarica la versione desktop per macOS, Windows o Linux da opencode.ai/download. Le app da terminale e desktop condividono lo stesso servizio in background e le stesse sessioni. Su Windows usa l’app desktop o lo zip autonomo; i gestori di pacchetti di Windows non sono supportati per la v2.

Due trappole da conoscere:

• Le vecchie guide usano il vecchio installer. opencode.ai/install (senza /v2/) compare ancora in molti tutorial, incluse alcune documentazioni ufficiali dei partner. Usa l’ /v2/install indirizzo qui sopra.
• utenti di mise devono avere mise 2026.10.9 o successivo, altrimenti ottengono OpenCode 1.

Passo 2 — Collega i tuoi modelli

Avvia OpenCode in una cartella di progetto ed esegui /connect:

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

Poi, a seconda di cosa paghi:

Hai	In /connect, scegli	Allora
OpenCode Go	OpenCode Go	Incolla la chiave API dalla OpenCode Console
Ollama	Niente; i modelli locali compaiono da soli	Oppure esegui ollama launch opencode
ChatGPT Plus o Pro	OpenAI → Accedi con ChatGPT	Accedi nel browser
GitHub Copilot	GitHub Copilot	Completa l’accesso da dispositivo
Claude Pro o Max	Claude Agent (non “Anthropic”, che serve per le chiavi API)	Esegui claude auth login prima in un terminale; leggi l’avvertenza della Parte 2
Piano di codifica GLM	Il provider Z.AI Coding Plan	Incolla la tua chiave Coding Plan, non una chiave API standard
Una chiave API	Il nome del provider	Incolla la chiave

Passo 3 — Scegli i tuoi modelli

Esegui /models e scegli. I modelli di OpenCode Go si chiamano opencode-go/<model-id>; i modelli Ollama locali compaiono sotto il provider Ollama. Copia gli ID esatti da /models nella tua configurazione, perché nomi e tag cambiano.

Passaggio 4 — Aggiungere una configurazione di progetto

Le impostazioni predefinite funzionano, ma un progetto di app merita un file di configurazione che fa tre cose: instradare ogni agente verso il modello giusto, tenere l’agente lontano da qualsiasi azione irreversibile e collegare i tuoi server MCP. Salvalo come opencode.jsonc nella radice del progetto, e sostituisci gli ID dei modelli /models che ti mostra:

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

Che cosa stai incollando, in parole semplici:

• Ogni comando shell chiede prima il permesso, tranne una manciata di comandi in sola lettura. In sola lettura asc le query (tutto ciò che elenca, più lo stato della revisione) sono consentite, così l’agente può controllare le build e l’avanzamento della revisione senza disturbarti.
• Alcune cose sono bloccate del tutto: il push del codice, la pubblicazione o l’invio di un’app in revisione e la conferma di azioni distruttive in App Store Connect. Queste le fai tu, di proposito. Il caricamento di una build su TestFlight resta consentito (dopo aver chiesto), perché non manda nulla in revisione.
• Le impostazioni predefinite di OpenCode chiedono già prima di leggere .env i file. Lascialo attivo.
• I permessi sono barriere di sicurezza, non una sandbox. Un modello determinato può trovare un altro modo per fare qualcosa. Tieni le credenziali di produzione, le chiavi di firma e la tua chiave Admin di App Store Connect lontano dalla macchina dove gli agenti girano senza supervisione.

Passo 5 — Scrivi un AGENTS.md prima di qualsiasi codice

OpenCode legge AGENTS.md nella radice del progetto all’inizio di ogni sessione, più uno personale in ~/.config/opencode/AGENTS.md se lo crei. Il /init comando può redigerne una scansionando il tuo repository. È l’abitudine più efficace nello sviluppo assistito dall’IA, e ho scritto dell’intero sistema nel mio guida al vibe coding. Per un’app per iPhone, deve contenere le regole del prodotto oltre ai comandi:

# Note per gli agenti di coding

## Che cos’è questa app
Una frase. Se una modifica non la serve, non ha posto qui.

## Non negoziabili
- Funziona offline. Le funzioni di rete degradano con gradualità.
- Niente analytics, pubblicità o SDK di tracciamento. Chiedi prima di aggiungere QUALSIASI dipendenza.
- Nessun segreto nel bundle dell’app. Le chiavi che costano denaro vivono su un server.
- Nessuna funzione nascosta, dormiente o solo di debug nelle build di release
  (linea guida 2.5.19 di App Review). I menu di debug sono compilati fuori da Release.
- Non inviare mai dati personali a un servizio IA di terze parti senza
  una schermata di consenso esplicita nell’app (linea guida 5.1.2(i)).
- Accessibilità: Dynamic Type, etichette VoiceOver, aree di tocco da 44 x 44 pt,
  modalità chiara e scura su ogni schermata.
- Ogni stringa visibile all’utente è localizzata, inclusi widget,
  notifiche e richieste di autorizzazione.

## Comandi
- Compila ed esegui: usa gli strumenti XcodeBuildMCP (build_run_sim), scheme "MyApp"
- Test: test_sim
- Non eseguire mai asc publish né nulla con --submit.

## Definizione di fatto
- Compila senza avvisi, i test passano
- Verificato con screenshot + snapshot_ui sul simulatore
- Funziona in modalità aereo, modalità scura e alla dimensione massima del testo

Passo 6 — La tua prima sessione vera

1. Inizia in modalità plan. Passa all’ plan agente (non può modificare i file del progetto) e chiedigli di contestare il tuo brief: “Leggi AGENTS.md e BRIEF.md. Elenca i flussi utente, i casi limite a cui non ho pensato e le schermate che mi mancano. Poi dimmi cosa tagliare.”
2. Salva il piano come tabella di marcia. Chiedigli di scriverlo ROADMAP.md come checklist di piccole fette end-to-end.
3. Costruisci una fetta alla volta con build l'agente. Una schermata, una funzionalità, funzionante end-to-end.
4. Rivedi il diff, eseguilo, fai commit. Ogni fetta termina con un commit. Se un passo va storto, /undo annulla l’ultimo passo dell’agente dai suoi snapshot di OpenCode; Git è la rete di sicurezza più grande.
5. Avvia una nuova sessione per la fetta successiva. Una sessione pulita che rilegge AGENTS.md e ROADMAP.md è di solito più intelligente di una lunga piena di presupposti obsoleti.

---

Parte 5 — Agenti, comandi, permessi e modalità Goal: OpenCode su misura per te

Quando le basi funzionano, quattro funzionalità trasformano OpenCode da una chat con un terminale in un laboratorio su misura per il tuo progetto.

Gli agenti integrati

Agente	Tipo	Cosa fa
build	Primario	Quello predefinito. Modifica i file, esegue comandi, fa il lavoro
plan	Primario	Esplora e pianifica senza modificare i file del progetto (può scrivere i propri file di piano)
general	Subagente	Ricerca e compiti in più passaggi; non può avviare altri subagenti
explore	Subagente	Cerca e legge codice o pagine web; non può modificare nulla

Gli agenti primari sono quelli con cui parli. I subagenti vengono lanciati da un agente primario per un compito mirato, così il contesto della sessione principale resta pulito.

Scrivi il tuo subagente: uno scettico dell’App Review

Gli agenti personalizzati sono file Markdown in .opencode/agents/ (oppure ~/.config/opencode/agents/ per ogni progetto). Il front matter configura l'agente e il corpo diventa le sue istruzioni. Questo esamina la tua app come farà App Review, e non può cambiare nulla mentre lo fa:

---
description: Esamina l'app e i suoi metadati rispetto alle App Review Guidelines di Apple prima dell'invio
mode: subagent
model: opencode-go/glm-5.3
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

Sei uno specialista scettico di App Review. Esamina il codice attuale e i
file in metadata/ ed elenca i problemi, dal più grave, con file e riga:

- Crash, testi segnaposto, link morti, account demo mancante (2.1)
- Qualsiasi cosa che sembri una copia di una categoria di app satura (4.3(b))
- Funzionalità nascoste, dormienti o non documentate, menu di debug, feature flag (2.5.19)
- Dati che lasciano il dispositivo e non sono nell'informativa sulla privacy o nell'etichetta privacy
- Dati personali inviati a qualsiasi servizio di IA senza consenso esplicito (5.1.2(i))
- Creazione dell'account senza eliminazione dell'account in-app (5.1.1(v))
- Screenshot o descrizioni che promettono funzionalità che la build non ha

Non correggere niente. Solo segnalazioni.

Salvalo come .opencode/agents/appstore-reviewer.md, poi chiedi: “Usa il subagente appstore-reviewer per esaminare tutto da dopo l’ultimo tag di release.”

Comandi personalizzati per i compiti che ripeti

I comandi sono modelli di prompt che esegui con uno slash. Mettili in .opencode/commands/; $ARGUMENTS viene sostituito con qualunque cosa digiti dopo il comando, e ` !command ` inserisce l’output di un comando shell prima che il prompt venga inviato. Questo abbozza le note di rilascio per l’App Store:

---
description: Abbozza le note "Novità" dell'App Store dai commit dall'ultimo tag
agent: build
---

Ecco i commit dall'ultima release:

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

Scrivi le note "Novità" per la versione $ARGUMENTS in un inglese semplice e amichevole,
sotto i 400 caratteri, solo modifiche visibili all'utente. Salvale in
metadata/en-US/release_notes.txt e mostrami il testo.

Salvalo come .opencode/commands/whats-new.md ed eseguilo con /whats-new 1.2.0. Un avvertimento dalla documentazione di OpenCode vale la pena ripeterlo: quei ! blocchi vengono eseguiti fuori dal sistema di permessi dell’agente, quindi metti solo comandi di cui ti fidi.

Un ricettario di permessi per progetti di app

La configurazione della Parte 4 è un buon inizio. Qualche altra regola che vale la pena conoscere:

• Regole per singolo agente vanno sotto agents.<id>.permissions e si aggiungono dopo quelle globali, così puoi, per esempio, lasciare che solo l’agente build esegua xcodebuild.
• Anche gli strumenti MCP sono azioni, chiamate <server>_<tool>. Una regola come { "action": "XcodeBuildMCP_*", "resource": "*", "effect": "ask" } fa sì che ogni chiamata a XcodeBuildMCP chieda conferma prima.
• Le skill possono essere vincolate da permessi con skill action: allow annuncia e carica una skill liberamente, ask la annuncia ma chiede prima di caricarla, deny la nasconde del tutto.
• Quando si controllano più risorse insieme, qualsiasi deny vince, poi qualsiasi ask.

Modalità Goal, worktree e pianificazioni

Tre funzionalità più recenti cambiano la percezione della durata dei lavori:

• Modalità obiettivo (2.2.1): /goal Fai superare a ogni schermata un controllo VoiceOver e correggi ciò che fallisce tiene la sessione al lavoro verso l’obiettivo finché non viene revisionato, con pause, resume e clear. Perfetto per i lavori grandi e noiosi: verifiche di accessibilità, localizzazione, copertura dei test.
• Worktree: avvia una sessione in un worktree Git separato dalla schermata di nuova sessione (o ⌘⌥O nell’app desktop), così un esperimento non può toccare il tuo branch principale. Le esecuzioni scriptate richiedono opencode run --worktree=<name> da 2.2.6. Butta via il worktree se l’esperimento fallisce.
• Prompt pianificati (opt-in, sperimentale): /schedule esegue un prompt secondo un orario mentre opencode serve è in esecuzione, ad esempio un “esegui i test e riassumi i fallimenti” notturno.

---

Parte 6 — Server MCP: dare delle mani all’agente

Da solo, un agente di coding sa leggere file ed eseguire comandi shell. MCP, il Model Context Protocol, è il modo standard per dargli di più: un progetto Xcode in esecuzione, un simulatore su cui può toccare e fare screenshot, i tuoi report di crash, la documentazione aggiornata, il tuo servizio di build. Ogni server MCP espone un insieme di strumenti e l’agente decide quando chiamarli.

C’è un costo, e la documentazione di OpenCode lo dice chiaramente: “Gli strumenti MCP consumano contesto del modello, quindi aggiungi solo i server che ti servono.” Ogni server collegato aggiunge descrizioni degli strumenti a ogni richiesta. Dieci server che usi raramente rendono ogni risposta più lenta e meno mirata.

La lista essenziale per chi sviluppa app

Server	Cosa dà all’agente	Aggiungilo a OpenCode	Da sapere
Xcode (Apple)	Il tuo progetto Xcode aperto: build, test e altro, attraverso Xcode stesso	opencode mcp add xcode -- xcrun mcpbridge	In Xcode → Impostazioni → Intelligenza, imposta Consenti agli agenti esterni di usare gli strumenti di Xcode a Sempre o Mentre Xcode è aperto. Apri il progetto in Xcode prima di lanciare il prompt; Xcode mostra quando un agente si collega
XcodeBuildMCP	Build headless, esecuzioni su simulatore e dispositivo, screenshot, tocchi e swipe, snapshot di accessibilità, test, debug con LLDB	opencode mcp add XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp	Open source (MIT), mantenuto da Sentry da quando ha acquisito il progetto a febbraio. Richiede macOS 14.5+, Xcode 16+ e Node 18+. Per impostazione predefinita sono attivi solo gli strumenti del simulatore
Expo	Build EAS, flussi di lavoro e invii, documentazione di Expo, simulatori cloud, dati su crash e feedback da TestFlight e dagli store	opencode mcp add expo --url https://mcp.expo.dev/mcp, allora opencode mcp auth expo	Serve un account Expo e l'SDK più recente. Alcuni strumenti richiedono un piano Expo a pagamento. Gli strumenti per il simulatore locale richiedono npx expo install expo-mcp --dev e SDK 54+
Context7	Documentazione aggiornata e specifica per versione di librerie e framework	opencode mcp add context7 --url https://mcp.context7.com/mcp	Impedisce al modello di inventare API che sono cambiate il mese scorso
Sentry	I tuoi crash ed errori reali	opencode mcp add sentry --url https://mcp.sentry.dev/mcp, allora opencode mcp auth sentry	Accesso tramite OAuth
Playwright	Un browser reale che l'agente può pilotare	opencode mcp add playwright -- npx @playwright/mcp@latest	Per la versione web della tua app e la tua landing page
Firebase	Il tuo progetto Firebase, le regole di sicurezza e la configurazione	opencode mcp add firebase -- npx -y firebase-tools@latest mcp	Chiede prima di modificare qualsiasi cosa nel tuo progetto

Controlla a cosa sei connesso con opencode mcp list, e attiva o disattiva i server per una sessione con /mcps.

Se progetti in Figma, il suo server MCP può fornire frame e variabili anche all'agente. Ho spiegato il dettaglio specifico di OpenCode (server remoto contro server desktop) nella mia guida a creare un'app da zero con l'IA.

Il bridge MCP di Xcode contro XcodeBuildMCP

Si sovrappongono, e funzionano bene insieme:

• Il server di Xcode stesso (xcrun mcpbridge) funziona tramite l'app Xcode che hai aperta. È di Apple, capisce il tuo progetto come lo capisce Xcode, e richiede che Xcode sia in esecuzione.
• XcodeBuildMCP avvolge gli strumenti a riga di comando di Apple (xcodebuild, simctl, devicectl), quindi funziona headless. Il suo vero punto di forza è il ciclo di verifica: build_run_sim per compilare e avviare, screenshot per guardare, snapshot_ui per leggere l'albero di accessibilità, tap e type_text per usare l'app, e test_sim per eseguire i test. Esegui xcodebuildmcp init una volta nel tuo progetto per installare le sue due skill complementari.

Nel file di configurazione

Gli stessi server possono risiedere in opencode.jsonc (la Parte 4 ha un esempio completo), che è meglio per un team perché la configurazione viaggia con il repository:

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

Due dettagli dalla documentazione MCP di OpenCode: i segreti si inseriscono come {env:NAME} (un semplice $NAME non viene espanso), e "disabled": true mantiene un server configurato senza connetterlo.

Quando uno strumento da riga di comando batte un server MCP

La mia regola: se esiste un buon strumento da riga di comando, provalo con una skill prima di aggiungere un server. L’agente sa già eseguire comandi, una CLI non costa contesto finché non viene usata, e il suo output si può filtrare prima che arrivi al modello. Per il lavoro sulle app, tre CLI coprono molto terreno:

• gh per GitHub: issue, pull request, release.
• asc per App Store Connect: build, TestFlight, metadati, screenshot, stato della revisione (Parte 9).
• eas per il servizio di build e invio di Expo.

La sicurezza MCP in quattro regole

1. Installa i server dai loro produttori o da progetti che puoi leggere. Un server è codice che gira sulla tua macchina con i tuoi permessi.
2. Tratta l’output degli strumenti come non attendibile. Una pagina web, il commento di una issue o un report di crash possono contenere istruzioni rivolte al tuo agente. Tieni le azioni rischiose su ask.
3. Filtra gli strumenti per nome. Ogni strumento MCP è un’azione di permesso chiamata <server>_<tool>, così puoi consentire quelli in sola lettura e far chiedere conferma per gli altri.
4. Rimuovi ciò che non usi. Costa contesto, ed è una cosa in meno che può andare storta.

---

Parte 7 — Skill: scrivi il tuo playbook una volta sola

AGENTS.md dice all’agente qual è il tuo progetto. Le skill insegnano come svolgi lavori specifici: pubblicare una build, scrivere una migrazione, preparare screenshot, verificare la privacy. Una skill è una cartella che contiene un SKILL.md file con una breve descrizione in cima e le istruzioni sotto, più gli script o i file di riferimento che le servono. Il formato è uno standard aperto condiviso da OpenCode, Claude Code, Codex e altri, ed è per questo che una skill scritta per un agente di solito funziona anche negli altri.

Come OpenCode usa una skill

1. A ogni passaggio, OpenCode mostra al modello un elenco delle skill che può usare: solo l’ID, il nome e la descrizione di ogni skill. Le istruzioni vere e proprie non vengono caricate, quindi cento skill non costano quasi nulla.
2. Quando un compito corrisponde, il modello chiama lo skill strumento con l’ID della skill, e OpenCode controlla i tuoi permessi.
3. OpenCode aggiunge le istruzioni alla conversazione, con il percorso della cartella della skill e un elenco di massimo dieci dei suoi file di supporto.
4. I file di supporto si caricano solo quando le istruzioni li richiedono. Una lunga checklist o uno script resta su disco finché non serve.

Puoi anche caricarne una tu stesso citandola in un prompt: @app-store-release.

Dove cerca OpenCode

Ambito di applicazione	Cartella
Il tuo progetto	.opencode/skills/
Il tuo progetto (condiviso con altri agenti)	.claude/skills/ e .agents/skills/
Ogni progetto sulla tua macchina	~/.config/opencode/skills/
Ogni progetto (condiviso)	~/.claude/skills/ e ~/.agents/skills/
Ovunque altro	Percorsi o cataloghi HTTP elencati in un competenze array in opencode.jsonc

L’ID di una skill deriva dal nome della sua cartella, non dal nome nel suo front matter, e l’ID distingue tra maiuscole e minuscole: .opencode/skills/app-store-release/SKILL.md ha come ID app-store-release. Quando due fonti definiscono lo stesso ID, vince l’ultima in questo ordine: integrata, .claude/skills, .agents/skills, la tua cartella globale, quella del tuo progetto .opencode/skills, poi le voci esplicite di configurazione. Una skill senza descrizione non viene annunciata affatto al modello.

Scrivi la tua prima skill: una checklist per il rilascio sull’App Store

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

---
name: App Store release
description: Prepara un rilascio iOS. Incrementa la versione e il numero di build, esegue la checklist di rilascio, archivia, carica su TestFlight con asc e prepara le note What's New. Usala quando ti viene chiesto di "ship", "release" o "send to TestFlight".
---

# App Store release

1. Controlla `git status`. Se l'albero di lavoro non è pulito, fermati e segnalalo.
2. Incrementa la versione marketing e il numero di build (chiedi quale versione se non è indicata).
3. Segui references/release-checklist.md. Ogni voce deve passare.
4. Archivia ed esporta l'IPA con scripts/archive.sh.
5. Carica: `asc builds upload --app "$ASC_APP_ID" --ipa build/MyApp.ipa`
6. Prepara le note What's New dai commit dall'ultimo tag e salvale
   in metadata/en-US/release_notes.txt.
7. Non inviare MAI in revisione. Segnala che la build è caricata, poi fermati.

Metti la checklist in references/release-checklist.md e lo script di archiviazione in scripts/archive.sh accanto. La prossima volta che dici “ship 1.2.0 to TestFlight”, l’agente trova la skill dalla descrizione e segue i tuoi passaggi invece di improvvisare.

Skill che vale la pena installare per il lavoro sulle app

Set di skill	Che cosa c’è dentro	Installa
Skill di Expo (ufficiali)	23 skill: 16 per l’Expo SDK (Router, UI nativa, @expo/ui, design system, aggiornamenti, moduli nativi e altro) e 7 per i servizi di Expo, tra cui eas-app-stores per compilare e inviare a TestFlight, all’App Store e a Google Play	npx skills add expo/skills
Skill della CLI di App Store Connect	Più di venti asc skill: flusso di rilascio, orchestrazione di TestFlight, sincronizzazione dei metadati con controllo dei limiti di caratteri, traduzione delle schede, pipeline di screenshot, configurazione della firma, stato dell’invio, analisi dei crash, audit ASO	asc install-skills, o npx skills add rorkai/app-store-connect-cli-skills
Skill di XcodeBuildMCP	Due skill che insegnano all’agente gli strumenti e la CLI di XcodeBuildMCP	xcodebuildmcp init
skills.sh	la directory aperta di skill della community di Vercel; elenca OpenCode tra gli agenti supportati	npx skills add <owner/repo>

Se OpenCode non mostra una skill che hai installato, controlla dove l’installer l’ha messa rispetto alle cartelle qui sopra, oppure copia la cartella della skill in .opencode/skills/.

Sicurezza delle skill

Una skill è istruzioni più, spesso, script che l’agente eseguirà. Leggi una skill di terze parti prima di installarla, come leggeresti uno script shell preso da internet. Preferisci le skill di chi realizza lo strumento (Expo per Expo, i asc manutentori di asc), tieni le skill sconosciute su ask con una regola sui permessi, e ricorda che deny nasconde completamente una skill al modello.

---

Parte 8 — Costruire l’app: dall’idea a una build di cui fidarti

Gli strumenti sono pronti. Ora la parte che decide se qualcuno scarica il risultato.

Scegli un’idea che App Review lascerà passare

L’IA ha reso economico costruire un’app, e Apple se n’è accorta. Il 9 giugno ha riscritto la linea guida 4.3(b), la sua regola anti-spam: le app che sono sostanzialmente identiche a ciò che è già abbondante nello store ora vengono rifiutate, e Apple cita le app di incontri, torcia, sfondi, timer e cartomanzia come categorie in cui serve un’esperienza sensibilmente diversa o migliore. Le app novelty a basso impegno possono essere rimosse, le app esistenti in quelle categorie possono essere ritirate se non vengono migliorate o non attirano utenti, e invii ripetuti di questo tipo possono costarti l’iscrizione come sviluppatore.

Quindi prima del primo prompt, un test: riesci a dire in una frase cosa fa la tua app che i primi risultati per il suo termine di ricerca principale non fanno? Se non ci riesci, l’agente lo costruirà in modo impeccabile e App Review te lo rispedirà indietro.

Piccolo e specifico batte grande e generico. Le mie due app sono volutamente ristrette:

• Stash ricorda dove metti le cose: fotografa il posto, scegli la stanza, salva, poi cerca per nome, stanza o nota vocale trascritta.
• PingAtlas misura i tempi di andata e ritorno della rete dal tuo iPhone, iPad o Mac verso 202 città, 278 destinazioni pubbliche, 109 giochi e 32 servizi online, senza un account né un servizio di misurazione remoto.

Un compito ciascuna. È questo che le rende realizzabili da una sola persona con un agente, e spiegabili in una frase su una pagina dell’App Store.

Scegli il tuo stack

	SwiftUI + Xcode 27.1	Expo SDK 58 (React Native 0.88)
Gira su	iPhone, iPad, Mac, Apple Watch e Vision Pro	iPhone, iPad, Android e il web da un unico codice sorgente
Linguaggio	Swift 6.4	TypeScript
Serve un Mac?	Sì	Non per compilare o inviare (ci pensa il cloud di Expo); sì per gli strumenti locali del simulatore iOS
Strumenti per agenti	Il bridge MCP di Xcode, XcodeBuildMCP, OpenCode dentro Xcode tramite ACP	Il server MCP di Expo, 23 skill ufficiali, un @expo/agent-cli e leggibile dalla macchina expo command:ps output per agenti
Novità di questo autunno	SDK iOS 27.1, un simulatore iPhone Duo (con alcuni limiti sulle estensioni)	Compilato con l’SDK iOS 27; le app passano al ciclo di vita delle scene di UIKit, pronte per iPhone Duo; supporto App Intents in alpha; macOS non è supportato nell’SDK 58
Ideale per	App solo Apple che vogliono le funzionalità più recenti della piattaforma	Una sola persona che pubblica su iPhone e Android, con una versione web

Se ti piace pubblicare prima una versione web (a me sì), l’output web di Expo ti permette di mettere una demo funzionante davanti alle persone prima che esista la versione per l’App Store. Il sito di Stash fa qualcosa di simile con una demo del browser costruita attorno a una casa di esempio: le persone possono provare l’idea prima di installare qualcosa.

Il ciclo di build che funziona

L’agente scrive in fretta. Ciò che rende il risultato affidabile è il ciclo che lo circonda:

1. Brief. Un BRIEF.mddi una pagina: la promessa in una frase, tre user story, l’elenco delle schermate.
2. Piano. L’ plan L’agente lo trasforma in ROADMAP.md: piccole fette verticali, ognuna con una funzionalità funzionante dall’inizio alla fine.
3. Realizza una fetta. L’ build l’agente la implementa e scrive i test.
4. Verifica come un utente. Con XcodeBuildMCP l’agente può compilare e avviare l’app nel simulatore, fare uno screenshot, leggere l’albero dell’accessibilità con snapshot_ui, toccare i passaggi del flusso ed eseguire i test. Con Expo, gli strumenti MCP locali fanno lo stesso per il simulatore. Chiedigli di confrontare ciò che vede con ciò che avevi chiesto.
5. Rivedi come App Review. Esegui l’ appstore-reviewer subagent della Parte 5.
6. Leggi tu stesso il diff. Ogni riga che finirà nell’app.
7. Fai il commit, spunta la casella, inizia una nuova sessione.

Per i grandi passaggi meccanici (aggiungere etichette di accessibilità ovunque, localizzare ogni stringa, aumentare la copertura dei test) usa la modalità goal: /goal Localizza ogni stringa visibile all’utente in tedesco, inclusi widget, notifiche e richieste di autorizzazione.

Tre modelli di prompt che vale la pena adattare:

Una slice: Implementa la fetta 4 di ROADMAP.md (ricerca). Leggi prima AGENTS.md. Scrivi prima i test unitari, poi il codice. Compila ed eseguila nel simulatore, fai uno screenshot della schermata dei risultati e confrontalo con il brief. Mostrami il diff ed elenca ogni ipotesi che hai fatto.

Un bug: Su un iPhone alla dimensione massima di Dynamic Type, la tastiera copre il pulsante Salva nella schermata Aggiungi. Riproducilo nel simulatore, fai uno screenshot, spiega la causa in due frasi, correggilo e controlla che ogni altro modulo non abbia lo stesso problema.

Una revisione prima del commit: Esamina tutto ciò che è cambiato dall'ultimo commit come un revisore iOS senior scettico: crash, perdita di dati, fughe di privacy, etichette di accessibilità mancanti, stringhe e colori hardcoded, qualsiasi cosa che rompa l'uso offline. Elenco numerato, dal più grave. Non correggere ancora niente.

Lezioni da due piccole app

Stash e la localizzazione. Stash 1.1.0 (28 ottobre) ha aggiunto dieci lingue all'inglese: spagnolo, francese, tedesco, italiano, portoghese brasiliano, olandese, polacco, giapponese, coreano e cinese semplificato. L'app ne rileva una dal dispositivo e ti permette di cambiarla in Impostazioni → Lingua, e le note di rilascio sottolineano che sono stati tradotti anche i widget, i promemoria e le richieste di autorizzazione di sistema. È proprio quest'ultimo dettaglio la lezione: la localizzazione è un lavoro ideale per un agente, ma le stringhe che gli agenti dimenticano vivono fuori dalle schermate principali, nei widget, nelle notifiche, nelle stringhe di motivazione delle autorizzazioni e nella formattazione delle date. Nominale in AGENTS.md e vengono fatte.

PingAtlas e promesse oneste. La descrizione di PingAtlas sull'App Store fa promesse precise: una risposta mancante appare come “Nessuna risposta”, mai come 0 ms; non c'è GPS e non c'è autorizzazione alla posizione; non ci sono pubblicità, né analytics né account; i risultati restano sul dispositivo a meno che tu non li esporti; e i controlli dei siti web usano solo richieste HEAD. Promesse così vanno messe in AGENTS.md come punti non negoziabili, perché sono anche ciò che dice la tua etichetta sulla privacy. L'etichetta di PingAtlas dice “Dati non raccolti”, e questo è vero solo finché il codice è d'accordo. Il subagente revisore serve a notare il giorno in cui non lo è.

La portata ridotta è una funzionalità. PingAtlas è un download da 1,9 MB. Stash, con foto, note vocali, sincronizzazione e widget, pesa circa 65 MB. Più funzionalità significano più cose da testare, più cose da spiegare nell'informativa sulla privacy e più cose che App Review può mettere in dubbio. Parti dalla versione più piccola che mantiene la promessa.

Accessibilità dal primo giorno

Le Accessibility Nutrition Labels ti permettono di dichiarare il supporto per nove funzionalità nella pagina del tuo App Store: VoiceOver, Voice Control, Larger Text, Dark Interface, Differentiate Without Color Alone, Sufficient Contrast, Reduced Motion, Captions e Audio Descriptions. Oggi sono volontarie, ma Apple dice che col tempo dovrai fornirle per inviare nuove app e aggiornamenti. Puoi dichiarare una funzionalità solo se le persone possono completare tutte le attività comuni della tua app con essa, compresi il primo avvio, l'accesso, gli acquisti e le impostazioni.

Nessuna delle mie schede ne dichiara ancora alcuna, ed è esattamente il tipo di lacuna che questa guida vuole scovare. L'agente può fare la maggior parte dell'audit: XcodeBuildMCP snapshot_ui legge l'albero dell'accessibilità, quindi /goal Rendi ogni schermata pienamente utilizzabile con VoiceOver e alla dimensione massima del testo, ed elenca tutto ciò che non riesci a correggere è un lavoro realistico per un pomeriggio.

---

Parte 9 — Pubblicare sull’App Store: lascia che OpenCode si occupi della burocrazia, poi premi Invia da solo

Costruire è la parte divertente. Pubblicare è un progetto a sé, ed è lì che gli sviluppatori alle prime armi perdono una settimana. La buona notizia per il 2026: quasi tutto può ormai essere gestito con script, il che significa che un agente può fare la digitazione mentre tu prendi le decisioni.

Cosa è cambiato in Apple nel 2026

Quando	Cosa è cambiato	Cosa fare
31 gen 2026	Le nuove domande sulla classificazione per età sono diventate obbligatorie per gli aggiornamenti	Rispondi per ogni app prima di inviare
28 apr 2026	I caricamenti devono essere compilati con Xcode 26 o successivo e gli SDK 26	Usa Xcode 26 o 27
9 giu 2026	Linea guida 4.3(b) riscritta: app imitative e di scarso impegno rifiutate o rimosse	Differenziati (Parte 8)
9 set 2026	Gli upload devono avere come destinazione iOS 13 o successivo	Niente, per qualsiasi nuova app
15 ott 2026	Xcode 27.1 (Swift 6.4, iOS 27.1 SDK; richiede macOS Tahoe 26.6+) e Expo SDK 58	Aggiorna la tua toolchain
16 ott 2026	Nuova linea guida 2.5.19 vieta funzionalità nascoste, dormienti o non documentate; regole più severe per le app che nascondono il proprio scopo durante la revisione	Escludi in compilazione i menu di debug e i feature flag dalle build di rilascio
In vigore	Linea guida 5.1.2(i): informa le persone e ottieni il loro consenso prima di condividere dati personali con AI di terze parti (aggiunto a novembre 2025)	Aggiungi una schermata di consenso se la tua app chiama un servizio AI
Ora	Screenshot: un set per iPhone con Dynamic Island (display medio) è obbligatorio, più iPad da 13 pollici se la tua app gira su iPad	Pianifica le dimensioni degli screenshot (Parte 10)
Aprile 2027	iPhone Duo screenshot richiesti per le app create con l'SDK iOS 27.1 o successivo	Inizia subito a progettare per il secondo display
Facoltativo, per ora	Accessibility Nutrition Labels	Dichiara ciò che supporti davvero

La nuova 2.5.19 è quella che colpisce le app costruite con l'IA. Gli agenti amano le aggiunte utili: una schermata di debug nascosta, un feature flag lasciato spento, un menu di test dietro una pressione prolungata. La nuova formulazione di Apple è netta: “Non includere nella tua app funzionalità nascoste, dormienti o non documentate.” Secondo il resoconto di 9to5Mac sul cambiamento, cercare di nascondere queste funzionalità, per esempio tramite l'offuscamento del codice, può portare alla rimozione dell'app e alla chiusura del tuo account sviluppatore. Metti la regola in AGENTS.md e chiedi al subagent revisore di cercarla prima di ogni invio.

Il flusso di lavoro, passo dopo passo

1. Iscriviti all'Apple Developer Program. Costa 99 $ all'anno (99 € in Germania). Le aziende si iscrivono come organizzazione, e serve un numero D-U-N-S. Inizia presto; la verifica può richiedere giorni. Iscriviti qui.
2. Dichiara il tuo status di operatore commerciale nell'UE. Ai sensi del Digital Services Act dell’UE, ogni sviluppatore deve dichiarare se è un operatore commerciale. Se pubblichi come azienda, il tuo indirizzo, il numero di telefono e l’email compaiono sulla pagina del prodotto in ogni paese dell’UE. Apple ha rimosso migliaia di app dagli storefront dell’UE a febbraio 2025 proprio per questa omissione.
3. Crea una chiave API di App Store Connect. In App Store Connect, vai su Utenti e accesso → Integrazioni → App Store Connect API e genera una chiave di team. Solo il titolare dell'account può richiedere l'accesso API in prima battuta. Assegna alla chiave il ruolo meno potente che basta allo scopo (la panoramica dei ruoli mostra cosa può fare ciascuno), scarica una sola volta il file .p8 e conservalo in un posto sicuro, fuori dal tuo repository.
4. Installa la CLI di App Store Connect e accedi. asc è uno strumento da riga di comando open source (MIT) per l'API di App Store Connect, pensato per script e agenti: stampa tabelle in un terminale e JSON quando è un altro programma a leggere l'output.

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

Poi installa le sue skill (asc install-skills) così OpenCode sa come usarla.

5. Crea il record dell'app. In App Store Connect, scegli App → + → Nuova app, e scegli con cura il bundle ID, perché non cambia mai (quello di Stash è network.grahammiranda.stash, quello di PingAtlas è network.grahammiranda.pingatlas). Le asc skill ne includono una che lo fa tramite l'automazione del browser, ma è un lavoro di due minuti che vale la pena fare a mano una volta.
6. Sistema la firma. Per un'app nativa, la firma automatica di Xcode gestisce certificati e profili. Per Expo, EAS gestisce le credenziali per te. La asc-signing-setup skill copre bundle ID, capability, certificati e profili se preferisci farlo via script.
7. Compila e carica. Nativo: crea l'archivio in Xcode (o lascia che lo faccia l'agente con la asc-xcode-build skill), poi carica:

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

Expo: eas build --platform ios, allora eas submit -p ios, che carica la build su App Store Connect (non la invia alla revisione). Il caricamento si può delegare tranquillamente; l'invio alla revisione no.

8. Prima prova con TestFlight. I tester interni (fino a 100 persone del tuo team) ricevono le build senza revisione. I tester esterni (fino a 10.000, via email o link pubblico) richiedono una breve Beta App Review per la prima build. Le build restano testabili per 90 giorni. L'agente può gestire i gruppi con asc testflight groups list --app "123456789" e il asc-testflight-orchestration skill. Fai provare l'app a cinque persone con iPhone diversi per una settimana; troveranno il crash che tu non hai trovato.
9. Scrivi i metadati, poi lascia che l'agente li controlli. Tieni la scheda in file nel repository (metadata/en-US/…) e applicala prima con una prova a vuoto:

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

L’ asc-metadata-sync skill controlla i limiti di caratteri di Apple prima che qualsiasi cosa venga caricata. La Parte 10 spiega cosa scrivere.

10. Crea gli screenshot. Almeno uno, fino a dieci, per ogni dimensione richiesta, in PNG o JPEG senza trasparenza. La asc-shots-pipeline skill può catturarli dal simulatore, incorniciarli e caricarli con asc screenshots upload. La Parte 10 riporta le dimensioni.
11. Rispondi con onestà alle domande su privacy, classificazione per età e conformità. Questa è la parte che non devi delegare alla cieca:

• L'etichetta sulla privacy. Nei termini di Apple, i dati contano come raccolti quando lasciano il dispositivo e vengono conservati più a lungo del tempo necessario a gestire la richiesta. I dati elaborati solo sul dispositivo non contano. Sincronizzare i contenuti delle persone sul tuo server conta, anche se solo loro possono vederli. Chiedi all’agente di verificare ogni chiamata di rete e ogni SDK, poi compila tu stesso l’etichetta partendo dalla sua tabella.
• L'informativa sulla privacy deve essere collegata in App Store Connect e raggiungibile dentro l'app, e deve descrivere questa app, non solo la tua azienda.
• IA di terze parti (linea guida 5.1.2(i)): se i dati personali finiscono in un servizio di IA, dichiaralo e chiedi prima il permesso.
• Eliminazione dell'account (linea guida 5.1.1(v)): se le persone possono creare un account, devono poterlo eliminare dentro l'app.
• Classificazione per età, conformità all'esportazione e le Accessibility Nutrition Labels. Se la tua app usa solo la crittografia integrata in iOS, come HTTPS, imposta ITSAppUsesNonExemptEncryption nel tuo Info.plist dopo aver controllato le indicazioni di Apple, così non ti viene chiesto a ogni caricamento.

12. Invia, tu stesso. Aggiungi la versione per la revisione e inviala dalla pagina dell'app in App Store Connect, oppure esegui asc publish appstore … --submit --confirm dal tuo terminale (le regole sui permessi della Parte 4 impediscono all'agente di eseguirlo). Poi lascia che l'agente controlli: asc review status --app "123456789".

La revisione: cosa aspettarsi

Apple afferma che in media il 90% delle proposte viene esaminato in meno di 24 ore e che oltre il 40% dei problemi irrisolti deriva dalla linea guida 2.1, App Completeness: crash, contenuti segnaposto, informazioni incomplete e link rotti. Se ti rifiutano, leggi il messaggio due volte, correggi il problema reale e rispondi in App Store Connect. La asc-submission-health skill aiuta a diagnosticare i blocchi, e l'agente è bravo a redigere una risposta calma e specifica. Inviala tu.

---

Parte 10 — Lancio: la scheda, gli screenshot, l’ASO e la vita dopo l’approvazione

Un'app approvata con una scheda debole è un negozio senza insegna. Ecco il resto del lavoro.

La scheda, campo per campo

Campo	Limite	Cosa funziona
Nome dell'app	30 caratteri	Marchio più beneficio. “Stash — Find It Fast” dice a uno sconosciuto a cosa serve l’app
Sottotitolo	30 caratteri	Il beneficio in parole semplici. PingAtlas usa “Ping città, giochi & servizi”
Parole chiave	100 caratteri	Separati da virgole, senza spazi. Non ripetere parole già presenti nel nome o nel sottotitolo; contano comunque
Testo promozionale	170 caratteri	Cambia senza una nuova revisione, quindi usalo per stagioni e notizie
Descrizione	4.000 caratteri	Cosa fa, a chi è rivolto, cosa non fa con i dati delle persone. Semplice e concreto
Novità	Per versione	Cambiamenti reali in parole umane; il /whats-new comando della Parte 5 lo redige
Screenshot	Da 1 a 10 per dimensione	Racconta la storia in ordine; quasi nessuno scorre oltre le prime tre

Due regole per lasciare che un agente scriva qualsiasi cosa di tutto questo: digli di usare solo funzionalità che esistono nel codice (e di indicare il file in cui si trova ciascuna), e tieni il risultato nel tuo repository così ogni modifica viene revisionata come il codice. La skill asc-aso-audit può poi controllare offline le lacune di parole chiave prima che qualcosa vada online.

Dimensioni degli screenshot a novembre 2026

Dispositivo	Obbligatorio?	Dimensioni verticali (pixel)
iPhone con Dynamic Island, display medio	Sì	1179 × 2556 o 1206 × 2622
iPhone con Dynamic Island, display grande	Opzionale	1260 × 2736, 1290 × 2796 o 1320 × 2868
iPad, display da 13 pollici	Sì, se la tua app gira su iPad	2064 × 2752 o 2048 × 2732
iPhone Duo (display esterno / interno)	Da Aprile 2027, per le app create con l'SDK iOS 27.1 o successivi	1398 × 2034 / 2007 × 2853

Se la tua interfaccia è identica in tutte le dimensioni e in tutte le lingue, ti serve solo la risoluzione più alta richiesta; App Store Connect la ridimensiona per i dispositivi più piccoli. Gli screenshot non possono contenere trasparenza.

Localizza la scheda, non solo l'app

Se l'app parla più lingue, anche la scheda dovrebbe farlo. La skill asc-localize-metadata traduce il testo della scheda e asc-metadata-sync controlla ogni lingua rispetto ai limiti di caratteri di Apple, ed è qui che di solito falliscono i sottotitoli tedeschi tradotti a mano. Fai rileggere il risultato a un madrelingua; la traduzione automatica oggi è ottima, ma il testo di un app store è marketing, e il marketing ha bisogno di un orecchio umano.

Dopo l'approvazione

• Chiedi la valutazione quando l’utente è contento. La richiesta di valutazione di sistema di Apple appare al massimo tre volte all'anno per persona, quindi non sprecarla al primo avvio. Chiedila subito dopo che qualcosa è andato bene.
• Usa il testo promozionale per il tempismo. Stagione dei traslochi, pulizie di primavera, un weekend di gaming. Cambia senza revisione.
• Controlla i crash dal primo giorno. L’ asc-crash-triage skill esamina i crash e i feedback di TestFlight; il server MCP di Expo può recuperare crash, feedback e recensioni (le risposte richiedono la tua conferma); il server MCP di Sentry porta dentro gli errori di produzione.
• Rilascia spesso piccoli aggiornamenti. Stash è andata online il 23 settembre, il 2 ottobre è uscito un restyling e il 28 ottobre ha aggiunto dieci lingue nella versione 1.1.0. Rilascia la versione che funziona, poi migliorala in pubblico.
• Dai all'app una casa sul web. Una pagina semplice con una demo, un'informativa sulla privacy scritta per l'app e, se sei in Germania, un Impressum. La mia guida app-from-scratch copre le pagine legali per sviluppatori tedeschi e dell'UE.

---

Parte 11 — Quanto costa: quattro budget per il primo anno

OpenCode è gratuito. Ollama è gratuito sul tuo hardware. L’unico costo che non puoi evitare per un’app per iPhone è l’iscrizione ad Apple; tutto il resto dipende da quanto tempo di modello vuoi comprare.

Budget	Che cosa c’è dentro	Primo anno (USD)
Solo locale	Apple Developer Program; OpenCode; Ollama con modelli locali su un Mac che possiedi già (32 GB o più)	$99
Base	Solo locale + OpenCode Go ($10 al mese)	$219
Consigliato	Starter + Ollama Pro con fatturazione annuale ($200)	$419
Massimo	Apple + OpenCode Go Plus ($40 al mese) + Ollama Max ($100 al mese)	$1,779

Prezzi di listino al 7 novembre 2026, IVA esclusa, senza sconti promozionali. Sostituisci con quello che preferisci: un GLM Coding Plan Lite invece di Go costa $216 all’anno con fatturazione mensile (circa $151 con fatturazione annuale) invece di $120; ChatGPT Plus costa $240 all’anno. Extra facoltativi: la commissione una tantum di $25 di Google Play se pubblichi su Android, i piani Expo a pagamento se superi il livello gratuito e quello che ti costa il tuo sito web.

Il costo vero però non è nella lista: sono le tue serate. L’IA accorcia la digitazione, non il pensiero, e il pensiero è la maggior parte del lavoro.

---

Parte 12 — Quindici errori da evitare

1. Lasciare che l’agente invii per la revisione. Nega l’autorizzazione nei permessi. Il pulsante lo premi tu.
2. Tenere una chiave API Admin dove gli agenti lavorano senza supervisione. Usa il ruolo meno potente che funziona e tieni le chiavi di firma e le credenziali di produzione da un’altra parte.
3. Costruire una copia di qualcosa che esiste già. La linea guida 4.3(b) ora cita intere categorie. Prima trova la tua differenza in una frase.
4. Pubblicare extra nascosti. Schermate di debug, feature flag dormienti e menu di test violano la linea guida 2.5.19. Escludile dalle build di rilascio in fase di compilazione.
5. Un’etichetta privacy plausibile invece che accurata. Se i dati lasciano il dispositivo e restano su un server, sono raccolti, anche se solo l’utente può vederli.
6. Inviare dati personali a un servizio di IA senza chiedere. La linea guida 5.1.2(i) richiede informativa e consenso.
7. Segreti nel bundle dell’app. Qualunque cosa dentro un’app può essere estratta. Le chiavi che costano denaro vivono su un server.
8. Collegare ogni server MCP che trovi. Ognuno costa contesto a ogni richiesta. Aggiungi solo quello che usi.
9. Installare skill e server che non hai letto. Sono istruzioni e codice che girano con i tuoi permessi.
10. Credere a “fatto”. Provala su un iPhone vero, offline, in modalità scura, con il testo alla dimensione più grande e VoiceOver attivo.
11. Usare modelli promozionali gratuiti per il codice dei clienti. Alcuni possono usare i tuoi dati per migliorare il modello. Disattivali per i progetti dei clienti.
12. Dimenticare la lunghezza del contesto di Ollama. Con il valore predefinito, un agente esaurisce lo spazio prima ancora di iniziare. Imposta 64K sul server.
13. Lasciare che le dipendenze si accumulino. Ogni pacchetto è codice che non hai letto e un aggiornamento che dovrai gestire. Fai in modo che l’agente chieda.
14. Sessioni lunghe e dispersive. Ricomincia da zero per ogni porzione e usa i worktree per gli esperimenti.
15. Promettere la tua roadmap. Gli screenshot e le descrizioni mostrano cosa fa questa build. Le idee stanno sul tuo sito web, etichettate come idee.

---

Parte 13 — Quale configurazione scegliere? Sei scenari

1. “Non ho mai scritto codice e ho un Mac.”

L’app desktop di OpenCode, OpenCode Go e Ollama per i lavori piccoli. Expo se vuoi anche Android; SwiftUI se ti interessa solo l’iPhone. Tieni i comandi shell sotto controllo ask, fai un commit dopo ogni passo che funziona e inizia con un’app che ha un solo compito.

2. “Il mio codice non deve mai lasciare la mia macchina.”

OpenCode con solo Ollama locale. Disattiva le funzioni cloud di Ollama, imposta OPENCODE_DISABLE_FREE_MODELS=1, e non collegare provider cloud in quel progetto. Aspettati un aiuto più lento e più semplice, e assegna all’agente compiti più piccoli. Un Mac con 64 GB o più rende tutto molto più comodo.

3. “Pago già per ChatGPT, Copilot o Claude.”

Collega prima quello che hai già. ChatGPT Plus e Pro e GitHub Copilot funzionano tramite accessi integrati senza costi aggiuntivi. Claude funziona tramite il provider Claude Agent; leggi la Parte 2 prima di affidarti a lui per il lavoro professionale. Aggiungi OpenCode Go più avanti se vuoi anche modelli aperti.

4. “Voglio iPhone e Android da un unico codice.”

Expo SDK 58, il server MCP di Expo, le skill ufficiali di Expo ed EAS per le build e i caricamenti sul cloud. Puoi compilare e caricare app iOS senza un Mac, anche se ti servirà comunque averne uno (e un iPhone) per i test.

5. “Mi interessano solo le piattaforme Apple e voglio tutto nativo.”

SwiftUI in Xcode 27.1, con OpenCode dentro Xcode tramite ACP (Xcode → Impostazioni → Intelligence → Aggiungi un agente…, eseguibile opencode, argomento acp) oppure nel tuo terminale con il bridge MCP di Xcode e XcodeBuildMCP. Un limite della via dentro Xcode: non c’è un selettore di modello, quindi imposta il tuo modello predefinito in opencode.jsonc prima.

6. “Voglio andare veloce e sono disposto a pagare.”

OpenCode Go Plus e Ollama Max, worktree per esperimenti in parallelo, la modalità goal per i lavori lunghi e meccanici, e un modello di frontiera tramite chiave API per i problemi davvero difficili. Tieni d’occhio la spesa ogni settimana. Per far girare più agenti fianco a fianco, il mio confronto tra harness copre le opzioni.

---

Domande frequenti

---

In sintesi

Apprendimento come usare OpenCode beh non consiste nel memorizzare comandi. Consiste nel costruire un piccolo sistema attorno all'agente: un piano di coding che stia nel tuo budget, Ollama per il lavoro che deve restare sulla tua macchina, una manciata di server MCP che permettono all'agente di vedere ciò che costruisce, skill che contengono il tuo playbook e autorizzazioni che lasciano in mano tua le decisioni irreversibili.

La mia raccomandazione resta: OpenCode con OpenCode Go e Ollama è il modo più economico, più flessibile e con meno vincoli per costruire un'app con l'IA a fine 2026. Aggiungi un abbonamento che già paghi, o un modello di frontiera tramite chiave API, quando un compito lo merita. Poi usa l'agente anche per il lavoro burocratico, e tieni per te il pulsante “Submit”.

Se vuoi vedere cosa produce questo tipo di processo su piccola scala, entrambe le mie app sono gratuite: Stash — Trovalo subito per le cose che metti via, e PingAtlas per verificare quanto è davvero vicino internet da dove sei seduto. Poi vai e costruisci la tua.

---

Stai costruendo con OpenCode? Mi piacerebbe sapere su quale piano di coding ti sei fermato, quale modello locale si è guadagnato un posto sul tuo Mac e quale server MCP o skill non potresti più fare a meno di usare. Correzioni e controprove sono benvenute; questo articolo viene aggiornato quando il quadro cambia.

Informativa: Stash e PingAtlas sono app mie, pubblicate dalla mia azienda, Graham Miranda UG (haftungsbeschränkt). Entrambe sono gratuite e senza pubblicità. Questo articolo contiene un link affiliato, al GLM Coding Plan di Z.ai nella Parte 2; se ti abboni tramite quel link ottieni il 10% di sconto e io ricevo una commissione. Nessuna delle aziende qui citate ha sponsorizzato, revisionato o approvato questo articolo.

Ultimo aggiornamento: 7 novembre 2026.