Come creare un'app da zero con l'IA nel 2026: Figma, OpenCode v2, MiniMax M3.1 e la storia di Stash

In ogni casa c'è un cassetto che “divora” le cose. Chiavi, il caricabatterie di riserva, il passaporto che ti serve due volte all'anno. Ci metti qualcosa "per sicurezza" e, tre mesi dopo, ti ritrovi in ginocchio a svuotare un intero armadio sul pavimento. Questa è una guida completa a Come creare un'app da zero con l'IA nel 2026, raccontato attraverso l'app che ho creato per riparare quel cassetto.

Stash è la mia risposta a quel cassetto. È una piccola e intuitiva app per iPhone e iPad: scatti una foto del punto in cui hai riposto qualcosa, le dai un nome e indichi in quale stanza si trova, e quando ne hai di nuovo bisogno, la cerchi. L’idea è proprio questa. È stata pubblicata sull’App Store il 23 settembre 2026. È gratuita e non contiene pubblicità.

Non ho una formazione nel campo della programmazione. Tutto ciò che realizzo, lo realizzo con agenti di intelligenza artificiale e, nell’ultimo anno, gli strumenti per farlo sono passati dall’essere una “bella demo” a diventare “qualcosa che si può davvero lanciare sul mercato”. Questa guida è quindi innanzitutto pratica: illustra ogni passaggio, da una cartella vuota a una scheda live sull’App Store, utilizzando Stash come esempio pratico per tutto il percorso.

Questa è la pila di libri che consiglierei a chiunque iniziasse oggi. Figma per il progetto. OpenCode v2 come agente codificante. MiniMax M3.1 come il modello che svolge il lavoro di elaborazione (a rigor di termini, M3.1-Flash-Preview, lanciato il 27 settembre, e spiegherò perché questa distinzione è importante). Poi tutte quelle “cose” che non compaiono mai nei tutorial su YouTube: il backend, l’informativa sulla privacy, App Store Connect, gli screenshot, la revisione, la landing page, le pagine legali e quanto costa tutto questo.

Tutto ciò che è riportato qui è stato verificato confrontandolo con la documentazione ufficiale, le note di rilascio e lo stesso App Store su 5 ottobre 2026. Alcune informazioni risulteranno obsolete nel giro di poche settimane. Il nuovo modello di MiniMax è solo un’anteprima, OpenCode rilascia aggiornamenti quasi ogni giorno e Figma sta ancora decidendo quali agenti di programmazione potranno connettersi al proprio server MCP. Ho segnalato le parti soggette a modifiche man mano che procedevo.

Informativa: Stash è la mia app, pubblicata dalla mia azienda, Graham Miranda UG. È gratuita, senza pubblicità né acquisti in-app. Questo articolo non contiene link di affiliazione. MiniMax, il team di OpenCode presso Anomaly, Figma, Apple, Google ed Expo non l’hanno sponsorizzato, revisionato né approvato.

---

TL;DR — La versione in 60 secondi

• Nel 2026 sarà possibile creare un’app vera e propria partendo da zero grazie all’intelligenza artificiale, ma oggi “partendo da zero” significa prendere decisioni, non digitare. L'agente si occupa della scrittura del codice. A te spettano il brief, la progettazione, il modello di dati, la politica sulla privacy, i test e le pratiche burocratiche relative all'App Store.
• Lo stack: Figma (schermate e variabili di progettazione) → OpenCode v2 (agente open source, licenza MIT) → MiniMax M3.1-Flash-Preview (contesto da 1 milione di token, legge testo, immagini e video, cinque livelli di difficoltà) → una build Expo o Xcode → TestFlight → l’App Store. Firebase se servono account e sincronizzazione.
• “Oggi ”MiniMax M3.1” indica M3.1-Flash-Preview. È stato lanciato il 27 settembre 2026 ed è disponibile esclusivamente tramite l’abbonamento M Plan di MiniMax ($22, $55 o $132 al mese, con 50% in omaggio sul primo mese con fatturazione mensile fino al 14 ottobre) e tramite l’app MiniMax Code. Non è previsto un prezzo per token, né pesi aperti, né un benchmark pubblicato al momento. Il pensiero non può essere disattivato e lo sforzo è impostato di default al massimo.
• Funziona in OpenCode v2 senza un file di configurazione: /connetti → “Piano MiniMax Token (minimax.io)” → incolla la tua chiave di abbonamento → /modelli → MiniMax-M3.1-Anteprima Flash.
• L'aspetto di Figma di cui nessuno parla: Il server MCP remoto di Figma non supporta ancora OpenCode. Durante la fase beta è consentito l'accesso solo agli utenti presenti nella lista bianca. Utilizza Figma’s desktop Server MCP all'indirizzo 127.0.0.1:3845 oppure (è necessaria l'app desktop di Figma e un abbonamento a pagamento di tipo Dev o Full, a partire da $12 al mese), oppure fornire all'agente i fotogrammi esportati, che M3.1 è in grado di leggere.
• La spedizione è un progetto a sé stante: $99 all’anno per l’Apple Developer Program (99 € in Germania), build realizzate con Xcode 26 o versioni successive, un’informativa sulla privacy, etichette sulla privacy che rispecchino la realtà, la possibilità di cancellare l’account dall’app se si offrono account e i dati identificativi del commerciante nell’UE. Apple afferma che il 90% delle richieste viene esaminato entro 24 ore.
• Stash in cifre: disponibile dal 23 settembre 2026, versione 1.0.1 con un nuovo design dal 2 ottobre, gratuita, compatibile con iOS e iPadOS 16.4 o versioni successive, circa 64 MB, senza tracciamento e con una modalità ospite che mantiene tutti i dati sul dispositivo.
• Quanto costa: a proposito di $363 per il primo anno con la configurazione essenziale (abbonamento Apple più M Plan Go), circa $500 con una licenza Figma Dev. I costi per il backend partono da zero grazie alle quote gratuite di Firebase.
• La regola più importante: “Fatto” è un’affermazione, non un dato di fatto. Prova l’app su un telefono vero, in modalità aereo, in modalità scura e con VoiceOver attivato. Solo allora potrai crederci.

---

Panoramica su The Stack

Strato	Strumento	Il suo ruolo in questo flusso di lavoro	Costo (ottobre 2026)
Progettazione	Figma	Schermate, componenti, variabili di colore e tipo, prototipo cliccabile	Piano Starter gratuito; una licenza Dev a partire da $12 al mese sblocca il server MCP desktop
Ponte tra progettazione e codice	Server Figma MCP (desktop)	Invia all'agente i frame, le variabili e gli screenshot	In dotazione con il sedile
Agente di codifica	OpenCode v2	Crea progetti, modifica file, esegue comandi e test; tramite terminale, app desktop o all’interno di Xcode 27	Gratuito, licenza MIT
Modello	MiniMax M3.1 - Anteprima Flash	Il cervello responsabile della progettazione e della programmazione; analizza screenshot e registrazioni dello schermo	Piano M a partire da $22 al mese
Framework dell'app	Expo SDK 56 (iPhone + Android) oppure SwiftUI con Xcode 27 (solo Apple)	L'app stessa	Gratuito; il piano gratuito di Expo include 15 build cloud per iOS e 15 per Android al mese
Backend	Firebase (Auth, Firestore, Storage, Functions, Messaging)	Account, sincronizzazione, archiviazione delle foto, notifiche	Quote gratuite; per lo storage e le funzioni è necessario il piano Blaze con pagamento a consumo
Distribuzione	App Store Connect + TestFlight	Test beta, revisione, rilascio	$99/anno Programma per sviluppatori Apple
Lancio	Una pagina di destinazione statica e le pagine legali	Spiegare, mostrare, rispettare	A prescindere dai costi di hosting

I prezzi indicati sono quelli di listino al 5 ottobre 2026, IVA esclusa. Le condizioni di abbonamento cambiano spesso, quindi ti consigliamo di verificarle prima dell'acquisto.

---

Indice

• Parte 1 — Scopri Stash: l’app su cui si basa questa guida
• Parte 2 — Lo stack del 2026 per sviluppare un'app da zero con l'IA
• Parte 3 — MiniMax M3.1: una spiegazione sincera
• Parte 4 — Configurazione di OpenCode v2 con MiniMax M3.1, passo dopo passo
• Parte 5 — Progettare la propria app in Figma anche se non si è designer
• Parte 6 — Collegamento di Figma a OpenCode: il problema dell’MCP
• Parte 7 — Come creare un'app da zero, fase per fase
• Parte 8 — Come pubblicare un'app sull'App Store nel 2026
• Parte 9 — “E altro”: Il kit di lancio relativo all’app
• Parte 10 — Quanto costa sviluppare un'app con l'IA nel 2026
• Parte 11 — Dieci errori da evitare quando si sviluppa la propria prima app con l'IA
• Parte 12 — È consigliabile utilizzare proprio questa combinazione? Sei scenari
• Parte 13 — Cosa tenere d’occhio nei prossimi mesi
• Domande frequenti
• In sintesi
• Fonti

---

Parte 1 — Scopri Stash: l’app su cui si basa questa guida

Prima degli strumenti, l’esempio. Una guida alla creazione di app vale solo quanto l’app che permette di realizzare, quindi ecco esattamente cos’è Stash, basandomi sulla sua scheda nell’App Store e sulla sua informativa sulla privacy piuttosto che sul mio entusiasmo.

L'annuncio si apre con una frase che riassume il lavoro: “Non dovrai mai più mettere la casa sottosopra per cercare qualcosa.” Poi descrive l'intero prodotto in tre frasi: “Stash è il modo più veloce per ricordarsi dove si mettono le cose. Scatta una foto, scegli la stanza, salva. L’app è tutta qui.”

Quell'ultima frase rappresenta le linee guida di progettazione. Ogni elemento dell'app serve a velocizzare il salvataggio o la ricerca. Tutto ciò che non soddisfa questi due requisiti non deve essere incluso.

Cosa fa Stash

Caratteristica	Cosa fa	Perché è importante
Foto del luogo	Si fotografa il cassetto, il ripiano o la scatola, non l'oggetto	I luoghi si ricordano visivamente; una foto del luogo è il ricordo stesso
Nome, stanza, punto esatto, nota	“Chiavi di casa · Corridoio · primo cassetto · nel piattino di ceramica a sinistra”	Quattro campi brevi sono meglio di un saggio in formato testo libero che non riuscirai mai a cercare bene
Note vocali, trascritte	Scrivi una breve nota; Stash la trasforma in testo ricercabile	Più veloce che digitare quando hai le mani occupate
Ricerca	Per nome dell'oggetto, stanza, nota o parole che hai registrato, con un filtro per gli oggetti che hanno delle foto	Il punto forte dell'app è proprio quel momento in cui hai bisogno di qualcosa
Camere	Esplora la tua casa una stanza alla volta	Perché quando non ti ricordi il nome, ma solo più o meno dove si trova
“Trovato!”	Basta un tocco quando lo hai recuperato	Chiude il ciclo
Promemoria	Gli articoli stagionali tornano a farsi vedere proprio quando ne hai bisogno	Pneumatici invernali, luci natalizie, attrezzatura da campeggio
Widget	Widget della schermata iniziale e della schermata di blocco	Due tocchi da “Dovrei ricordarmelo” a “Salvato”
Prima offline, poi sincronizza	Funziona anche senza segnale; si sincronizza tra iPhone e iPad se si dispone di un account	Nelle cantine e nei garage la ricezione è pessima
Aspetto	Chiaro, scuro o seguire il sistema	Sembra tranquillo anche alle 23:00
Esporta ed elimina	Esporta i tuoi stash; elimina il tuo account dalle Impostazioni	I tuoi dati rimangono di tua proprietà, e Apple richiede il secondo

Come appare

La direzione visiva è volutamente sobria: uno sfondo bianco sporco dai toni caldi, un verde bosco intenso, un unico accento color corallo, titoli in carattere serif e un semplice carattere sans-serif per tutto il resto. Le schermate dell’App Store raccontano la storia in sei titoli: Ogni cosa ha il suo posto. Trovalo. In pochi secondi. Conserva quel posto. La tua casa. Stanza per stanza. Ricorda i piccoli dettagli. Chiaro. Con qualsiasi luce.

Mostra immagine Stash su iPhone: salva il posto, ritrovalo in pochi secondi, sfoglia stanza per stanza. Chiaro o scuro, la stessa tranquillità.

Come vengono trattati i tuoi dati

Questo aspetto è più importante di qualsiasi altra funzionalità, quindi citerò testualmente l'informativa sulla privacy anziché parafrasarla:

• Modalità ospite: “Se non crei un account, le tue stanze, i tuoi oggetti, le tue foto e le tue note vocali rimangono sul tuo dispositivo e non vengono caricate.”
• Con un account: La sincronizzazione e il backup vengono eseguiti su Google Firebase (Autenticazione, Cloud Firestore, Cloud Storage, Cloud Functions e Cloud Messaging), con regole di sicurezza che garantiscono l'isolamento dei dati di ciascun utente.
• Nessun modello di business basato su di te: “Non mostriamo annunci pubblicitari, non effettuiamo attività pubblicitarie né di monitoraggio analitico, non creiamo profili utente e non vendiamo i tuoi dati.”
• Note vocali: Per trasformare una registrazione in testo ricercabile è possibile utilizzare il servizio di riconoscimento vocale integrato nel telefono (quello di Apple, su iOS).
• Cancellazione: Elimina il tuo account dalle Impostazioni o tramite un modulo web; le copie vengono rimosse dai backup entro 30 giorni.

Se avete letto il mio articolo su Perché il software "local-first" sta tornando in auge, ne riconoscerete la filosofia. L'app dovrebbe funzionare perfettamente anche senza il cloud. Il cloud è una comodità a cui si può scegliere di ricorrere.

Riquadro informativo

Nome sull’App Store	Stash — Trovalo subito
Sottotitolo	Trova tutto quello che hai messo via
Prima versione	23 settembre 2026 (versione 1.0)
Versione attuale	1.0.1, rilasciata il 2 ottobre 2026: “Nuovo design e correzioni di bug.”
Prezzo	Gratuito, senza acquisti in-app
Requisiti	iOS o iPadOS 16.4 o versioni successive; funziona anche sui Mac con Apple Silicon e su Apple Vision Pro come app per iPad
Dimensioni	Circa 64 MB
Categoria	Produttività (elencata anche nella sezione "Utilità")
Classificazione per età	4+
Sviluppatore	Graham Miranda UG (a responsabilità limitata), Blankenburg (Harz), Germania
Sito web	stash.grahammiranda.network, in dieci lingue, con un demo del browser
Scarica	Scarica Stash dall'App Store

Cosa non è (ancora) presente nell'app

Il sito web presenta una sezione intitolata Esplorazioni progettuali con tre idee: indicare il punto esatto su una foto, Trasloco veloce quando la posizione di un oggetto cambia, e scatole ed etichette così puoi vedere cosa c'è dentro una scatola senza aprirla. Il sito specifica chiaramente che “Queste idee fanno parte del concept interattivo, non sono funzionalità presenti nella versione disponibile sull’App Store.”

Mi piace questa distinzione e la consiglierei a chiunque stia sviluppando la propria prima app. Sperimentate liberamente con un prototipo. Pubblicate solo ciò che funziona. La pagina dell’App Store non dovrebbe mai promettere ciò che l’app non è in grado di fare. I revisori di Apple lo verificano, e lo stesso fanno gli utenti che vi assegnano una stella.

Perché questa è una buona struttura per una prima app

Se stai leggendo questo articolo perché vuoi creare la tua app, prendi spunto da Stash anche se non ti interessa la questione delle chiavi smarrite:

• Un ciclo principale. Prima salva, poi cerca. Tutto il resto è al servizio di questo ciclo.
• Dati generati dal dispositivo. Non serve alcun server fin dal primo giorno, quindi puoi lanciare il prodotto prima ancora di aver sviluppato il backend.
• Una manciata di vere funzionalità della piattaforma. La fotocamera, il microfono, le notifiche e i widget rappresentano la giusta dose di funzionalità “native” da imparare senza sentirsi sopraffatti.
• Un cloud opzionale. Le funzionalità relative agli account e alla sincronizzazione possono essere introdotte nella versione due senza dover riscrivere la versione uno.
• Niente feed, niente chat, niente pagamenti. Ognuno di essi costituisce un progetto a sé stante, con le proprie modalità di fallimento.

Un agente di intelligenza artificiale è in grado di costruire praticamente qualsiasi cosa tu riesca a descrivere. La difficoltà sta nel descrivere qualcosa di abbastanza piccolo da poter essere portato a termine.

---

Parte 2 — Lo stack del 2026 per sviluppare un'app da zero con l'IA

Tre strumenti, tre lavori distinti:

1. È Figma a determinare l'aspetto dell'app.
2. OpenCode stabilisce come viene svolto il lavoro: quali file leggere, quali comandi eseguire, cosa chiederti prima di compiere qualsiasi azione rischiosa.
3. È MiniMax M3.1 a pensare Dietro le quinte di OpenCode: pianificazione, scrittura del codice, analisi degli screenshot, risoluzione dei problemi.

Mantenere separati questi compiti è la decisione architettonica più importante di tutta questa guida, e non ha nulla a che vedere con il codice. Quando il mese prossimo uscirà un modello migliore (e ne uscirà sicuramente uno), basterà modificare una riga in un file di configurazione. Quando uscirà uno strumento di progettazione migliore, al tuo agente non importerà nulla. Nulla è incastrato in modo rigido.

Perché OpenCode v2 è l'agente

OpenCode è un agente di programmazione basato sull'intelligenza artificiale open source, distribuito sotto licenza MIT. Basta indicargli la cartella di un progetto, descrivere ciò che si desidera e lui lavora proprio come farebbe uno sviluppatore: legge il codice, elabora un piano, modifica i file, esegue i comandi, analizza gli errori, li corregge e prosegue il lavoro.

La versione 2.0.0, frutto di una ricostruzione completa, è stata rilasciata l'11 settembre 2026, e il team aveva già pubblicato la versione 2.0.22 entro il 2 ottobre. Ho trattato in modo approfondito la ricostruzione nel mio Analisi approfondita di OpenCode v2, quindi ecco solo ciò che conta per sviluppare un'app:

• È indipendente dal modello. Oltre 75 fornitori tramite Models.dev, oltre a modelli locali. MiniMax è integrato.
• Un unico server di background condiviso. L'interfaccia del terminale, l'applicazione desktop, l'interfaccia utente del browser e le estensioni dell'IDE visualizzano tutte le stesse sessioni.
• Autorizzazioni che funzionano come un firewall. Un elenco ordinato di regole di autorizzazione, richiesta e rifiuto in cui prevale l'ultima corrispondenza, quindi “non eseguire mai git push” e “non inviare mai all'App Store” sono una riga ciascuno.
• Annulla ogni operazione. Istantanee prima e dopo ogni fase della modellazione, con /annulla e /ripeti.
• Sottoagenti che puoi individuare e fermare, e le competenze che vengono caricate da .opencode, .claude e .agenti cartelle.
• Funziona all’interno di Xcode 27. Il nuovo Xcode di Apple accetta qualsiasi agente che utilizzi il protocollo Agent Client Protocol, e opencode acp fa proprio questo (come illustrato nella Parte 4).

La homepage conta ora 208.000 stelle su GitHub, 950 collaboratori e 16 milioni di sviluppatori al mese. Due avvertenze da tenere presenti, tratte dalla documentazione della v2: la condivisione delle sessioni non è ancora stata reintrodotta nella v2 e i plugin della v1 non vengono caricati.

Perché il MiniMax M3.1 è il modello ideale

La Parte 3 approfondisce l'argomento, ma in sintesi si tratta di tre proprietà che si rivelano particolarmente adatte alla creazione di app:

• Una finestra di contesto di 1.000.000 di token. Una piccola app, le relative note di progettazione, il file AGENTS.md e la documentazione pertinente rientrano tranquillamente in una sola sessione di lavoro, con ancora un po’ di margine.
• Legge immagini e video, non solo testo. Puoi allegare un frame di Figma, uno screenshot del simulatore o una registrazione dello schermo che mostra il bug.
• Cinque livelli di intensità, da basso a max, così il lavoro di pianificazione richiede una riflessione approfondita e quello tecnico viene svolto con rapidità.

Il rovescio della medaglia è che si tratta di un'anteprima senza benchmark pubblicati né prezzi per token, disponibile solo tramite l'abbonamento offerto da MiniMax. Tornerò su questo punto, perché non è un aspetto da sottovalutare.

Perché Figma è lo strumento di progettazione ideale

Figma rimane il punto di riferimento per la progettazione di app. Il piano Starter gratuito è sufficiente per progettare una prima app. Il suo variabili diventeranno i tuoi "design token", ovvero i colori, le spaziature e le dimensioni dei caratteri che garantiscono la coerenza su ogni schermata. E il suo Server MCP consente a un agente di codifica di leggere direttamente un fotogramma selezionato, il che è quanto di più vicino ci sia finora a una soluzione che permetta davvero di “farlo apparire così”.

In occasione di Config 2026 (dal 23 al 25 giugno a San Francisco), Figma ha inoltre reso disponibile Figma Agent per tutti i piani a pagamento in versione beta aperta, ha aggiunto una timeline per l’animazione e ha presentato in anteprima i “code layers”, che trattano il codice come un oggetto di primo livello sull’area di lavoro. Non serve nulla di tutto ciò per creare la tua prima app. È utile sapere in che direzione si sta andando.

E le “cose”

Le parti che nessuno inserisce nella miniatura:

Cosa	Opzioni	Trattato in
Framework dell'app	Expo (React Native) per iPhone e Android; SwiftUI con Xcode 27 solo per Apple; Flutter	Parte 7
Backend	Firebase è la soluzione predefinita più semplice per la gestione degli account, la sincronizzazione e l'archiviazione dei file	Parte 7
Controllo delle versioni	Git, sempre. GitHub o piattaforme simili come backup	Parti 4 e 7
Compilazioni e firma	Xcode su un Mac, oppure le build cloud EAS di Expo senza Mac	Parti 7 e 8
Test e rilascio	TestFlight e App Store Connect	Parte 8
Lancio	Una landing page, una demo, le pagine legali, l'ottimizzazione per l'App Store	Parte 9

Mostra immagine L'intero flusso di lavoro in un'unica pagina. Ti trovi a sinistra (il brief), al centro (dove esamini ogni modifica) e a destra (dove clicchi su “Invia per la revisione”).

Cosa significa oggi “da zero”

Ecco la scomoda verità sullo sviluppo di un’app con l’intelligenza artificiale nel 2026: l’agente si occupa della parte che prima era difficile, lasciandoti quella che è sempre stata difficile.

Possiedi	L'agente possiede
A cosa serve l'app e cosa non fa	Trasformare il tutto in file, componenti e funzioni
Le schermate e il sistema di progettazione	Attuarle, schermata per schermata
Il modello di dati: cosa viene archiviato, dove e per quanto tempo	Scrittura del codice relativo all'archiviazione, alla sincronizzazione e alla migrazione
L'informativa sulla privacy, le pagine legali e le risposte relative all'App Store	Verifica del codice per garantire l'accuratezza delle tue risposte
Test su dispositivi reali, con persone reali	Scrittura ed esecuzione di test automatizzati
Cliccando su “Invia”	Non premere mai “Invia”

Se quella tabella ti rende un po’ nervoso, bene. È proprio quel nervosismo a distinguere un’app pronta per il lancio da una cartella piena di codice che funziona solo a metà.

---

Parte 3 — MiniMax M3.1: una spiegazione sincera

Se cercate “MiniMax M3.1” in questo momento, troverete articoli che ne parlano con sicurezza, pur trattandosi di un modello che, a rigor di termini, non è ancora stato lanciato sul mercato. Ecco cosa esiste davvero, cosa potete usare oggi e cosa nessuno sa ancora.

Ciò che esiste, in ordine

• 1° giugno 2026: MiniMax M3. Un modello a peso aperto, nativamente multimodale, con una finestra di contesto di 1 milione di token, una struttura di tipo “mixture-of-experts” con circa 428 miliardi di parametri totali e circa 23 miliardi attivi per token, e il sistema di attenzione sparsa proprietario di MiniMax. L’ho confrontato con GLM-5.3-Flash per OpenCode ad agosto, in GLM-5.3-Flash vs MiniMax M3.
• Luglio: “M3.1” diventa un nome. I resoconti provenienti dalla Conferenza mondiale sull’intelligenza artificiale di Shanghai hanno descritto un modello M3.1 con un contesto di un milione di token e capacità multimodali più avanzate. Non sono stati forniti né il nome del modello, né l’ID del modello, né il prezzo.
• 23 settembre: una modella misteriosa. Un modello anonimo denominato “Space Bunny Alpha” è apparso su OpenRouter e su OpenCode come anteprima gratuita, con un contesto di 1 milione e un ragionamento regolabile. L’analisi indipendente delle impronte digitali del tokenizzatore ha indicato MiniMax. MiniMax non ha confermato nulla, e la corrispondenza del tokenizzatore costituisce un indizio riguardo a una famiglia di modelli, non una prova.
• 27 settembre: Anteprima di MiniMax M3.1-Flash. Il primo modello con il marchio M3.1 accessibile a tutti, lanciato nell’app di programmazione di MiniMax, MiniMax Code, e tramite il suo abbonamento alla programmazione. MiniMax lo descrive come un modello per “Sviluppo quotidiano, veloce, affidabile e pronto per l’uso pratico, dalle rapide correzioni di bug alle funzionalità complete.”
• 30 settembre: il Piano M. MiniMax Code 3.1.0 è stato lanciato con un nuovo abbonamento denominato "M Plan", che sostituisce il "Token Plan" per i nuovi clienti a parità di prezzi.

La versione completa dell'M3.1 prevista per l'estate non è ancora stata rilasciata. Quando a ottobre 2026 si parlerà di “M3.1”, ci si riferirà all'M3.1-Flash-Preview, e lo stesso farò anch'io nel resto di questo articolo.

Mostra immagine Tutto ciò che è descritto in questo articolo è accaduto nell'arco di quattro mesi e mezzo, e sette di queste nove date ricadono nelle ultime cinque settimane.

MiniMax M3 vs M3.1 - Anteprima Flash

	MiniMax M3	MiniMax M3.1 - Anteprima Flash
Pubblicato	1° giugno 2026	27 settembre 2026
Stato	Disponibile al pubblico	Anteprima
ID modello	MiniMax-M3	MiniMax-M3.1-Anteprima Flash
Finestra di contesto	1 milione di token	1.000.000 di token
Input	Testo, immagine, video	Testo, immagine, video
Riflessioni	Può essere attivato o disattivato	Sempre attivo. Cinque livelli di intensità: basso, medio, alto, xalto, max (impostazione predefinita max)
Pesi liberi	Sì, ai sensi della licenza MiniMax Community	Senza pesi, senza scheda del modello
Prezzo a consumo	$0,30 per milione di token in ingresso, $1,20 in uscita, $0,06 in cache; il doppio se l'ingresso supera i 512K	Non pubblicato. Solo per abbonati
Dove è possibile utilizzarlo	API MiniMax, OpenRouter, OpenCode Go, Ollama Cloud e molti altri host	Solo abbonamento al Piano M e codice MiniMax
Benchmark pubblicati	Sì, da MiniMax e da schede indipendenti	Nessuno
Architettura	~428 miliardi in totale, ~23 miliardi attivi, MoE sparsa	Non divulgato
In OpenCode v2	Integrato, tramite diversi fornitori	Integrato tramite “MiniMax Token Plan (minimax.io)”

Istantanea tratta dalla documentazione di MiniMax e da Models.dev del 5 ottobre 2026. Le anteprime sono soggette a modifiche senza preavviso; si raccomanda di verificare prima di fare affidamento su qualsiasi riga.

Una cosa che vale la pena approfondire: i documenti dicono che il pensiero non può essere disattivato. Invia thinking.type: "disabled" o uno sforzo di nessuno, e l'API restituisce un errore 400 che, in sostanza, indica che il modello “richiede un pensiero flessibile.” Quello che puoi controllare è quanto intensamente ragiona.

Come ottenerlo: il Piano M

La documentazione di MiniMax è molto chiara riguardo all'accesso: “MiniMax-M3.1-Flash-Preview è disponibile, per il momento, solo tramite M Plan e MiniMax Code.”

Livello M del piano	Prezzo	Cosa è incluso
Vai	$22/mese	M3.1-Flash-Preview, oltre ai modelli audio e video di MiniMax
Esplora	$55/mese	Tutto ciò che riguarda Go, oltre al modello video H3
Costruire	$132 al mese	Tutto ciò che offre Explore, con il pacchetto dati più ampio

Alcuni dettagli che contano più dei prezzi indicati:

• Offerta di lancio: 50% di sconto sul primo mese con fatturazione mensile, fino al 14 ottobre 2026. È esclusa la fatturazione annuale. Dopo il primo mese, l’abbonamento si rinnova a prezzo pieno, a meno che non si disattivi il rinnovo automatico.
• Settimana gratuita: Tutti gli abbonati hanno avuto accesso illimitato a M3.1-Flash-Preview dal 1° al 7 ottobre (ora cinese). Se stai leggendo questo messaggio dopo il 7, l'offerta è ormai scaduta.
• È una chiave di abbonamento, non una chiave API. La documentazione di MiniMax indica chiaramente che le chiavi di abbonamento e le chiavi API pay-as-you-go non sono intercambiabili. Dovrai incollare la chiave di abbonamento in OpenCode.
• Quote, non misurazione. L'utilizzo è limitato a finestre mobili di cinque ore e settimanali, e la quota non utilizzata non viene riportata al periodo successivo. Per i livelli equivalenti del Token Plan, le indicazioni fornite da MiniMax erano di circa tre-quattro, quattro-cinque e sei-sette agenti attivi contemporaneamente.
• Abbonati al Piano Token esistente mantengono il loro piano. I nuovi clienti acquistano il Piano M.
• Strumenti supportati Nella pagina dedicata al piano M di MiniMax figurano Claude Code, Codex, Cursor, OpenCode, Hermes Agent e OpenClaw.

Codice MiniMax È un agente desktop per macOS e Windows, dotato di una modalità di programmazione e di una modalità “lavoro” dedicata alla ricerca e alla gestione dei documenti, oltre a una versione da riga di comando. È un ottimo modo per provare il modello. Utilizzo OpenCode perché non mi vincola a nessun produttore di modelli in particolare, il che è proprio il punto centrale della Parte 2.

Perché è adatto allo sviluppo di app

• La finestra di contesto cambia il tuo modo di lavorare. Una piccola app mobile richiede poche migliaia di righe di codice, forse qualche decina di migliaia. Con un milione di token, l’agente può contenere contemporaneamente l’intero codice sorgente, il file AGENTS.md, il modello di dati e una parte della documentazione della piattaforma. Meno momenti del tipo “Non ricordo più cosa avevamo deciso”. (La guida OpenCode di MiniMax limita la finestra a 512K nella sua configurazione di esempio, che io consiglierei di copiare. Contesti più brevi significano risposte più veloci.)
• Mostralo, non descriverlo. Dato che supporta immagini e video, puoi inserire un frame esportato da Figma, uno screenshot dal simulatore iOS o una registrazione dello schermo che mostra il bug in cui la tastiera copre il pulsante “Salva”. Già solo quest’ultima opzione ti fa risparmiare un’enorme quantità di digitazione.
• L'impegno è come una manopola, non come un interruttore. max per pianificare una funzionalità o risolvere un bug di sincronizzazione. basso o medio per rinominare elementi, scrivere test e tradurre stringhe. La Parte 4 illustra come configurare tali impostazioni per ciascun agente.
• Il costo è fisso. Per chi sviluppa da solo, una fattura mensile prevedibile è preferibile al dover tenere d’occhio un contatore a token durante una lunga sessione di debug.

Uno dei primi test indipendenti ha rilevato una velocità compresa tra circa 90 e 110 token al secondo il primo giorno. Si tratta di una singola misurazione, non di un benchmark, ma è in linea con il nome “Flash”.

Quello che nessuno sa ancora

Questa è la parte che la maggior parte degli articoli sull’M3.1 tralascia:

• Non ci sono parametri di riferimento. Non da MiniMax, né dai forum indipendenti, perché un modello accessibile solo tramite l’abbonamento di una singola azienda è difficile da testare in modo indipendente. Il punto di riferimento sei tu. Assegna al modello un compito reale tratto dal tuo progetto, affida lo stesso compito a un modello di cui ti fidi già e confronta i risultati.
• Non esiste un prezzo per singolo token. Va bene nell'ambito di un abbonamento. Il problema sorge se si vuole eseguire il modello in CI o in un prodotto, dove è necessario sapere quanto costa un milione di token.
• È un'anteprima. Può cambiare comportamento, essere rinominato o sostituito dalla versione completa M3.1 senza preavviso. Conserva l'ID del modello in un unico file di configurazione, in modo che sostituirlo richieda solo una riga di modifica.
• Il pensiero non si ferma mai. Anche le richieste più banali comportano un certo sforzo di elaborazione. Riducete lo sforzo richiesto per i compiti di minore entità.
• È disponibile esclusivamente presso MiniMax. Al momento della stesura di questo articolo, il servizio non è disponibile su OpenRouter, Ollama Cloud né OpenCode Go. I prompt e il codice vengono inviati ai server di MiniMax, quindi, se si lavora per conto di clienti soggetti a rigide norme sulla protezione dei dati, si consiglia di leggere prima i termini di servizio di MiniMax oppure di mantenere il progetto su modelli locali.

Non scaricare “MiniMax M3.1”

A meno di un giorno dal lancio, sono comparsi su GitHub dei repository che non hanno nulla a che vedere con MiniMax, che promettevano un “download ufficiale gratuito” di M3.1-Flash sotto forma di file zip per Windows da “estrarre ed eseguire”. Non esistono file M3.1 da scaricare, e il codice di MiniMax è disponibile solo sul sito ufficiale di MiniMax. Considerate qualsiasi “download di M3.1” come malware fino a prova contraria.

Quando è preferibile utilizzare invece MiniMax M3

Utilizzo M3 se avete bisogno di una delle funzionalità che la versione di anteprima non offre: tariffazione pay-as-you-go, OpenWeights che potete ospitare autonomamente, oppure accesso tramite OpenCode Go, Ollama Cloud o OpenRouter. È anche la scelta più sicura per qualsiasi processo automatizzato, poiché il suo prezzo e il suo funzionamento sono documentati. Se desiderate una panoramica più ampia delle alternative, il mio MiniMax M3 vs Kimi K2.7 Code vs Nemotron 3 Ultra Il confronto abbraccia l'intero settore.

---

Parte 4 — Configurazione di OpenCode v2 con MiniMax M3.1, passo dopo passo

Questa è la configurazione che consiglierei a un amico. Ci vogliono circa quindici minuti, la maggior parte dei quali trascorsi ad aspettare che i file vengano scaricati.

Fase 0 — Cosa ti serve prima di tutto

• Un Mac con Apple Silicon, se desideri compilare ed eseguire app per iPhone in locale. Xcode 27 (rilasciato il 14 settembre 2026) non supporta più i Mac con processori Intel e richiede macOS Tahoe 26.4 o versioni successive. Se scegliete la strada di Expo nella Parte 7, potrete compilare app iOS nel cloud da Windows o Linux, ma avrete comunque bisogno di un vero iPhone su cui testarle.
• Git. Le istantanee, i rami e la tua stessa sanità mentale dipendono tutti da questo.
• Node.js (LTS) se utilizzerai Expo.
• Un abbonamento al piano MiniMax M (Parte 3).
• Un terminal moderno. Il Terminale di macOS va bene; Ghostty, WezTerm e Kitty sono migliori.

Passaggio 1 — Installare OpenCode v2

bash

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

opencode --version # dovrebbe visualizzare 2.0.x
opencode service status     # il server in background condiviso dovrebbe essere in esecuzione

Vuoi anche l'app per desktop? Scaricala da opencode.ai/download, oppure su un Mac esegui brew install --cask opencode-desktop. Il terminale e l'app desktop condividono lo stesso server, quindi una sessione avviata su uno dei due viene visualizzata anche sull'altro.

Un aspetto da tenere d’occhio: la guida OpenCode di MiniMax riporta ancora l’URL del programma di installazione della versione 1 (opencode.ai/install). Utilizza il /v2/install quello sopra.

Fase 2 — Ottieni la chiave di abbonamento al piano M

Iscriviti alla piattaforma MiniMax e crea un chiave di abbonamento nella console. Non si tratta di una chiave API a consumo: sono prodotti diversi e solo la chiave di abbonamento ti consente di accedere a M3.1-Flash-Preview.

Considera la chiave come una password. Non inserirla mai in una chat, in uno screenshot o in un repository Git.

Fase 3 — Collegare MiniMax all’interno di OpenCode

bash

cd ~/code/my-app
opencode

Quindi, all'interno di OpenCode:

1. Tipo /connetti e cerca Piano MiniMax Token (minimax.io). Il fornitore ha mantenuto il suo vecchio nome; accetta le chiavi M Plan.
2. Incolla la tua chiave di abbonamento.
3. Tipo /modelli e scegliere MiniMax-M3.1-Anteprima Flash.

Ecco fatto. Il catalogo dei modelli di OpenCode (Models.dev) include già il modello con il suo contesto da 1.000.000 di token, gli input di immagini e video e i cinque livelli di sforzo, quindi non serve un file di configurazione per iniziare. Se non compare in /modelli, aggiorna prima OpenCode; la configurazione descritta al punto 4 lo aggiunge anche manualmente.

Due alternative: Accesso tramite OpenCode fa la stessa cosa dal terminale e la procedura guidata di configurazione di MiniMax (npx -y mmx-cli@latest agent setup) installa e configura OpenCode per te, impostando M3 come impostazione predefinita. Successivamente, passa a M3.1 con /modelli. Gli account sulla piattaforma cinese di MiniMax utilizzano la versione “(minimax.cn)” del provider.

Passaggio 4 — Aggiungere una configurazione di progetto

Le impostazioni predefinite funzionano, ma un progetto di app merita un file di configurazione che svolga tre funzioni: indirizzi ogni agente al giusto livello di impegno, imposti autorizzazioni che impediscano all’agente di compiere azioni irreversibili e colleghi i tuoi server MCP. Salva questo file come opencode.jsonc nella directory principale del progetto:

jsonc

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

  // Modello predefinito per le nuove sessioni
  "model": "minimax-coding-plan/MiniMax-M3.1-Flash-Preview",

  "providers": {
    "minimax-coding-plan": {
 "models": {
 "MiniMax-M3.1-Flash-Preview": {
 // L'esempio OpenCode di MiniMax limita la finestra a 512K
          "limit": { "context": 524288 },

 // Il ragionamento è sempre attivo e il valore predefinito è "max".
 // Queste varianti inviano il campo output_config.effort documentato da MiniMax.
          "varianti": [
 { "id": "quick", "corpo": { "output_config": { "effort": "low" } } },
            { "id": "steady", "body": { "output_config": { "effort": "medium" } } },
            { "id": "careful", "body": { "output_config": { "effort": "high" } } }
 ]
 }
 }
    }
  },

  "agents": {
    // La pianificazione riceve il massimo sforzo predefinito: un piano sbagliato costa di più in seguito
    "plan":    { "model": "minimax-coding-plan/MiniMax-M3.1-Flash-Preview" },
    // Generazione: approfondita, ma più veloce rispetto a "max"
    "build":   { "model": "minimax-coding-plan/MiniMax-M3.1-Flash-Preview#careful" },
    // Ricerca in sola lettura nel codice sorgente: la velocità conta più della profondità
    "explore": { "model": "minimax-coding-plan/MiniMax-M3.1-Flash-Preview#quick" }
  },

  "permissions": [
    { "action": "shell", "resource": "*", "effect": "ask"   },
    { "action": "shell", "resource": "git status *", "effect": "allow" },
    { "azione": "shell", "risorsa": "git diff *", "effetto": "consenti" },
    { "azione": "shell", "risorsa": "git log *", "effetto": "consenti" },
    { "azione": "shell", "risorsa": "npm test *", "effetto": "consenti" },
    { "azione": "shell", "risorsa": "npx tsc *", "effetto": "consenti" },
    { "azione": "shell", "risorsa": "npx expo lint *",    "effetto": "consenti" },
    { "azione": "shell", "risorsa": "git push *", "effetto": "negare"  },
    { "action": "shell", "resource": "eas submit *", "effect": "deny"  },
    { "azione": "shell", "risorsa": "firebase deploy *",  "effetto": "negare"  }
  ],

  "mcp": {
    "servers": {
 // Server MCP desktop di Figma (Parte 6). Locale, quindi senza OAuth.
      "figma-desktop": {
 "type": "remote",
 "url": "http://127.0.0.1:3845/mcp",
 "oauth": false
 },
      // Server MCP ufficiale di Firebase. Chiede conferma prima di apportare modifiche al progetto.
      "firebase": {
 "type": "local",
 "command": ["npx", "-y", "firebase-tools@latest", "mcp"]
 }
    }
  }
}

Alcune note per farti capire cosa stai incollando:

• Le regole relative ai permessi vengono lette dall'alto verso il basso e prevale l'ultima corrispondenza. Ogni comando della shell richiede prima un'autorizzazione; i comandi innocui come Git e test possono essere eseguiti liberamente, mentre tre operazioni vengono negate categoricamente: il push del codice, l'invio all'App Store e la distribuzione del backend. Queste operazioni le esegui tu stesso, di proposito.
• Sostituisci i comandi consentiti con quelli della tua toolchain. Se stai sviluppando in modo nativo con Xcode anziché con Expo, sostituisci il npx righe con i comandi di test e lint.
• Se una variante sembra non avere alcun effetto, correre /modelli to confirm the variant names, and check the request in OpenCode’s logs. MiniMax uses max when no effort is sent, so the worst case is a slower answer, not a broken one.
• Older v1-style examples still work. MiniMax’s guide uses the v1 provider key; OpenCode v2 reads supported v1 settings without rewriting your file.

Step 5 — Write an AGENTS.md before you write a line of code

OpenCode reads AGENTS.md at the start of every session. It’s the single most effective habit in AI-assisted development, and my vibe coding guide goes into the whole system. For an app, it should hold the product’s rules as well as the build commands. Here’s the shape of one for an app like Stash:

markdown

# Notes for coding agents (example for a Stash-style app)

## What this app is
Stash remembers where things are. Photo of the spot + name + room = found in seconds.
If a change doesn't make saving or finding faster, it doesn't belong.

## Non-negotiables
- Offline first. Every feature works with no network. Sync is a bonus.
- Guest mode never uploads anything.
- No analytics, ads or tracking SDKs. Ask before adding ANY dependency.
- No secrets in the app bundle. Privileged work happens in Cloud Functions.
- Accessibility: Dynamic Type, VoiceOver labels, 44 x 44 pt touch targets.
- Light and dark mode for every screen.

## Design
- Tokens live in src/theme/tokens.ts. Never hard-code a colour or a font size.
- When implementing a Figma frame: get_design_context, then get_variable_defs,
  then get_screenshot to compare your result.

## Commands
- Install: npm install
- Run: npx expo start
- Test: npm test
- Types: npx tsc --noEmit
- Lint: npx expo lint

## Definition of done
- Tests, types and lint pass
- Works in airplane mode
- Works in light and dark mode, at the largest text size
- No new warnings in the console

Step 6 (optional) — Run OpenCode inside Xcode, and give it Xcode’s tools

Xcode now has agentic coding built in, and it accepts outside agents in two different ways. Both are worth knowing if you build natively.

OpenCode as an agent inside Xcode (ACP). Xcode can host any agent that speaks the Agent Client Protocol, and OpenCode does, through opencode acp.

1. Sign in from the terminal first: Accesso tramite OpenCode.
2. Esegui which opencode and copy the absolute path. Xcode doesn’t expand ~ or read your shell’s PATH.
3. In Xcode, choose Xcode → Settings → Intelligence, then under Agents click Add an Agent.
4. Paste the path as the command and add acp as the argument.
5. Start a new conversation in Xcode’s Intelligence sidebar and pick OpenCode.

You can’t switch models from Xcode’s interface, so set your default model in opencode.jsonc first.

Xcode’s tools inside OpenCode (MCP). The other direction is often more useful: OpenCode stays in your terminal, but it can build your project, run tests and render SwiftUI previews through Xcode.

1. In Xcode → Settings → Intelligence, under Model Context Protocol, turn on Allow external agents to use Xcode tools.
2. Add Xcode’s bridge to OpenCode: opencode mcp add xcode -- xcrun mcpbridge
3. Open your project in Xcode before you prompt. The bridge talks to the running Xcode, and Xcode tells you when an external agent connects.

Which effort level for which job

Task	Agent	Effort
Planning a feature, the data model or the sync logic	plan	max (the default)
Implementing a screen from a Figma frame	build	alto
Fixing a bug with a clear way to reproduce it	build	alto; max if it’s a sync or race-condition bug
Writing tests, renaming, small refactors	build	medio
Searching the codebase, reading docs	explore	basso
Copy changes and string translations	build	basso o medio

Higher effort means more thinking tokens and more waiting, in MiniMax’s own words. Most of the time in an agent loop is spent waiting, so match the effort to the risk.

---

Parte 5 — Progettare la propria app in Figma anche se non si è designer

You don’t need to be a designer to design a good first app. You need a small number of decisions, made once, written down where the agent can read them.

Start with words, not rectangles

Before you open Figma, write three things in a plain text file:

1. The promise, in one sentence. For Stash: the fastest way to remember where you put things.
2. Three user stories. “I put my passport in the desk drawer and want to find it in March.” “I’m in the garage, I have no signal, and I want to log where the drill went.” “I want the Christmas lights to remind me they exist in November.”
3. The screen list. Stash ships with four tabs (Home, Search, Rooms and Settings) plus an Add screen and an item detail view. Six screens. That’s a whole app.

Then give that file to the plan agent and ask it to argue with you: “Read this brief. List the user flows, the edge cases I haven’t thought about, and the screens I’m missing. Then tell me what I should cut.” This is exactly the kind of boring, thorough work that max effort is for: the “what happens when the user denies camera access?” kind of question. Ten minutes of it can save you a redesign.

Set up variables before you draw anything

Figma variabili are named values: colours, spacing, corner radii, sizes. Set them up first, with a light and a dark mode for the colours, and your app will be consistent by default.

They matter twice as much with an AI agent. When the agent implements a screen, Figma’s MCP server can hand it the exact variables used in that frame (the get_variable_defs tool), so it writes colors.green instead of guessing at a hex code from a screenshot.

Here’s the palette from Stash’s public design concept:

Token	Valore	Used for	Contrast on Paper
Paper	#F6F4EE	App background	—
Surface	#FFFCF7	Cards and fields	—
Ink	#172E2A	Primary text	13.1 : 1
Green	#23594C	Buttons, selected states, brand	7.3 : 1
Green soft	#E1EBE4	Quiet highlights	—
Coral	#D46F4F	Accent dot, one word in a headline	3.1 : 1
Coral soft	#F8E8DE	Warm highlights	—
Muted	#6E7D76	Secondary text	3.9 : 1
Line	#DEDFD7	Dividers and borders	—

Headlines use a serif; everything else uses the system’s sans-serif. That’s the whole type system.

The contrast column is the part to copy. Ink and green clear the 4.5 : 1 that WCAG asks for normal text with a lot to spare. Coral, at about 3 : 1, only passes for large text, so it belongs on big headline words and small accent dots, which is exactly where Stash uses it. The muted grey sits at 3.9 : 1, so it belongs on larger captions rather than small print. Check this in Figma before the agent copies a token into fifty places.

Mostra immagine Nine colours, two typefaces, a handful of components. A design system doesn’t have to be big to be useful; it has to be written down.

Build five components, not fifty

For a first app you need roughly five reusable components: a button (primary and quiet), a text field, un card, un list row or tile (Stash’s room tile) and the tab bar. Build them as Figma components with variants for their states: default, pressed, disabled, error.

Apple publishes official iOS design resources for Figma. Use them as reference for system pieces such as sheets, alerts and the keyboard rather than redrawing them. Your agent will use the real system components anyway.

Design the screens the agent will forget

AI agents are very good at the happy path and quietly terrible at everything around it. Design these on purpose:

• Empty states. The first launch, a room with nothing in it (Stash’s rooms grid shows “No items yet”), a search with no results.
• Huge text. Set your phone to the largest Dynamic Type size and look at your layouts. Long item names wrap. Buttons grow.
• Dark mode, for every screen, not just the pretty ones.
• No photo. What does an item card look like without one?
• Permission denied. The user said no to the camera. Now what?
• Non connesso. What does “saved, will sync later” look like?

Let AI help inside Figma, but keep the source of truth yours

Figma’s own AI has grown up fast this year. The Figma Agent went into open beta for all paid plans at Config 2026, and it’s free during the beta for Full seats. It can generate and remix designs inside your file. Figma Make turns prompts into clickable prototypes. Weave tools now run image jobs such as background swaps without leaving the design file.

They’re excellent for exploring. Generate ten variations of a home screen, steal the one good idea, then rebuild it with your own components and variables. If generated layers become your source of truth, your design system drifts, and the coding agent inherits the drift.

Stash does something I’d recommend to anyone: its experimental ideas live in a separate, clearly labelled interactive concept on the website, not in the app. You get to explore in public without promising features that don’t exist.

Prototype, then watch three people use it

Wire the screens into a clickable prototype, hand your phone to three people, and ask each of them to save something and find it again. Don’t explain anything. Watch where they hesitate. Three people will find most of the problems that matter, and fixing a frame in Figma takes minutes, while fixing it after the agent has built it takes a session.

---

Parte 6 — Collegamento di Figma a OpenCode: il problema dell’MCP

This is the part of the workflow that feels like the future when it works: select a frame in Figma, tell the agent to build it, and it reads the real layout, the real variables and the real components instead of squinting at a screenshot.

It’s also the part where most guides skip a detail that will cost you an evening.

What the Figma MCP server gives an agent

MCP, the Model Context Protocol, is the standard way for an AI agent to use outside tools. Figma’s MCP server exposes a set of tools; these are the ones that matter for building an app:

Strumento	What it returns
get_design_context	The design context for the selected layer or frame. Figma calls it the default starting point
get_variable_defs	The variables and styles used in the selection: your colours, spacing, type
get_screenshot	An image of the selection, so the agent can compare its result
get_metadata	A sparse XML outline of the layer structure
get_code_connect_map	Mappings between Figma components and your real code components
create_design_system_rules	A prompt that writes a rules file describing your design system for the agent

There are also scrivere tools (use_figma to create and edit native Figma content, generate_figma_design to turn a running web UI into Figma layers, and more), but nearly all of them are available only on the remote server. Hold that thought.

Remote server vs desktop server

Figma runs two versions of the server:

• The remote server at https://mcp.figma.com/mcp. Figma recommends it, it doesn’t need the desktop app, it works on every seat and plan, and it has the full tool set including writing to the canvas.
• The desktop server at http://127.0.0.1:3845/mcp, which runs inside the Figma desktop app. It requires a Dev or Full seat on a paid plan, and it’s mostly read-only.

The catch: OpenCode isn’t allowed on the remote server yet

The remote server only accepts approved clients during its beta. Figma’s list includes Claude Code, Codex, Cursor, VS Code, Gemini CLI, Kiro, Warp and Xcode, among others. OpenCode isn’t on it. Try to connect, and the registration step fails with an HTTP 403.

This isn’t a bug on OpenCode’s side. In May, a Figma staff member explained on Figma’s forum that the connection scope is “intentionally gated to supported clients while we’re in beta”, and pointed people to the desktop server, which “bypasses the OAuth issue and the allowlist entirely.” OpenCode’s team has an open pull request to add a registered Figma client, still waiting on Figma’s approval at the time of writing.

You’ll find posts suggesting you borrow another app’s OAuth client ID to sneak past the allowlist. Don’t. Use the desktop server and wait for official support.

Mostra immagine Three routes from Figma to OpenCode. Only one of them is a dead end, and it’s the one Figma recommends for everyone else.

Setting up the desktop server with OpenCode

1. Install the Figma desktop app and sign in with an account that has a Dev or Full seat on a paid plan. On the Professional plan a Dev seat costs $12 a month and a Full seat $16.
2. Open your design file and switch to Dev Mode con Shift + D.
3. In the inspect panel, find the Server MCP section and click Enable desktop MCP server.
4. Add it to OpenCode. Either use the figma-desktop block from the config in Part 4, or run:

bash

   opencode mcp add figma-desktop --url http://127.0.0.1:3845/mcp

If OpenCode tries to start an OAuth sign-in for it, set "oauth": false on the server in opencode.jsonc. The desktop server is local and doesn’t need one. 5. Check it’s connected with opencode mcp list.

Keep the Figma desktop app open while you work. If Figma is closed, the agent’s Figma tools simply disappear.

Mind the rate limits

On the Professional plan, Dev and Full seats get up to 200 MCP tool calls a day and 10 a minute. Organization seats get 15 a minute; Enterprise gets 600 a day and 20 a minute. View and Collab seats are capped at a handful of calls a month. Two hundred sounds like a lot until an eager agent calls get_screenshot after every small edit, so tell it, in AGENTS.md, to compare against the screenshot once per screen rather than once per change.

The prompt pattern that works

Select a frame in Figma, then in OpenCode:

Implement the selected Figma frame as the Add Item screen. First call get_design_context and get_variable_defs. Use only tokens from src/theme/tokens.ts; if a value is missing, add a token rather than hard-coding it. Reuse our existing Button, TextField and Card components. When you’re done, call get_screenshot and list every visible difference between the frame and what you built. Then fix them.

Two habits make this far more reliable:

• Esegui create_design_system_rules once at the start of the project and save the result as a section of your AGENTS.md or as a skill in .opencode/skills/. From then on, every session knows your design rules without being told.
• One frame per request. “Build the whole app from this file” produces a whole app that’s a bit wrong everywhere. One screen at a time produces screens that are right.

No paid seat? The free route

You can do all of this without MCP. M3.1 reads images, so export each frame as a PNG at 2x, attach it to your prompt, and paste your colour and spacing values into a tokens file in the repository. You lose the exact layer data and the variable lookups, so expect more back and forth on spacing. For a first app with six screens, it’s entirely workable, and it costs nothing.

---

Parte 7 — Come creare un'app da zero, fase per fase

This is the “from scratch” part. Seven phases, in the order I’d do them, with the prompts and the traps.

Phase 0 — Pick your framework

You have three sensible choices in 2026, and the right one depends on where your app needs to run.

	SwiftUI + Xcode 27	Expo SDK 56 (React Native)	Flutter
Runs on	iPhone, iPad, Mac, Apple Watch, Vision Pro	iPhone, iPad, Android, web	iPhone, iPad, Android, web, desktop
Language	Swift 6.4	TypeScript	Dart
Need a Mac?	Sì	Not to build or submit: Expo’s EAS service builds iOS apps in the cloud	Yes, for iOS builds, unless you use cloud CI
Widget	Native WidgetKit	Stable for iOS since SDK 56	Through plugins plus native WidgetKit code
Agent-friendliness	Very good, especially with Xcode’s own MCP tools; the Swift compiler catches a lot	Very good: TypeScript types, fast reloads and a huge amount of public example code	Buono
Ideale per	Apple-only apps that want every native feature	One codebase for iPhone and Android, built by one person	Identical-looking UI on every platform

My rule of thumb:

• Apple only, and you want the platform’s newest toys (Apple’s on-device AI frameworks, Live Activities, deep system integration): SwiftUI, with OpenCode running inside Xcode or using Xcode’s tools (Part 4).
• iPhone and Android from one codebase, and you’re one person: Expo. SDK 56 shipped on 21 May 2026 with React Native 0.85, moved its minimum to iOS 16.4, made its SwiftUI and Jetpack Compose UI layer production-ready, and promoted iOS widgets to stable. Its EAS service builds and submits iOS apps from Windows or Linux, and the free tier includes 15 iOS and 15 Android builds a month.
• Flutter if you or your team already know it.

Stash’s App Store listing requires iOS 16.4, and its privacy policy already covers an Android build, so it’s clearly meant to travel beyond the iPhone.

Phase 1 — Scaffold, commit, brief

Create the empty project and make sure it runs before the agent touches it.

Expo:

bash

npx create-expo-app@latest my-app
cd my-app
npx expo start        # open it on your phone with Expo Go, or in the iOS Simulator

SwiftUI: in Xcode, choose File → New → Project → iOS → App, select SwiftUI, and run it once in the Simulator.

Then add the files from Part 4 (AGENTS.md e opencode.jsonc), plus two more:

• ROADMAP.md: the list of vertical slices below, with checkboxes. The agent reads it, ticks things off, and you always know where you are.
• src/theme/tokens.ts (or a Swift equivalent): your Figma variables as code. Copy them in by hand, or let the agent pull them with get_variable_defs.

Commit. If Git isn’t already set up, git init first. From now on, every working step ends with a commit.

Phase 2 — Plan the data model before any screens

The data model is the decision that’s most expensive to change later, because once real users have real data, every change needs a migration. Use the plan agent at full effort:

You’re planning a “where did I put it?” app. Read AGENTS.md, ROADMAP.md and the brief. Propose the data model, the local storage approach and the folder structure. The app must work fully offline with no account; accounts and sync come later and must not require rewriting the local layer. List the trade-offs, the migrations we’d need if we add sync later, and anything in the brief that’s ambiguous. Don’t write code yet.

For an app shaped like Stash, you’ll end up with something like this (an illustration, not Stash’s actual schema):

ts

type Room = {
  id: string;
  name: string;            // "Hallway"
  createdAt: number;
  updatedAt: number;
};

type Item = {
  id: string;
  name: string;            // "House keys"
  roomId: string;
  spot?: string;           // "Top drawer"
  note?: string;           // "In the ceramic dish on the left"
  photoPath?: string;      // local file first; cloud copy only with an account
  voiceNotePath?: string;
  transcript?: string;     // what makes voice notes searchable
  remindAt?: number;       // seasonal reminder
  createdAt: number;
  updatedAt: number;       // used to resolve sync conflicts
  deletedAt?: number;      // soft delete, so deletions can sync too
};

Read the plan properly. Argue with it. This is the cheapest moment in the whole project to change your mind.

Phase 3 — Build in vertical slices

A vertical slice is one feature that works end to end, from the screen to storage and back, before you start the next. Here’s the order I’d build a Stash-like app in:

1. Add an item: name, room, spot and note, saved locally.
2. Photos: camera and photo library, stored as local files.
3. Casa: recently saved items and the rooms row.
4. Ricerca: by name, room and note, plus a “with photos” filter.
5. Item detail and “Found it”.
6. Camere: the grid, plus adding, renaming and deleting rooms.
7. Voice notes: record, transcribe, make the transcript searchable.
8. Promemoria: local notifications for seasonal items.
9. Widget for the Home Screen and Lock Screen.
10. Impostazioni: appearance, export and, once accounts exist, account deletion.
11. Accounts and sync: version two material, if you’re sensible.

Each slice follows the same loop:

1. Plan: the plan agent writes a short plan for the slice. You correct it.
2. Design: select the Figma frame, then use the prompt pattern from Part 6.
3. Build: the build agent implements, runs the tests and fixes what fails.
4. Run it yourself, on a device, and try to break it.
5. Read the diff. Every line that’s going to ship.
6. Commit, tick the box in ROADMAP.md, start a fresh session for the next slice.

That fresh session matters more than it looks. Even with a million tokens of context, a long session accumulates stale assumptions. A clean start that re-reads AGENTS.md and ROADMAP.md is often smarter than a long one.

Phase 4 — Offline first, then sync

Stash’s privacy policy describes a pattern I’d copy for almost any personal app: without an account, everything stays on the device; with an account, data syncs through a backend. It makes the first version simpler, App Review easier and your users’ trust stronger.

The order of operations:

1. Make the local layer complete first. SQLite through Expo’s library, or SwiftData in a native app. Photos and recordings live as files on the device.
2. Add accounts with Firebase Authentication. Email sign-in is enough to start. If you add Google or another third-party login as the main way to sign in, Apple’s guideline 4.8 requires an equivalent privacy-focused option such as Sign in with Apple.
3. Sync item records to Cloud Firestore, and photos and voice notes to Cloud Storage, each under the user’s own path.
4. Do privileged work on the server. Anything that needs admin rights, such as wiping every file when an account is deleted, belongs in Cloud Functions, never in the app bundle.
5. Lock it down with security rules so that each user can only ever read and write their own data:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{uid}/{document=**} {
      allow read, write: if request.auth != null && request.auth.uid == uid;
    }
  }
}

Write the equivalent rule for Cloud Storage, and have the agent write tests that try to read another user’s data and fail. Firebase’s official MCP server (it’s in the Part 4 config) lets the agent understand and validate your rules, and asks for your approval before it changes anything in the project. Deploying stays your job, which is why firebase deploy is denied in the permissions.

Two money notes. Firebase’s free Spark plan covers Authentication (50,000 monthly users) and Firestore’s free quotas (1 GiB stored, 50,000 reads and 20,000 writes a day), but Cloud Storage and Cloud Functions need the pay-as-you-go Blaze plan. Blaze keeps generous no-cost quotas, including 5 GB of storage and 2 million function invocations a month, so a small app can still cost nothing. Set a budget alert on day one anyway.

If you want the deeper “why” behind local-first design, I wrote about it in Perché il software "local-first" sta tornando in auge.

Phase 5 — The iPhone-specific bits

These are the details that separate “it works on my phone” from “it passes review”:

• Permission prompts need honest reasons. Camera, photo library, microphone and, if you use Apple’s speech framework, speech recognition each need a purpose string that says exactly why. “To photograph where you put something” is good. “This app needs access” is a classic rejection reason.
• Ask at the right moment. Ask for notifications when someone sets their first reminder, not on first launch. People say yes when the reason is obvious.
• Prefer on-device speech recognition where the phone supports it, and say in your privacy policy that the platform’s speech service may process audio. Stash’s policy does exactly that.
• Widgets are their own small app. They have their own lifecycle, their own memory limits and their own way of reading your data. Budget a full slice for them.
• Privacy manifests. Since May 2024, apps (including the SDKs inside them) must declare approved reasons for certain system APIs. Firebase’s SDKs ship their own manifests; make sure yours exists too.
• Dark mode, Dynamic Type, VoiceOver. Check all three on every screen. Agents are far more reliable about accessibility labels when AGENTS.md demands them, so make it demand them.

Phase 6 — Test like a sceptic

The agent will tell you it’s done. It will often be wrong in small ways, and sometimes in large ones. Xcode 27’s agents can now run tests and check SwiftUI previews themselves, which helps, but nothing replaces a person with a phone.

Automated: unit tests for search, the data model, and especially the sync merge logic. Those are the bugs that lose people’s data.

By hand, before every release:

• A real device, not just the Simulator
• Airplane mode: save, search, edit, then reconnect and check that it syncs
• Dark mode and the largest text size on every screen
• VoiceOver: can you save and find an item with your eyes closed?
• Every permission denied, one at a time
• A fresh install, and an upgrade over the previous version (data must survive)
• Delete account: is everything actually gone?

When something breaks, record it. Use the iPhone’s screen recording, attach the video, and ask M3.1 what’s wrong. It accepts video input, and “watch this” beats three paragraphs of description.

Prompt templates for this kind of app

Adapt these rather than copying them blindly.

A slice:

Implement slice 4 from ROADMAP.md (search). Read AGENTS.md first. Search must match item names, room names, notes and voice-note transcripts, case-insensitively, as the user types. Add a “With photos” filter. Write unit tests first, then the implementation. Run the tests and the type checker. Show me the diff and a list of any assumptions you made.

A bug:

Attached is a screen recording. On an iPhone with the largest text size, the keyboard covers the Save button on the Add screen. Find the cause, explain it in two sentences, fix it, and check the other forms in the app for the same problem.

A review:

Review every change since the last commit as a sceptical senior iOS reviewer. Look for crashes, data loss, privacy leaks, missing accessibility labels, hard-coded colours and anything that breaks offline use. Don’t fix anything yet; give me a numbered list, most serious first.

That last prompt is worth running before every single commit. It costs a minute and catches the problems that cost a weekend.

---

Parte 8 — Come pubblicare un'app sull'App Store nel 2026

Building the app is the fun part. Publishing it is paperwork, and the paperwork is where first-time developers lose a week. Here’s all of it in one place.

What Apple requires as of October 2026

Requisiti	Dettagli	In force since
Apple Developer Program	$99 a year (€99 in Germany). Companies enrol as an organisation, which needs a D-U-N-S number	—
Build tools	Uploads must be built with Xcode 26 or later using the iOS 26 SDK	28 April 2026
Minimum target	Apps must target iOS 13 or later	9 September 2026
Classificazione per età	Answer Apple’s updated age-rating questions	31 January 2026
Privacy manifest	Approved reasons for “required reason” APIs, including in third-party SDKs	1 May 2024
Privacy policy	Linked in App Store Connect e reachable inside the app (guideline 5.1.1(i))	—
Account deletion	“If your app supports account creation, you must also offer account deletion within the app” (5.1.1(v))	—
EU trader status	Every developer declares it. Traders’ address, phone and email are shown on the product page in all 27 EU countries	—

Apple’s current versions are Xcode 27 and iOS 27, both released on 14 September 2026. You don’t have to build with Xcode 27 yet, but you can no longer upload anything built with Xcode 16 or older (Apple jumped straight from Xcode 16 to 26 when it switched to year-based version numbers).

A note for German and EU developers: if you publish as a business, you’re a trader under the EU’s Digital Services Act, and Apple verifies your contact details before showing them on your product page. In February 2025, Apple pulled thousands of apps from EU storefronts for missing this information. Don’t be one of them.

App Store Connect, field by field

Create the app record in App Store Connect, then fill in:

• Bundle ID. A reverse-domain identifier that never changes, such as Stash’s network.grahammiranda.stash. Pick it carefully.
• Name (30 characters) and subtitle (30). Stash uses Stash — Trovalo subito e Trova tutto quello che hai messo via: the brand plus the benefit, then the benefit in plain words.
• Keywords (100 characters), separated by commas without spaces. Don’t repeat words already in your name or subtitle; they count anyway.
• Promotional text (170 characters), which you can change without a new review, and the description (4,000).
• Screenshots. One to ten per device size, PNG or JPEG, no transparency. For iPhone, the 6.9-inch size (1320 × 2868) or the 6.5-inch size (1284 × 2778); for iPad, the 13-inch size (2064 × 2752). Stash’s set uses the 6.5-inch and 13-inch sizes.
• Category. A primary and an optional secondary. Stash is Productivity, with Utilities second.
• URLs. Support, marketing and privacy policy. Every one must work.
• App Privacy, the “nutrition label”. More on this below, because it’s where honest people still get it wrong.
• Classificazione per età questionnaire.
• App Review information: contact details, notes for the reviewer and, if your app requires sign-in, a demo account. A guest mode like Stash’s makes the reviewer’s life easier.
• Export compliance. If your app only uses the encryption built into the operating system, such as HTTPS, it usually qualifies for an exemption. Check Apple’s guidance, then set ITSAppUsesNonExemptEncryption in your Info.plist so you’re not asked on every upload.

The text fields are good work for the agent too: “Draft the App Store subtitle, keywords, promotional text and description. Use only features that exist in the code; list the file where each feature lives.” That last instruction keeps it from inventing features.

TestFlight before anything else

Upload a build (from Xcode’s Organizer, or with eas build --platform ios --auto-submit on Expo) and test it through TestFlight first:

• Internal testers: up to 100 people on your team, no review needed.
• External testers: up to 10,000, invited by email or with a public link. The first external build goes through a short Beta App Review.
• Builds stay testable for 90 days.

Give it to five friends with different phones for a week. They’ll find the crash you didn’t.

What actually gets apps rejected

Apple says that “on average, 90% of submissions are reviewed in less than 24 hours”, and that “over 40% of unresolved issues are related to guideline 2.1: App Completeness”: crashes, placeholder content, incomplete information and broken links. The usual suspects for a first app:

Guideline	What it means in practice
2.1 App Completeness	No crashes, no “Lorem ipsum”, no dead links, demo account details if sign-in is required
4.2 Minimum Functionality	“Your app should include features, content, and UI that elevate it beyond a repackaged website”
4.8 Login Services	Third-party login as the main sign-in means you must also offer a privacy-focused option such as Sign in with Apple
5.1.1(i) Privacy policy	Linked in App Store Connect and inside the app; says what you collect, who processes it, and how deletion works
5.1.1(v) Account deletion	If people can create an account, they can delete it in the app
Accurate metadata	Screenshots and descriptions show what the binary actually does, not the roadmap

Stash keeps its design explorations on the website, clearly labelled, and off the App Store page, which is the right side of that last line.

Privacy labels: get them right, not just plausible

Apple’s definition is precise: “‘Collect’ refers to transmitting data off the device in a way that allows you and/or your third-party partners to access it for a period longer than what is necessary to service the transmitted request in real time.” Data processed only on the device isn’t collected.

In practice, for a Stash-shaped app:

• Guest mode only (nothing leaves the phone): the data isn’t collected.
• Accounts with sync: the email address, the photos, the voice recordings and the notes stored on your backend are collected, because they leave the device and stay on a server, even though only the user can see them. They go in the label as data linked to the user, used for app functionality, and not used for tracking.

The agent is an excellent auditor here, because it can read every network call in the codebase:

Audit this codebase for every piece of data that leaves the device: what it is, where it goes (which SDK or endpoint), whether it’s stored, for how long, and whether it’s linked to the user. Include data sent by third-party SDKs. Output a table I can use to fill in Apple’s App Privacy questions and the Google Play Data safety form.

Then make sure three documents tell the same story: your privacy policy, your App Store privacy label and, if you ship on Android, your Google Play Data safety form. Stash’s privacy policy says its data table is written to match both store declarations, which is the right standard to hold yourself to.

Mostra immagine Print it, stick it next to the screen, tick it before every first submission.

How Stash shipped

Stash 1.0 went live on 23 September 2026. Version 1.0.1, with “New Design and bug fixes”, followed on 2 October, nine days later. Ship the version that works, then improve it in public: that’s the healthiest rhythm I know for a first app.

---

Parte 9 — “E altro”: Il kit di lancio relativo all’app

An app on the App Store with nothing around it is a shop with no sign. Here’s the rest of the kit, again using Stash as the example.

A landing page with a demo people can touch

Stash’s website does a few things I’d copy for any first app:

• One promise above the fold. “Put it away. Know where.” Then one sentence and two buttons: get the app, or try it in the browser.
• A live preview in the hero. The phone on the right isn’t a picture. You can tap around in it.
• A real browser demo. A sample home where you can search for the keys, browse rooms and add a test item. The demo “runs in your browser tab”, doesn’t touch the app’s data, and forgets everything when you reload. It lets people try the idea before they commit to an install.
• Three steps, four features, no jargon. Photograph the spot. Give it a name and a room. Find it when you need it.
• The design explorations, clearly labelled as concepts rather than features.
• Ten languages (English, German, French, Spanish, Italian, Dutch, Brazilian Portuguese, Polish, Swedish and Danish), each with proper hreflang tags so search engines show the right one, plus a light and dark appearance switch.
• Structured data describing the app as a MobileApplication, with its price, platforms and App Store link, so search engines understand the page is about an app.
• Nothing creepy. The site’s code has no analytics, no advertising pixels, no social embeds, no external fonts, no sign-in and no contact form. It stores only your chosen language and appearance in your browser.

Mostra immagine The Stash landing page. The phone on the right is a working demo, not a screenshot.

A static page like this is also a perfect first project for the same OpenCode and M3.1 setup: plain HTML, CSS and a little JavaScript, no framework required, and you can see every change in a browser instantly.

Legal pages, if you’re in Germany or the EU

This is general information from someone who has been through it, not legal advice. When in doubt, ask a lawyer.

Shipping from Germany means a few more pages than a US tutorial will tell you about:

• An Impressum (imprint) under § 5 of the Digitale-Dienste-Gesetz (DDG), the German law that replaced the old Telemediengesetz in 2024: company name, address, managing director, register entry, contact details and, where you have one, the VAT ID.
• Two separate privacy texts. One for the website and one for the app, because they process different data. Stash has both, and each says clearly which one you’re reading.
• An app privacy policy with real substance. Stash’s covers the controller, a table of exactly what’s collected and why, the legal basis for each purpose under Article 6 GDPR, the processors involved (Firebase, from Google), how international transfers are covered (the EU-U.S. Data Privacy Framework and standard contractual clauses), retention and deletion, users’ rights, the responsible supervisory authority, children, security and how changes are announced.
• A way to delete an account outside the app. Stash offers a web form as well as the in-app option. Google Play requires a web link for account deletion if your app lets people create accounts, so you’ll need one anyway the day you ship on Android.
• The data processing terms with your backend provider, accepted in its console before real user data arrives.

Cookies are the other classic headache. Stash’s website sidesteps most of it by having nothing to ask consent for: no analytics, no ad pixels, no tracking, just a remembered language and theme. The cheapest consent banner is the one you never need.

App Store optimisation without the snake oil

App Store search works on your name, subtitle and keywords, and people decide in seconds from your icon and first screenshots. A few rules that hold up:

• Name: brand plus benefit. “Stash — Find It Fast” tells a stranger what the app is for.
• Screenshots tell a story, in order. Stash’s six read like a short ad: Ogni cosa ha il suo posto. Trovalo. In pochi secondi. Conserva quel posto. La tua casa. Stanza per stanza. Ricorda i piccoli dettagli. Chiaro. Con qualsiasi luce. Plenty of people never scroll past the first two or three, so put the core loop there.
• Localise the listing in every language your app actually supports.
• Ask for ratings at a happy moment. Apple’s review prompt can appear at most three times a year per user, so don’t waste it on first launch. In an app like Stash, the obvious moment is just after someone taps “Found it”.
• Use promotional text for seasons. Spring cleaning, moving house, putting the winter things away. It changes without a new review.

Android, when you’re ready

If you built with Expo or Flutter, Android is mostly a build away. The paperwork is lighter but different:

• Google Play charges $25 once to open a developer account.
• New personal accounts (created after 13 November 2023) must run a closed test with at least 12 testers, opted in for 14 days in a row, before they can publish. Organisation accounts are exempt, which is one more reason to publish through a company if you have one.
• The Data safety form is Google’s version of the privacy label. Keep it consistent with your privacy policy and your App Store answers.

---

Parte 10 — Quanto costa sviluppare un'app con l'IA nel 2026

The software in this stack is mostly free. What you pay for is the model, the Apple membership and, optionally, a better Figma seat.

Item	List price	When you need it
Apple Developer Program	$99 a year (€99 in Germany)	To publish on the App Store at all
OpenCode v2	Gratuito, licenza MIT	Always
MiniMax M Plan	Go $22, Explore $55, Build $132 a month (50% off the first month on monthly billing until 14 October)	To use M3.1-Flash-Preview
Figma	Starter free; Professional Dev seat $12 a month, Full seat $16	A paid seat only for the desktop MCP server
Xcode	Gratuito	Native builds, on an Apple silicon Mac
Expo EAS	Free tier with 15 iOS and 15 Android builds a month; Starter $19 a month	If you build with Expo
Firebase	Free Spark plan; Blaze is pay-as-you-go with no-cost quotas	Accounts and sync; Storage and Functions need Blaze
Google Play	$25, once	Only if you ship on Android
Landing page	Whatever your hosting and domain cost	Strongly recommended

Three realistic first-year budgets

Budget	What’s in it	First year
Lean	Apple membership + M Plan Go; Figma Starter with exported frames; Expo, Firebase and OpenCode on free tiers	$363
Comfortable	Lean + a Figma Dev seat for the desktop MCP server + Google Play	$532
Power	Apple + M Plan Explore + a Figma Full seat + Expo Starter + Google Play	$1,204

Mostra immagine The model subscription is the biggest line in every budget. The Apple fee is the only one you can’t avoid.

List prices in US dollars on 5 October 2026, excluding VAT, at full monthly rates (no launch discounts). Your backend bill depends on your users; at small scale, Firebase’s no-cost quotas usually cover it. Set a budget alert anyway.

The lean budget works out at about $30 a month. The real cost of the project isn’t on the list, though: it’s your evenings. AI shortens the typing, not the thinking, and the thinking is most of it.

---

Parte 11 — Dieci errori da evitare quando si sviluppa la propria prima app con l'IA

1. Starting with code instead of a brief. The agent will happily build the wrong app very quickly.
2. Building everything at once. “Make the whole app” gives you a whole app that’s slightly broken everywhere. Build vertical slices.
3. Skipping AGENTS.md. Without it, every session starts from zero, and the agent re-decides things you already decided.
4. Letting the agent add dependencies freely. Every package is code you didn’t read, extra app size and a future update to manage. Make it ask.
5. Hard-coding colours and sizes. Then changing the design means editing 140 files. Tokens, always.
6. Believing “done”. Agents report success optimistically. Run it on a real phone, in airplane mode, in dark mode, at the largest text size.
7. Putting secrets in the app. Anything inside an app bundle can be extracted. API keys that cost money, or give admin access, live on a server.
8. A privacy label that’s plausible rather than accurate. If data leaves the device and stays on a server, it’s collected, even when only the user can see it.
9. Forgetting account deletion. Apple requires it in the app if you allow sign-up; Google Play requires a web link as well.
10. Promising your roadmap. Screenshots and descriptions show what the app does today. Concepts belong on your website, labelled as concepts.

And one more for luck: not reading the diff. Vibe coding means not writing every line. It doesn’t mean not reading the lines that ship. The security numbers in my State of AI 2026 round-up are the reason.

---

Parte 12 — È consigliabile utilizzare proprio questa combinazione? Sei scenari

1. “I’ve never written a line of code.”

Expo, the OpenCode desktop app, M3.1 on the M Plan’s Go tier, and Figma’s free plan with exported frames. Keep your first app to one core loop, like Stash’s save-and-find. Leave shell commands on ask, commit after every working step, and use /annulla without guilt.

2. “I only care about the iPhone, and I want it fully native.”

SwiftUI in Xcode 27, with OpenCode either inside Xcode through ACP or in your terminal with Xcode’s MCP tools. M3.1 for planning and building. You’ll get first access to Apple’s newest frameworks and the tightest integration with the system.

3. “I already pay for Claude or ChatGPT.”

Use what you have, and be fair about where it wins. Claude Code, Codex and Cursor are on Figma’s approved list for the remote MCP server today, including the write-to-canvas tools that OpenCode can’t reach yet. OpenCode can sign in with ChatGPT Plus or Pro directly. Add M3.1 through OpenCode for the jobs where its million-token context and video input shine.

4. “I want the cheapest possible start.”

MiniMax M3 instead of M3.1 (through OpenCode Go at $10 a month, or pay-as-you-go), Figma Starter, Expo’s free builds and Firebase’s free plan. The $99 Apple membership is the only cost you can’t avoid for an iPhone app. If you’re not ready for that, build the web version first.

5. “My app handles sensitive data.”

Design for guest mode first, keep third-party SDKs to a minimum, and think about where your code goes, too. Your prompts and source code go to the model provider. For very sensitive projects, local models through Ollama keep everything on your own machine (my OpenCode v2 article covers that setup), and get a privacy professional to review the app before launch.

6. “I build apps for clients.”

A Figma Organization plan with Code Connect, OpenCode’s policies to control which providers each client project may use, an M Plan tier with room for several parallel agents, and paid EAS builds. Put each client’s design rules in a committed skill or AGENTS.md so every session and every teammate starts from the same rules.

---

Parte 13 — Cosa tenere d’occhio nei prossimi mesi

• MiniMax’s full M3.1. Whether it ships, whether it gets a per-token price, published benchmarks and open weights like M3, and whether the Flash preview reaches OpenRouter, OpenCode Go or Ollama Cloud.
• OpenCode on Figma’s allowlist. OpenCode’s pull request for a registered Figma client is waiting on Figma. When it lands, the remote server’s write tools open up to OpenCode users.
• Figma’s write-to-canvas pricing. Figma says those features are free during the beta and will become usage-based later.
• Figma Code Layers, previewed at Config, which promises design and code on the same canvas.
• OpenCode v2 maturing: session sharing coming back, plugins catching up, and the 2.0.x releases settling down.
• Apple’s next SDK deadline. If Apple follows its usual pattern, builds made with Xcode 27 will become mandatory for uploads around next spring.
• Stash itself. The three design explorations on its website (pinning the exact spot, Quick Move, boxes and labels) show where the ideas are heading.

---

Domande frequenti

Can I build an app from scratch with no coding experience?

Yes. In 2026, an AI coding agent such as OpenCode, paired with a strong model such as MiniMax M3.1, writes the code while you make the decisions: what the app does, how it looks, what data it stores and how you test it. You still need to learn how to read a plan, review a diff, test on a real device and handle App Store Connect. Start with an app that has one core loop and no payments.

How long does it take to build an app with AI?

It depends far more on scope than on tools. A small app with one core loop, like a save-and-find app, is a matter of weeks of evenings rather than months, if you build in vertical slices and test as you go. Publishing adds a few days for TestFlight and App Store paperwork; Apple says 90% of submissions are reviewed in under 24 hours.

What is MiniMax M3.1?

MiniMax M3.1 is the next generation of MiniMax’s M3 model family. As of October 2026, the only version you can use is MiniMax-M3.1-Flash-Preview, launched on 27 September 2026: a multimodal coding model with a 1,000,000-token context window, text, image and video input, always-on thinking and five effort levels from low to max. It’s available only through MiniMax’s M Plan subscription and the MiniMax Code app.

Is MiniMax M3.1 available through the API?

Only with a subscription key. M3.1-Flash-Preview works on MiniMax’s OpenAI-compatible and Anthropic-compatible endpoints, but only with an M Plan subscription key. There’s no pay-as-you-go price, no open weights and no listing on OpenRouter, Ollama Cloud or OpenCode Go yet. MiniMax M3 remains available pay-as-you-go at $0.30 per million input tokens and $1.20 per million output tokens.

How do I use MiniMax M3.1 in OpenCode?

Install OpenCode v2, start it in your project folder, run /connetti, choose “MiniMax Token Plan (minimax.io)” and paste your M Plan subscription key. Then run /modelli and select MiniMax-M3.1-Flash-Preview. No config file is needed, though a project opencode.jsonc lets you set effort levels per agent and add permissions.

Does the Figma MCP server work with OpenCode?

Partly. Figma’s remote MCP server only accepts approved clients during its beta, and OpenCode isn’t on the list yet, so connecting fails with an HTTP 403. Figma’s desktop MCP server does work: enable it in Dev Mode in the Figma desktop app and point OpenCode at http://127.0.0.1:3845/mcp. It requires a Dev or Full seat on a paid plan and offers mostly read-only tools.

Do I need a Mac to build an iPhone app?

Not necessarily. Native development with Xcode needs a Mac, and Xcode 27 requires Apple silicon. With Expo, EAS builds your iOS app in the cloud and EAS Submit uploads it to App Store Connect from macOS, Windows or Linux. You’ll still want an iPhone for testing, and you need an Apple Developer Program membership to publish.

How much does it cost to publish an app on the App Store?

The Apple Developer Program costs $99 a year, or the local equivalent (€99 in Germany). Apple doesn’t charge per app or per submission. Building costs depend on your tools; the lean setup in this guide comes to about $363 for the first year including a MiniMax M Plan subscription, with free tiers for OpenCode, Figma, Expo and Firebase.

How long does App Store review take?

Apple says that on average 90% of submissions are reviewed in less than 24 hours. The most common reason apps get stuck is guideline 2.1, App Completeness: crashes, placeholder content, incomplete review information and broken links, including the support and privacy policy URLs.

Should I use SwiftUI, React Native (Expo) or Flutter?

Use SwiftUI with Xcode 27 if your app is Apple-only and you want the newest platform features. Use Expo (React Native) if you want one codebase for iPhone and Android and you’re working alone: SDK 56 supports iOS 16.4 and later, has stable iOS widgets and can build in the cloud. Use Flutter if you or your team already know Dart.

What’s the difference between MiniMax M3 and M3.1?

MiniMax M3, released on 1 June 2026, is generally available with open weights, published benchmarks and per-token pricing, and runs on many providers. M3.1-Flash-Preview, released on 27 September 2026, is a subscription-only preview with no weights, price or benchmarks yet, always-on thinking and five effort levels. Both have a 1M-token context and accept text, images and video.

What is Stash?

Stash — Find It Fast is a free iPhone and iPad app from Graham Miranda UG that remembers where you put things. You photograph the spot, give the item a name and a room, and search for it later by name, room, note or transcribed voice note. It also offers reminders for seasonal items, widgets, offline use and sync between iPhone and iPad. It launched on the App Store on 23 September 2026.

Does Stash collect my data?

Stash has no ads, no analytics tracking and doesn’t sell data. In guest mode, without an account, your rooms, items, photos and voice notes stay on your device. If you create an account, they sync through Google Firebase so they’re available on your iPhone and iPad, isolated from other users, and you can delete your account and data from Settings or through a web form.

---

In sintesi

Building an app from scratch in 2026 is no longer a question of whether you can write the code. An agent like OpenCode v2, running a model like MiniMax M3.1, will write more code in an afternoon than you’d read in a week. The real work has moved to the edges: deciding what the app is, designing it carefully enough that an agent can’t misread it, testing it like a sceptic, and doing the unglamorous paperwork that turns a project folder into something a stranger can download.

The stack in this guide is the one I’d recommend today. Figma for decisions you can see. OpenCode v2 because it’s open, scriptable, careful with permissions and loyal to no single model. MiniMax M3.1 because a million tokens of context and video input suit app building unusually well, as long as you treat a preview like a preview. And the “stuff” (Firebase, TestFlight, privacy labels, a landing page, legal pages) because that’s what users actually meet.

Stash is what that looks like when it ships: one small promise, kept well. Download Stash on the App Store, o try the browser demo first. Then go and build yours.

---

Building your first app with AI? I’d like to hear which framework you picked, whether you got Figma’s MCP server talking to your agent, and how MiniMax M3.1 is treating you. Corrections and counter-evidence are welcome; this article gets updated when the picture changes.

Informativa: Stash is my own app, published by my company, Graham Miranda UG. It’s free, with no ads and no in-app purchases. There are no affiliate links in this article, and none of the companies mentioned sponsored or reviewed it before publication.

Last updated: 5 October 2026.