Utiliser OpenCode du premier prompt à l’App Store : le guide 2026 des forfaits de codage, d’Ollama, des serveurs MCP et des skills

Quelque part entre le premier prompt et le premier e-mail d’App Review, un agent de codage IA cesse d’être un jouet pour devenir un outil avec lequel tu livres. Ce guide explique comment utiliser OpenCode pour passer de l’un à l’autre : l’installer sur un Mac tout propre, choisir ce que tu paies pour le modèle qui réfléchit, faire tourner des modèles sur ta propre machine avec Ollama, donner de vraies mains à l’agent avec les serveurs MCP, lui apprendre tes habitudes avec des skills, puis faire passer une appli iPhone par TestFlight et App Review sans perdre une semaine en paperasse.

Je ne viens pas du développement. Je dirige une petite entreprise informatique en Allemagne, et je construis des logiciels avec des agents IA. Deux des résultats sont arrivés sur l’App Store cet automne : Stash, qui se souvient de l’endroit où tu ranges tes affaires, et PingAtlas, qui mesure la latence réseau depuis ton propre appareil. Ils apparaissent dans ce guide là où ils sont vraiment utiles comme exemples, et nulle part ailleurs.

Tout ce qui suit a été vérifié dans la documentation officielle, les notes de version, les pages de tarifs et l’App Store lui-même le 7 novembre 2026. Le codage IA va vite : OpenCode a publié au moins dix versions 2 rien qu’entre le 20 et le 30 octobre, Ollama et MiniMax ont tous deux refondu leurs forfaits depuis la fin août, et Apple a réécrit des parties de ses directives de review au moins deux fois cette année. Les chiffres volatils sont signalés là où ils apparaissent. Vérifie-les avant d’acheter quoi que ce soit.

Mention légale : Stash et PingAtlas sont mes propres applis, publiées par ma société, Graham Miranda UG (haftungsbeschränkt). Les deux sont gratuites et sans publicité. Cet article contient un lien d’affiliation: le lien vers le GLM Coding Plan de Z.ai dans la partie 2 te donne 10 % de réduction et me verse une commission si tu t’abonnes. L’équipe d’OpenCode chez Anomaly, Ollama, Apple, Expo, Z.ai et toutes les autres entreprises citées ici n’ont ni sponsorisé, ni relu, ni approuvé cet article.

---

TL;DR — tout le parcours en dix points

• OpenCode est un agent de codage gratuit et open source (MIT) qui fonctionne avec presque n’importe quel modèle : abonnements cloud, API facturées au token ou modèles tournant sur ton propre Mac. Il en est à la version 2.2.6 (6 novembre 2026), avec une appli terminal, une appli de bureau, une interface web et mobile, et un mode ACP qui tourne dans Xcode 27.
• Tu paies le modèle, pas l’agent. Les “forfaits de codage” sont des abonnements mensuels à prix fixe pour du temps de modèle. Pour la plupart des gens qui débutent, OpenCode Go (10 $ par mois) plus Ollama (gratuit en local, 20 $ par mois pour les crédits cloud Pro) est la configuration que je recommande : pas chère, agnostique côté modèle, sans rétention par défaut pour la plupart des modèles, et sans zone grise dans les conditions d’utilisation de qui que ce soit.
• Les alternatives existent vraiment. ChatGPT Plus et Pro, GitHub Copilot et le GLM Coding Plan de Z.ai se branchent tous sur OpenCode via des fournisseurs intégrés. Les abonnements Claude fonctionnent de nouveau grâce au nouveau fournisseur Claude Agent d’OpenCode 2.2.3, mais Anthropic n’a pas publiquement validé cette voie, alors lis la partie 2 avant de compter dessus.
• Ollama est un seul moteur pour les modèles locaux et cloud. ollama launch opencode les relie, les modèles locaux ont besoin d’au moins une fenêtre de contexte de 64K, et un Mac de 32 Go peut faire tourner de bons modèles de codage comme qwen3.8:27b (un téléchargement de 18 Go).
• Les serveurs MCP donnent des mains à l’agent. Pour le travail sur appli, la sélection courte, c’est le pont MCP intégré à Xcode (xcrun mcpbridge), XcodeBuildMCP, le serveur MCP d’Expo, Context7 pour la documentation à jour et Sentry pour les plantages. N’ajoute que ce que tu utilises : chaque serveur coûte du contexte.
• Les skills donnent à l’agent ton playbook. Un skill est un dossier avec un SKILL.md fichier. OpenCode les lit depuis .opencode/skills et aussi depuis .claude/skills et .agents/skills, donc les skills écrits pour d’autres agents fonctionnent aussi. Expo en publie 23 officiels, et la CLI App Store Connect (asc) en fournit plus de vingt.
• Laisse l’agent faire la paperasse, jamais l’envoi. Le asc CLI et ses skills peuvent envoyer des builds, gérer TestFlight, synchroniser les métadonnées et les captures d’écran, et vérifier l’état de la review. Refuse la commande de soumission dans les permissions d’OpenCode et appuie toi-même sur le bouton.
• Les règles d’Apple pour 2026 comptent pour les applis construites avec l’IA. Les applis clonées dans des catégories saturées sont désormais refusées (règle 4.3(b), juin), les fonctionnalités cachées ou dormantes sont interdites (nouvelle 2.5.19, octobre), les builds exigent Xcode 26 ou plus récent, et à partir d’avril 2027 les applis construites avec le SDK iOS 27.1 devront fournir des captures d’écran iPhone Duo.
• Coût la première année : 99 $ si tu fais tout tourner en local et ne paies qu’Apple, environ $419 pour la configuration que je recommande (Apple + OpenCode Go + Ollama Pro en facturation annuelle), et environ 1 779 $ pour une configuration musclée. Tous les prix sont hors TVA.
• La règle la plus importante : “fini” est une affirmation, pas un fait. Lance-la sur un vrai iPhone, en mode avion, en mode sombre, à la taille de texte maximale, avec VoiceOver activé. Ensuite, crois-le.

---

Le parcours en un coup d’œil

Étape	Ce que tu fais	Ce que fait OpenCode	Outils
1. Configuration	Installer, choisir un forfait de codage, connecter les modèles	Rien pour l’instant	OpenCode, OpenCode Go, Ollama
2. Apprentissage	Écrire AGENTS.md, ajouter des skills, connecter les serveurs MCP	Les lit à chaque session	AGENTS.md, skills, MCP
3. Planification	Écrire le brief, discuter du plan	Transforme le brief en plan et en feuille de route	plan agent, /goal
4. Développement	Relire chaque diff, tester sur un appareil	Écrit le code par petits morceaux, compile, lance les tests, prend des captures d’écran	construire agent, Xcode MCP, XcodeBuildMCP ou Expo MCP
5. Bêta	Inviter des testeurs, lire les retours	Archive, envoie, gère les groupes TestFlight	Xcode, asc ou EAS
6. Paperasse	Répondre honnêtement aux questions juridiques et de confidentialité	Rédige les métadonnées, audite les flux de données, redimensionne les captures d’écran	asc compétences
7. Soumission	Tu appuie sur “Soumettre pour vérification”	Vérifie le statut de l’examen, trie les rejets	App Store Connect
8. Lancement	Répondre aux utilisateurs, planifier les mises à jour	Traduit, rédige les notes de version, trie les plantages	asc, Sentry, ton site web

---

Table des matières

• Partie 1 — Ce qu’est OpenCode en novembre 2026, et pourquoi je le recommande
• Partie 2 — Les forfaits de codage expliqués (et les deux que je recommande)
• Partie 3 — Ollama : un seul moteur pour les modèles locaux et cloud
• Partie 4 — Comment utiliser OpenCode : l’installer et connecter tes modèles, étape par étape
• Partie 5 — Agents, commandes, permissions et mode Goal : personnaliser OpenCode
• Partie 6 — Serveurs MCP : donner des mains à l’agent
• Partie 7 — Skills : écris ton manuel une seule fois
• Partie 8 — Construire l’app : de l’idée à une compilation à laquelle tu fais confiance
• Partie 9 — Publier sur l’App Store : laisse OpenCode faire la paperasse, puis appuie toi-même sur Soumettre
• Partie 10 — Lancement : la fiche, les captures d’écran, l’ASO et la vie après l’approbation
• Partie 11 — Combien ça coûte : quatre budgets pour la première année
• Partie 12 — Quinze erreurs à éviter
• Partie 13 — Quelle configuration choisir ? Six scénarios
• Foire aux questions
• En résumé

---

Partie 1 — Ce qu’est OpenCode en novembre 2026, et pourquoi je le recommande

OpenCode est un agent de codage IA open source. Tu le lances dans un dossier de projet, tu décris ce que tu veux, et il travaille comme un développeur : il lit tes fichiers, établit un plan, modifie le code, exécute des commandes, lit les erreurs et continue jusqu’à ce que le travail soit terminé ou qu’il ait besoin de toi. Il est publié sous licence MIT par Anomaly, l’équipe qui le développe, et il ne se soucie pas du modèle que tu lui donnes.

La page d’accueil du projet revendique plus de 220 000 étoiles GitHub, 1 089 contributeurs et 22 millions de développeurs par mois. Ce sont les chiffres du projet lui-même et ils bougent chaque semaine, mais ils expliquent pourquoi OpenCode est devenu l’alternative indépendante des modèles la plus connue face aux agents des fabricants de modèles eux-mêmes, Claude Code et Codex.

Où ça tourne

OpenCode n’est plus une seule application. Depuis la réécriture 2.0, un service en arrière-plan tourne sur ta machine et chaque interface lui parle, donc une session que tu démarres à un endroit apparaît dans les autres.

Interface	Ce que c’est	Idéal pour
Terminal (TUI)	L’application terminal plein écran classique	Travail rapide au clavier, sessions SSH, serveurs
Application de bureau	Une application Electron pour macOS (Apple silicon et Intel), Windows (x64 et ARM64) et Linux (.deb, .rpm, AppImage), avec onglets, diffs, terminaux et un navigateur intégré	Ceux qui ne vivent pas dans un terminal
Web et téléphone	opencode pair affiche un lien à usage unique (il expire au bout de cinq minutes) qui ouvre tes sessions locales dans un navigateur ; la 2.2.6 a ajouté un composeur adapté au téléphone et à la tablette	Vérifier une longue tâche depuis le canapé
Dans Xcode 27	OpenCode parle l’Agent Client Protocol, donc opencode acp peut être ajouté comme agent dans les réglages Intelligence de Xcode	Développeurs Swift natifs qui veulent rester dans Xcode
SDK et scripts	opencode run pour les tâches ponctuelles, plus un SDK JavaScript	Automatisation et CI

Ce qui a changé depuis la 2.0

OpenCode 2.0 a été une reconstruction complète : selon l’annonce de l’équipe en juillet, le runtime est passé de Bun à Node.js pour réduire l’usage mémoire, l’application de bureau est passée de Tauri à Electron, l’API a été repensée et OpenCode a commencé à tourner comme un service par défaut. La version 2.0.0 est sortie le 11 septembre 2026. Les versions publiées depuis ont surtout ajouté les fonctions qui comptent pour de longs projets réels :

Version	Date	Ce qu’elle a ajouté
2.2.0	27 oct.	Plugins de bureau expérimentaux, application de bureau rafraîchie, API d’image et de décision pour les plugins
2.2.1	29 oct.	Mode objectif (/goal <objective>, avec pause, reprise et effacement), optionnel prompts planifiés, génération d’images
2.2.2	29 oct.	Génération d’images activée par défaut quand un fournisseur connecté la prend en charge ; un sélecteur de worktree depuis la branche Git
2.2.3	30 oct.	Le Claude Agent fournisseur (plus de détails dans la partie 2)
2.2.4	30 oct.	Configuration guidée de Claude Agent, planifications qui tournent sous opencode serve, terminaux de bureau persistants
2.2.5	30 oct.	Raccourcis worktree et mode shell, un tampon de compaction en pourcentage
2.2.6	6 nov.	opencode run --worktree pour les exécutions scriptées, un dock de composeur mobile, des connexions MCP partagées

Source : le changelog d’OpenCode, vérifié le 7 novembre 2026. Attends-toi à une version plus récente au moment où tu liras ces lignes.

Pourquoi c’est l’agent que je recommande

1. Il n’est fidèle à aucun modèle. OpenCode se connecte aux abonnements, aux API facturées au token et aux modèles locaux via une seule /connect commande. Quand un meilleur modèle sort le mois prochain, tu changes une ligne dans un fichier de config, pas tout ton flux de travail.
2. Ses permissions fonctionnent comme un pare-feu. Chaque action (lire, éditer, lancer une commande shell, charger une skill, appeler un outil MCP) passe par une liste ordonnée de allow, demander et deny règles où la dernière correspondance l’emporte. “Ne lance jamais git push” “ et ” ne jamais soumettre à l'App Store » occupent chacun une ligne.
3. Il parle les formats de tout le monde. On peut y lire : AGENTS.md (et retombe sur CLAUDE.md), charge les skills depuis .claude/skills et .agents/skills ainsi que ses propres dossiers, et se connecte à n’importe quel serveur MCP. L’écosystème bâti par les autres agents fonctionne ici aussi.
4. Il va là où tu es. Terminal sur un serveur, application de bureau sur un Mac, navigateur sur ton téléphone, ou à l’intérieur de Xcode.
5. Il ne coûte rien. OpenCode est gratuit, et il inclut même une série tournante de modèles gratuits que tu peux utiliser sans compte.

Où il n’est pas le meilleur choix

Honnêteté d’abord : OpenCode n’est pas le meilleur score des classements de codage, parce qu’il n’est pas un modèle. Les harnais qui les dominent sont des tandems de fournisseurs : Claude Code avec le meilleur modèle d’Anthropic, Codex avec celui d’OpenAI. Ils sont réglés ensemble et ils sont excellents. J’en ai comparé vingt-huit dans mon comparatif des harnais de codage IA, et si tu paies déjà l’un de ces abonnements et que tu l’adore, rien dans ce guide ne t’oblige à changer.

Il y a aussi des aspérités. OpenCode publie des versions presque chaque jour, donc les choses bougent sous tes pieds. L’ancienne documentation de la version 1 existe toujours à docs.opencode.ai (avec une bannière qui pointe vers la v2), et beaucoup de guides tiers, y compris la page OpenCode d’Ollama, affichent encore l’adresse de l’installateur v1. Plusieurs des fonctionnalités les plus récentes sont marquées expérimentales. Et les gestionnaires de paquets Windows ne sont pas pris en charge pour l’outil en ligne de commande v2 ; les utilisateurs de Windows disposent de l’application de bureau ou d’un zip autonome.

---

Partie 2 — Les forfaits de codage expliqués (et les deux que je recommande)

OpenCode est gratuit. Le modèle qui réfléchit ne l’est pas. Il y a trois façons de le payer, et la plupart de la confusion autour des “plans de codage IA” vient du fait de les confondre.

1. Lance-le toi-même. Des modèles à poids ouverts sur ton propre Mac via Ollama. Tu paies en matériel et en patience, pas en argent. Ton code ne quitte jamais la machine.
2. Abonne-toi à un plan de codage. Un forfait mensuel fixe achète une enveloppe d’usage, généralement mesurée en fenêtres de cinq heures et hebdomadaires. C’est là que vivent OpenCode Go, Ollama Pro, le GLM Coding Plan et les abonnements ChatGPT et Claude.
3. Paie au token. Apporte une clé API de n’importe quel fournisseur et paie exactement ce que tu utilises. Idéal pour le problème difficile occasionnel ; dangereux pour une longue session de débogage sans alerte de budget.

Les plans de codage qui fonctionnent dans OpenCode (novembre 2026)

Plan	Prix mensuel (USD)	Ce que tu obtiens	Comment il se connecte à OpenCode
Modèles gratuits OpenCode	$0	Une série tournante de modèles gratuits à durée limitée	Intégré, aucun compte nécessaire
Ollama, local	$0	Tout modèle à poids ouverts que ton Mac peut héberger	Détecté automatiquement, ou ollama launch opencode
OpenCode Go ⭐	$10 · Go Plus 40 $ · Go Teams 20 $ par membre	32 modèles ouverts, dont GLM-5.3, GLM-5.3-Flash, Kimi K3 et K3.1 Pro, MiniMax M3.1 Flash, DeepSeek V4.1 Flash et Qwen3.8 Max	/connect → OpenCode Go → colle ta clé
Ollama Pro / Max ⭐	$20 (200 $ par an) · Max 100 $	60 $ (Pro) ou 300 $ (Max) de crédits de modèles cloud par mois, plus un usage local illimité	Comme Ollama en local ; les modèles cloud apparaissent à côté des modèles locaux
Plan de codage GLM (Z.ai)	Lite 18 $ · Pro 80 $ · Max 168 $ (20 % de réduction au trimestre, 30 % à l’année)	GLM-5.3 et GLM-5.3-Flash, tous deux avec une fenêtre de contexte de 1M tokens	/connect → le fournisseur Z.AI Coding Plan
Formule MiniMax M	Go 22 $ · Explore 55 $ · Build 132 $ (deux mois offerts en facturation annuelle)	MiniMax M3.1 Flash, plus des modèles d’image, d’audio et (à partir d’Explore) de vidéo	Le fournisseur de plan de codage de MiniMax, avec une clé M Plan
ChatGPT	La famille GPT-6 d’OpenAI via ton abonnement ChatGPT	→ OpenAI → “Se connecter avec ChatGPT”	/connect Pro 10 $ · Pro+ 39 $ · Max 100 $
GitHub Copilot	Le pool de modèles de Copilot, mesuré en GitHub AI Credits	→ GitHub Copilot → connexion par appareil	/connect Pro 20 $ · Max à partir de 100 $
Claude	Pro 20 $ · Max à partir de 100 $	Les modèles d’Anthropic via Claude Code	/connect → Claude Agent (OpenCode 2.2.3+, Claude Code installé) ; voir la réserve ci-dessous
Paiement au token	Ce que tu utilises	L’API de n’importe quel fournisseur, y compris la passerelle à l’usage d’OpenCode elle-même	/connect → le fournisseur → clé API

Prix catalogue au 7 novembre 2026, hors TVA. ⭐ = ce que ce guide recommande. Prix, quotas et catalogues de modèles changent sans arrêt : vérifie la page de chaque fournisseur avant de t’abonner. Les prix GLM viennent d’un relevé du 24 septembre et du slogan de Z.ai “des plans à partir de 18 $” ; l’abonnement Kimi (à partir de 19 $) est omis, car je n’ai pas pu confirmer une voie officielle via OpenCode.

Comment les limites fonctionnent vraiment

Le prix affiché en dit très peu. C’est l’allocation qui compte au quotidien.

• OpenCode Go donne à chaque modèle sa propre allocation mensuelle en dollars, et tu peux en dépenser 20 % sur une fenêtre de cinq heures et 50 % sur une semaine. Sur le plan à 10 $, par exemple, GLM-5.3-Flash reçoit 60 $ par mois, DeepSeek V4.1 Flash 100 $ et Kimi K3 15 $, donc les modèles légers et efficaces vont bien plus loin que les poids lourds. Quand tu atteins une limite, les requêtes sont bloquées, sauf si tu as activé Extra Usage, qui bascule sur du crédit à l’usage. Les modèles gratuits continuent de fonctionner dans les deux cas.
• Ollama est passé aux crédits : Pro inclut 60 $ d’usage cloud par mois et Max 300 $, tous deux facturés au token, et le crédit non utilisé n’est pas reporté. Pro autorise trois requêtes à la fois, Max dix. Les prix baissent en dehors de la plage 12:00–18:00 UTC en semaine et tout le week-end, ce qui tombe bien pour les soirées européennes. Les modèles locaux sont illimités sur tous les plans, y compris le gratuit.
• Le GLM Coding Plan utilise des crédits par fenêtre de cinq heures et par semaine, et l’usage hors pointe (en dehors de 14:00 à 18:00 heure de Chine en semaine) coûte la moitié des crédits.
• ChatGPT et Copilot comptabilisent via leurs propres systèmes : ChatGPT en estimations de messages par cinq heures et par modèle, Copilot en AI Credits. Dans OpenCode, les connexions ChatGPT n’affichent aucun coût par requête, car l’usage est décompté de ton plan, et OpenCode plafonne par défaut la fenêtre de contexte en entrée pour ces modèles (500 000 tokens sur les modèles GPT les plus récents).

Confidentialité et conservation des données

Tes prompts contiennent ton code. L’endroit où ils vont compte, surtout pour du travail client soumis aux règles européennes de protection des données.

• OpenCode Go bloque par défaut les points de terminaison payants qui s’entraînent sur tes données. La plupart des modèles (GLM, Kimi, MiniMax, Qwen, MiMo et d’autres) sont servis sans conservation ; quelques-uns (Grok, les modèles GPT Luna, Claude Haiku et deux modèles promotionnels gratuits) gardent des journaux pendant 30 jours. Les modèles “Contributor” à prix réduit s’entraînent bel et bien sur tes prompts et doivent être activés volontairement. Les régions par défaut sont l’Europe et les États-Unis, et les modèles de DeepSeek exigent d’accepter le routage mondial, avec un accord de non-conservation valable jusqu’au 30 novembre 2026.
• Nuage d'Ollama dit clairement : “Les données de prompt ou de réponse ne sont jamais journalisées ni utilisées pour l’entraînement.” Les modèles tournent principalement aux États-Unis, la capacité de débordement pouvant être routée vers l’Europe.
• Les modèles gratuits d’OpenCode sont une autre histoire : la doc note que certains modèles gratuits peuvent utiliser tes données pour améliorer le modèle. Parfait pour des expérimentations, pas pour du code client. Mets OPENCODE_DISABLE_FREE_MODELS=1 pour les masquer.
• Modèles locaux ne quittent jamais ta machine. Pour tout ce qui relève d’un accord strict de traitement des données, c’est encore la réponse la plus propre.

La question Claude

Les abonnements Claude ont connu une année agitée dans les outils tiers. En janvier, Anthropic a resserré ses contrôles, si bien que les connexions Claude Pro et Max ont cessé de fonctionner dans des harnais comme OpenCode, et en mars OpenCode a retiré son option de connexion à la demande d’Anthropic. Le 30 octobre, OpenCode 2.2.3 a ramené les abonnements par une autre voie : un fournisseur intégré Claude Agent qui pilote ton Claude Code installé localement (version 2.1.248 ou ultérieure) via l’Agent SDK officiel d’Anthropic, après que tu t’es connecté avec claude auth login.

Les faits à connaître avant de l’utiliser :

• OpenCode ne lit pas la connexion enregistrée de Claude Code ; c’est le véritable exécutable claude qui envoie les requêtes.
• Les outils et réglages propres à Claude Code, CLAUDE.md les fichiers, hooks, serveurs MCP et skills sont désactivés. Claude passe à la place par les outils et les invites d’autorisation d’OpenCode.
• La documentation de l’Agent SDK d’Anthropic indique que les développeurs tiers ne peuvent pas proposer la connexion claude.ai ni les limites d’abonnement dans leurs produits sans l’accord d’Anthropic. Au moment d’écrire, Anthropic n’avait pas commenté publiquement le fournisseur d’OpenCode, et personne ne peut te dire avec certitude si cela met ton compte en danger.

Mon conseil : si tu paies déjà pour Claude et que tu veux essayer, utilise-le pour des projets personnels et surveille une déclaration officielle. Pour du travail professionnel, utilise une clé API Anthropic, la seule voie que nomme la documentation d’Anthropic.

Ce que je recommande, et pourquoi

Commence par OpenCode Go et Ollama. Voici le raisonnement :

• Le prix. 10 $ par mois donnent accès à 32 modèles ouverts solides. Ajoute Ollama Pro à 20 $ si tu veux plus de marge dans le cloud ; passe-le si ton Mac fait bien tourner les modèles locaux.
• Le choix sans enfermement. Go et Ollama Cloud embarquent les mêmes familles à poids ouverts (GLM, Kimi, MiniMax, DeepSeek et d’autres), donc tu peux comparer les modèles sur ton propre projet au lieu de faire confiance à un classement.
• La confidentialité par défaut. Zéro conservation pour la plupart des modèles Go, une politique de non-journalisation chez Ollama, et la possibilité de tout faire en local pour le travail sensible.
• Aucune zone grise. Les deux sont conçus exactement pour cet usage, dans OpenCode.
• Le repli local est gratuit. Quand la fenêtre de cinq heures s'épuise à 23 h, un modèle local sur Ollama te permet de continuer sur les petites tâches.

Quand choisir autre chose. Si tu paies déjà ChatGPT Plus ou Copilot, commence par le connecter ; cela ne te coûte rien de plus. Si GLM doit devenir ton outil quotidien, le quota du GLM Coding Plan’ peut être plus intéressant que les limites par modèle de Go’, et tu peux obtenir 10 % de réduction sur le GLM Coding Plan via mon lien d'affiliation (lien d'affiliation, voir la mention en haut de l'article). Les clés Coding Plan et les clés API Z.ai standard n’ont rien à voir, alors choisis le fournisseur Coding Plan dans /connect. Et si ton travail exige le sommet absolu du classement, un modèle de pointe par clé API pour les tâches les plus difficiles est un bon investissement.

---

Partie 3 — Ollama : un seul moteur pour les modèles locaux et cloud

Ollama fait tourner des modèles à poids ouverts sur ton propre ordinateur et les sert via une API locale simple. Depuis l'an dernier, il fait aussi tourner des modèles plus gros dans son propre cloud, via la même application et la même API, si bien que pour OpenCode un modèle cloud ressemble exactement à un modèle local. C’est tout l’intérêt : un seul moteur, une seule configuration, et un basculement entre “privé et gratuit” et “gros et rapide” qui tient juste à un nom de modèle.

Installer Ollama (étape par étape)

1. Télécharge-le de ollama.com/download. Sur un Mac, ouvre le fichier téléchargé et glisse Ollama dans Applications. Sous Windows, lance l'installateur. Sous Linux, la commande officielle en une ligne est :

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

2. Lance-le. Ouvre l'application, ou tape ollama dans un terminal. Depuis la version 0.40.15 (début novembre), lancer ollama sans argument ouvre un lanceur d'accueil.
3. Connecte-toi si tu veux des modèles cloud. L'application te le demande pendant la configuration. Les modèles locaux fonctionnent sans compte ; ton usage cloud est sur ollama.com/settings/usage.
4. Récupère un modèle pour vérifier que tout fonctionne :

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

Connecter Ollama à OpenCode

Tu as trois options, de la plus simple à la plus souple.

Option 1 : laisse OpenCode le trouver. OpenCode v2 vérifie l'adresse Ollama locale par défaut au démarrage et ajoute chaque modèle capable d'écrire du texte à /models. Pas de compte, pas de configuration. Les modèles uniquement d'embedding sont ignorés.

Option 2 : laisse Ollama le configurer.

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

ollama launch fonctionne avec OpenCode v2 depuis Ollama 0.40.12 (27 octobre). Il n’écrase pas ton ~/.config/opencode/opencode.json, donc tes propres réglages s’appliquent toujours. Une bizarrerie : les modèles que tu as définis uniquement dans la config d’OpenCode n’apparaissent pas dans le sélecteur de lancement d’Ollama.

Option 3 : pointer OpenCode vers un serveur Ollama situé ailleurs. Si Ollama tourne sur un Mac mini dans le placard ou sur un serveur, ajoute-le comme fournisseur avec son adresse. Le /v1 à la fin compte :

{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "ollama": {
      "settings": {
        "baseURL": "https://ollama.example.com/v1",
        "apiKey": "{env:OLLAMA_API_KEY}"   // optional, sent as a bearer token
      }
    }
  }
}

Le réglage qui casse la plupart des configurations locales : la longueur de contexte

La FAQ d’Ollama donne une fenêtre de contexte par défaut de 4 096 tokens. Le guide OpenCode d’Ollama lui-même demande au moins 64K, car le prompt système d’un agent, les définitions d'outils et le contenu des fichiers remplissent une petite fenêtre avant même que le travail commence. Configure-le sur le serveur Ollama, pas dans OpenCode :

# Si tu lances le serveur toi-même :
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# Si tu utilises l'app Mac : définis la variable pour launchd, puis quitte et rouvre Ollama
launchctl setenv OLLAMA_CONTEXT_LENGTH 65536

Vérifie ensuite que c'est bien pris en compte : ollama ps affiche la taille de contexte de chaque modèle chargé et s’il s’exécute sur le GPU. Une fenêtre plus grande consomme plus de mémoire, donc sur un Mac de 32 Go, 64K est un plafond raisonnable pour un modèle de 27 milliards de paramètres.

Quel modèle local convient à ton Mac

Une règle empirique utile tirée du classement de BenchLM’ en novembre : un modèle a besoin d'environ sa taille de téléchargement plus 20 % pour le contexte, et un Mac peut consacrer près de trois quarts de sa mémoire unifiée au GPU. En pratique, garde le téléchargement en dessous d’environ 60 % de la mémoire de ton Mac.

La mémoire de ton Mac	gemma4:12b	Télécharger	Contexte	Idéal pour
16 Go	gemma4:12b ou gemma4:e4b	7.7 GB / 6.6 GB	256K / 128K	Explications, petites modifications, messages de commit. Trop petit pour de longues sessions d’agent ; utilise des modèles cloud pour construire
24 à 32 Go	qwen3.8:27b (aussi comme 27b-mlx pour Apple silicon)	18 GB	256 Ko	Le bon compromis local pour coder avec un agent
24 à 32 Go	qwen3-coder:30b	19 GB	256 Ko	Un codeur mixture-of-experts avec seulement environ 3 milliards de paramètres actifs, donc il’est rapide
24 à 32 Go	gpt-oss:20b	14 GB	128 K	Le plus petit modèle à poids ouverts d’OpenAI ; celui qui laisse le plus de marge
64 GB	Les mêmes modèles en précision supérieure, comme qwen3.8:27b-q8_0	30 GB	256 Ko	De meilleures réponses, de la place pour un grand contexte
96–128 GB	gpt-oss:120b ou devstral-2:123b	65 GB / 75 GB	128K / 256K	La qualité d’un grand modèle sans le cloud

Tailles et fenêtres de contexte issues de la bibliothèque Ollama au 7 novembre 2026. La vitesse dépend de la bande passante mémoire de ta puce autant que de sa capacité de mémoire. Pour le volet matériel, vois mon guide MacBook pour les LLM locaux.

Ollama Cloud : les modèles que ton Mac ne peut pas contenir

Les modèles de codage à poids ouverts les plus puissants aujourd’hui sont bien trop gros pour un ordinateur portable. Ollama Cloud les exécute pour toi. Dans l’appli ou le CLI, ils portent une :cloud étiquette et ne téléchargent rien :

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

La partie du catalogue cloud utile pour le codage au 7 novembre :

Modèle	Créateur	Contexte	La note d’usage d’Ollama	Notes
glm-5.3	Z.ai	1 million	Haut	Le fer de lance de Z.ai ; performant sur les longues tâches agentiques
glm-5.3-flash	Z.ai	1 million	Moyen	Nativement multimodal, 18 milliards de paramètres actifs ; un excellent modèle par défaut pour construire
kimi-k3.1-pro	Moonshot AI	1 million	Très élevée	L’entrée la plus récente (mise à jour le 4 novembre), multimodale, le modèle le plus capable de Moonshot
kimi-k2.7-code	Moonshot AI	256 Ko	Haut	Ajusté pour le codage et plus économe en tokens de réflexion
minimax-m3.1-flash	MiniMax	976K	Moyen	Lit les images ; 0,15 $ en entrée et 0,60 $ en sortie par million de tokens
deepseek-v4.1-flash	DeepSeek	1 million	Moyen	Conçu pour la vitesse et le débit ; lit les images
mistral-large-4	Mistral	1 million	Haut	Laboratoire européen, poids ouverts
gemma4	Google	256 Ko	Faible	Assez bon marché pour les assistants et les sous-agents

La note est le raccourci d’Ollama pour dire à quelle vitesse un modèle dépense tes crédits. Si tu veux comparer les gros modèles correctement, mes Kimi K3 vs Fable 5.1 vs GLM-5.3 et GLM-5.3-Flash vs MiniMax M3 comparaisons vont plus loin.

Le modèle de routage que je copierais

Tu n’es pas obligé de choisir un seul modèle. Donne à chaque type de travail le modèle le moins cher qui le fait bien :

• Planification (c’est là que les erreurs les plus coûteuses arrivent) : ton modèle le plus fort.
• Développement: un modèle rapide et compétent comme GLM-5.3-Flash ou MiniMax M3.1 Flash.
• Chercher dans le code, lire la doc, écrire des tests et des messages de commit: un modèle local. Il ne coûte rien et ton code reste chez toi.

La partie 4 montre exactement comment régler ça dans la config d’OpenCode.

Mode 100 % local pour les projets sensibles

Si un projet ne doit jamais toucher un modèle cloud, fais-en un réglage plutôt qu’une promesse. Ollama peut couper complètement ses fonctions cloud (ajoute "disable_ollama_cloud": true à ~/.ollama/server.json, ou définis OLLAMA_NO_CLOUD=1, puis redémarre-le), et les modèles cloud gratuits d’OpenCode peuvent être masqués avec OPENCODE_DISABLE_FREE_MODELS=1. Ensuite, ne connecte que des fournisseurs locaux dans ce projet.

Les réserves honnêtes sur Ollama

• Les modèles locaux sont plus lents et plus faibles sur les usages d’outils longs et en plusieurs étapes que les gros modèles cloud. Ils brillent sur les tâches bien délimitées.
• Le cloud reste l’ordinateur de quelqu’un d’autre. La politique de non-journalisation d’Ollama est bonne, mais ton code quitte quand même ta machine, le plus souvent pour les États-Unis.
• Les crédits s’épuisent. 60 $ de crédit Pro vont loin sur GLM-5.3-Flash et bien moins sur un modèle noté “extra high” (très élevé).
• Une réponse lente n’est pas toujours la faute du modèle. Chaque requête cloud fait d’abord un aller-retour par ton Wi-Fi, ton routeur et l’internet au sens large. Si les réponses te semblent lentes, vérifie la connexion avant d’accuser le modèle : mon application PingAtlas mesure les temps d’aller-retour depuis ton iPhone, ton iPad ou ton Mac vers des villes et vers des services comme GitHub, et j’explique le reste du chemin dans ce qui se passe à l'intérieur de ton routeur.

---

Partie 4 — Comment utiliser OpenCode : l’installer et connecter tes modèles, étape par étape

C’est la config que je donnerais à un ami. Elle prend une vingtaine de minutes, surtout du téléchargement.

Étape 0 — Ce dont tu as besoin avant toute chose

• Un Mac équipé d'un processeur Apple Silicon, si tu veux créer des apps iPhone en natif. Xcode 27.1 (sorti le 15 octobre, avec Swift 6.4 et le SDK iOS 27.1) exige macOS Tahoe 26.6 ou une version ultérieure. Si tu développes avec Expo, son service cloud peut compiler des apps iOS depuis Windows ou Linux, mais tu voudras quand même un iPhone pour tester.
• Xcode depuis le Mac App Store, ouverte une fois pour qu’il puisse installer ses composants.
• Git. Ton vrai bouton d’annulation.
• Node.js, seulement si tu utilises Expo : le SDK 58 demande Node 22.13 ou ultérieur, 24.3 ou ultérieur, ou 26 et plus (les versions impaires comme 23 et 25 ne sont pas prises en charge).
• Un forfait de codage de la partie 2, ou Ollama de la partie 3.

Étape 1 — Installer OpenCode

Sur macOS ou Linux :

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

Tu préfères une app ? Télécharge la version bureau pour macOS, Windows ou Linux depuis opencode.ai/download. Les apps terminal et bureau partagent le même service en arrière-plan et les mêmes sessions. Sous Windows, utilise l’app bureau ou le zip autonome ; les gestionnaires de paquets Windows ne sont pas pris en charge pour la v2.

Deux pièges à connaître :

• Les vieux guides utilisent l’ancien installateur. opencode.ai/install (sans /v2/) apparaît encore dans beaucoup de tutoriels, y compris dans certaines docs officielles de partenaires. Utilise l’ /v2/installation adresse ci-dessus.
• Utilisateurs de mise ont besoin de mise 2026.10.9 ou ultérieur, sinon ils récupèrent OpenCode 1.

Étape 2 — Connecter tes modèles

Lance OpenCode dans un dossier de projet et exécute /connect:

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

Ensuite, selon ce que tu paies :

Tu as	En /connect, choisis	Ensuite
OpenCode Go	OpenCode Go	Colle la clé API depuis OpenCode Console
Ollama	Rien ; les modèles locaux apparaissent tout seuls	Ou exécute ollama launch opencode
ChatGPT Plus ou Pro	OpenAI → Se connecter avec ChatGPT	Connecte-toi dans le navigateur
GitHub Copilot	GitHub Copilot	Termine la connexion de l'appareil
Claude Pro ou Max	Claude Agent (pas “Anthropic”, qui sert pour les clés API)	Courir claude auth login dans un terminal d'abord ; lis la mise en garde de la partie 2
Plan de codage GLM	Le fournisseur Z.AI Coding Plan	Colle ta clé Coding Plan, pas une clé API standard
Une clé API	Le nom du fournisseur	Colle la clé

Étape 3 — Choisis tes modèles

Courir /models et choisis. Les modèles OpenCode Go s'appellent opencode-go/<model-id>; les modèles Ollama locaux apparaissent sous le fournisseur Ollama. Copie les identifiants exacts depuis /models dans ta config, car les noms et les tags changent.

Étape 4 — Ajouter une configuration de projet

Les valeurs par défaut fonctionnent, mais un projet d'app mérite un fichier de config qui remplit trois rôles : router chaque agent vers le bon modèle, tenir l'agent à l'écart de tout ce qui est irréversible, et connecter tes serveurs MCP. Enregistre-le sous opencode.jsonc à la racine du projet, et remplace les identifiants de modèle /models te montre :

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

  // The model new sessions start with
  "model": "opencode-go/glm-5.3-flash",

  "agents": {
    // Planning: your strongest model, because a bad plan costs the most later
    "plan":    { "model": "opencode-go/glm-5.3" },
    // Building: fast and capable
    "build":   { "model": "opencode-go/glm-5.3-flash" },
    // Read-only exploring: local, free, private
    "explore": { "model": "ollama/qwen3.8:27b" }
  },

  // Rules are checked in order and the LAST match wins
  "permissions": [
    { "action": "shell", "resource": "*",                     "effect": "ask"   },
    { "action": "shell", "resource": "git status *",          "effect": "allow" },
    { "action": "shell", "resource": "git diff *",            "effect": "allow" },
    { "action": "shell", "resource": "git log *",             "effect": "allow" },
    { "action": "shell", "resource": "xcodebuild -list *",    "effect": "allow" },
    { "action": "shell", "resource": "asc * list *",          "effect": "allow" },
    { "action": "shell", "resource": "asc review status *",   "effect": "allow" },
    { "action": "shell", "resource": "git push *",            "effect": "deny"  },
    { "action": "shell", "resource": "asc publish appstore *","effect": "deny"  },
    { "action": "shell", "resource": "* --submit *",          "effect": "deny"  },
    { "action": "shell", "resource": "* --confirm *",         "effect": "deny"  }
  ],

  "mcp": {
    "servers": {
      // Apple's bridge to the Xcode project you have open (Part 6)
      "xcode": { "type": "local", "command": ["xcrun", "mcpbridge"] },
      // Headless builds, simulator control and screenshots (Part 6)
      "XcodeBuildMCP": { "type": "local", "command": ["npx", "-y", "xcodebuildmcp@latest", "mcp"] },
      // Up-to-date library documentation
      "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" }
    }
  }
}

Ce que tu colles, en clair :

• Chaque commande shell demande d'abord, sauf quelques-unes en lecture seule. Les asc requêtes en lecture seule (tout ce qui liste, plus le statut de la review) sont autorisées, pour que l'agent puisse vérifier les builds et l'avancement de la review sans te déranger.
• Quelques choses sont bloquées d'office: pousser du code, publier ou soumettre une app à la review, et confirmer les actions destructrices dans App Store Connect. Tu fais ça toi-même, exprès. Envoyer un build vers TestFlight reste autorisé (après demande), parce que ça n'envoie rien en review.
• Les valeurs par défaut d'OpenCode demandent déjà avant de lire .env fichiers. Laisse ça activé.
• Les permissions sont des garde-fous, pas un bac à sable. Un modèle déterminé peut trouver une autre façon de faire. Garde les identifiants de production, les clés de signature et ta clé Admin App Store Connect hors de la machine où les agents tournent sans surveillance.

Étape 5 — Écris un AGENTS.md avant la moindre ligne de code

OpenCode indique AGENTS.md à la racine de ton projet au début de chaque session, plus un personnel dans ~/.config/opencode/AGENTS.md si tu le crées. La /init commande peut en rédiger un en scannant ton dépôt. C'est l'habitude la plus efficace du développement assisté par IA, et j'ai écrit sur tout le système dans mon Guide de codage Vibe. Pour une app iPhone, il doit contenir les règles du produit autant que les commandes :

# Notes pour les agents de codage

## Ce qu'est cette app
Une phrase. Si un changement ne la sert pas, il n'a pas sa place.

## Non négociables
- Fonctionne hors ligne. Les fonctions réseau se dégradent proprement.
- Pas d'analytics, de pubs ni de SDK de tracking. Demande avant d'ajouter la MOINDRE dépendance.
- Pas de secrets dans le bundle de l'app. Les clés qui coûtent de l'argent vivent sur un serveur.
- Pas de fonctions cachées, dormantes ou réservées au debug dans les builds de release
  (règle 2.5.19 de l'App Review). Les menus de debug sont exclus à la compilation en Release.
- Ne jamais envoyer de données personnelles à un service d'IA tiers sans
  un écran de consentement explicite dans l'app (règle 5.1.2(i)).
- Accessibilité : Dynamic Type, labels VoiceOver, cibles tactiles de 44 x 44 pt,
  mode clair et mode sombre sur chaque écran.
- Chaque chaîne visible par l'utilisateur est localisée, y compris les widgets,
  les notifications et les demandes de permission.

## Commandes
- Compiler et lancer : utiliser les outils XcodeBuildMCP (build_run_sim), schéma "MyApp"
- Tests : test_sim
- Ne jamais lancer asc publish ni quoi que ce soit avec --submit.

## Définition de « terminé »
- Compile sans avertissement, les tests passent
- Vérifié avec screenshot + snapshot_ui sur le simulateur
- Fonctionne en mode avion, en mode sombre et à la taille de texte maximale

Étape 6 — Ta première vraie session

1. Commence en mode plan. Passe à l' plan agent (il ne peut pas modifier les fichiers de ton projet) et demande-lui de contester ton brief : “Lis AGENTS.md et BRIEF.md. Liste les parcours utilisateur, les cas limites auxquels je n'ai pas pensé et les écrans qui me manquent. Puis dis-moi quoi couper.”
2. Enregistre le plan sous forme de feuille de route. Demande-lui d'écrire ROADMAP.md sous forme de liste de contrôle de petites tranches de bout en bout.
3. Construis une tranche à la fois avec l' construire agent. Un écran, une fonctionnalité, qui fonctionne de bout en bout.
4. Relis le diff, exécute-le, commit. Chaque tranche se termine par un commit. Si une étape se passe mal, /undo annule la dernière étape de l'agent à partir des instantanés d'OpenCode ; Git reste le filet de sécurité principal.
5. Démarre une nouvelle session pour la tranche suivante. Une session propre qui relit AGENTS.md et ROADMAP.md est généralement plus intelligente qu'une longue session pleine d'hypothèses périmées.

---

Partie 5 — Agents, commandes, permissions et mode Goal : personnaliser OpenCode

Une fois les bases en place, quatre fonctionnalités transforment OpenCode d'un simple chat dans un terminal en un atelier adapté à ton projet.

Les agents intégrés

Agent	Type	Fonctionnalités
construire	Principal	Celui par défaut. Modifie les fichiers, exécute les commandes, fait le travail
plan	Principal	Explore et planifie sans modifier les fichiers de ton projet (il peut écrire ses propres fichiers de plan)
general	Sous-agent	Recherche et tâches en plusieurs étapes ; ne peut pas lancer d'autres sous-agents
découvrir	Sous-agent	Cherche et lit du code ou des pages web ; ne peut rien modifier

Les agents principaux sont ceux à qui tu parles. Les sous-agents sont lancés par un agent principal pour une tâche ciblée, afin que le contexte de la session principale reste propre.

Écris ton propre sous-agent : un sceptique de l'App Review

Les agents personnalisés sont des fichiers Markdown dans .opencode/agents/ (ou ~/.config/opencode/agents/ pour tous les projets). Le front matter configure l'agent et le corps devient ses instructions. Celui-ci passe ton app en revue comme le fera l'App Review, et ne peut rien modifier pendant ce temps :

---
description: Passe en revue l'app et ses métadonnées au regard des App Review Guidelines d'Apple avant une soumission
mode: subagent
model: opencode-go/glm-5.3
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

Tu es un spécialiste sceptique de l'App Review. Examine le code actuel et les
fichiers de metadata/ et liste les problèmes, du plus grave au moins grave, avec fichier et ligne :

- Plantages, textes de remplacement, liens morts, compte de démo manquant (2.1)
- Tout ce qui ressemble à une copie d'une catégorie d'app saturée (4.3(b))
- Fonctionnalités cachées, dormantes ou non documentées, menus de débogage, feature flags (2.5.19)
- Données qui quittent l'appareil et ne figurent ni dans la politique de confidentialité ni dans l'étiquette de confidentialité
- Données personnelles envoyées à un service d'IA sans consentement explicite (5.1.2(i))
- Création de compte sans suppression de compte dans l'app (5.1.1(v))
- Captures d'écran ou descriptions qui promettent des fonctionnalités absentes de la build

Ne corrige rien. Signale seulement.

Enregistre-le sous .opencode/agents/appstore-reviewer.md, puis demande : “Utilise le sous-agent appstore-reviewer pour passer en revue tout ce qui a changé depuis le dernier tag de version.”

Des commandes personnalisées pour les tâches que tu répètes

Les commandes sont des modèles de prompt que tu lances avec un slash. Place-les dans .opencode/commands/; $ARGUMENTS est remplacé par ce que tu tapes après la commande, et ` !command ` insère la sortie d'une commande shell avant l'envoi du prompt. Celui-ci rédige les notes de version de l'App Store :

---
description: Rédige les notes « What's New » de l'App Store à partir des commits depuis le dernier tag
agent: build
---

Voici les commits depuis la dernière version :

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

Rédige les notes « What's New » de la version $ARGUMENTS en anglais simple et accessible,
sous 400 caractères, uniquement les changements visibles par l'utilisateur. Enregistre-les dans
metadata/en-US/release_notes.txt et montre-moi le texte.

Enregistre-le sous .opencode/commands/whats-new.md et lance-la avec /whats-new 1.2.0. Un avertissement de la doc d'OpenCode mérite d'être répété : ces ! blocs s'exécutent en dehors du système de permissions de l'agent, alors ne mets que des commandes auxquelles tu fais confiance.

Un recueil de permissions pour les projets d'app

La configuration de la partie 4 est un bon point de départ. Quelques autres règles à connaître :

• Règles par agent vont sous agents.<id>.permissions et s'ajoutent après les règles globales, ce qui te permet, par exemple, de laisser uniquement l' construire agent exécuter xcodebuild.
• Les outils MCP sont aussi des actions, nommées <server>_<tool>. Une règle comme { "action": "XcodeBuildMCP_*", "resource": "*", "effect": "ask" } fait demander confirmation à chaque appel XcodeBuildMCP.
• Les skills peuvent être soumises à autorisation avec l' skill action: allow annonce et charge une skill librement, demander l'annonce mais demande confirmation avant de la charger, deny la masque complètement.
• Quand plusieurs ressources sont vérifiées en même temps, n'importe quel deny l'emporte, puis n'importe quel demander.

Mode Goal, worktrees et planifications

Trois fonctionnalités plus récentes changent la perception de la durée des tâches :

• Mode objectif (2.2.1): /goal Fais passer un audit VoiceOver à chaque écran et corrige ce qui échoue garde la session au travail vers l'objectif jusqu'à ce qu'il soit examiné, avec pause, resume et clear. Parfait pour les gros travaux ennuyeux : les passes d'accessibilité, la traduction, la couverture de tests.
• Worktrees: démarre une session dans un worktree Git séparé depuis l'écran de nouvelle session (ou ⌘⌥O dans l'application de bureau), pour qu'une expérience ne puisse pas toucher ta branche principale. Les exécutions scriptées prennent opencode run --worktree=<name> depuis la 2.2.6. Jette le worktree si l'expérience échoue.
• Prompts planifiés (sur activation, expérimental) : /schedule exécute un prompt selon un calendrier pendant que opencode serve est en cours, par exemple un “lance les tests et résume les échecs” nocturne.

---

Partie 6 — Serveurs MCP : donner des mains à l’agent

À lui seul, un agent de codage peut lire des fichiers et exécuter des commandes shell. MCP, le Model Context Protocol, est la façon standard de lui en donner plus : un projet Xcode en cours d'exécution, un simulateur qu'il peut toucher et capturer, tes rapports de plantage, la documentation à jour, ton service de build. Chaque serveur MCP expose un ensemble d'outils, et l'agent décide quand les appeler.

Il y a un coût, et la documentation d'OpenCode le dit clairement : “Les outils MCP consomment le contexte du modèle, donc n'ajoute que les serveurs dont tu as besoin.” Chaque serveur connecté ajoute des descriptions d'outils à chaque requête. Dix serveurs que tu utilises rarement rendent chaque réponse plus lente et moins précise.

La sélection du développeur d'applications

Serveur	Ce que ça apporte à l'agent	L'ajouter à OpenCode	À savoir
Xcode (Apple)	Ton projet Xcode ouvert : compilation, tests et plus encore, via Xcode lui-même	opencode mcp add xcode -- xcrun mcpbridge	Dans Xcode → Réglages → Intelligence, règle Autoriser les agents externes à utiliser les outils Xcode à Toujours ou Lorsque Xcode est ouvert. Ouvre le projet dans Xcode avant de lancer ton prompt ; Xcode indique quand un agent se connecte
XcodeBuildMCP	Compilations sans interface, exécutions sur simulateur et appareil, captures d'écran, appuis et balayages, instantanés d'accessibilité, tests, débogage LLDB	opencode mcp add XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp	Open source (MIT), maintenu par Sentry depuis son rachat du projet en février. Nécessite macOS 14.5+, Xcode 16+ et Node 18+. Seuls les outils de simulateur sont activés par défaut
Expo	Builds, flux de travail et soumissions EAS, docs Expo, simulateurs cloud, données de plantage et de retours depuis TestFlight et les stores	opencode mcp add expo --url https://mcp.expo.dev/mcp, alors opencode mcp auth expo	Nécessite un compte Expo et le dernier SDK. Certains outils demandent un abonnement Expo payant. Les outils de simulateur locaux nécessitent npx expo install expo-mcp --dev et le SDK 54+
Context7	Une documentation à jour et propre à chaque version pour les bibliothèques et frameworks	opencode mcp add context7 --url https://mcp.context7.com/mcp	Empêche le modèle d'inventer des API qui ont changé le mois dernier
Sentry	Tes vrais plantages et erreurs	opencode mcp add sentry --url https://mcp.sentry.dev/mcp, alors opencode mcp auth sentry	Connexion via OAuth
Playwright	Un vrai navigateur que l'agent peut piloter	opencode mcp add playwright -- npx @playwright/mcp@latest	Pour la version web de ton app et ta page de destination
Firebase	Ton projet Firebase, tes règles de sécurité et ta configuration	opencode mcp add firebase -- npx -y firebase-tools@latest mcp	Demande avant de modifier quoi que ce soit dans ton projet

Vérifie l’état des connexions avec Liste des MCP OpenCode, et active ou désactive des serveurs pour une session avec /mcps.

Si tu conçois dans Figma, son serveur MCP peut aussi fournir des frames et des variables à l'agent. J'ai couvert le piège propre à OpenCode (serveur distant contre serveur de bureau) dans mon guide consacré à la création d'une app de zéro avec l'IA.

Le pont MCP d’Xcode face à XcodeBuildMCP

Ils se chevauchent, et ils fonctionnent bien ensemble :

• Le serveur d’Xcode (xcrun mcpbridge) fonctionne via l'app Xcode que tu as ouverte. C’est celui d’Apple, il comprend ton projet comme Xcode, et il a besoin que Xcode soit lancé.
• XcodeBuildMCP encapsule les outils en ligne de commande d’Apple (xcodebuild, simctl, devicectl), il tourne donc sans interface. Sa vraie force, c'est la boucle de vérification : build_run_sim pour compiler et lancer, screenshot pour regarder, snapshot_ui pour lire l'arbre d'accessibilité, tap et type_text pour utiliser l'app, et test_sim pour lancer les tests. Lance xcodebuildmcp init une fois dans ton projet pour installer ses deux skills complémentaires.

Dans le fichier de configuration

Les mêmes serveurs peuvent vivre dans opencode.jsonc (la partie 4 en donne un exemple complet), ce qui est mieux pour une équipe, car la configuration voyage avec le dépôt :

"mcp": {
  "servers": {
    "expo":   { "type": "remote", "url": "https://mcp.expo.dev/mcp" },
    "sentry": { "type": "remote", "url": "https://mcp.sentry.dev/mcp" },
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "headers": { "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}" }
    },
    "playwright": { "type": "local", "command": ["npx", "@playwright/mcp@latest"], "disabled": true }
  }
}

Deux détails tirés de la doc MCP d’OpenCode : les secrets s’insèrent sous la forme {env:NAME} (un simple $NAME n’est pas développé), et "disabled": true garde un serveur configuré sans le connecter.

Quand un outil en ligne de commande bat un serveur MCP

Ma règle : si un bon outil en ligne de commande existe, essaie-le avec une compétence avant d’ajouter un serveur. L’agent sait déjà exécuter des commandes, un CLI ne coûte aucun contexte tant qu’il n’est pas utilisé, et sa sortie peut être filtrée avant d’atteindre le modèle. Pour le travail sur une app, trois CLI couvrent déjà beaucoup de terrain :

• gh pour GitHub : issues, pull requests, releases.
• asc pour App Store Connect : builds, TestFlight, métadonnées, captures d’écran, statut de la revue (partie 9).
• eas pour le service de build et de soumission d’Expo.

La sécurité MCP en quatre règles

1. Installe les serveurs de leurs créateurs ou de projets que tu peux lire. Un serveur, c’est du code qui tourne sur ta machine avec tes permissions.
2. Traite la sortie des outils comme non fiable. Une page web, un commentaire d’issue ou un rapport de plantage peut contenir des instructions destinées à ton agent. Garde les actions risquées sur demander.
3. Contrôle les outils par leur nom. Chaque outil MCP est une action de permission appelée <server>_<tool>, donc tu peux autoriser ceux en lecture seule et faire demander confirmation pour les autres.
4. Retire ce que tu n’utilises pas. Ça coûte du contexte, et c’est une chose de moins qui peut mal tourner.

---

Partie 7 — Skills : écris ton manuel une seule fois

AGENTS.md dit à l’agent ce qu’est ton projet. Compétences lui apprennent comment tu fais des tâches précises : publier un build, écrire une migration, préparer des captures d’écran, auditer la confidentialité. Une compétence est un dossier contenant un SKILL.md fichier avec une courte description en haut et les instructions en dessous, plus tous les scripts ou fichiers de référence dont elle a besoin. Le format est un standard ouvert partagé par OpenCode, Claude Code, Codex et d’autres, c’est pourquoi une compétence écrite pour un agent fonctionne généralement dans les autres.

Comment OpenCode utilise une compétence

1. À chaque étape, OpenCode montre au modèle une liste des compétences qu’il peut utiliser : juste l’ID, le nom et la description de chacune. Les instructions elles-mêmes ne sont pas chargées, donc cent compétences ne coûtent presque rien.
2. Quand une tâche correspond, le modèle appelle l’outil skill avec l’ID de la compétence, et OpenCode vérifie tes permissions.
3. OpenCode ajoute les instructions à la conversation, avec le chemin du dossier de la compétence et une liste d’au plus dix de ses fichiers de support.
4. Les fichiers de support ne se chargent que lorsque les instructions les demandent. Une longue checklist ou un script reste sur le disque jusqu’à ce qu’on en ait besoin.

Tu peux aussi en charger une toi-même en la mentionnant dans un prompt : @app-store-release.

Où OpenCode cherche

Champ d'application	Dossier
Ton projet	.opencode/compétences/
Ton projet (partagé avec d’autres agents)	.claude/skills/ et .agents/skills/
Tous les projets de ta machine	~/.config/opencode/skills/
Tous les projets (partagés)	~/.claude/skills/ et ~/.agents/skills/
Partout ailleurs	Chemins ou catalogues HTTP listés dans un compétences tableau dans opencode.jsonc

L’ID d’une skill vient du nom de son dossier, pas du nom nom dans son front matter, et il est sensible à la casse : .opencode/skills/app-store-release/SKILL.md a l’ID app-store-release. Quand deux sources définissent le même ID, la dernière dans cet ordre l’emporte : intégré, .claude/skills, .agents/skills, ton dossier global, celui de ton projet .opencode/skills, puis les entrées de configuration explicites. Une skill sans description n’est pas du tout exposée au modèle.

Écris ta première skill : une liste de contrôle de publication sur l’App Store

Crée .opencode/skills/app-store-release/SKILL.md:

---
name: App Store release
description: Prépare une version iOS. Incrémente la version et le numéro de build, exécute la liste de contrôle de publication, archive, envoie sur TestFlight avec asc et rédige les notes « Nouveautés ». À utiliser quand on demande de « publier », « sortir » ou « envoyer sur TestFlight ».
---

# App Store release

1. Vérifie `git status`. Si l’arbre de travail n’est pas propre, arrête-toi et signale-le.
2. Incrémente la version marketing et le numéro de build (demande quelle version si elle n’est pas précisée).
3. Parcours references/release-checklist.md. Chaque point doit passer.
4. Archive et exporte l’IPA avec scripts/archive.sh.
5. Envoie : `asc builds upload --app "$ASC_APP_ID" --ipa build/MyApp.ipa`
6. Rédige les notes « Nouveautés » à partir des commits depuis le dernier tag et enregistre-les
   dans metadata/en-US/release_notes.txt.
7. Ne soumets JAMAIS pour review. Signale que le build est envoyé, puis arrête-toi.

Mets la liste de contrôle dans references/release-checklist.md et le script d’archivage dans scripts/archive.sh à côté. La prochaine fois que tu dis “envoie la 1.2.0 sur TestFlight”, l’agent trouve la skill grâce à sa description et suit tes étapes au lieu d’improviser.

Des skills qui valent le coup pour le travail d’app

Jeu de skills	Que contient-il ?	Installer
Skills Expo (officielles)	23 skills : 16 pour le SDK Expo (Router, UI native, @expo/ui, systèmes de design, mises à niveau, modules natifs et plus) et 7 pour les services d’Expo, dont eas-app-stores pour compiler et soumettre sur TestFlight, l’App Store et Google Play	npx skills add expo/skills
Skills CLI App Store Connect	Plus de vingt asc skills : flux de publication, orchestration TestFlight, synchronisation des métadonnées avec contrôle des limites de caractères, traduction des fiches, pipelines de captures d’écran, configuration de la signature, santé de la soumission, tri des plantages, audits ASO	asc install-skillsou npx skills add rorkai/app-store-connect-cli-skills
Skills XcodeBuildMCP	Deux skills qui apprennent à l’agent les outils et le CLI de XcodeBuildMCP	xcodebuildmcp init
skills.sh	L’annuaire ouvert de skills communautaires de Vercel ; il cite OpenCode parmi les agents pris en charge	npx skills add <owner/repo>

Si OpenCode n’affiche pas une skill que tu as installée, vérifie où l’installateur l’a mise par rapport aux dossiers ci-dessus, ou copie le dossier de la skill dans .opencode/compétences/.

Sécurité des skills

Une skill, ce sont des instructions et, souvent, des scripts que l’agent va exécuter. Lis une skill tierce avant de l’installer, comme tu lirais un script shell venu d’internet. Privilégie les skills des gens qui font l’outil (Expo pour Expo, les asc mainteneurs de asc), garde les skills inconnues sur demander avec une règle de permission, et souviens-toi que deny cache complètement une skill au modèle.

---

Partie 8 — Construire l’app : de l’idée à une compilation à laquelle tu fais confiance

Les outils sont prêts. Maintenant la partie qui décide si quelqu’un téléchargera le résultat.

Choisis une idée que l’App Review acceptera

L’IA a rendu la création d’une app bon marché, et Apple l’a remarqué. Le 9 juin, elle a réécrit la règle 4.3(b), sa règle anti-spam : les apps essentiellement identiques à ce qui pullule déjà sur le store sont désormais rejetées, et Apple cite les apps de rencontre, les lampes de poche, les fonds d’écran, les minuteurs et les apps de voyance parmi les catégories où il faut une expérience réellement différente ou meilleure. Les apps gadgets à faible effort peuvent être retirées, les apps existantes de ces catégories peuvent être supprimées si elles ne sont pas améliorées ou n’attirent pas d’utilisateurs, et des soumissions répétées de ce genre peuvent te coûter ton adhésion de développeur.

Donc avant le premier prompt, un test : peux-tu dire en une phrase ce que ton app fait que les premiers résultats de son terme de recherche principal ne font pas ? Si tu n’y arrives pas, l’agent le construira à la perfection et l’App Review te le renverra.

Le petit et le précis l’emportent sur le grand et le générique. Mes deux applications sont volontairement étroites :

• Stash retient où tu ranges les choses : photographie l’endroit, choisis la pièce, enregistre, puis cherche par nom, par pièce ou par note vocale transcrite.
• PingAtlas mesure les temps d’aller-retour réseau depuis ton propre iPhone, iPad ou Mac vers 202 villes, 278 destinations publiques, 109 jeux et 32 services en ligne, sans compte ni service de mesure distant.

Une seule fonction chacune. C’est ce qui les rend réalisables par une personne seule avec un agent, et explicables en une phrase sur une page de l’App Store.

Choisis ta stack

	SwiftUI + Xcode 27.1	Expo SDK 58 (React Native 0.88)
Fonctionne sous	iPhone, iPad, Mac, Apple Watch, Vision Pro	iPhone, iPad, Android et le web depuis une seule base de code
Langue	Swift 6.4	TypeScript
Tu as besoin d'un Mac ?	Oui	Pas pour compiler ni soumettre (le cloud d’Expo s’en charge) ; oui pour les outils de simulateur iOS en local
Outillage d’agent	le pont MCP de Xcode, XcodeBuildMCP, OpenCode dans Xcode via ACP	Le serveur MCP d’Expo, 23 skills officiels, un @expo/agent-cli expérimental et une sortie lisible par machine de la commande expo command:ps à destination des agents
Nouveautés de cet automne	SDK iOS 27.1, un simulateur iPhone Duo (avec quelques limites sur les extensions)	Compilé avec le SDK iOS 27 ; les apps passent au cycle de vie de scène d’UIKit, prêtes pour iPhone Duo ; prise en charge d’App Intents en alpha ; macOS n’est pas pris en charge dans le SDK 58
Meilleur pour	Les apps Apple uniquement qui veulent les fonctionnalités les plus récentes de la plateforme	Une seule personne qui publie sur iPhone et Android, avec une version web

Si tu aimes publier d’abord une version web (c’est mon cas), la sortie web d’Expo te permet de mettre une démo fonctionnelle sous les yeux des gens avant même que la version App Store existe. Le site de Stash fait quelque chose de similaire avec un démonstration dans le navigateur construit autour d’une maison d’exemple : les gens peuvent essayer l’idée avant d’installer quoi que ce soit.

La boucle de développement qui fonctionne

L’agent écrit vite. Ce qui rend le résultat fiable, c’est la boucle qui l’entoure :

1. Brief. Un BRIEF.mdd’une page : la promesse en une phrase, trois user stories, la liste des écrans.
2. Plan. Le plan l’agent le transforme en ROADMAP.md: de petites tranches verticales, chaque fonctionnalité fonctionnant de bout en bout.
3. Construis une tranche. Le construire l’agent l’implémente et écrit les tests.
4. Vérifie comme un utilisateur. Avec XcodeBuildMCP, l’agent peut compiler et lancer l’app dans le simulateur, prendre une capture d’écran, lire l’arbre d’accessibilité avec snapshot_ui, naviguer dans le parcours en tapotant et lancer les tests. Avec Expo, les outils MCP locaux font la même chose pour le simulateur. Demande-lui de comparer ce qu’il voit avec ce que tu as demandé.
5. Fais la revue comme l’App Review. Lance le appstore-reviewer sous-agent de la partie 5.
6. Lis le diff toi-même. Toutes les lignes qui vont être expédiées.
7. Fais un commit, coche la case, démarre une session vierge.

Pour les grands passages mécaniques (ajouter des libellés d’accessibilité partout, traduire chaque chaîne, augmenter la couverture de tests), utilise le mode goal : /goal Traduis chaque chaîne visible par l’utilisateur en allemand, y compris les widgets, les notifications et les invites d’autorisation.

Trois modèles de prompt à adapter :

Une part : Implémente la tranche 4 de ROADMAP.md (recherche). Lis d’abord AGENTS.md. Écris d’abord les tests unitaires, puis le code. Compile et lance l’app dans le simulateur, prends une capture d’écran de l’écran de résultats et vérifie-la par rapport au brief. Montre-moi le diff et liste toutes les hypothèses que tu as posées.

Un bug : Sur un iPhone à la taille maximale de Dynamic Type, le clavier recouvre le bouton Enregistrer de l’écran d’ajout. Reproduis-le dans le simulateur, fais une capture d’écran, explique la cause en deux phrases, corrige-le et vérifie si les autres formulaires ont le même problème.

Une relecture avant commit : Passe en revue tout ce qui a changé depuis le dernier commit comme le ferait un réviseur iOS senior et sceptique : plantages, pertes de données, fuites de confidentialité, libellés d'accessibilité manquants, chaînes et couleurs codées en dur, tout ce qui casse l'usage hors ligne. Liste numérotée, du plus grave au moins grave. Ne corrige rien pour l’instant.

Leçons de deux petites applis

Stash et la localisation. Stash 1.1.0 (28 octobre) a ajouté dix langues à l'anglais : espagnol, français, allemand, italien, portugais du Brésil, néerlandais, polonais, japonais, coréen et chinois simplifié. L'appli en reprend une depuis l'appareil et te laisse la changer dans Réglages → Langue, et les notes de version signalent que les widgets, les rappels et les invites de permission du système ont aussi été traduits. Ce dernier détail est la leçon : la localisation est un travail idéal pour un agent, mais les chaînes que les agents oublient vivent en dehors des écrans principaux, dans les widgets, les notifications, les chaînes d'objet des permissions et le formatage des dates. Nomme-les dans AGENTS.md et elles seront faites.

PingAtlas et les promesses honnêtes. La description App Store de PingAtlas fait des promesses précises : une réponse manquante s’affiche comme “Aucune réponse”, jamais comme 0 ms ; pas de GPS et pas de permission de localisation ; pas de publicité, pas d'analytics et pas de compte ; les résultats restent sur l’appareil sauf si tu les exportes ; et les vérifications de sites n’utilisent que des requêtes HEAD. Des promesses comme celles-là ont leur place dans AGENTS.md comme non négociables, parce qu’elles sont aussi ce que dit ton étiquette de confidentialité. L’étiquette de PingAtlas indique “Données non collectées”, et ce n'est vrai que tant que le code est d'accord. Le sous-agent réviseur est là pour repérer le jour où il ne l'est plus.

Le périmètre est une fonctionnalité. PingAtlas pèse 1,9 Mo au téléchargement. Stash, avec photos, notes vocales, synchronisation et widgets, fait environ 65 Mo. Plus de fonctionnalités, c'est plus de choses à tester, plus à expliquer dans la politique de confidentialité et plus de questions d'App Review. Commence par la plus petite version qui tient la promesse.

L'accessibilité dès le premier jour

Les étiquettes de nutrition d'accessibilité d'Apple te permettent de déclarer la prise en charge de neuf fonctions sur ta page App Store : VoiceOver, Commande vocale, Texte plus grand, Interface sombre, Différencier sans couleur, Contraste suffisant, Réduire les animations, Sous-titres et audiodescriptions. Elles sont facultatives aujourd'hui, mais Apple dit qu'avec le temps il faudra les remplir pour soumettre de nouvelles applis et des mises à jour. Tu ne peux déclarer une fonction que si les gens peuvent accomplir toutes les tâches courantes de ton appli avec, y compris le premier lancement, la connexion, les achats et les réglages.

Aucune de mes deux fiches n'en déclare encore, et c’est exactement le genre de trou que ce guide est censé repérer. L'agent peut faire l'essentiel de l'audit : XcodeBuildMCP snapshot_ui lit l'arbre d'accessibilité, donc /goal Rends chaque écran pleinement utilisable avec VoiceOver et à la taille de texte maximale, et liste tout ce que tu ne peux pas corriger c’est un après-midi de travail réaliste.

---

Partie 9 — Publier sur l’App Store : laisse OpenCode faire la paperasse, puis appuie toi-même sur Soumettre

Construire, c'est la partie amusante. Publier est un projet en soi, et c'est là que les développeurs qui débutent perdent une semaine. La bonne nouvelle pour 2026 : presque tout peut désormais être scripté, ce qui veut dire qu'un agent peut faire la frappe pendant que tu prends les décisions.

Ce qui a changé chez Apple en 2026

Quand	Qu'est-ce qui a changé ?	Quoi faire
31 janv. 2026	De nouvelles questions sur la classification par âge sont devenues obligatoires pour les mises à jour	Réponds-y pour chaque appli avant de soumettre
28 avr. 2026	Les fichiers à télécharger doivent être créés avec Xcode 26 ou version ultérieure et les SDK 26	Utilise Xcode 26 ou 27
9 juin 2026	Ligne directrice 4.3(b) réécrite : les applis copiées et les applis bâclées sont rejetées ou retirées	Différencie-toi (partie 8)
9 sept. 2026	Les envois doivent cibler iOS 13 ou version ultérieure	Rien, pour toute nouvelle appli
15 oct. 2026	Xcode 27.1 (Swift 6.4, SDK iOS 27.1 ; nécessite macOS Tahoe 26.6+) et Expo SDK 58	Mets à jour ta chaîne d'outils
16 oct. 2026	Nouvelle directive 2.5.19 interdit les fonctionnalités cachées, dormantes ou non documentées ; règles plus strictes pour les applis qui cachent leur but pendant la revue	Compile les menus de débogage et les feature flags en dehors des versions de production
En vigueur	Ligne directrice 5.1.2(i): préviens les gens et obtiens leur permission avant de partager des données personnelles avec une IA tierce (ajouté en novembre 2025)	Ajoute un écran de consentement si ton appli appelle un service d'IA
Maintenant	Captures d'écran : un jeu pour iPhone avec Dynamic Island (écran moyen) est requis, plus un iPad de 13 pouces si ton appli tourne sur iPad	Planifie la taille de tes captures d'écran (partie 10)
Avril 2027	l'iPhone Duo captures d'écran exigées pour les apps compilées avec le SDK iOS 27.1 ou une version ultérieure	Commence dès maintenant à concevoir pour le second écran
Facultatif, pour l'instant	de nutrition d'accessibilité d'Apple	Déclare ce que tu prends réellement en charge

La nouvelle règle 2.5.19 est celle qui pose problème aux apps construites par IA. Les agents adorent les extras bien intentionnés : un écran de débogage caché, un feature flag laissé désactivé, un menu de test derrière un appui long. La formulation d’Apple est sans détour : “Aucune fonctionnalité cachée, dormante ou non documentée ne doit figurer dans l’app.” Selon le compte rendu de 9to5Mac sur ce changement, tenter de masquer de telles fonctionnalités, par exemple par obfuscation du code, peut entraîner le retrait de l’app et la fermeture de ton compte développeur. Inscris la règle dans AGENTS.md et demande au sous-agent reviewer de la chercher avant chaque soumission.

Le flux de travail, étape par étape

1. Inscris-toi à l'Apple Developer Program. Cela coûte 99 $ par an (99 € en Allemagne). Les entreprises s'inscrivent en tant qu'organisation, ce qui exige un numéro D-U-N-S. Commence tôt ; la vérification peut prendre plusieurs jours. Inscris-toi ici.
2. Déclare ton statut de professionnel dans l'UE. Au titre du règlement de l’UE sur les services numériques (DSA), chaque développeur doit indiquer s’il est un professionnel. Si tu publies en tant qu'entreprise, ton adresse, ton numéro de téléphone et ton e-mail apparaissent sur ta page produit dans chaque pays de l'UE. Apple a retiré des milliers d'apps des vitrines européennes en février 2025 pour ce manquement.
3. Crée une clé API App Store Connect. Dans App Store Connect, va dans Utilisateurs et accès → Intégrations → App Store Connect API et génère une clé d'équipe. Seul le titulaire du compte peut demander un accès à l'API. Donne à la clé le rôle le moins puissant qui fasse l’affaire (le tableau des rôles montre ce que chacun peut faire), télécharge le .p8 une seule fois, et conserve-le dans un endroit sûr, en dehors de ton dépôt.
4. Installe l'App Store Connect CLI et connecte-toi. asc est un outil en ligne de commande open source (MIT) pour l'API App Store Connect, conçu pour les scripts et les agents : il affiche des tableaux dans un terminal et du JSON quand un autre programme lit sa sortie.

brew install asc        # or: curl -fsSL https://asccli.sh/install | bash

asc auth login --name "MyApp" --key-id "ABC123" --issuer-id "DEF456" \
  --private-key ~/keys/AuthKey_ABC123.p8 --network
asc auth status --validate

Installe ensuite ses skills (asc install-skills) pour qu'OpenCode sache s'en servir.

5. Crée la fiche de l'app. Dans App Store Connect, choisis Apps → + → Nouvelle app, et choisis ton bundle ID avec soin, parce qu’il ne change jamais (celui de Stash est network.grahammiranda.stash, celui de PingAtlas network.grahammiranda.pingatlas). Les asc skills en contiennent un qui fait cela par automatisation du navigateur, mais c’est un travail de deux minutes qu'il vaut la peine de faire à la main une fois.
6. Règle la signature. Pour une app native, la signature automatique d’Xcode gère les certificats et les profils. Avec Expo, EAS s'occupe des identifiants à ta place. La asc-signing-setup skill couvre les bundle IDs, les capacités, les certificats et les profils si tu préfères passer par un script.
7. Compile et téléverse. Natif : archive dans Xcode (ou laisse l'agent le faire avec la asc-xcode-build skill), puis téléverse :

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

Exposition : eas build --platform ios, alors eas submit -p ios, qui téléverse le build vers App Store Connect (il ne l’envoie pas à la revue). Tu peux déléguer le téléversement sans risque ; la soumission à la revue ne l’est pas.

8. Teste d'abord avec TestFlight. Les testeurs internes (jusqu'à 100 personnes de ton équipe) reçoivent les builds sans examen. Les testeurs externes (jusqu'à 10 000, par e-mail ou lien public) ont besoin d'un court Beta App Review pour le premier build. Les builds restent testables 90 jours. L'agent peut gérer les groupes avec asc testflight groups list --app "123456789" et le asc-testflight-orchestration skill. Confie l'appli pendant une semaine à cinq personnes qui ont des iPhone différents ; elles trouveront le plantage que tu n'as pas trouvé.
9. Rédige les métadonnées, puis laisse l'agent les vérifier. Garde ta fiche dans des fichiers du dépôt (metadata/en-US/…) et applique-la d'abord en simulation :

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

Le asc-metadata-sync skill vérifie les limites de caractères d'Apple avant tout envoi. La partie 10 explique quoi écrire.

10. Fais les captures d'écran. Au moins une, jusqu'à dix, par taille requise, en PNG ou JPEG sans transparence. La asc-shots-pipeline skill peut les capturer depuis le simulateur, les encadrer et les envoyer avec asc screenshots upload. La partie 10 donne les tailles.
11. Réponds honnêtement aux questions de confidentialité, de classement par âge et de conformité. C'est la partie que tu ne dois pas déléguer à l'aveugle :

• L'étiquette de confidentialité. Dans les conditions d'Apple, une donnée est considérée comme collectée quand elle quitte l'appareil et est conservée plus longtemps que le temps nécessaire pour traiter la demande. Une donnée traitée uniquement sur l'appareil ne compte pas. Synchroniser le contenu des gens vers ton serveur compte, même si eux seuls peuvent le voir. Demande à l'agent d'auditer chaque appel réseau et SDK, puis remplis l'étiquette toi-même à partir de son tableau.
• La politique de confidentialité doit être liée dans App Store Connect et accessible dans l'appli, et elle doit décrire cette appli, pas seulement ton entreprise.
• IA de tiers (règle 5.1.2(i)) : si des données personnelles partent vers un service d'IA, dis-le et demande l'autorisation d'abord.
• Suppression du compte (règle 5.1.1(v)) : si les gens peuvent créer un compte, ils doivent pouvoir le supprimer dans l'appli.
• Classement par âge, conformité à l'export et les Accessibility Nutrition Labels. Si ton appli n'utilise que le chiffrement intégré à iOS, comme HTTPS, définis ITSAppUtiliseUnChiffrementNonExempté dans ton Info.plist après avoir vérifié les recommandations d'Apple, pour qu'on ne te le demande pas à chaque envoi.

12. Soumets toi-même. Ajoute la version pour examen et soumets-la sur la page de l'appli dans App Store Connect, ou lance asc publish appstore … --submit --confirm depuis ton propre terminal (les règles de permissions de la partie 4 empêchent l'agent de l'exécuter). Ensuite, laisse l'agent surveiller : asc review status --app "123456789".

L'examen : à quoi t'attendre

Apple affirme qu'en moyenne 90 % des soumissions sont examinées en moins de 24 heures, et que plus de 40 % des problèmes non résolus viennent de la règle 2.1, App Completeness : plantages, contenu de remplacement, informations incomplètes et liens cassés. Si on te rejette, lis le message deux fois, corrige le vrai problème et réponds dans App Store Connect. La asc-submission-health skill aide à diagnostiquer les blocages, et l'agent est bon pour rédiger une réponse calme et précise. Envoie-la toi-même.

---

Partie 10 — Lancement : la fiche, les captures d’écran, l’ASO et la vie après l’approbation

Une appli approuvée avec une fiche faible, c'est une boutique sans enseigne. Voici le reste du travail.

La fiche, champ par champ

Champ	Limite	Ce qui marche
Nom de l'appli	30 caractères	Marque plus bénéfice. “Stash — Trouve-le vite” dit à un inconnu à quoi sert l'appli
Sous-titre	30 caractères	Le bénéfice en mots simples. PingAtlas utilise “Ping villes, jeux & services”
Mots-clés	100 caractères	Séparés par des virgules, sans espaces. Ne répète pas les mots déjà présents dans le nom ou le sous-titre ; ils comptent quand même
Texte promotionnel	170 caractères	Modifications sans nouvelle validation, alors utilise-le pour les saisons et l'actualité
Description	4 000 caractères	Ce qu'il fait, à qui il s'adresse, ce qu'il ne fait pas avec les données des gens. Clair et précis
Nouveautés	Par version	De vrais changements en mots humains ; la /whats-new commande de la partie 5 le rédige
Captures d'écran	1 à 10 par taille	Raconte l'histoire dans l'ordre ; la plupart des gens ne font jamais défiler au-delà des trois premières

Deux règles pour laisser un agent écrire tout ça : demande-lui d'utiliser uniquement des fonctionnalités qui existent dans le code (et de nommer le fichier où chacune se trouve), et garde le résultat dans ton dépôt pour que chaque changement soit relu comme du code. La asc-aso-audit compétence peut ensuite vérifier les lacunes de mots-clés hors ligne avant que quoi que ce soit ne soit publié.

Tailles des captures d'écran en novembre 2026

Appareil	Requis ?	Tailles portrait (pixels)
iPhone avec Dynamic Island, écran moyen	Oui	1179 × 2556 ou 1206 × 2622
iPhone avec Dynamic Island, grand écran	En option	1260 × 2736, 1290 × 2796 ou 1320 × 2868
iPad, écran de 13 pouces	Oui, si ton app tourne sur iPad	2064 × 2752 ou 2048 × 2732
l'iPhone Duo (écran externe / interne)	À partir de Avril 2027, pour les apps compilées avec le SDK iOS 27.1 ou une version ultérieure	1398 × 2034 / 2007 × 2853

Si ton interface est identique quelle que soit la taille et la langue, tu n'as besoin que de la résolution la plus élevée requise ; App Store Connect la réduit pour les appareils plus petits. Les captures d'écran ne peuvent pas contenir de transparence.

Traduis la fiche, pas seulement l'app

Si l'app parle plusieurs langues, la fiche devrait aussi. La asc-localize-metadata compétence traduit le texte de la fiche et asc-metadata-sync vérifie chaque langue par rapport aux limites de caractères d'Apple, et c'est là que les sous-titres allemands traduits à la main se trompent généralement. Fais relire le résultat par un locuteur natif ; la traduction automatique est excellente aujourd'hui, mais le texte d'une fiche App Store, c'est du marketing, et le marketing a besoin d'une oreille humaine.

Après la validation

• Demande aux gens de te noter lorsqu'ils sont de bonne humeur. L'invite de notation du système d'Apple n'apparaît pas plus de trois fois par an et par personne, alors ne la gaspille pas au premier lancement. Demande juste après que quelque chose s'est bien passé.
• Utilise le texte promotionnel pour coller au calendrier. La saison des déménagements, le grand ménage de printemps, un week-end Gaming. Ça change sans validation.
• Surveille les plantages dès le premier jour. Le asc-crash-triage compétence examine les plantages et les retours TestFlight ; le serveur MCP d'Expo peut récupérer les plantages, les retours et les avis (les réponses nécessitent ta confirmation) ; le serveur MCP de Sentry apporte les erreurs de production.
• Publie souvent de petites mises à jour. Stash est sorti le 23 septembre, a reçu une refonte le 2 octobre et a ajouté dix langues dans la version 1.1.0 le 28 octobre. Publie la version qui fonctionne, puis améliore-la en public.
• Donne à l'app une maison sur le web. Une page simple avec une démo, une politique de confidentialité écrite pour l'app et, si tu es en Allemagne, un Impressum. Mon guide pour créer une app de zéro couvre les pages légales pour les développeurs allemands et de l'UE.

---

Partie 11 — Combien ça coûte : quatre budgets pour la première année

OpenCode est gratuit. Ollama est gratuit sur ton propre matériel. Le seul coût que tu ne peux pas éviter pour une app iPhone, c’est l’adhésion Apple ; tout le reste, c’est la quantité de temps de modèle que tu veux acheter.

Budget	Que contient-il ?	Première année (USD)
Local uniquement	Apple Developer Program ; OpenCode ; Ollama avec des modèles locaux sur un Mac que tu possèdes déjà (32 Go ou plus)	$99
Débutant	Local uniquement + OpenCode Go ($10 par mois)	$219
Recommandé	Starter + Ollama Pro en facturation annuelle ($200)	$419
Puissance	Apple + OpenCode Go Plus ($40 par mois) + Ollama Max ($100 par mois)	$1,779

Prix catalogue au 7 novembre 2026, hors TVA, sans remises promotionnelles. Remplace par tes propres choix : un GLM Coding Plan Lite au lieu de Go coûte $216 par an en facturation mensuelle (environ $151 en facturation annuelle) au lieu de $120 ; ChatGPT Plus coûte $240 par an. En option : les $25 uniques de Google Play si tu publies sur Android, les forfaits Expo payants si l’offre gratuite ne te suffit plus, et ce que coûte ton site web.

Le vrai coût n’est pas sur la liste, pourtant : ce sont tes soirées. L’IA raccourcit la frappe, pas la réflexion, et la réflexion, c’est l’essentiel du travail.

---

Partie 12 — Quinze erreurs à éviter

1. Laisser l’agent soumettre à la validation. Refuse-le dans les permissions. C’est toi qui appuies sur le bouton.
2. Garder une clé API Admin là où les agents tournent sans surveillance. Utilise le rôle le moins puissant qui fonctionne, et garde les clés de signature et les identifiants de production ailleurs.
3. Construire une copie de quelque chose qui existe déjà. La directive 4.3(b) nomme désormais des catégories entières. Trouve d’abord ta différence en une phrase.
4. Publier des extras cachés. Les écrans de débogage, les feature flags dormants et les menus de test enfreignent la directive 2.5.19. Exclus-les des builds de release.
5. Un label de confidentialité qui semble plausible, mais qui n'est pas exact. Si des données quittent l’appareil et restent sur un serveur, elles sont collectées, même si seul l’utilisateur peut les voir.
6. Envoyer des données personnelles à un service d’IA sans demander. La directive 5.1.2(i) exige une information et une autorisation.
7. Des secrets dans le bundle de l’app. Tout ce qui se trouve dans une app peut être extrait. Les clés qui coûtent de l’argent vivent sur un serveur.
8. Connecter tous les serveurs MCP que tu trouves. Chacun coûte du contexte à chaque requête. Ajoute seulement ce que tu utilises.
9. Installer des skills et des serveurs que tu n’as pas lus. Il s’agit d’instructions et de code qui tournent avec tes permissions.
10. Croire que c’est “ terminé ”. Lance-le sur un vrai iPhone, hors ligne, en mode sombre, avec la plus grande taille de texte et VoiceOver activé.
11. Utiliser des modèles promotionnels gratuits pour du code client. Certains peuvent utiliser tes données pour améliorer le modèle. Désactive-les pour les projets clients.
12. Oublier la longueur de contexte d’Ollama. Avec la valeur par défaut, un agent manque de place avant même de commencer. Règle 64K sur le serveur.
13. Laisser les dépendances s’accumuler. Chaque paquet est du code que tu n’as pas lu et une mise à jour que tu devras gérer. Oblige l’agent à demander.
14. Des sessions longues et décousues. Repars de zéro pour chaque tranche, et utilise des worktrees pour les expériences.
15. Promettre ta feuille de route. Les captures d’écran et les descriptions montrent ce que fait cette version. Les idées vont sur ton site web, étiquetées comme des idées.

---

Partie 13 — Quelle configuration choisir ? Six scénarios

1. “Je n’ai jamais écrit de code et j’ai un Mac.”

L’app de bureau d’OpenCode, OpenCode Go et Ollama pour les petites tâches. Expo si tu veux aussi Android ; SwiftUI si seul l’iPhone t’intéresse. Garde les commandes shell sur demander, fais un commit après chaque étape qui fonctionne, et commence par une app qui n’a qu’un seul rôle.

2. “Mon code ne doit jamais quitter ma machine.”

OpenCode avec Ollama local uniquement. Désactive les fonctions cloud d’Ollama, règle OPENCODE_DISABLE_FREE_MODELS=1, et ne connecte aucun fournisseur cloud dans ce projet. Attends-toi à une aide plus lente et plus simple, et donne des tâches plus petites à l’agent. Un Mac avec 64 Go ou plus rend tout cela bien plus confortable.

3. “Je paie déjà pour ChatGPT, Copilot ou Claude.”

Connecte d’abord ce que tu as déjà. ChatGPT Plus et Pro ainsi que GitHub Copilot fonctionnent via des connexions intégrées, sans surcoût. Claude passe par le fournisseur Claude Agent ; lis la partie 2 avant d’en dépendre pour du travail professionnel. Ajoute OpenCode Go plus tard si tu veux aussi des modèles ouverts.

4. “Je veux iPhone et Android à partir d’une seule base de code.”

Expo SDK 58, le serveur MCP d’Expo, les skills officiels d’Expo et EAS pour les builds et les envois dans le cloud. Tu peux compiler et envoyer des apps iOS sans Mac, même si tu en voudras quand même un (et un iPhone) pour tester.

5. “Je ne m’intéresse qu’aux plateformes Apple et je veux que tout soit natif.”

SwiftUI dans Xcode 27.1, avec OpenCode soit dans Xcode via ACP (Xcode → Réglages → Intelligence → Ajouter un agent…, exécutable opencode, argument acp) soit dans ton terminal avec le pont MCP de Xcode et XcodeBuildMCP. Une limite de la voie dans Xcode : il n’y a pas de sélecteur de modèle, alors définis ton modèle par défaut dans opencode.jsonc Tout d'abord.

6. “Je veux aller vite et je suis prêt à payer pour ça.”

OpenCode Go Plus and Ollama Max, des worktrees pour des expériences en parallèle, le mode goal pour les longues tâches mécaniques et un modèle de pointe par clé API pour les problèmes vraiment difficiles. Surveille tes dépenses chaque semaine. Pour faire tourner plusieurs agents côte à côte, mon comparatif de harnais couvre les options.

---

Foire aux questions

---

En résumé

Apprentissage comment utiliser OpenCode bien ne consiste pas à mémoriser des commandes. Il s’agit de construire un petit système autour de l’agent : un forfait de codage qui tient dans ton budget, Ollama pour le travail qui doit rester sur ta machine, une poignée de serveurs MCP qui permettent à l’agent de voir ce qu’il construit, des skills qui portent ton playbook, et des permissions qui laissent les décisions irréversibles entre tes mains.

Ma recommandation reste la même : OpenCode avec OpenCode Go et Ollama est la façon la moins chère, la plus souple et la moins enfermante de construire une app avec l’IA fin 2026. Ajoute un abonnement que tu paies déjà, ou un modèle de pointe par clé API, quand une tâche le mérite. Ensuite, utilise aussi l’agent pour la paperasse, et garde le bouton “Soumettre” pour toi.

Si tu veux voir ce que ce genre de processus produit à petite échelle, mes deux apps sont gratuites : Stash — Trouvez-le rapidement pour les choses que tu ranges, et PingAtlas pour vérifier à quelle distance se trouve vraiment Internet depuis l’endroit où tu es assis. Ensuite, va construire la tienne.

---

Tu construis avec OpenCode ? J’aimerais savoir quel forfait de codage tu as retenu, quel modèle local a gagné sa place sur ton Mac, et quel serveur MCP ou quelle skill tu ne pourrais plus lâcher. Les corrections et les contre-exemples sont bienvenus ; cet article est mis à jour quand la situation change.

Mention légale : Stash et PingAtlas sont mes propres apps, publiées par ma société, Graham Miranda UG (haftungsbeschränkt). Les deux sont gratuites et sans publicité. Cet article contient un lien d’affiliation, vers le GLM Coding Plan de Z.ai dans la partie 2 ; si tu t’abonnes via ce lien, tu bénéficies de 10 % de réduction et je perçois une commission. Aucune société mentionnée ici n’a sponsorisé, relu ou approuvé cet article.

Dernière mise à jour : 7 novembre 2026.