OpenCode von der ersten Eingabe bis in den App Store: Der Leitfaden 2026 zu Coding-Plänen, Ollama, MCP-Servern und Skills

Irgendwo zwischen dem ersten Prompt und der ersten E-Mail von App Review hört ein KI-Coding-Agent auf, ein Spielzeug zu sein, und wird zu einem Werkzeug, mit dem du auslieferst. In diesem Leitfaden geht es darum, wie du OpenCode nutzt um von einem zum anderen zu kommen: es auf einem frischen Mac installieren, entscheiden, wofür du beim denkenden Modell zahlst, Modelle mit Ollama auf deiner eigenen Maschine laufen lassen, dem Agenten mit MCP-Servern echte Hände geben, ihm deine Gewohnheiten mit Skills beibringen und dann eine iPhone-App durch TestFlight und App Review bringen, ohne eine Woche an Papierkram zu verlieren.

Ich komme nicht aus der Programmierung. Ich führe ein kleines IT-Unternehmen in Deutschland und baue Software mit KI-Agenten. Zwei der Ergebnisse sind diesen Herbst im App Store live gegangen: Stash, das sich merkt, wo du Dinge hinlegst, und PingAtlas, das die Netzwerklatenz von deinem eigenen Gerät misst. Sie tauchen in diesem Leitfaden nur dort auf, wo sie als Beispiele wirklich nützlich sind, und nirgendwo sonst.

Alles im Folgenden wurde gegen offizielle Dokumentation, Release Notes, Preisseiten und den App Store selbst geprüft, am 7. November 2026. KI-Coding ist schnell: OpenCode hat allein zwischen dem 20. und 30. Oktober mindestens zehn Version-2-Releases ausgeliefert, Ollama und MiniMax haben seit Ende August beide ihre Pläne umgebaut, und Apple hat Teile seiner Review-Richtlinien in diesem Jahr mindestens zweimal umgeschrieben. Schwankende Zahlen sind dort gekennzeichnet, wo sie auftauchen. Prüfe sie, bevor du etwas kaufst.

Offenlegung: Stash und PingAtlas sind meine eigenen Apps, veröffentlicht von meiner Firma, Graham Miranda UG (haftungsbeschränkt). Beide sind kostenlos und zeigen keine Werbung. Dieser Artikel enthält einen Affiliate-Link: Der Link zum Z.ai GLM Coding Plan in Teil 2 gibt dir 10 % Rabatt und bringt mir eine Provision, wenn du abonnierst. OpenCodes Team bei Anomaly, Ollama, Apple, Expo, Z.ai und jedes andere hier genannte Unternehmen haben diesen Artikel weder gesponsert, geprüft noch freigegeben.

---

TL;DR — Die ganze Reise in zehn Punkten

• OpenCode ist ein kostenloser Open-Source-Coding-Agent (MIT) der mit fast jedem Modell funktioniert: Cloud-Abos, Pay-per-Token-APIs oder Modelle, die auf deinem eigenen Mac laufen. Er steht bei Version 2.2.6 (6. November 2026), mit einer Terminal-App, einer Desktop-App, einer Web- und Telefon-Oberfläche und einem ACP-Modus, der in Xcode 27 läuft.
• Du zahlst für das Modell, nicht für den Agenten. “Coding-Pläne” sind pauschale Monatsabos für Modellzeit. Für die meisten Einsteiger ist OpenCode Go (10 $ im Monat) plus Ollama (lokal kostenlos, 20 $ im Monat für Pro-Cloud-Credits) das Setup, das ich empfehle: günstig, modellunabhängig, standardmäßig Zero-Retention für die meisten Modelle und keine Grauzonen in den Nutzungsbedingungen irgendeines Anbieters.
• Die Alternativen sind real. ChatGPT Plus und Pro, GitHub Copilot und der Z.ai GLM Coding Plan lassen sich alle über eingebaute Provider in OpenCode einbinden. Claude-Abos funktionieren jetzt wieder über den neuen Claude-Agent-Provider von OpenCode 2.2.3, aber Anthropic hat diesen Weg nicht öffentlich unterstützt, also lies Teil 2, bevor du dich darauf verlässt.
• Ollama ist eine Engine für lokale und Cloud-Modelle. ollama launch opencode verbindet sie miteinander, lokale Modelle brauchen mindestens ein 64K-Kontextfenster, und ein Mac mit 32 GB kann solide Coding-Modelle wie qwen3.8:27b (ein 18-GB-Download).
• MCP-Server geben dem Agenten Hände. Für App-Arbeit ist die Auswahl kurz: Xcodes eigene MCP-Bridge (xcrun mcpbridge), XcodeBuildMCP, der Expo MCP-Server, Context7 für aktuelle Dokumentation und Sentry für Abstürze. Füge nur hinzu, was du nutzt: Jeder Server kostet Kontext.
• Skills geben dem Agenten dein Playbook. Ein Skill ist ein Ordner mit einer SKILL.md Datei. OpenCode liest sie aus .opencode/skills und außerdem aus .claude/skills und .agents/skills, also funktionieren auch Skills, die für andere Agenten geschrieben wurden. Expo veröffentlicht 23 offizielle, und die App Store Connect CLI (asc) bringt mehr als zwanzig mit.
• Lass den Agenten den Papierkram machen, niemals die Einreichung. Die asc CLI und ihre Skills können Builds hochladen, TestFlight verwalten, Metadaten und Screenshots synchronisieren und den Review-Status prüfen. Verweigere den Submit-Befehl in OpenCodes Berechtigungen und drücke den Knopf selbst.
• Apples Regeln von 2026 zählen für mit KI gebaute Apps. Nachahmer-Apps in gesättigten Kategorien werden jetzt abgelehnt (Richtlinie 4.3(b), Juni), versteckte oder ruhende Funktionen sind verboten (neu 2.5.19, Oktober), Builds brauchen Xcode 26 oder neuer, und ab April 2027 brauchen Apps, die mit dem iOS 27.1 SDK gebaut wurden, iPhone-Duo-Screenshots.
• Kosten im ersten Jahr: 99 $, wenn du alles lokal laufen lässt und nur Apple zahlst, etwa $419 für das Setup, das ich empfehle (Apple + OpenCode Go + Ollama Pro bei jährlicher Abrechnung), und rund 1.779 $ für ein Power-Setup. Alle Preise ohne MwSt.
• Die wichtigste Regel: “fertig” ist eine Behauptung, keine Tatsache. Führe es auf einem echten iPhone aus, im Flugmodus, im Dunkelmodus, mit der größten Textgröße, mit VoiceOver an. Dann glaub es.

---

Die Reise auf einen Blick

Phase	Was du tust	Was OpenCode tut	Werkzeuge
1. Einrichten	Installieren, einen Kodierungsplan wählen, Modelle verbinden	Noch nichts	OpenCode, OpenCode Go, Ollama
2. Anlernen	AGENTS.md schreiben, Skills hinzufügen, MCP-Server verbinden	Liest sie in jeder Sitzung	AGENTS.md, Skills, MCP
3. Planen	Das Briefing schreiben, mit dem Plan streiten	Macht aus dem Briefing einen Plan und eine Roadmap	Plan Agent, /goal
4. Bauen	Jeden Diff prüfen, auf einem Gerät testen	Schreibt Code in kleinen Schritten, baut, führt Tests aus, macht Screenshots	Erstellen Agent, Xcode MCP, XcodeBuildMCP oder Expo MCP
5. Beta	Tester einladen, Feedback lesen	Archiviert, lädt hoch, verwaltet TestFlight-Gruppen	Xcode, asc oder EAS
6. Papierkram	Die rechtlichen und Datenschutz-Fragen ehrlich beantworten	Entwirft Metadaten, prüft Datenflüsse, skaliert Screenshots	asc Fähigkeiten
7. Einreichen	Du drückst “Submit for Review”	Prüft den Review-Status, sortiert Ablehnungen vor	App Store Connect
8. Launch	Auf Nutzer antworten, Updates planen	Lokalisiert, schreibt Release Notes, sortiert Abstürze vor	asc, Sentry, deine Website

---

Inhaltsverzeichnis

• Teil 1 — Was OpenCode im November 2026 ist und warum ich es empfehle
• Teil 2 — Kodierungspläne erklärt (und die zwei, die ich empfehle)
• Teil 3 — Ollama: eine Engine für lokale und Cloud-Modelle
• Teil 4 — So nutzt du OpenCode: installieren und Modelle verbinden, Schritt für Schritt
• Teil 5 — Agenten, Befehle, Berechtigungen und Goal-Modus: So machst du OpenCode zu deinem
• Teil 6 — MCP-Server: dem Agenten Hände geben
• Teil 7 — Skills: dein Playbook einmal schreiben
• Teil 8 — Die App bauen: von der Idee zu einem Build, dem du vertraust
• Teil 9 — Im App Store veröffentlichen: Lass OpenCode den Papierkram machen und drück dann selbst auf Submit
• Teil 10 — Launch: der Eintrag, Screenshots, ASO und das Leben nach der Freigabe
• Teil 11 — Was es kostet: vier Budgets für das erste Jahr
• Teil 12 — Fünfzehn Fehler, die du vermeiden solltest
• Teil 13 — Welches Setup solltest du wählen? Sechs Szenarien
• Häufig gestellte Fragen
• Das Fazit

---

Teil 1 — Was OpenCode im November 2026 ist und warum ich es empfehle

OpenCode ist ein Open-Source-KI-Coding-Agent. Du startest ihn in einem Projektordner, beschreibst, was du willst, und er arbeitet wie ein Entwickler: Er liest deine Dateien, macht einen Plan, ändert Code, führt Befehle aus, liest die Fehler und macht weiter, bis die Arbeit erledigt ist oder er dich braucht. Er ist unter der MIT-Lizenz von Anomaly veröffentlicht, dem Team dahinter, und es ist ihm egal, welches Modell du ihm gibst.

Die Startseite des Projekts nennt mehr als 220.000 GitHub-Sterne, 1.089 Mitwirkende und 22 Millionen Entwickler pro Monat. Das sind die eigenen Zahlen des Projekts, und sie ändern sich jede Woche – aber sie erklären, warum OpenCode die bekannteste modellunabhängige Alternative zu den eigenen Agenten der Modellhersteller geworden ist, Claude Code und Codex.

Wo es läuft

OpenCode ist längst nicht mehr nur eine App. Seit dem Umbau auf 2.0 läuft ein Hintergrunddienst auf deinem Rechner, und jede Oberfläche spricht mit ihm, sodass eine Sitzung, die du an einer Stelle startest, auch in den anderen auftaucht.

Oberfläche	Was es ist	Geeignet für
Terminal (TUI)	Die klassische Terminal-App im Vollbild	Schnelles Arbeiten mit der Tastatur, SSH-Sitzungen, Server
Desktop-App	Eine Electron-App für macOS (Apple Silicon und Intel), Windows (x64 und ARM64) und Linux (.deb, .rpm, AppImage), mit Tabs, Diffs, Terminals und einem integrierten Browser	Wer nicht im Terminal lebt
Web und Smartphone	opencode pair gibt einen Einmal-Link aus (er verfällt nach fünf Minuten), der deine lokalen Sitzungen im Browser öffnet; 2.2.6 hat eine für Smartphone und Tablet optimierte Eingabemaske ergänzt	Mal vom Sofa aus nach einer langen Aufgabe sehen
In Xcode 27	OpenCode spricht das Agent Client Protocol und lässt sich daher opencode acp als Agent in den Intelligence-Einstellungen von Xcode hinzufügen	Native-Swift-Entwickler, die in Xcode bleiben wollen
SDK und Skripte	opencode run für einmalige Aufgaben, dazu ein JavaScript-SDK	Automatisierung und CI

Was sich seit 2.0 geändert hat

OpenCode 2.0 war ein Neuaufbau von Grund auf: Laut der Ankündigung, die das Team im Juli veröffentlichte, wechselte die Laufzeit von Bun zu Node.js, um Speicher zu sparen, die Desktop-App wechselte von Tauri zu Electron, die API wurde neu gestaltet, und OpenCode läuft seitdem standardmäßig als Dienst. Version 2.0.0 erschien am 11. September 2026. Die Releases seither haben vor allem die Funktionen ergänzt, die für lange, echte Projekte zählen:

Version	Datum	Was dazukam
2.2.0	27. Okt.	Experimentelle Desktop-Plugins, eine aufgefrischte Desktop-App, Bild- und Entscheidungs-APIs für Plugins
2.2.1	29. Okt.	Goal-Modus (/goal <objective>, mit Pause, Fortsetzen und Zurücksetzen), Opt-in geplante Prompts, Bildgenerierung
2.2.2	29. Okt.	Bildgenerierung standardmäßig an, wenn ein verbundener Anbieter sie unterstützt; eine Worktree-Auswahl direkt aus dem Git-Branch
2.2.3	30. Okt.	Die Claude Agent Anbieter (mehr dazu in Teil 2)
2.2.4	30. Okt.	Geführte Einrichtung des Claude Agent, Zeitpläne, die unter opencode servelaufen, persistente Desktop-Terminals
2.2.5	30. Okt.	Worktree- und Shell-Modus-Shortcuts, ein prozentbasierter Kompaktierungspuffer
2.2.6	6. Nov.	opencode run --worktree für skriptgesteuerte Läufe, ein mobiles Eingabe-Dock, gemeinsame MCP-Verbindungen

Quelle: OpenCodes Changelog, geprüft am 7. November 2026. Rechne damit, dass es eine neuere Version gibt, wenn du das hier liest.

Warum es der Agent ist, den ich empfehle

1. Es hält keinem Modell die Treue. OpenCode verbindet Abonnements, Pay-per-Token-APIs und lokale Modelle über einen einzigen /connect Befehl. Wenn nächsten Monat ein besseres Modell erscheint, änderst du eine Zeile in einer Konfigurationsdatei – nicht deinen ganzen Workflow.
2. Seine Berechtigungen funktionieren wie eine Firewall. Jede Aktion (Lesen, Bearbeiten, einen Shell-Befehl ausführen, einen Skill laden, ein MCP-Tool aufrufen) läuft durch eine geordnete Liste von allow, fragen und deny Regeln, bei denen der letzte Treffer gewinnt. “Führe niemals git push”“ und ”niemals im App Store einreichen“ bestehen jeweils aus einer Zeile.
3. Es versteht die Formate von allen. Darin heißt es AGENTS.md (und greift zurück auf CLAUDE.md), lädt Skills aus .claude/skills und .agents/skills sowie aus eigenen Ordnern und verbindet sich mit jedem MCP-Server. Das Ökosystem, das andere Agenten aufgebaut haben, funktioniert hier ebenfalls.
4. Es geht dorthin, wo du bist. Terminal auf einem Server, Desktop-App auf einem Mac, ein Browser auf deinem Handy oder direkt in Xcode.
5. Es kostet nichts. OpenCode ist kostenlos und enthält sogar ein wechselndes Set kostenloser Modelle, die du ohne Konto nutzen kannst.

Wo es nicht die beste Wahl ist

Ehrlichkeit zuerst: OpenCode ist nicht der Spitzenreiter auf Coding-Leaderboards, weil es kein einzelnes Modell ist. Die Harnesses an der Spitze sind Hersteller-Paare: Claude Code mit Anthropics bestem Modell, Codex mit dem von OpenAI. Sie sind aufeinander abgestimmt und sie sind exzellent. Ich habe achtundzwanzig davon verglichen in meinem KI-Coding-Harness-Vergleich, und wenn du bereits eines dieser Abonnements zahlst und es liebst, zwingt dich nichts in diesem Leitfaden zum Wechsel.

Es gibt auch raue Kanten. OpenCode veröffentlicht fast täglich Releases, also verschiebt sich alles unter deinen Füßen. Die alte Version-1-Dokumentation existiert noch unter docs.opencode.ai (mit einem Banner, der auf v2 verweist), und viele Drittanbieter-Leitfäden, einschließlich Ollamas eigener OpenCode-Seite, zeigen noch immer die v1-Installer-Adresse. Mehrere der neuesten Funktionen sind als experimentell gekennzeichnet. Und Windows-Paketmanager werden für das v2-Kommandozeilentool nicht unterstützt; Windows-Nutzer bekommen die Desktop-App oder ein eigenständiges zip.

---

Teil 2 — Kodierungspläne erklärt (und die zwei, die ich empfehle)

OpenCode ist kostenlos. Das Modell, das denkt, nicht. Es gibt drei Wege, dafür zu zahlen, und die meiste Verwirrung über “Coding-Pläne” entsteht dadurch, dass man sie verwechselt.

1. Betreib es selbst. Modelle mit offenen Gewichten auf deinem eigenen Mac über Ollama. Du zahlst mit Hardware und Geduld, nicht mit Geld. Dein Code verlässt nie die Maschine.
2. Abonniere einen Coding-Plan. Eine monatliche Pauschale kauft ein Nutzungskontingent, normalerweise gemessen in Fünf-Stunden- und Wochenfenstern. Hier leben OpenCode Go, Ollama Pro, der GLM Coding Plan sowie ChatGPT- und Claude-Abonnements.
3. Zahle pro Token. Bring einen API-Schlüssel von einem beliebigen Anbieter mit und zahle genau für das, was du nutzt. Ideal für das gelegentliche schwierige Problem; gefährlich für eine lange Debugging-Session ohne Budget-Warnung.

Die Coding-Pläne, die in OpenCode funktionieren (November 2026)

Plan	Monatspreis (USD)	Was du bekommst	Wie es mit OpenCode verbunden wird
Kostenlose Modelle in OpenCode	$0	Ein wechselndes Set zeitlich begrenzt kostenloser Modelle	Integriert, kein Konto nötig
Ollama, lokal	$0	Jedes Modell mit offenen Gewichten, das dein Mac tragen kann	Automatisch erkannt, oder ollama launch opencode
OpenCode Go ⭐	$10 · Go Plus $40 · Go Teams $20 pro Mitglied	32 offene Modelle, darunter GLM-5.3, GLM-5.3-Flash, Kimi K3 und K3.1 Pro, MiniMax M3.1 Flash, DeepSeek V4.1 Flash und Qwen3.8 Max	/connect → OpenCode Go → Schlüssel einfügen
Ollama Pro / Max ⭐	$20 ($200 pro Jahr) · Max $100	$60 (Pro) oder $300 (Max) Guthaben für Cloud-Modelle pro Monat, plus unbegrenzte lokale Nutzung	Wie bei lokalem Ollama; Cloud-Modelle erscheinen neben den lokalen
GLM-Kodierungsplan (Z.ai)	Lite $18 · Pro $80 · Max $168 (20 % Rabatt bei vierteljährlicher, 30 % bei jährlicher Zahlung)	GLM-5.3 und GLM-5.3-Flash, beide mit 1M-Token-Kontext	/connect → der Z.AI Coding Plan-Anbieter
MiniMax M-Tarif	Go $22 · Explore $55 · Build $132 (zwei Monate gratis bei jährlicher Abrechnung)	MiniMax M3.1 Flash, plus Bild-, Audio- und (ab Explore) Videomodelle	Der Coding-Plan-Anbieter von MiniMax, mit einem M-Plan-Schlüssel
ChatGPT	Plus $20 · Pro ab $100	OpenAIs GPT-6-Familie über deinen ChatGPT-Plan	/connect → OpenAI → “Mit ChatGPT anmelden”
GitHub Copilot	Pro $10 · Pro+ $39 · Max $100	Der Modellpool von Copilot, abgerechnet in GitHub AI Credits	/connect → GitHub Copilot → Geräte-Login
Claude	Pro 20 $ · Max ab 100 $	Anthropics Modelle über Claude Code	/connect → Claude Agent (OpenCode 2.2.3+, Claude Code installiert); siehe den Hinweis unten
Zahlung pro Token	Was du nutzt	Die API jedes Anbieters, auch das Pay-as-you-go-Gateway von OpenCode selbst	/connect → den Anbieter → API-Schlüssel

Listenpreise am 7. November 2026, ohne MwSt. ⭐ = was dieser Leitfaden empfiehlt. Preise, Kontingente und Modelllisten ändern sich ständig, prüfe also die Seite des jeweiligen Anbieters, bevor du abonnierst. Die GLM-Preise stammen von einem Stand vom 24. September und aus der Schlagzeile von Z.ai “Pläne ab 18 $”; Kimis Mitgliedschaft (ab 19 $) fehlt, weil ich keinen offiziellen Weg über OpenCode dafür bestätigen konnte.

Wie die Limits wirklich funktionieren

Der groß genannte Preis sagt dir sehr wenig. Mit dem Kontingent lebst du.

• OpenCode Go gibt jedem Modell ein eigenes monatliches Dollar-Kontingent, und du kannst 20 % davon in jedem Fünf-Stunden-Fenster und 50 % in jeder Woche ausgeben. Im 10-$-Tarif bekommt zum Beispiel GLM-5.3-Flash 60 $ im Monat, DeepSeek V4.1 Flash 100 $ und Kimi K3 15 $, sodass billige, effiziente Modelle viel weiter reichen als Schwergewichte. Wenn du ein Limit erreichst, werden Anfragen blockiert, es sei denn, du hast Extra Usage aktiviert, das auf Pay-as-you-go-Guthaben zurückfällt. Kostenlose Modelle funktionieren in jedem Fall weiter.
• Ollama ist auf Guthaben umgestellt: Pro enthält 60 $ Cloud-Nutzung pro Monat und Max 300 $, beides zu Token-Preisen abgerechnet, und ungenutztes Guthaben verfällt. Pro erlaubt drei Anfragen gleichzeitig, Max zehn. Außerhalb von 12:00 bis 18:00 UTC an Wochentagen und das ganze Wochenende sinken die Preise, was gut zu europäischen Abenden passt. Lokale Modelle sind in jedem Tarif unbegrenzt, auch im kostenlosen.
• Der GLM Coding Plan verbraucht Guthaben pro Fünf-Stunden- und Wochenfenster, und die Nutzung außerhalb der Stoßzeiten (an Wochentagen außerhalb von 14:00 bis 18:00 Uhr chinesischer Zeit) kostet die Hälfte der Guthaben.
• ChatGPT und Copilot rechnen über ihre eigenen Systeme ab: ChatGPT in Fünf-Stunden-Nachrichtenschätzungen pro Modell, Copilot in AI Credits. In OpenCode zeigen ChatGPT-Anmeldungen keine Kosten pro Anfrage an, weil die Nutzung auf deinen Tarif angerechnet wird, und OpenCode begrenzt das Eingabe-Kontextfenster für sie standardmäßig (500.000 Token bei den neuesten GPT-Modellen).

Datenschutz und Datenaufbewahrung

Deine Prompts enthalten deinen Code. Wohin sie gehen, ist wichtig, besonders bei Kundenarbeit unter EU-Datenschutzbedingungen.

• OpenCode Go blockiert standardmäßig bezahlte Endpunkte, die mit deinen Daten trainieren. Die meisten Modelle (GLM, Kimi, MiniMax, Qwen, MiMo und weitere) werden ohne Aufbewahrung bereitgestellt; einige wenige (Grok, die GPT-Luna-Modelle, Claude Haiku und zwei kostenlose Aktionsmodelle) speichern Protokolle für 30 Tage. Vergünstigte “Contributor”-Modelle trainieren tatsächlich mit deinen Prompts und müssen bewusst aktiviert werden. Standardregionen sind Europa und die Vereinigten Staaten, und DeepSeeks Modelle erfordern die ausdrückliche Zustimmung zum globalen Routing, mit einer Vereinbarung zur Nullaufbewahrung, die bis zum 30. November 2026 gilt.
• Ollama-Wolke sagt klar: “Prompt- oder Antwortdaten werden niemals protokolliert oder für das Training verwendet.” Die Modelle laufen hauptsächlich in den Vereinigten Staaten, wobei Überlaufkapazität möglicherweise nach Europa geleitet wird.
• OpenCodes kostenlose Modelle sind eine andere Sache: Die Dokumentation weist darauf hin, dass einige kostenlose Modelle deine Daten verwenden können, um das Modell zu verbessern. In Ordnung für Experimente, nicht für Kundencode. Setze OPENCODE_DISABLE_FREE_MODELS=1 um sie auszublenden.
• Lokale Modelle verlassen niemals deinen Rechner. Für alles unter einer strengen Auftragsverarbeitungsvereinbarung ist das noch immer die sauberste Antwort.

Die Claude-Frage

Claude-Abonnements hatten ein schwieriges Jahr in Drittanbieter-Tools. Im Januar verschärfte Anthropic seine Prüfungen, sodass Claude-Pro- und -Max-Anmeldungen in Harnesses wie OpenCode nicht mehr funktionierten, und im März entfernte OpenCode auf Anthropics Wunsch seine Anmeldeoption. Am 30. Oktober brachte OpenCode 2.2.3 die Abonnements über einen anderen Weg zurück: einen integrierten Claude Agent Anbieter, der dein lokal installiertes Claude Code (Version 2.1.248 oder neuer) über Anthropics offizielles Agent SDK steuert, nachdem du dich angemeldet hast mit claude auth login.

Die Fakten, die du vor der Nutzung kennen musst:

• OpenCode liest nicht die gespeicherte Anmeldung von Claude Code; das eigentliche claude Programm sendet die Anfragen.
• Claude Codes eigene Tools, Einstellungen, CLAUDE.md Dateien, Hooks, MCP-Server und Skills sind abgeschaltet. Claude arbeitet stattdessen über OpenCodes Tools und Berechtigungsabfragen.
• Anthropics Agent-SDK-Dokumentation besagt, dass Drittanbieter in ihren Produkten weder claude.ai-Login noch Abonnement-Limits anbieten dürfen, sofern Anthropic dem nicht zugestimmt hat. Zum Zeitpunkt des Schreibens hatte Anthropic sich nicht öffentlich zu OpenCodes Anbieter geäußert, und niemand kann dir mit Sicherheit sagen, ob er dein Konto gefährdet.

Mein Rat: Wenn du bereits für Claude zahlst und es ausprobieren willst, nutze es für private Projekte und achte auf eine offizielle Stellungnahme. Für geschäftliche Arbeit verwendest du einen Anthropic-API-Schlüssel, den einzigen Weg, den Anthropics Dokumentation nennt.

Was ich empfehle und warum

Fang mit OpenCode Go und Ollama an. Die Begründung:

• Preis. Für 10 $ im Monat bekommst du Zugang zu 32 starken offenen Modellen. Ergänze Ollama Pro für 20 $, wenn du mehr Cloud-Luft nach oben willst; lass es weg, wenn dein Mac lokale Modelle gut ausführt.
• Auswahl ohne Bindung. Go und Ollama Cloud führen dieselben Modellfamilien mit offenen Gewichten (GLM, Kimi, MiniMax, DeepSeek und mehr), sodass du Modelle in deinem eigenen Projekt vergleichen kannst, statt einer Bestenliste zu vertrauen.
• Datenschutz standardmäßig. Keine Aufbewahrung bei den meisten Go-Modellen, eine No-Logging-Richtlinie bei Ollama und die Option, für sensible Arbeit vollständig lokal zu bleiben.
• Keine Grauzonen. Beide sind genau für diesen Zweck gedacht, innerhalb von OpenCode.
• Der lokale Fallback ist kostenlos. Wenn das Fünf-Stunden-Fenster um 23 Uhr ausgeschöpft ist, bringt dich ein lokales Modell auf Ollama bei den kleinen Aufgaben weiter.

Wann du etwas anderes wählen solltest. Wenn du bereits für ChatGPT Plus oder Copilot zahlst, verbinde es zuerst; es kostet dich nichts extra. Wenn GLM dein Daily Driver wird, kann das Kontingent des GLM Coding Plan’s mehr Sinn ergeben als Go’s Limits pro Modell, und du kannst über meinen Affiliate-Link 10 % Rabatt auf den GLM Coding Plan bekommen (Affiliate-Link, siehe Offenlegung oben). Coding-Plan-Schlüssel und normale Z.ai-API-Schlüssel sind nicht austauschbar, wähle also den Coding-Plan-Provider in /connect. Und wenn deine Arbeit die absolute Spitze des Leaderboards braucht, ist ein Frontier-Modell per API-Schlüssel für die härtesten Aufgaben gut investiertes Geld.

---

Teil 3 — Ollama: eine Engine für lokale und Cloud-Modelle

Ollama führt Modelle mit offenen Gewichten auf deinem eigenen Computer aus und stellt sie über eine einfache lokale API bereit. Seit letztem Jahr führt es auch größere Modelle in seiner eigenen Cloud aus, über dieselbe App und dieselbe API, sodass ein Cloud-Modell für OpenCode genau wie ein lokales aussieht. Das ist der ganze Reiz: eine Engine, eine Einrichtung und ein Wechsel zwischen “privat und kostenlos” und “groß und schnell”, der nur ein Modellname ist.

Ollama installieren (Schritt für Schritt)

1. Lade es herunter aus ollama.com/download. Öffne auf einem Mac den Download und ziehe Ollama in Programme. Führe unter Windows den Installer aus. Unter Linux lautet der offizielle Einzeiler:

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

2. Starte es. Öffne die App oder tippe ollama in ein Terminal ein. Seit Version 0.40.15 (Anfang November) öffnet ollama ohne Argumente einen Willkommens-Launcher.
3. Melde dich an, wenn du Cloud-Modelle willst. Die App fragt dich während der Einrichtung. Lokale Modelle funktionieren ohne Konto; deine Cloud-Nutzung findest du unter ollama.com/settings/usage.
4. Lade ein Modell herunter um zu prüfen, ob alles funktioniert:

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

Verbinde Ollama mit OpenCode

Du hast drei Möglichkeiten, von der einfachsten bis zur flexibelsten.

Option 1: OpenCode findet es selbst. OpenCode v2 prüft beim Start die standardmäßige lokale Ollama-Adresse und fügt jedes Modell, das Text schreiben kann, hinzu /models. Kein Konto, keine Konfiguration. Reine Embedding-Modelle werden übersprungen.

Option 2: Ollama richtet es ein.

ollama launch opencode            # OpenCode für Ollama konfigurieren und starten
ollama launch opencode --config   # nur konfigurieren, keine Sitzung starten

ollama launch funktioniert seit Ollama 0.40.12 (27. Oktober) mit OpenCode v2. Es rührt’s nicht an: deine ~/.config/opencode/opencode.json, also deine eigenen Einstellungen, gelten weiter. Eine Eigenheit: Modelle, die du nur in OpenCode’s Konfiguration definiert hast, erscheinen nicht in Ollama’s Launch-Auswahl.

Option 3: Richte OpenCode auf einen Ollama-Server an einem anderen Ort aus. Wenn Ollama auf einem Mac mini im Schrank oder auf einem Server läuft, füge ihn mit seiner Adresse als Provider hinzu. Das /v1 am Ende zählt:

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

Die Einstellung, die die meisten lokalen Setups kaputt macht: die Kontextlänge

Ollama’s FAQ nennt als Standard-Kontextfenster 4.096 Token. Ollama’s eigener OpenCode-Leitfaden verlangt mindestens 64K, weil der System-Prompt eines Agenten, die Tool-Definitionen und die Dateiinhalte ein kleines Fenster füllen, bevor’s an die eigentliche Arbeit geht. Setze es auf dem Ollama-Server, nicht in OpenCode:

# Wenn du den Server selbst startest:
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# Wenn du die Mac-App nutzt: die Variable für launchd setzen, dann Ollama beenden und neu öffnen
launchctl setenv OLLAMA_CONTEXT_LENGTH 65536

Prüfe dann, ob es gewirkt hat: ollama ps zeigt die Kontextgröße jedes geladenen Modells und ob’s auf der GPU läuft. Ein größeres Fenster braucht mehr Speicher, deshalb sind 64K auf einem 32-GB-Mac eine vernünftige Obergrenze für ein Modell mit 27 Milliarden Parametern.

Welches lokale Modell zu deinem Mac passt

Eine nützliche Faustregel aus BenchLM’s November-Rankings: Ein Modell braucht ungefähr seine Downloadgröße plus 20 % für den Kontext, und ein Mac kann dem GPU etwa drei Viertel seines Unified Memory geben. In der Praxis gilt: halte den Download unter etwa 60 % des Arbeitsspeichers deines Macs.

Der Speicher deines Mac’s	Modell für den ersten Test	Herunterladen	Kontext	Geeignet für
16 GB	gemma4:12b oder gemma4:e4b	7.7 GB / 6.6 GB	256K / 128K	Erklärungen, kleine Änderungen, Commit-Nachrichten. Zu klein für lange Agentensitzungen; nutze für den Bau Cloud-Modelle
24–32 GB	qwen3.8:27b (auch als 27b-mlx für Apple Silicon)	18 GB	256 KB	Der lokale Sweet Spot fürs Coding mit einem Agenten
24–32 GB	qwen3-coder:30b	19 GB	256 KB	Ein Mixture-of-Experts-Coder mit nur rund 3 Milliarden aktiven Parametern, deshalb ist er schnell
24–32 GB	gpt-oss:20b	14 GB	128K	OpenAIs kleineres Modell mit offenen Gewichten; lässt den meisten Spielraum
64 GB	Dieselben Modelle mit höherer Präzision, zum Beispiel qwen3.8:27b-q8_0	30 GB	256 KB	Bessere Antworten, Platz für ein großes Kontextfenster
96–128 GB	gpt-oss:120b oder devstral-2:123b	65 GB / 75 GB	128K / 256K	Qualität großer Modelle ohne die Cloud

Größen und Kontextfenster aus der Ollama-Bibliothek vom 7. November 2026. Die Geschwindigkeit hängt genauso von der Speicherbandbreite deines Chips ab wie von seiner Speichergröße. Zur Hardware-Seite siehe mein MacBook-Leitfaden für lokale LLMs.

Ollama Cloud: die Modelle, die dein Mac nicht halten kann

Die stärksten Coding-Modelle mit offenen Gewichten sind heute viel zu groß für ein Notebook. Ollama Cloud führt sie für dich aus. In der App oder im CLI tragen sie einen :cloud Tag und laden nichts herunter:

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

Der coding-relevante Teil des Cloud-Katalogs am 7. November:

Modell	Hersteller	Kontext	Ollamas Nutzungsbewertung	Anmerkungen
glm-5.3	Z.ai	1 Mio.	Hoch	Z.ais Flaggschiff; stark bei langen agentischen Aufgaben
glm-5.3-flash	Z.ai	1 Mio.	Mittel	Nativ multimodal, 18 Mrd. aktive Parameter; ein hervorragendes Standardmodell für den Bau
kimi-k3.1-pro	Moonshot AI	1 Mio.	Sehr hoch	Der neueste Eintrag (aktualisiert am 4. November), multimodal, Moonshots leistungsfähigstes Modell
kimi-k2.7-code	Moonshot AI	256 KB	Hoch	Auf Coding abgestimmt und sparsamer bei Thinking-Tokens
minimax-m3.1-flash	MiniMax	976K	Mittel	Liest Bilder; 0,15 $ Eingabe und 0,60 $ Ausgabe pro Million Tokens
deepseek-v4.1-flash	DeepSeek	1 Mio.	Mittel	Auf Geschwindigkeit und Durchsatz ausgelegt; liest Bilder
mistral-large-4	Mistral	1 Mio.	Hoch	Europäisches Labor, offene Gewichte
gemma4	Google	256 KB	Niedrig	Günstig genug für Helfer und Subagenten

Die Bewertung ist Ollamas Kurzform dafür, wie schnell ein Modell deine Credits verbraucht. Wenn du die großen richtig vergleichen willst, lies meine Kimi K3 vs. Fable 5.1 vs. GLM-5.3 und GLM-5.3-Flash im Vergleich zu MiniMax M3 Vergleiche, die tiefer gehen.

Das Routing-Muster, das ich übernehmen würde

Du musst dich nicht für ein Modell entscheiden. Gib jeder Art von Arbeit das günstigste Modell, das sie gut erledigt:

• Planung (hier passieren die teuersten Fehler): dein stärkstes Modell.
• Umsetzung: ein schnelles, leistungsfähiges Modell wie GLM-5.3-Flash oder MiniMax M3.1 Flash.
• Codebasis durchsuchen, Dokumentation lesen, Tests und Commit-Nachrichten schreiben: ein lokales Modell. Es kostet nichts und dein Code bleibt, wo er ist.

Teil 4 zeigt genau, wie du das in OpenCodes Konfiguration einrichtest.

Nur-lokal-Modus für sensible Projekte

Wenn ein Projekt niemals ein Cloud-Modell berühren darf, mach das zu einer Einstellung statt zu einem Versprechen. Ollama kann seine Cloud-Funktionen komplett abschalten (füge "disable_ollama_cloud": true zu ~/.ollama/server.json, oder setze OLLAMA_NO_CLOUD=1, dann starte es neu), und OpenCodes kostenlose Cloud-Modelle lassen sich ausblenden mit OPENCODE_DISABLE_FREE_MODELS=1. Verbinde dann in diesem Projekt nur lokale Anbieter.

Ehrliche Einschränkungen bei Ollama

• Lokale Modelle sind langsamer und schwächer bei langer, mehrstufiger Werkzeugnutzung als die großen Cloud-Modelle. Sie glänzen bei überschaubaren Aufgaben.
• Cloud ist immer noch der Computer von jemand anderem. Ollamas Policy ohne Logging ist gut, aber dein Code verlässt trotzdem deinen Rechner, meist in Richtung USA.
• Credits gehen aus. $60 Pro-Guthaben reichen bei GLM-5.3-Flash weit und bei einem Modell mit der Bewertung “extra high” deutlich weniger.
• Eine langsame Antwort liegt nicht immer am Modell. Jede Cloud-Anfrage macht zuerst einen Roundtrip über dein Wi-Fi, deinen Router und das weitere Internet. Wenn sich Antworten zäh anfühlen, prüfe die Verbindung, bevor du dem Modell die Schuld gibst: Meine eigene App PingAtlas misst Roundtrip-Zeiten von deinem iPhone, iPad oder Mac zu Städten und zu Diensten wie GitHub, und den Rest des Wegs habe ich erklärt in was im Inneren deines Routers geschieht.

---

Teil 4 — So nutzt du OpenCode: installieren und Modelle verbinden, Schritt für Schritt

Das ist das Setup, das ich einem Freund empfehlen würde. Es dauert etwa zwanzig Minuten, größtenteils Downloads.

Schritt 0 – Was du zunächst benötigst

• Ein Mac mit Apple Silicon, wenn du iPhone-Apps nativ bauen willst. Xcode 27.1 (erschienen am 15. Oktober, mit Swift 6.4 und dem iOS 27.1 SDK) braucht macOS Tahoe 26.6 oder neuer. Wenn du mit Expo baust, kann dessen Cloud-Dienst iOS-Apps von Windows oder Linux aus bauen, aber zum Testen willst du trotzdem ein iPhone.
• Xcode aus dem Mac App Store, einmal geöffnet, damit es seine Komponenten installieren kann.
• Git. Dein echter Rückgängig-Knopf.
• Node.js, nur wenn du Expo nutzt: SDK 58 braucht Node 22.13 oder neuer, 24.3 oder neuer oder 26 und neuer (ungerade Releases wie 23 und 25 werden nicht unterstützt).
• Ein Coding-Plan aus Teil 2 oder Ollama aus Teil 3.

Schritt 1 — OpenCode installieren

Unter macOS oder Linux:

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

Lieber eine App? Lade die Desktop-Version für macOS, Windows oder Linux von opencode.ai/download. Terminal- und Desktop-App teilen denselben Hintergrunddienst und dieselben Sessions. Unter Windows nutzt du die Desktop-App oder das eigenständige Zip; Windows-Paketmanager werden für v2 nicht unterstützt.

Zwei Fallen, die du kennen solltest:

• Alte Leitfäden nutzen den alten Installer. opencode.ai/install (ohne /v2/) taucht noch in vielen Anleitungen auf, auch in einigen offiziellen Partner-Docs. Nutze die /v2/install Adresse oben.
• mise-Nutzer brauchen mise 2026.10.9 oder neuer, sonst bekommen sie OpenCode 1.

Schritt 2 — Verbinde deine Modelle

Starte OpenCode in einem Projektordner und führe aus /connect:

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

Dann, je nachdem, wofür du zahlst:

Du hast	Unter /connect, wähle	Dann
OpenCode Go	OpenCode Go	Füge den API-Schlüssel aus der OpenCode Console ein
Ollama	Nichts; lokale Modelle erscheinen von selbst	Oder führe aus ollama launch opencode
ChatGPT Plus oder Pro	OpenAI → Mit ChatGPT anmelden	Im Browser anmelden
GitHub Copilot	GitHub Copilot	Schließe die Geräteanmeldung ab
Claude Pro oder Max	Claude Agent (nicht “Anthropic”, das ist für API-Schlüssel)	Laufen claude auth login zuerst in einem Terminal; lies den Hinweis in Teil 2
GLM-Kodierungsplan	Der Anbieter Z.AI Coding Plan	Füge deinen Coding-Plan-Schlüssel ein, keinen Standard-API-Schlüssel
Ein API-Schlüssel	Der Name des Anbieters	Füge den Schlüssel ein

Schritt 3 — Wähle deine Modelle

Laufen /models und wähle aus. OpenCode Go-Modelle heißen opencode-go/<model-id>; lokale Ollama-Modelle erscheinen unter dem Anbieter Ollama. Kopiere die genauen IDs aus /models in deine Konfiguration, weil sich Namen und Tags ändern.

Schritt 4 – Projektkonfiguration hinzufügen

Die Standardeinstellungen funktionieren, aber ein App-Projekt verdient eine Konfigurationsdatei, die drei Aufgaben erfüllt: jeden Agenten auf das richtige Modell leiten, den Agenten von allem Unumkehrbaren fernhalten und deine MCP-Server verbinden. Speichere sie als opencode.jsonc im Projektstamm und setze die Modell-IDs ein, die /models dir zeigt:

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

Was du da einfügst, in einfachen Worten:

• Jeder Shell-Befehl fragt erst nach, außer ein paar schreibgeschützten. Schreibgeschützte asc Abfragen (alles, was auflistet, dazu der Review-Status) sind erlaubt, damit der Agent Builds und den Review-Fortschritt prüfen kann, ohne dich zu stören.
• Ein paar Dinge sind komplett blockiert: Code pushen, eine App veröffentlichen oder zum Review einreichen und zerstörerische Aktionen in App Store Connect bestätigen. Das machst du selbst, absichtlich. Einen Build zu TestFlight hochzuladen bleibt erlaubt (nach Nachfrage), weil dabei nichts zum Review geht.
• OpenCodes Standardeinstellungen fragen schon vor dem Lesen nach .env -Dateien gelesen werden. Lass das an.
• Berechtigungen sind Leitplanken, keine Sandbox. Ein entschlossenes Modell findet einen anderen Weg, etwas zu tun. Halte Produktions-Zugangsdaten, Signing-Keys und deinen App Store Connect Admin Key von der Maschine fern, auf der Agenten unbeaufsichtigt laufen.

Schritt 5 — Schreib eine AGENTS.md, bevor du Code schreibst

OpenCode lautet AGENTS.md in deinem Projektstamm zu Beginn jeder Sitzung, dazu eine persönliche unter ~/.config/opencode/AGENTS.md wenn du sie anlegst. Der /init Befehl kann eine entwerfen, indem er dein Repository scannt. Es ist die mit Abstand wirksamste Gewohnheit in der KI-gestützten Entwicklung, und ich habe das ganze System beschrieben in meinem Leitfaden zur Vibe-Codierung. Für eine iPhone-App sollten darin die Regeln des Produkts stehen, ebenso wie die Befehle:

# Hinweise für Coding-Agenten

## Was diese App ist
Ein Satz. Wenn eine Änderung ihm nicht dient, gehört sie nicht dazu.

## Nicht verhandelbar
- Funktioniert offline. Netzwerkfunktionen degradieren sauber.
- Keine Analytics-, Werbe- oder Tracking-SDKs. Frag nach, bevor du IRGENDEINE Abhängigkeit hinzufügst.
- Keine Secrets im App-Bundle. Schlüssel, die Geld kosten, liegen auf einem Server.
- Keine versteckten, ruhenden oder reinen Debug-Funktionen in Release-Builds
  (App Review guideline 2.5.19). Debug-Menüs werden aus Release herauskompiliert.
- Sende niemals personenbezogene Daten an einen Drittanbieter-KI-Dienst ohne
  einen ausdrücklichen In-App-Zustimmungsbildschirm (guideline 5.1.2(i)).
- Barrierefreiheit: Dynamic Type, VoiceOver-Labels, 44 x 44 pt große Touch-Ziele,
  heller und dunkler Modus auf jedem Bildschirm.
- Jeder nutzerseitige String ist lokalisiert, einschließlich Widgets,
  Mitteilungen und Berechtigungsdialogen.

## Befehle
- Bauen und ausführen: nutze die XcodeBuildMCP-Tools (build_run_sim), Scheme \"MyApp\"
- Tests: test_sim
- Führe niemals asc publish oder irgendetwas mit --submit aus.

## Definition von fertig
- Baut ohne Warnungen, Tests laufen durch
- Mit Screenshot + snapshot_ui im Simulator geprüft
- Funktioniert im Flugmodus, im dunklen Modus und bei größter Textgröße

Schritt 6 — Deine erste echte Sitzung

1. Starte im Plan-Modus. Wechsle zum Plan Agenten (er kann deine Projektdateien nicht bearbeiten) und bitte ihn, gegen dein Briefing zu argumentieren: “Lies AGENTS.md und BRIEF.md. Liste die Nutzerflüsse, die Randfälle, an die ich nicht gedacht habe, und die Bildschirme, die mir fehlen. Dann sag mir, was ich weglassen soll.”
2. Speichere den Plan als Roadmap. Lass es ROADMAP.md als Checkliste kleiner, durchgängiger Slices schreiben.
3. Baue jeweils einen Slice mit dem Erstellen Agenten. Ein Bildschirm, eine Funktion, die von Anfang bis Ende funktioniert.
4. Prüfe den Diff, führe ihn aus, committe. Jeder Slice endet mit einem Commit. Wenn ein Schritt schiefgeht, /undo setzt den letzten Schritt des Agenten aus den Snapshots von OpenCode zurück; Git ist das größere Sicherheitsnetz.
5. Starte eine frische Session für den nächsten Slice. Eine saubere Session, die AGENTS.md und ROADMAP.md erneut liest, ist meist klüger als eine lange, die voller veralteter Annahmen steckt.

---

Teil 5 — Agenten, Befehle, Berechtigungen und Goal-Modus: So machst du OpenCode zu deinem

Sobald die Grundlagen laufen, machen vier Funktionen aus OpenCode – bisher nur ein Chat mit einem Terminal – eine Werkstatt, die zu deinem Projekt passt.

Die integrierten Agenten

Agent	Typ	Was es bewirkt
Erstellen	Primary	Der Standard. Bearbeitet Dateien, führt Befehle aus, erledigt die Arbeit
Plan	Primary	Erkundet und plant, ohne deine Projektdateien zu bearbeiten (es darf eigene Plandateien schreiben)
general	Subagent	Recherche und mehrstufige Aufgaben; kann keine weiteren Subagenten starten
entdecken	Subagent	Durchsucht und liest Code oder Webseiten; kann nichts bearbeiten

Primäre Agenten sind die, mit denen du sprichst. Subagenten werden von einem primären Agenten für eine gezielte Aufgabe gestartet, damit der Kontext der Hauptsession sauber bleibt.

Schreib deinen eigenen Subagenten: ein App-Review-Skeptiker

Eigene Agenten sind Markdown-Dateien in .opencode/agents/ (oder ~/.config/opencode/agents/ für jedes Projekt). Der Front-Matter-Block konfiguriert den Agenten, und der Textkörper wird zu seinen Anweisungen. Dieser hier prüft deine App so, wie App Review es tun wird, und kann dabei nichts ändern:

---
description: Prüft die App und ihre Metadaten vor der Einreichung gegen Apples App Review Guidelines
mode: subagent
model: opencode-go/glm-5.3
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

Du bist ein skeptischer App-Review-Spezialist. Prüfe den aktuellen Code und die
Dateien in metadata/ und liste die Probleme auf, das schwerwiegendste zuerst, mit Datei und Zeile:

- Abstürze, Platzhaltertexte, tote Links, fehlendes Demo-Konto (2.1)
- Alles, was wie die Kopie einer übersättigten App-Kategorie aussieht (4.3(b))
- Versteckte, ruhende oder undokumentierte Funktionen, Debug-Menüs, Feature-Flags (2.5.19)
- Daten, die das Gerät verlassen und nicht in der Datenschutzerklärung oder im Datenschutz-Label stehen
- Personenbezogene Daten, die ohne ausdrückliche Zustimmung an einen KI-Dienst gehen (5.1.2(i))
- Konto-Erstellung ohne Löschmöglichkeit im App (5.1.1(v))
- Screenshots oder Beschreibungen, die Funktionen versprechen, die der Build nicht hat

Ändere nichts. Melde nur.

Speichere es als .opencode/agents/appstore-reviewer.md, und frage dann: “Nutze den Subagenten appstore-reviewer, um alles seit dem letzten Release-Tag zu prüfen.”

Eigene Befehle für die Aufgaben, die du wiederholst

Befehle sind Prompt-Vorlagen, die du mit einem Slash ausführst. Lege sie in .opencode/commands/; $ARGUMENTS wird durch das ersetzt, was du nach dem Befehl eintippst, und ` !command ` fügt die Ausgabe eines Shell-Befehls ein, bevor der Prompt gesendet wird. Dieser hier entwirft die Release Notes für den App Store:

---
description: Entwirft die "What's New"-Notizen für den App Store aus den Commits seit dem letzten Tag
agent: build
---

Hier sind die Commits seit dem letzten Release:

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

Schreibe die "What's New"-Notizen für Version $ARGUMENTS in einfachem, freundlichem Englisch,
unter 400 Zeichen, nur nutzerseitige Änderungen. Speichere sie in
metadata/en-US/release_notes.txt und zeige mir den Text.

Speichere es als .opencode/commands/whats-new.md und starte ihn mit /whats-new 1.2.0. Eine Warnung aus der OpenCode-Dokumentation ist es wert, wiederholt zu werden: Diese ! Blöcke laufen außerhalb des Berechtigungssystems des Agenten, also packe nur Befehle hinein, denen du vertraust.

Ein Kochbuch für Berechtigungen in App-Projekten

Die Konfiguration aus Teil 4 ist ein guter Anfang. Ein paar weitere Regeln, die du kennen solltest:

• Regeln pro Agent gehören unter agents.<id>.permissions und werden nach den globalen hinzugefügt, sodass du zum Beispiel nur den Erstellen Agenten xcodebuild.
• MCP-Tools sind ebenfalls Aktionen, benannt <server>_<tool>. Eine Regel wie { "action": "XcodeBuildMCP_*", "resource": "*", "effect": "ask" } lässt jeden XcodeBuildMCP-Aufruf zuerst nachfragen.
• Skills lassen sich beschränken mit dem skill action: allow macht einen Skill bekannt und lädt ihn ohne Nachfrage, fragen macht ihn bekannt, fragt aber vor dem Laden nach, deny versteckt ihn vollständig.
• Wenn mehrere Ressourcen gleichzeitig geprüft werden, gewinnt eine beliebige deny , dann eine beliebige fragen.

Goal-Modus, Worktrees und Zeitpläne

Drei neuere Funktionen verändern, wie sich lange Jobs anfühlen:

• Goal-Modus (2.2.1): /goal Lass jeden Screen einen VoiceOver-Audit bestehen und behebe, was durchfällt lässt die Sitzung auf das Ziel hinarbeiten, bis es geprüft ist, mit pause, resume und clear. Perfekt für die großen, langweiligen Jobs: Barrierefreiheits-Durchläufe, Lokalisierung, Testabdeckung.
• Worktrees: Starte eine Sitzung in einem separaten Git-Worktree vom Bildschirm für neue Sitzungen aus (oder ⌘⌥O in der Desktop-App), damit ein Experiment deinen Hauptbranch nicht anfassen kann. Skriptgesteuerte Läufe nutzen opencode run --worktree=<name> seit 2.2.6. Wirf den Worktree weg, wenn das Experiment scheitert.
• Geplante Prompts (Opt-in, experimentell): /schedule führt einen Prompt nach Zeitplan aus, während opencode serve läuft, etwa ein nächtliches “Tests ausführen und Fehler zusammenfassen”.

---

Teil 6 — MCP-Server: dem Agenten Hände geben

Von sich aus kann ein Coding-Agent Dateien lesen und Shell-Befehle ausführen. MCP, das Model Context Protocol, ist der Standardweg, ihm mehr zu geben: ein laufendes Xcode-Projekt, einen Simulator, den es antippen und per Screenshot festhalten kann, deine Absturzberichte, aktuelle Dokumentation, deinen Build-Service. Jeder MCP-Server stellt eine Reihe von Tools bereit, und der Agent entscheidet, wann er sie aufruft.

Das hat einen Preis, und die Dokumentation von OpenCode sagt es klar: “MCP-Tools verbrauchen Modellkontext, also füge nur die Server hinzu, die du brauchst.” Jeder verbundene Server fügt jeder Anfrage Tool-Beschreibungen hinzu. Zehn Server, die du selten nutzt, machen jede Antwort langsamer und weniger fokussiert.

Die Shortlist für App-Entwickler

Server	Was es dem Agenten gibt	So fügst du es OpenCode hinzu	Gut zu wissen
Xcode (Apple)	Dein geöffnetes Xcode-Projekt: Bauen, Testen und mehr, durch Xcode selbst	opencode mcp add xcode -- xcrun mcpbridge	In Xcode → Einstellungen → Intelligence stellst du Externen Agenten erlauben, Xcode-Tools zu verwenden zu Immer oder Während Xcode geöffnet ist. Öffne das Projekt in Xcode, bevor du den Prompt abschickst; Xcode zeigt an, wenn ein Agent sich verbindet
XcodeBuildMCP	Headless-Builds, Läufe auf Simulator und Gerät, Screenshots, Taps und Wischgesten, Barrierefreiheits-Snapshots, Tests, LLDB-Debugging	opencode mcp add XcodeBuildMCP -- npx -y xcodebuildmcp@latest mcp	Open Source (MIT), wird seit der Übernahme des Projekts im Februar von Sentry gepflegt. Braucht macOS 14.5+, Xcode 16+ und Node 18+. Standardmäßig sind nur die Simulator-Tools aktiv
Expo	EAS-Builds, Workflows und Einreichungen, Expo-Doku, Cloud-Simulatoren, Absturz- und Feedback-Daten aus TestFlight und den Stores	opencode mcp add expo --url https://mcp.expo.dev/mcp, dann opencode mcp auth expo	Braucht ein Expo-Konto und das aktuelle SDK. Manche Tools brauchen ein kostenpflichtiges Expo-Abo. Lokale Simulator-Tools brauchen npx expo install expo-mcp --dev und SDK 54+
Context7	Aktuelle, versionsspezifische Dokumentation für Bibliotheken und Frameworks	opencode mcp add context7 --url https://mcp.context7.com/mcp	Hindert das Modell daran, APIs zu erfinden, die sich letzten Monat geändert haben
Sentry	Deine echten Abstürze und Fehler	opencode mcp add sentry --url https://mcp.sentry.dev/mcp, dann opencode mcp auth sentry	Anmeldung per OAuth
Playwright	Ein echter Browser, den der Agent steuern kann	opencode mcp add playwright -- npx @playwright/mcp@latest	Für die Web-Version deiner App und deine Landingpage
Firebase	Dein Firebase-Projekt, deine Sicherheitsregeln und deine Konfiguration	opencode mcp add firebase -- npx -y firebase-tools@latest mcp	Fragt nach, bevor es etwas in deinem Projekt ändert

Prüfe, was verbunden ist, mit opencode mcp-Liste, und schalte Server für eine Sitzung ein oder aus mit /mcps.

Wenn du in Figma designst, kann sein MCP-Server dem Agenten auch Frames und Variablen liefern. Die OpenCode-spezifische Besonderheit (Remote-Server versus Desktop-Server) habe ich in meinem Leitfaden zum Bauen einer App von Grund auf mit KI.

Xcodes MCP-Bridge vs. XcodeBuildMCP

Sie überschneiden sich, und sie arbeiten gut zusammen:

• Xcodes eigener Server (xcrun mcpbridge) arbeitet über die Xcode-App, die du geöffnet hast. Er ist von Apple, er versteht dein Projekt so wie Xcode, und er braucht ein laufendes Xcode.
• XcodeBuildMCP kapselt Apples Kommandozeilen-Tools (xcodebuild, simctl, devicectl), läuft also headless. Seine eigentliche Stärke ist die Prüfschleife: build_run_sim zum Bauen und Starten, screenshot zum Ansehen, snapshot_ui zum Auslesen des Accessibility-Baums, tap und type_text zum Bedienen der App, und test_sim zum Ausführen der Tests. Führe xcodebuildmcp init einmal in deinem Projekt aus, um seine beiden dazugehörigen Skills zu installieren.

In der Konfigurationsdatei

Dieselben Server können auch in opencode.jsonc (Teil 4 enthält ein vollständiges Beispiel), was für ein Team besser ist, weil die Einrichtung mit dem Repository mitwandert:

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

Zwei Details aus OpenCode’s MCP-Doku: Secrets kommen als {env:NAME} (ein einfaches $NAME wird nicht expandiert), und "disabled": true hält einen Server konfiguriert, ohne ihn zu verbinden.

Wann ein CLI besser ist als ein MCP-Server

Meine Regel: Wenn es ein gutes Kommandozeilen-Tool gibt, probier es mit einem Skill aus, bevor du einen Server hinzufügst. Der Agent weiß schon, wie man Befehle ausführt, ein CLI kostet keinen Kontext, bis es benutzt wird, und seine Ausgabe lässt sich filtern, bevor sie das Modell erreicht. Für App-Arbeit decken drei CLIs eine Menge ab:

• gh für GitHub: Issues, Pull Requests, Releases.
• asc für App Store Connect: Builds, TestFlight, Metadaten, Screenshots, Prüfstatus (Teil 9).
• eas für den Build- und Submit-Service von Expo.

MCP-Sicherheit in vier Regeln

1. Installiere Server von ihren Herstellern oder aus Projekten, die du lesen kannst. Ein Server ist Code, der auf deiner Maschine mit deinen Berechtigungen läuft.
2. Behandle Tool-Ausgaben als nicht vertrauenswürdig. Eine Webseite, ein Issue-Kommentar oder ein Absturzbericht kann Anweisungen enthalten, die auf deinen Agenten zielen. Halte riskante Aktionen an kurzer Leine. fragen.
3. Regle den Zugriff auf Tools über ihren Namen. Jedes MCP-Tool ist eine Berechtigungsaktion namens <server>_<tool>, sodass du die schreibgeschützten erlauben und die übrigen nachfragen lassen kannst.
4. Entferne, was du nicht benutzt. Es kostet Kontext, und es ist eine Sache weniger, die schiefgehen kann.

---

Teil 7 — Skills: dein Playbook einmal schreiben

AGENTS.md sagt dem Agenten, was dein Projekt ist. Skills bringen ihm bei, wie du bestimmte Aufgaben erledigst: einen Build veröffentlichen, eine Migration schreiben, Screenshots vorbereiten, Datenschutz prüfen. Ein Skill ist ein Ordner mit einer SKILL.md Datei mit einer kurzen Beschreibung oben und den Anweisungen darunter, plus allen Skripten oder Referenzdateien, die er braucht. Das Format ist ein offener Standard, den OpenCode, Claude Code, Codex und andere teilen, weshalb ein für einen Agenten geschriebener Skill meist auch in den anderen funktioniert.

Wie OpenCode einen Skill verwendet

1. Bei jedem Schritt, zeigt OpenCode dem Modell eine Liste der Skills, die es verwenden darf: nur ID, Name und Beschreibung jedes Skills. Die Anweisungen selbst werden nicht geladen, deshalb kosten hundert Skills fast nichts.
2. Wenn eine Aufgabe passt, ruft das Modell das skill Tool mit der ID des Skills auf, und OpenCode prüft deine Berechtigungen.
3. OpenCode fügt die Anweisungen der Konversation hinzu, zusammen mit dem Ordnerpfad des Skills und einer Liste von bis zu zehn seiner Begleitdateien.
4. Begleitdateien werden nur geladen, wenn die Anweisungen sie anfordern. Eine lange Checkliste oder ein Skript bleibt auf der Festplatte liegen, bis es gebraucht wird.

Du kannst einen auch selbst laden, indem du ihn in einem Prompt erwähnst: @app-store-release.

Wo OpenCode sucht

Umfang	Ordner
Dein Projekt	.opencode/skills/
Dein Projekt (mit anderen Agenten geteilt)	.claude/skills/ und .agents/skills/
Jedes Projekt auf deiner Maschine	~/.config/opencode/skills/
Jedes Projekt (geteilt)	~/.claude/skills/ und ~/.agents/skills/
Überall sonst	Pfade oder HTTP-Kataloge, die in einem Fähigkeiten Array in opencode.jsonc

Die ID eines Skills stammt aus seinem Ordnernamen, nicht aus dem Name im Front Matter, und sie unterscheidet Groß- und Kleinschreibung: .opencode/skills/app-store-release/SKILL.md hat die ID app-store-release. Wenn zwei Quellen dieselbe ID definieren, gewinnt die spätere in dieser Reihenfolge: integriert, .claude/skills, .agents/skills, dein globaler Ordner, der deines Projekts .opencode/skills, dann explizite Konfigurationseinträge. Ein Skill ohne eine Beschreibung wird dem Modell gar nicht erst angezeigt.

Schreib deinen ersten Skill: eine Checkliste für die App-Store-Veröffentlichung

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

---
name: App Store release
description: Bereite ein iOS-Release vor. Erhöht Version und Build-Nummer, führt die Release-Checkliste aus, archiviert, lädt mit asc zu TestFlight hoch und entwirft die Notizen zu „What's New“. Verwende dies, wenn nach „ship“, „release“ oder „send to TestFlight“ gefragt wird.
---

# App Store release

1. Prüfe `git status`. Wenn der Working Tree nicht sauber ist, stoppe und sag es.
2. Erhöhe die Marketing-Version und die Build-Nummer (frag nach der Version, wenn keine angegeben ist).
3. Arbeite references/release-checklist.md durch. Jeder Punkt muss bestehen.
4. Archiviere und exportiere die IPA mit scripts/archive.sh.
5. Upload: `asc builds upload --app "$ASC_APP_ID" --ipa build/MyApp.ipa`
6. Entwirf die What's New-Notizen aus den Commits seit dem letzten Tag und speichere sie
   in metadata/en-US/release_notes.txt.
7. NIEMALS zur Review einreichen. Melde, dass der Build hochgeladen ist, und stoppe dann.

Leg die Checkliste in references/release-checklist.md und das Archivierungsskript in scripts/archive.sh daneben. Wenn du das nächste Mal “ship 1.2.0 to TestFlight” sagst, findet der Agent den Skill anhand seiner Beschreibung und befolgt deine Schritte, statt zu improvisieren.

Skills, die sich für App-Arbeit lohnen

Skill-Set	Was ist drin?	Installieren
Expo-Skills (offiziell)	23 Skills: 16 für das Expo SDK (Router, native UI, @expo/ui, Designsysteme, Upgrades, native Module und mehr) und 7 für die Dienste von Expo, darunter eas-app-stores für das Bauen und Einreichen bei TestFlight, dem App Store und Google Play	npx skills add expo/skills
App Store Connect CLI-Skills	Mehr als zwanzig asc Skills: Release-Ablauf, TestFlight-Orchestrierung, Metadaten-Abgleich mit Zeichenlimit-Prüfung, Übersetzung der Store-Einträge, Screenshot-Pipelines, Signing-Einrichtung, Zustand der Einreichung, Crash-Triage, ASO-Audits	asc install-skills, oder npx skills add rorkai/app-store-connect-cli-skills
XcodeBuildMCP-Skills	Zwei Skills, die dem Agenten die Tools und die CLI von XcodeBuildMCP beibringen	xcodebuildmcp init
skills.sh	Vercels offenes Verzeichnis für Community-Skills; es führt OpenCode unter den unterstützten Agenten auf	npx skills add <owner/repo>

Wenn OpenCode einen Skill nicht anzeigt, den du installiert hast, prüfe, wohin der Installer ihn gelegt hat, und vergleiche das mit den Ordnern oben, oder kopiere den Ordner des Skills nach .opencode/skills/.

Sicherheit von Skills

Ein Skill besteht aus Anweisungen und oft aus Skripten, die der Agent ausführen wird. Lies einen fremden Skill, bevor du ihn installierst, so wie du ein Shell-Skript aus dem Internet lesen würdest. Bevorzuge Skills von den Leuten, die das Tool machen (Expo für Expo, die asc Maintainer für asc), halte unbekannte Skills auf fragen mit einer Berechtigungsregel, und denk daran, dass deny einen Skill vollständig vor dem Modell verbirgt.

---

Teil 8 — Die App bauen: von der Idee zu einem Build, dem du vertraust

Die Tools sind bereit. Jetzt kommt der Teil, der entscheidet, ob jemand das Ergebnis herunterlädt.

Wähle eine Idee, die App Review durchlässt

KI hat das Bauen einer App billig gemacht, und Apple hat es bemerkt. Am 9. Juni hat der Konzern Richtlinie 4.3(b), ihre Spam-Regel, umgeschrieben: Apps, die im Wesentlichen dasselbe sind wie das, was es im Store ohnehin reichlich gibt, werden jetzt abgelehnt, und Apple nennt Dating-, Taschenlampen-, Wallpaper-, Timer- und Wahrsage-Apps als Kategorien, in denen du ein deutlich anderes oder besseres Erlebnis brauchst. Billige Neuheiten-Apps können entfernt werden, bestehende Apps in diesen Kategorien können herausgenommen werden, wenn sie nicht verbessert werden oder keine Nutzer anziehen, und wiederholte Einreichungen dieser Art können dich deine Entwicklermitgliedschaft kosten.

Also vor dem ersten Prompt ein Test: Kannst du in einem Satz sagen, was deine App kann, das die Top-Ergebnisse für ihren wichtigsten Suchbegriff nicht können? Wenn du’s nicht hinbekommst, baut der Agent es wunderschön und App Review schickt es zurück.

Klein und spezifisch schlägt groß und generisch. Meine beiden eigenen Apps sind bewusst eng gefasst:

• Stash merkt sich, wo du Dinge hinlegst: fotografiere den Platz, wähle den Raum, speichere, dann suche nach Name, Raum oder einer transkribierten Sprachnotiz.
• PingAtlas misst Netzwerk-Roundtrip-Zeiten von deinem eigenen iPhone, iPad oder Mac zu 202 Städten, 278 öffentlichen Zielen, 109 Spielen und 32 Online-Diensten, ohne Konto und ohne entfernten Messdienst.

Je eine Aufgabe. Das macht sie von einer Person mit einem Agenten baubar und in einem Satz auf einer App-Store-Seite erklärbar.

Wähle deinen Stack

	SwiftUI + Xcode 27.1	Expo SDK 58 (React Native 0.88)
Läuft auf	iPhone, iPad, Mac, Apple Watch, Vision Pro	iPhone, iPad, Android und das Web aus einer Codebasis
Sprache	Swift 6.4	TypeScript
Brauchst du einen Mac?	Ja	Nicht zum Bauen oder Einreichen (das macht Expo’s Cloud); ja für lokale iOS-Simulator-Tools
Agenten-Tooling	Xcode’s MCP-Bridge, XcodeBuildMCP, OpenCode in Xcode über ACP	Der Expo-MCP-Server, 23 offizielle Skills, ein experimenteller @expo/agent-cli und maschinenlesbare expo command:ps Ausgabe für Agenten
Neu diesen Herbst	iOS 27.1 SDK, ein iPhone-Duo-Simulator (mit einigen Einschränkungen bei Erweiterungen)	Gegen das iOS 27 SDK gebaut; Apps wechseln zu UIKit’s Scene-Life-Cycle, bereit für iPhone Duo; App-Intents-Unterstützung in Alpha; macOS wird in SDK 58 nicht unterstützt
Am besten für	Nur-Apple-Apps, die die neuesten Plattformfunktionen wollen	Eine Person, die für iPhone und Android ausliefert, mit einer Web-Version

Wenn du gern zuerst eine Web-Version auslieferst (ich schon), kannst du mit Expo’s Web-Ausgabe eine funktionierende Demo vor Leute stellen, bevor die App-Store-Version existiert. Stash’s Website macht etwas Ähnliches mit einem Browser-Demo rund um ein Beispiel-Zuhause herum gebaut: Leute können die Idee ausprobieren, bevor sie etwas installieren.

Der Build-Loop, der funktioniert

Der Agent schreibt schnell. Was das Ergebnis vertrauenswürdig hält, ist der Kreislauf darum:

1. Briefing. Ein einseitiges BRIEF.md: das Versprechen in einem Satz, drei User Stories, die Liste der Screens.
2. Plan. Die Plan Der Agent macht daraus ROADMAP.md: kleine vertikale Slices, jede mit einem Feature, das von Anfang bis Ende funktioniert.
3. Baue ein Slice. Die Erstellen Der Agent implementiert es und schreibt die Tests.
4. Prüfe wie ein Nutzer. Mit XcodeBuildMCP kann der Agent die App bauen und im Simulator starten, einen Screenshot machen, den Accessibility-Baum auslesen mit snapshot_ui, sich durch den Ablauf tippen und die Tests laufen lassen. Mit Expo machen die lokalen MCP-Tools dasselbe für den Simulator. Bitte ihn, das Gesehene mit dem zu vergleichen, was du verlangt hast.
5. Prüfe wie App Review. Starte den appstore-reviewer Subagenten aus Teil 5.
6. Lies den Diff selbst. Jede Zeile, die ausgeliefert wird.
7. Committen, Häkchen setzen, eine frische Sitzung starten.

Für die großen mechanischen Durchläufe (überall Accessibility-Labels hinzufügen, jeden String lokalisieren, die Testabdeckung erhöhen) nutze den Goal-Modus: /goal Lokalisiere jeden benutzersichtbaren String ins Deutsche, einschließlich Widgets, Mitteilungen und Berechtigungsabfragen.

Drei Prompt-Vorlagen, die es wert sind, angepasst zu werden:

Ein Stück: Implementiere Slice 4 aus ROADMAP.md (Suche). Lies zuerst AGENTS.md. Schreibe zuerst die Unit-Tests, dann den Code. Baue die App und starte sie im Simulator, mach einen Screenshot des Ergebnis-Screens und prüfe ihn gegen das Briefing. Zeig mir den Diff und liste jede Annahme auf, die du getroffen hast.

Ein Fehler: Auf einem iPhone mit der größten Dynamic-Type-Größe verdeckt die Tastatur den Speichern-Button auf dem Hinzufügen-Screen. Reproduziere das im Simulator, mach einen Screenshot, erkläre die Ursache in zwei Sätzen, behebe es und prüfe jedes andere Formular auf dasselbe Problem.

Ein Review vor dem Commit: Prüfe alles seit dem letzten Commit wie ein skeptischer Senior-iOS-Reviewer: Abstürze, Datenverlust, Datenschutzlecks, fehlende Barrierefreiheits-Labels, hart codierte Strings und Farben, alles, was die Offline-Nutzung kaputt macht. Nummerierte Liste, das Schwerste zuerst. Repariere noch nichts.

Lektionen aus zwei kleinen Apps

Stash und Lokalisierung. Stash 1.1.0 (28. Oktober) hat zehn Sprachen zu Englisch hinzugefügt: Spanisch, Französisch, Deutsch, Italienisch, brasilianisches Portugiesisch, Niederländisch, Polnisch, Japanisch, Koreanisch und vereinfachtes Chinesisch. Die App übernimmt eine davon vom Gerät und lässt dich sie unter Einstellungen → Sprache ändern, und die Release Notes weisen darauf hin, dass auch Widgets, Erinnerungen und die Systemdialoge für Berechtigungen übersetzt wurden. Genau dieses letzte Detail ist die Lektion: Lokalisierung ist ideale Agentenarbeit, aber die Strings, die Agenten vergessen, liegen außerhalb der Hauptbildschirme – in Widgets, Mitteilungen, Begründungstexten für Berechtigungen und in der Datumsformatierung. Nenne sie in AGENTS.md, und sie werden erledigt.

PingAtlas und ehrliche Versprechen. PingAtlas’ App-Store-Beschreibung macht konkrete Versprechen: Eine fehlende Antwort erscheint als “Keine Antwort”, nie als 0 ms; es gibt kein GPS und keine Standortberechtigung; es gibt keine Werbung, keine Analysen und kein Konto; Ergebnisse bleiben auf dem Gerät, solange du sie nicht exportierst; und Website-Prüfungen nutzen nur HEAD-Requests. Solche Versprechen gehören als Unverhandelbares in AGENTS.md, weil sie auch das sind, was dein Datenschutz-Label aussagt. PingAtlas’ Label lautet “Keine Daten erfasst”, und das stimmt nur so lange, wie der Code mitspielt. Der Reviewer-Subagent ist dafür da, den Tag zu bemerken, an dem er nicht mehr mitspielt.

Ein enger Umfang ist ein Feature. PingAtlas ist ein Download von 1,9 MB. Stash ist mit Fotos, Sprachnotizen, Sync und Widgets etwa 65 MB groß. Mehr Funktionen bedeuten mehr zu testen, mehr in der Datenschutzerklärung zu erklären und mehr, das App Review hinterfragen kann. Fang mit der kleinsten Version an, die das Versprechen hält.

Barrierefreiheit von Anfang an

Apple’s Barrierefreiheits-Labels lassen dich auf deiner App-Store-Seite Unterstützung für neun Funktionen angeben: VoiceOver, Voice Control, Größerer Text, Dunkle Oberfläche, Unterscheidung ohne Farbe, Ausreichender Kontrast, Bewegungen reduzieren, Untertitel und Audiobeschreibungen. Sie sind heute freiwillig, aber Apple sagt, dass du sie mit der Zeit bereitstellen musst, um neue Apps und Updates einzureichen. Du darfst eine Funktion nur angeben, wenn Menschen alle üblichen Aufgaben deiner App damit erledigen können, einschließlich Erststart, Anmeldung, Käufen und Einstellungen.

Keiner meiner eigenen Einträge gibt bisher welche an, und genau solche Lücken soll dieser Leitfaden aufdecken. Den Großteil der Prüfung kann der Agent übernehmen: XcodeBuildMCP’s snapshot_ui liest den Barrierefreiheitsbaum aus, also /goal Mach jeden Bildschirm mit VoiceOver und bei größter Textgröße voll nutzbar, und liste alles auf, was du nicht beheben kannst ist eine realistische Aufgabe für einen Nachmittag.

---

Teil 9 — Im App Store veröffentlichen: Lass OpenCode den Papierkram machen und drück dann selbst auf Submit

Das Bauen ist der spaßige Teil. Das Veröffentlichen ist ein eigenes Projekt, und dabei verlieren Einsteiger eine Woche. Die gute Nachricht für 2026: Fast alles davon lässt sich inzwischen per Skript erledigen, was heißt, dass ein Agent die Tipparbeit übernehmen kann, während du die Entscheidungen triffst.

Was sich 2026 bei Apple geändert hat

Wann	Was hat sich geändert?	Was zu tun ist
31. Jan. 2026	Neue Fragen zur Altersfreigabe wurden für Updates Pflicht	Beantworte sie für jede App, bevor du einreichst
28. Apr. 2026	Uploads müssen mit folgendem erstellt werden: Xcode 26 oder höher und die 26er-SDKs	Nutze Xcode 26 oder 27
9. Juni 2026	Leitfaden 4.3(b) überarbeitet: Nachahmer-Apps und Apps mit wenig Aufwand werden abgelehnt oder entfernt	Differenzieren (Teil 8)
9. Sept. 2026	Uploads müssen ausgerichtet sein auf iOS 13 oder höher	Nichts, für jede neue App
15. Okt. 2026	Xcode 27.1 (Swift 6.4, iOS 27.1 SDK; benötigt macOS Tahoe 26.6+) und Expo SDK 58	Aktualisiere deine Toolchain
16. Okt. 2026	Neue Richtlinie 2.5.19 verbietet versteckte, ruhende oder nicht dokumentierte Funktionen; strengere Regeln für Apps, die ihren Zweck während der Prüfung verbergen	Kompiliere Debug-Menüs und Feature-Flags aus Release-Builds heraus
In Kraft	Leitfaden 5.1.2(i): Sag es den Leuten und hole ihre Erlaubnis ein, bevor du personenbezogene Daten an KI von Drittanbietern weitergibst (hinzugefügt im November 2025)	Füge einen Zustimmungsbildschirm hinzu, wenn deine App einen KI-Dienst aufruft
Jetzt	Screenshots: ein Satz für iPhone mit Dynamic Island (mittleres Display) ist erforderlich, plus 13-Zoll-iPad, wenn deine App auf dem iPad läuft	Plane deine Screenshot-Größen (Teil 10)
April 2027	iPhone Duo Screenshots erforderlich für Apps, die mit dem iOS 27.1 SDK oder neuer gebaut wurden	Fang jetzt an, für das zweite Display zu gestalten
Vorerst freiwillig	Barrierefreiheits-Labels	Gib an, was du wirklich unterstützt

Die neue 2.5.19 ist die, die bei KI-gebauten Apps zubeißt. Agenten lieben hilfreiche Extras: ein versteckter Debug-Screen, ein Feature-Flag, das ausgeschaltet bleibt, ein Testmenü hinter einem langen Druck. Apple’s neue Formulierung ist unverblümt: “Nimm keine versteckten, ruhenden oder undokumentierten Funktionen in deine App auf.” Laut 9to5Mac’s Bericht über die Änderung kann der Versuch, solche Funktionen zu verbergen, etwa durch Code-Obfuskation, zur Entfernung der App und zur Kündigung deines Entwicklerkontos führen. Schreib die Regel in AGENTS.md und bitte den Reviewer-Subagenten, vor jeder Einreichung danach zu suchen.

Der Workflow, Schritt für Schritt

1. Melde dich im Apple Developer Program an. Es kostet 99 $ pro Jahr (99 € in Deutschland). Unternehmen melden sich als Organisation an, was eine D-U-N-S-Nummer erfordert. Fang früh an; die Verifizierung kann Tage dauern. Hier anmelden.
2. Gib deinen EU-Händlerstatus an. Nach dem Digital Services Act der EU muss jeder Entwickler angeben, ob er Händler ist. Wenn du als Unternehmen veröffentlichst, erscheinen deine Adresse, Telefonnummer und E-Mail auf deiner Produktseite in jedem EU-Land. Apple hat im Februar 2025 Tausende Apps aus EU-Storefronts entfernt, weil diese Angabe fehlte.
3. Erstelle einen App Store Connect API-Schlüssel. Gehe in App Store Connect zu Benutzer und Zugriff → Integrationen → App Store Connect API und erzeuge einen Team-Schlüssel. Nur der Account-Inhaber kann überhaupt API-Zugriff beantragen. Gib dem Schlüssel die schwächste Rolle, die die Aufgabe erledigt (Apple’s Rollenübersicht zeigt, was jede kann), lade die .p8 Datei einmal herunter und bewahre sie sicher außerhalb deines Repositories auf.
4. Installiere die App Store Connect CLI und melde dich an. asc ist ein Open-Source-Kommandozeilenwerkzeug (MIT) für die App Store Connect API, gebaut für Skripte und Agenten: Es gibt Tabellen im Terminal aus und JSON, wenn ein anderes Programm seine Ausgabe liest.

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

Installiere dann seine Skills (asc install-skills), damit OpenCode weiß, wie man sie benutzt.

5. Erstelle den App-Eintrag. Wähle in App Store Connect Apps → + → Neue App, und wähle deine Bundle-ID sorgfältig, denn sie ändert sich nie (die von Stash ist network.grahammiranda.stash, die von PingAtlas network.grahammiranda.pingatlas). Die asc Skills enthalten einen, der das über Browser-Automatisierung erledigt, aber es ist eine Zwei-Minuten-Aufgabe, die es wert ist, einmal von Hand gemacht zu werden.
6. Kläre die Signierung. Bei einer nativen App übernimmt Xcode’s automatische Signierung Zertifikate und Profile. Bei Expo verwaltet EAS die Anmeldedaten für dich. Der asc-signing-setup Skill deckt Bundle-IDs, Capabilities, Zertifikate und Profile ab, wenn du es lieber per Skript machst.
7. Bauen und hochladen. Nativ: in Xcode archivieren (oder den Agenten das mit dem asc-xcode-build Skill erledigen lassen), dann hochladen:

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

Expo: eas build --platform ios, dann eas submit -p ios, der den Build zu App Store Connect hochlädt (er schickt ihn nicht zur Prüfung). Hochladen kannst du sicher delegieren; zur Prüfung einreichen nicht.

8. Teste zuerst mit TestFlight. Interne Tester (bis zu 100 Personen in deinem Team) erhalten Builds ohne Prüfung. Externe Tester (bis zu 10.000, per E-Mail oder öffentlichem Link) brauchen für den ersten Build eine kurze Beta-App-Prüfung. Builds bleiben 90 Tage testbar. Der Agent kann Gruppen verwalten mit asc testflight groups list --app "123456789" und die asc-testflight-orchestration Skill. Gib die App fünf Personen mit unterschiedlichen iPhones für eine Woche; sie finden den Absturz, den du nicht gefunden hast.
9. Schreib die Metadaten, dann lass den Agenten sie prüfen. Leg deinen Eintrag als Dateien im Repository ab (metadata/en-US/…) und wende ihn zuerst in einem Probelauf an:

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

Die asc-metadata-sync Skill prüft Apples Zeichenlimits, bevor irgendetwas hochgeladen wird. Teil 10 behandelt, was du schreiben solltest.

10. Mach die Screenshots. Mindestens einer, bis zu zehn, pro erforderlicher Größe, als PNG oder JPEG ohne Transparenz. Die asc-shots-pipeline Skill kann sie aus dem Simulator aufnehmen, sie rahmen und hochladen mit asc screenshots upload. Teil 10 enthält die Größen.
11. Beantworte die Fragen zu Datenschutz, Altersfreigabe und Compliance ehrlich. Diesen Teil darfst du nicht blind delegieren:

• Die Datenschutzangaben. Nach Apples Definition gelten Daten als erfasst, wenn sie das Gerät verlassen und länger gespeichert werden, als es für die Bearbeitung der Anfrage nötig ist. Daten, die nur auf dem Gerät verarbeitet werden, zählen nicht. Die Inhalte der Nutzer auf deinen Server zu synchronisieren zählt dagegen sehr wohl, auch wenn nur sie sie sehen können. Lass den Agenten jeden Netzwerkaufruf und jedes SDK prüfen und fülle das Label dann selbst anhand seiner Tabelle aus.
• Die Datenschutzerklärung muss in App Store Connect verlinkt sein und in der App erreichbar sein, und sie sollte diese App beschreiben, nicht nur dein Unternehmen.
• KI von Drittanbietern (Richtlinie 5.1.2(i)): Wenn personenbezogene Daten an einen KI-Dienst gehen, sag es und hol vorher die Erlaubnis ein.
• Konto löschen (Richtlinie 5.1.1(v)): Wenn Personen ein Konto erstellen können, müssen sie es in der App löschen können.
• Altersfreigabe, Export-Compliance und die Accessibility Nutrition Labels. Wenn deine App nur die in iOS integrierte Verschlüsselung nutzt, etwa HTTPS, setz ITSAppVerwendetNichtAusgenommeneVerschlüsselung in deiner Info.plist, nachdem du Apples Hinweise geprüft hast, damit du nicht bei jedem Upload gefragt wirst.

12. Selbst einreichen. Füge die Version zur Prüfung hinzu und reiche sie auf der App-Seite in App Store Connect ein, oder führe asc publish appstore … --submit --confirm in deinem eigenen Terminal aus (die Berechtigungsregeln in Teil 4 hindern den Agenten daran, ihn auszuführen). Dann lass den Agenten beobachten: asc review status --app "123456789".

Prüfung: Was dich erwartet

Apple sagt, dass durchschnittlich 90 % der Einreichungen in weniger als 24 Stunden geprüft werden und dass mehr als 40 % der ungelösten Probleme auf Richtlinie 2.1, App Completeness, zurückgehen: Abstürze, Platzhalterinhalte, unvollständige Informationen und defekte Links. Wenn du abgelehnt wirst, lies die Nachricht zweimal, behebe das eigentliche Problem und antworte in App Store Connect. Der asc-submission-health Skill hilft, Blocker zu diagnostizieren, und der Agent formuliert gut eine ruhige, konkrete Antwort. Schick sie selbst ab.

---

Teil 10 — Launch: der Eintrag, Screenshots, ASO und das Leben nach der Freigabe

Eine genehmigte App mit schwachem Eintrag ist ein Laden ohne Schild. Hier ist der Rest der Arbeit.

Der Eintrag, Feld für Feld

Feld	Limit	Was funktioniert
App-Name	30 Zeichen	Marke plus Nutzen. “Stash — Find It Fast” sagt einem Fremden, wofür die App da ist
Untertitel	30 Zeichen	Der Nutzen in einfachen Worten. PingAtlas nutzt “Ping cities, games & services”
Schlüsselwörter	100 Zeichen	Durch Kommas getrennt, ohne Leerzeichen. Wiederhole keine Wörter, die schon im Namen oder Untertitel stehen; sie zählen trotzdem mit
Werbetext	170 Zeichen	Änderungen ohne neue Prüfung, also nutze es für Saisons und Neuigkeiten
Beschreibung	4.000 Zeichen	Was es tut, für wen es gedacht ist, was es nicht mit den Daten der Leute macht. Klar und konkret
Was ist neu	Pro Version	Echte Änderungen in verständlichen Worten; der /whats-new Befehl aus Teil 5 entwirft ihn
Screenshots	1 bis 10 pro Größe	Erzähl die Geschichte der Reihe nach; die meisten scrollen nie über die ersten drei hinaus

Zwei Regeln, wenn ein Agent das schreiben soll: Sag ihm, nur Funktionen zu verwenden, die es im Code gibt (und die Datei zu nennen, in der jede davon lebt), und halte das Ergebnis in deinem Repository, damit jede Änderung wie Code geprüft wird. Der asc-aso-audit Skill kann dann Keyword-Lücken offline prüfen, bevor irgendetwas live geht.

Screenshot-Größen im November 2026

Gerät	Erforderlich?	Hochformat-Größen (Pixel)
iPhone mit Dynamic Island, mittleres Display	Ja	1179 × 2556 oder 1206 × 2622
iPhone mit Dynamic Island, großes Display	Optional	1260 × 2736, 1290 × 2796 oder 1320 × 2868
iPad, 13-Zoll-Display	Ja, wenn deine App auf dem iPad läuft	2064 × 2752 oder 2048 × 2732
iPhone Duo (äußeres / inneres Display)	Ab April 2027, für Apps, die mit dem iOS 27.1 SDK oder neuer gebaut wurden	1398 × 2034 / 2007 × 2853

Wenn deine Oberfläche über alle Größen und Sprachen gleich aussieht, brauchst du nur die höchste erforderliche Auflösung; App Store Connect skaliert sie für kleinere Geräte herunter. Screenshots dürfen keine Transparenz enthalten.

Lokalisiere den Eintrag, nicht nur die App

Wenn die App mehrere Sprachen spricht, sollte der Eintrag das auch. Der asc-localize-metadata Skill übersetzt den Text des Eintrags und asc-metadata-sync prüft jede Sprache gegen Apples Zeichenlimits, und genau da gehen handübersetzte deutsche Untertitel meist schief. Lass das Ergebnis von einem Muttersprachler lesen; maschinelle Übersetzung ist heute exzellent, aber App-Store-Texte sind Marketing, und Marketing braucht ein menschliches Ohr.

Nach der Freigabe

• Frag in einem glücklichen Moment nach Bewertungen. Apples Systemabfrage für Bewertungen erscheint pro Person höchstens dreimal im Jahr, also verschwende sie nicht beim ersten Start. Frag direkt danach, wenn etwas gut gelaufen ist.
• Nutze den Werbetext für den Zeitpunkt. Umzugssaison, Frühjahrsputz, ein Gaming-Wochenende. Er ändert sich ohne Prüfung.
• Beobachte Abstürze ab dem ersten Tag. Die asc-crash-triage Skill prüft TestFlight-Abstürze und Feedback; der Expo-MCP-Server kann Abstürze, Feedback und Rezensionen abrufen (Antworten brauchen deine Bestätigung); Sentrys MCP-Server bringt Produktionsfehler herein.
• Veröffentliche oft kleine Updates. Stash ging am 23. September live, bekam am 2. Oktober ein Redesign und fügte am 28. Oktober in Version 1.1.0 zehn Sprachen hinzu. Veröffentliche die Version, die funktioniert, und verbessere sie dann öffentlich.
• Gib der App ein Zuhause im Web. Eine einfache Seite mit einer Demo, einer Datenschutzerklärung, die für die App geschrieben ist, und, wenn du in Deutschland bist, einem Impressum. Mein Leitfaden „App from scratch“ deckt die rechtlichen Seiten für deutsche und EU-Entwickler ab.

---

Teil 11 — Was es kostet: vier Budgets für das erste Jahr

OpenCode ist kostenlos. Ollama ist auf deiner eigenen Hardware kostenlos. Die einzigen Kosten, die du bei einer iPhone-App nicht vermeiden kannst, sind Apples Mitgliedschaft; alles andere ist die Frage, wie viel Modellzeit du kaufen willst.

Haushalt	Was ist drin?	Erstes Jahr (USD)
Nur lokal	Apple Developer Program; OpenCode; Ollama mit lokalen Modellen auf einem Mac, den du bereits besitzt (32 GB oder mehr)	$99
Einstieg	Nur lokal + OpenCode Go (10 $ im Monat)	$219
Empfohlen	Starter + Ollama Pro bei jährlicher Abrechnung (200 $)	$419
Leistung	Apple + OpenCode Go Plus (40 $ im Monat) + Ollama Max (100 $ im Monat)	$1,779

Listenpreise am 7. November 2026, ohne Mehrwertsteuer, ohne Aktionsrabatte. Setze deine eigenen Optionen ein: Ein GLM Coding Plan Lite statt Go kostet bei monatlicher Abrechnung 216 $ im Jahr (etwa 151 $ bei jährlicher Abrechnung) statt 120 $; ChatGPT Plus kostet 240 $ im Jahr. Optionale Extras: die einmalige Gebühr von 25 $ bei Google Play, wenn du für Android veröffentlichst, kostenpflichtige Expo-Pläne, wenn du den kostenlosen Tarif übersteigst, und was deine Website sonst kostet.

Die eigentlichen Kosten stehen aber nicht auf der Liste: Es sind deine Abende. KI verkürzt das Tippen, nicht das Denken, und das Denken ist der größte Teil der Arbeit.

---

Teil 12 — Fünfzehn Fehler, die du vermeiden solltest

1. Den Agenten zur Prüfung einreichen lassen. Verweigere es in den Berechtigungen. Du drückst den Knopf.
2. Einen Admin-API-Schlüssel dort aufbewahren, wo Agenten unbeaufsichtigt laufen. Nutze die schwächste Rolle, die funktioniert, und bewahre Signaturschlüssel und Produktionszugangsdaten woanders auf.
3. Eine Kopie von etwas bauen, das es schon gibt. Richtlinie 4.3(b) nennt inzwischen ganze Kategorien. Finde zuerst deinen Unterschied in einem Satz.
4. Versteckte Extras ausliefern. Debug-Bildschirme, ruhende Feature-Flags und Testmenüs verletzen Richtlinie 2.5.19. Kompiliere sie aus Release-Builds heraus.
5. Ein Datenschutzsiegel, das eher glaubwürdig als zutreffend ist. Wenn Daten das Gerät verlassen und auf einem Server bleiben, gelten sie als erfasst, selbst wenn nur der Nutzer sie sehen kann.
6. Personenbezogene Daten ohne Nachfrage an einen KI-Dienst senden. Richtlinie 5.1.2(i) verlangt Offenlegung und Erlaubnis.
7. Geheimnisse im App-Bundle. Alles in einer App lässt sich extrahieren. Schlüssel, die Geld kosten, gehören auf einen Server.
8. Jeden MCP-Server verbinden, den du findest. Jeder einzelne kostet Kontext bei jeder Anfrage. Füge nur hinzu, was du nutzt.
9. Skills und Server installieren, die du nicht gelesen hast. Sie sind Anweisungen und Code, die mit deinen Berechtigungen laufen.
10. Denken, dass man “fertig” ist. Führe es auf einem echten iPhone aus, offline, im Dark Mode, mit der größten Textgröße und mit aktiviertem VoiceOver.
11. Kostenlose Promo-Modelle für Kundencode verwenden. Manche nutzen deine Daten vielleicht, um das Modell zu verbessern. Deaktiviere sie für Kundenprojekte.
12. Ollamas Kontextlänge vergessen. Mit dem Standardwert geht einem Agenten der Platz aus, bevor er anfängt. Setze 64K auf dem Server.
13. Abhängigkeiten sich anhäufen lassen. Jedes Paket ist Code, den du nicht gelesen hast, und ein Update, das du verwalten musst. Lass den Agenten fragen.
14. Lange, ausufernde Sitzungen. Fang für jeden Abschnitt neu an und nutze Worktrees für Experimente.
15. Deine Roadmap versprechen. Screenshots und Beschreibungen zeigen, was dieser Build macht. Ideen gehören auf deine Website, gekennzeichnet als Ideen.

---

Teil 13 — Welches Setup solltest du wählen? Sechs Szenarien

1. “Ich habe noch nie Code geschrieben und besitze einen Mac.”

OpenCodes Desktop-App, OpenCode Go und Ollama für die kleinen Aufgaben. Expo, wenn du auch Android willst; SwiftUI, wenn dich nur das iPhone interessiert. Stelle Shell-Befehle auf fragen, committe nach jedem funktionierenden Schritt und fang mit einer App an, die eine einzige Aufgabe hat.

2. “Mein Code darf niemals meinen Rechner verlassen.”

OpenCode nur mit lokalem Ollama. Deaktiviere Ollamas Cloud-Funktionen, setze OPENCODE_DISABLE_FREE_MODELS=1, und verbinde in diesem Projekt keine Cloud-Anbieter. Erwarte langsamere, einfachere Hilfe und gib dem Agenten kleinere Aufgaben. Ein Mac mit 64 GB oder mehr macht das deutlich angenehmer.

3. “Ich zahle schon für ChatGPT, Copilot oder Claude.”

Verbinde zuerst, was du schon hast. ChatGPT Plus und Pro sowie GitHub Copilot funktionieren über integrierte Anmeldungen ohne Zusatzkosten. Claude läuft über den Claude-Agent-Provider; lies Teil 2, bevor du dich bei geschäftlicher Arbeit darauf verlässt. Füge später OpenCode Go hinzu, wenn du offene Modelle daneben willst.

4. “Ich will iPhone und Android aus einer Codebasis.”

Expo SDK 58, der Expo MCP-Server, Expos offizielle Skills und EAS für Cloud-Builds und Uploads. Du kannst iOS-Apps ohne Mac bauen und hochladen, obwohl du trotzdem einen (und ein iPhone) zum Testen haben willst.

5. “Ich interessiere mich nur für Apple-Plattformen und will alles nativ.”

SwiftUI in Xcode 27.1, wobei OpenCode entweder in Xcode über ACP läuft (Xcode → Einstellungen → Intelligence → Agent hinzufügen…, ausführbare Datei opencode, Argument acp) oder in deinem Terminal mit Xcodes MCP-Bridge und XcodeBuildMCP. Eine Einschränkung des Wegs in Xcode: Es gibt keine Modellauswahl, also legst du dein Standardmodell in opencode.jsonc Erstens.

6. “Ich will schnell sein und dafür bezahlen.”

OpenCode Go Plus and Ollama Max, Worktrees für parallele Experimente, der Goal-Modus für die langen mechanischen Arbeiten und ein Frontier-Modell per API-Schlüssel für die wirklich schwierigen Probleme. Behalte deine Ausgaben wöchentlich im Blick. Für mehrere Agenten nebeneinander deckt mein Harness-Vergleich die Optionen ab.

---

Häufig gestellte Fragen

---

Das Fazit

Lernen wie du OpenCode nutzt ist keine Frage des Auswendiglernens von Befehlen. Es geht darum, ein kleines System rund um den Agenten zu bauen: ein Coding-Plan, der zu deinem Budget passt, Ollama für die Arbeit, die auf deiner Maschine bleiben soll, eine Handvoll MCP-Server, mit denen der Agent sieht, was er baut, Skills, in denen dein Playbook steckt, und Berechtigungen, die die unumkehrbaren Entscheidungen bei dir lassen.

Meine Empfehlung gilt weiterhin: OpenCode mit OpenCode Go und Ollama ist der günstigste, flexibelste und am wenigsten bindende Weg, Ende 2026 mit KI eine App zu bauen. Nimm ein Abonnement dazu, das du ohnehin zahlst, oder ein Frontier-Modell per API-Schlüssel, wenn eine Aufgabe es verdient. Dann nutze den Agenten auch für den Papierkram und behalte den “Einreichen”-Button für dich.

Wenn du sehen willst, was dieser Prozess im Kleinen hervorbringt – beide meiner Apps sind kostenlos: Stash – Schnell finden für die Dinge, die du wegräumst, und PingAtlas um zu prüfen, wie nah das Internet von dort, wo du sitzt, wirklich ist. Dann baue deine eigene.

---

Baust du mit OpenCode? Ich würde gern hören, für welchen Coding-Plan du dich entschieden hast, welches lokale Modell sich einen Platz auf deinem Mac verdient hat und auf welchen MCP-Server oder Skill du nicht mehr verzichten willst. Korrekturen und Gegenbelege sind willkommen; dieser Artikel wird aktualisiert, wenn sich das Bild ändert.

Offenlegung: Stash und PingAtlas sind meine eigenen Apps, veröffentlicht von meiner Firma, der Graham Miranda UG (haftungsbeschränkt). Beide sind kostenlos und werbefrei. Dieser Artikel enthält einen Affiliate-Link: den GLM Coding Plan von Z.ai in Teil 2; wenn du darüber abonnierst, bekommst du 10 % Rabatt und ich erhalte eine Provision. Keines der hier genannten Unternehmen hat diesen Artikel gesponsert, geprüft oder freigegeben.

Zuletzt aktualisiert: 7. November 2026.