Creare un'app con Claude Code: tutorial per iPhone

Creare un'app con Claude Code: la risposta breve

Per creare un'app con Claude Code ti servono un accesso a pagamento a Claude Code (abbonamento compatibile o Console a consumo), Node.js, un iPhone con Expo Go e un progetto Expo. Scrivi un file CLAUDE.md che descrive il tuo stack e le tue regole, chiedi una schermata alla volta, testi ogni schermata sul tuo iPhone, poi invii l'app su TestFlight con EAS.

Questo tutorial completa la mia guida creare un'app iOS con l'IA, che spiega cosa l'IA fa bene e cosa sbaglia. Qui passiamo alla pratica: i comandi, i file, i prompt.

Programmo le mie app iOS con Claude Code e Cursor tutti i giorni. Il mio stack: React Native, Expo, EAS, RevenueCat e Supabase. Solys, una sveglia con mini-giochi, e TradaZen, un'app per allenarsi al trading, sono pubblicate sull'App Store. Nolera e Clic sono state rifiutate da Apple, poi corrette. Tutto quello che segue viene da questo lavoro.

Per vedere questo metodo applicato a un'app pubblicata, ho documentato il percorso di TradaZen, dal primo commit ai rifiuti di Apple e ai pivot. Questa esperienza completa i passaggi del tutorial.

Passo 1: riunire i prerequisiti

Prima del primo comando, controlla di avere tutto questo.

Un account Claude a pagamento

Claude Code non è incluso nel piano gratuito di claude.ai. Secondo la documentazione di Anthropic, serve un account Pro, Max, Team, Enterprise o Console. Il piano Pro ti permette di iniziare, entro i suoi limiti di utilizzo.

Node.js e un terminale

Expo richiede Node.js in versione LTS, su macOS, Windows o Linux. Claude Code gira su macOS 13 o successivo, Windows 10 o successivo e sulle principali distribuzioni Linux.

Un iPhone ed Expo Go

Installa Expo Go dall'App Store sul tuo iPhone per provare le prime schermate senza compilare la tua app. Prima di creare il progetto, controlla la versione dell'SDK compatibile con la tua installazione sulla pagina di Expo Go. L'ultimo SDK e la versione distribuita sull'App Store non sono sempre disponibili nello stesso momento: Expo ha documentato in particolare questo sfasamento a maggio 2026. Quindi non partire da un numero di versione trovato in un vecchio tutorial. Per usare moduli nativi tuoi, prevedi una build di sviluppo.

Un Mac? Non è obbligatorio

Le build iOS vengono compilate sui server di Expo con EAS Build, con la versione di Xcode scelta dal tuo SDK Expo (ITMS-90725), e EAS Submit funziona su macOS, Linux e Windows. Puoi quindi arrivare fino a TestFlight da un PC. La guida pubblicare un'app iOS senza Mac descrive questa catena nel dettaglio.

Un account Apple Developer, più avanti

Non ti serve per programmare e testare nell'Expo Go dell'App Store. Diventa obbligatorio quando invii l'app su TestFlight. Ci torniamo al passo 7.

Passo 2: installare Claude Code

Su macOS, Linux o WSL, il metodo consigliato da Anthropic è l'installer nativo:

curl -fsSL https://claude.ai/install.sh | bash

Su Windows, in PowerShell:

irm https://claude.ai/install.ps1 | iex

Poi verifica che l'installazione abbia funzionato:

claude --version

Se preferisci npm, il comando è npm install -g @anthropic-ai/claude-code. Non metterci davanti sudo: la documentazione lo sconsiglia esplicitamente.

Al primo avvio di claude, si apre un browser per collegarti al tuo account. Poi scrivi in italiano: Claude legge i tuoi file, propone modifiche e lancia comandi, con il tuo consenso.

Passo 3: creare il progetto Expo

Spostati nella cartella dove tieni i tuoi progetti e lancia:

npx create-expo-app@latest mon-app
cd mon-app
npx expo start

Se lo strumento ti chiede di scegliere tra la compatibilità con l'Expo Go dell'App Store e l'ultimo SDK, per questo esercizio scegli la compatibilità. In ogni caso, verifica che la versione creata sia supportata dall'Expo Go installato sul tuo iPhone prima di proseguire. Potrai preparare una build di sviluppo quando il progetto ne avrà bisogno.

Nel terminale compare un QR code. Scansionalo con la fotocamera dell'iPhone: l'app si apre in Expo Go. Un dettaglio blocca spesso la prima volta: Expo Go apre il tuo progetto solo se Expo CLI ed Expo Go sono collegati allo stesso account Expo. Lancia npx expo login sul computer e accedi con lo stesso account nell'app.

Perché Expo e non Swift? Claude conosce molto bene React Native, e testi senza Mac. Spiego questa scelta nella pagina React Native ed Expo per un'app mobile.

Tieni a mente un limite di Expo Go: contiene solo i moduli nativi che include già. Appena aggiungi una libreria nativa che non conosce, per esempio gli acquisti in-app, ti servirà una build di sviluppo. Per le prime schermate non è un problema.

Scegliere l'ambiente di test giusto

Expo Go, una build di sviluppo e TestFlight non dimostrano la stessa cosa. Expo descrive la build di sviluppo come la tua app di test, con i moduli nativi di cui il progetto ha bisogno.

Cosa vuoi verificare	Dove testare	Limiti del test
Mostrare una prima schermata e provarne la navigazione	Expo Go, con un SDK compatibile	Il comportamento dei moduli nativi assenti da Expo Go
Usare una libreria nativa aggiunta al progetto	Una build di sviluppo che include quella libreria	La versione distribuita e la sua approvazione da parte di Apple
Percorrere l'app destinata ai tester, poi testarne gli acquisti	Una build inviata su TestFlight e prodotti configurati correttamente	Un pagamento reale di un cliente o la convalida della messa in vendita

Prima di aggiungere una dipendenza, chiedi a Claude: "È compatibile con il mio SDK e con il mio ambiente di test attuale? Bisogna ricompilare l'app? Basa la risposta sulla documentazione." Eviti di passare una serata a correggere un modulo che Expo Go semplicemente non può caricare, o un SDK rifiutato all'invio per API non pubblica.

Passo 4: scrivere il file CLAUDE.md del progetto

È il passo che rende di più. Claude Code può conservare una memoria di progetto, ma devi rendere esplicite le sue regole. Il file CLAUDE.md, nella radice del progetto, fornisce istruzioni comuni a tutte le sessioni. Lì scrivi quello che Claude non può indovinare.

Nella cartella del progetto lancia claude, poi digita /init. Secondo la documentazione, Claude analizza il progetto e genera un primo CLAUDE.md con i comandi e le convenzioni che trova. Poi lo completi con le tue regole. Anthropic consiglia di restare sotto le 200 righe: più il file è lungo, meno le istruzioni vengono seguite.

Ecco un esempio breve, simile a quello che uso io:

# La mia app

## Stack

- Expo (SDK di create-expo-app), React Native, TypeScript strict
- Navigazione: Expo Router, un file per schermata in app/
- Dati: Supabase (più avanti), mai una chiave segreta nell'app

## Regole

- Una schermata alla volta. Non toccare file fuori dalla richiesta.
- Nessuna altezza fissa in punti: dimensioni relative allo schermo,
  ScrollView se il contenuto può eccedere.
- Ogni schermata gestisce 3 stati: caricamento, vuoto, errore.
- Testi dell'interfaccia in italiano con gli accenti.
- Prima di modificare più di 2 file: proponi un piano e aspetta il mio ok.

## Comandi

- Avvio: npx expo start
- Test: usare lo script realmente presente in package.json.
  Se non esiste ancora, segnalarlo; non dichiarare test superati.
- Tipi: npx tsc --noEmit
- Dopo ogni modifica: lanciare test e tipi, poi dirmi
  cosa è cambiato e come verificarlo su iPhone.

La regola sulle altezze fisse non è lì per caso. Ci torniamo al passo 6.

Passo 5: un prompt per schermata

"Creami un'app per tracciare le abitudini con abbonamento" produce un progetto enorme, fragile, impossibile da rileggere. Il metodo che funziona è l'opposto: una richiesta, una schermata, un risultato che puoi testare in cinque minuti.

Inizia con un piano

Per tutto ciò che tocca più file, passa alla modalità piano. Premi Shift+Tab finché non vedi plan mode on nella barra di stato. In questa modalità, Claude legge i file e propone un piano, ma non modifica niente prima del tuo ok. Rileggi, correggi, poi approvi.

Un primo prompt di inquadramento è fatto così:

Voglio un'app per tracciare le abitudini. Versione 1: una sola funzione,
spuntare le abitudini del giorno. Proponi l'elenco delle schermate e la
struttura delle cartelle. Per ora non scrivere codice.

Descrivi la schermata, i suoi stati e i suoi limiti

Poi, un prompt per schermata. Più nomini i casi limite, meno Claude li dimentica:

Crea la schermata app/index.tsx che elenca le abitudini del giorno.
- Ogni riga: nome dell'abitudine, casella da spuntare, serie in corso.
- Stato vuoto: un testo e un pulsante "Aggiungi un'abitudine".
- Stato di caricamento e stato di errore con un pulsante "Riprova".
- Per ora i dati arrivano da un array locale.
- Deve stare su un iPhone SE come sull'iPhone più grande:
  nessuna altezza fissa, la lista scorre.
Alla fine lancia i test e i tipi.

Correggi senza far riscrivere tutto

Quando un dettaglio non va, sii preciso e limita il perimetro:

Sul mio iPhone, il pulsante "Aggiungi un'abitudine" finisce sotto la barra
in basso quando la lista è lunga. Correggi solo questo problema in
app/index.tsx, senza toccare gli altri file. Spiega la causa.

Puoi anche incollare uno screenshot nel terminale: Claude lo legge.

Esercizio: un'abitudine che resta spuntata dopo il riavvio

Ecco un esercizio didattico da fare nel tuo progetto, non la cattura di una funzionalità già rilasciata. L'obiettivo è passare da una schermata generata a un comportamento verificabile. Non richiede né account utente né acquisti in-app.

1. Tieni una sola abitudine locale chiamata "Leggere 10 minuti".
2. Chiedi una casella da spuntare e un salvataggio locale compatibile con il tuo progetto Expo.
3. Chiedi all'agente di indicare i file modificati, l'eventuale dipendenza e i comandi realmente eseguiti.
4. Installa o apri l'app sull'iPhone, poi fai le verifiche qui sotto.

Partendo dalla schermata esistente, rendi spuntabile l'abitudine
"Leggere 10 minuti" e conservane lo stato dopo la chiusura e la riapertura dell'app.
Usa lo storage locale compatibile con le dipendenze del progetto.
Non creare account, server, abbonamenti o statistiche aggiuntive.
Prima di scrivere codice, spiega come gestirai il caricamento e un errore
di lettura o di salvataggio. Poi fai una modifica limitata.
Alla fine: file modificati, comandi eseguiti, limiti non testati
e passaggi esatti per verificare il risultato su iPhone.

Azione sul tuo iPhone	Risultato atteso	Se non funziona
Aprire l'app per la prima volta	L'abitudine e la sua casella sono visibili, senza errori	Verificare lo stato iniziale e il caricamento dello storage
Spuntare, poi chiudere e riaprire l'app	L'abitudine resta spuntata	Controllare la scrittura e poi la lettura della stessa chiave
Togliere la spunta e riavviare	L'abitudine resta non spuntata	Verificare che venga salvato anche il valore false
Rifare il percorso in modalità aereo	La funzione locale resta disponibile	Individuare una dipendenza di rete aggiunta senza motivo
Aumentare la dimensione del testo	Il nome e il controllo restano accessibili	Rimuovere i vincoli che troncano o nascondono l'azione

Se una riga fallisce, non chiedere "riscrivi tutto". Descrivi l'azione, il risultato atteso e il risultato osservato. Per esempio: "Dopo il riavvio, la casella torna vuota anche se l'avevo spuntata. Spiega la causa e correggi la persistenza senza modificare il design."

Scarica il modello CLAUDE.md e la scheda di verifica (.md). Aprilo nel tuo editor o in un'app di note. Adatta i comandi al tuo progetto prima di affidarlo all'agente.

Passo 6: far rileggere e testare

Claude Code scrive codice che sembra giusto. Solo i tuoi test e il tuo iPhone ti dicono se lo è davvero.

Test per non rompere quello che funziona

Più la tua app cresce, più ogni richiesta rischia di rompere una schermata già approvata. Il progetto creato da Expo non ha test: chiedi prima a Claude di installare Jest con jest-expo, come consiglia la documentazione di Expo. Poi chiedi test per la logica importante (calcolo di una serie, validazione di un modulo) e falli lanciare dopo ogni modifica. Per questo i comandi di test sono scritti nel CLAUDE.md: Claude li esegue senza che tu debba ricordarglielo. Con un file di regole e dei test, l'IA rompe molto meno quello che già funzionava.

Rileggi ogni modifica

Non devi capire ogni riga. Devi sapere quali file sono cambiati, e perché. Se Claude ha toccato un file fuori tema, chiedigli il motivo prima di accettare. Poi fai la domanda: "cosa può rompersi qui?".

Verifica su un iPhone piccolo e su uno grande

È la lezione che mi è costata di più. Solys è stata rifiutata da Apple in base alla regola 2.1: la demo dell'onboarding era impossibile da vincere su un iPad Air, dove l'app girava in modalità compatibilità iPhone. La causa: altezze scritte in punti fissi, non relative alla dimensione dello schermo. Sul mio iPhone andava tutto bene. Il codice era stato riletto, i test erano verdi. Nessuno strumento aveva guardato lo schermo a un'altra dimensione.

Da allora controllo ogni schermata almeno sull'iPhone più piccolo e su quello più grande. Se hai un solo telefono, va bene il simulatore di Xcode su Mac o un amico con un altro modello. Guarda in particolare i testi lunghi, la tastiera aperta sui moduli e i pulsanti fissati in basso.

Cosa Claude Code fa male

Claude Code eccelle su schermate e logica. Fuori dalla tua cartella è molto meno affidabile.

Firma e certificati

Senza un accesso autorizzato al tuo account Apple, Claude non ne conosce lo stato. Può inventarsi una procedura per i certificati che mescola Xcode ed Expo. Lascia gestire la firma a EAS: la documentazione di Expo spiega che EAS CLI può generare e conservare questi file per te, dopo il collegamento al tuo account Apple Developer.

App Store Connect

La scheda, le dichiarazioni sulla privacy, gli screenshot e i link legali sono dati da verificare in App Store Connect. Claude Code ora può agire in un browser collegato tramite la sua integrazione con Chrome, con gli accessi necessari. Questo non garantisce che i campi siano esatti: rileggi le informazioni, controlla gli account usati e approva tu stesso gli impegni e l'invio in revisione.

Gli abbonamenti

Scrivere un paywall richiede dieci minuti. Far combaciare i prodotti di App Store Connect, la loro configurazione in RevenueCat e il codice è un'altra storia. Basta un identificativo diverso di un carattere e il paywall resta vuoto per il reviewer. Le trappole più comuni sono elencate in gli errori di paywall iOS dei principianti.

I casi limite

Senza istruzioni, Claude gestisce il caso nominale. Niente rete, una lista vuota, un acquisto interrotto: tocca a te nominarli.

La sicurezza di Supabase

Quando Claude crea tabelle in Supabase, verifica che la sicurezza a livello di riga (RLS) sia attiva, con policy che limitano ogni utente ai propri dati. Verifica anche che nessuna chiave segreta finisca nel codice dell'app. Scrivi questi due divieti nel tuo CLAUDE.md appena colleghi un database.

Passo 7: passare su TestFlight con EAS

Le tue schermate sono state verificate in Expo Go o in una build di sviluppo, a seconda dei moduli usati. Ora passa alla build che verrà distribuita ai tester.

Preparare EAS

Ora ti serve un account Apple Developer a pagamento: Expo lo ricorda, è obbligatorio per inviare un'app all'App Store. Poi installa lo strumento di Expo e configura il progetto:

npm install --global eas-cli
eas login
eas build:configure

Aggiungi un bundle identifier univoco in app.json, sotto ios.bundleIdentifier, per esempio com.yourname.myapp.

Compilare e inviare

eas build --platform ios --profile production
eas submit --platform ios

Il primo comando compila l'app sui server di Expo. Al primo avvio, EAS ti propone di collegarti al tuo account Apple per creare i certificati. Il secondo invia la build ad App Store Connect. Puoi anche fare tutto in un colpo con eas build --platform ios --auto-submit.

La build deve essere elaborata da Apple prima di comparire in TestFlight, e questa elaborazione può rifiutarla, per esempio con ITMS-90717 per un'icona trasparente. Un invio riuscito quindi non significa che sia già installabile: controlla il suo stato in App Store Connect. Tester interni, esterni e revisione beta sono spiegati nella mia guida TestFlight per testare la tua app iPhone.

Rifai le verifiche del passo 6 su questa build. Un'app che funziona in Expo Go può ancora andare in crash in produzione, per esempio quando manca un modulo nativo.

Quanto costa davvero

Ecco i prezzi indicati dai servizi e verificati il 27 settembre 2026, in dollari. L'importo addebitato dipende anche dalla tua regione, dalle tasse e dal tuo utilizzo: controlla l'offerta prima di abbonarti.

• Abbonamento Claude: il piano Pro costa 20 $ al mese, o 17 $ al mese con pagamento annuale. I piani Max partono da 100 $ al mese, per un utilizzo maggiore.
• Account Apple Developer: 99 $ all'anno, obbligatorio per TestFlight e l'App Store.
• EAS: il piano gratuito di Expo include 15 build iOS al mese, in una coda a bassa priorità. Il piano Starter costa 19 $ al mese, più l'utilizzo extra.

Per un piccolo prototipo, Pro e il piano gratuito di EAS possono costituire una base, se resti nelle loro quote. Aggiungi l'account Apple prima di TestFlight, poi calcola a parte i servizi davvero necessari: database, storage o API a pagamento. Il modello di budget per una prima app ti aiuta a mettere giù queste voci. Il tempo di configurazione e di verifica resta da mettere in conto.

I limiti onesti, e dove ci si blocca

Claude Code ha cambiato chi può creare un'app per iPhone. Non ha cambiato quello che Apple richiede per pubblicarla. Un rifiuto arriva in fretta: Solys ne ha presi, Nolera e Clic pure. I motivi più frequenti sono raccontati in perché Apple rifiuta un'app.

Con questo tutorial puoi arrivare da solo fino a TestFlight. Il punto in cui ci si blocca più spesso viene dopo: collegare gli abbonamenti, preparare il materiale per il reviewer, capire un rifiuto. Per la visione d'insieme del percorso, leggi la pagina creare un'applicazione iPhone.

Per questa parte, l'iOS Kit riunisce il codice di partenza delle mie app, abbonamenti compresi, le skill di Claude Code per ogni passo e l'Apple Review Kit. Il percorso completo è nella pagina corso Claude Code per creare un'app iOS.

Sei già bloccato e non sai su cosa? La diagnosi gratuita ti dice cosa ti frena davvero e ti invia la mia checklist anti-rifiuto di Apple.

Domande frequenti

Si può creare un'app iPhone con Claude Code senza saper programmare?

Sì per le schermate e la logica semplice, se rileggi e testi ogni passo. No se speri di non capire niente del tutto. Devi saper leggere un messaggio di errore, lanciare un comando e verificare cosa ha modificato Claude. Si impara in fretta costruendo.

Claude Code è gratis?

No. Claude Code richiede un account Pro, Max, Team, Enterprise o Console. Il piano gratuito di claude.ai non lo include. Il piano Pro ti permette di iniziare, con limiti di utilizzo da tenere d'occhio.

Serve un Mac per creare un'app iOS con Claude Code?

No. Programmi su qualsiasi computer, testi in Expo Go sul tuo iPhone, ed EAS compila e invia l'app dai server di Expo. Un Mac resta comodo per il simulatore, ma non è obbligatorio.

Claude Code o Cursor per un'app React Native?

Uso entrambi, tutti i giorni. Claude Code lavora nel terminale e concatena da solo modifiche e test. Cursor è un editor. Il metodo conta più dello strumento: regole, una schermata alla volta, test.

Quanto tempo serve per pubblicare una prima app con Claude Code?

Dipende dalla dimensione dell'app e dal tuo tempo. Un'app con una sola funzione va molto più veloce. La parte più imprevedibile resta la revisione di Apple.

Claude Code può configurare gli abbonamenti in-app?

Può scrivere il codice del paywall e di RevenueCat. Con strumenti collegati e le autorizzazioni necessarie, può anche intervenire nelle console. Non dedurre mai dalla presenza del codice che i prodotti siano configurati: verifica identificativi, prezzi e diritti dopo l'acquisto, poi testa l'acquisto e il ripristino su TestFlight. Gli errori frequenti dei paywall iOS ti indicano i punti da controllare.