Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design
Codex

Anwendungsfall für Codex

SwiftUI-Ansichten refaktorieren

Teile eine zu große SwiftUI-Ansicht mit Codex in kleine Subviews auf, ohne ihr Verhalten oder Layout zu ändern.

Schwierigkeitsgrad Advanced
Zeithorizont 1h

Teile eine umfangreiche SwiftUI-Ansicht mit Codex und dem Plugin „Build iOS Apps“ in eigene Views für die einzelnen Abschnitte auf. Verschiebe Seiteneffekte aus body in eigene Methoden, stabilisiere die Zustandsverwaltung und setze Observation konsistent ein. Bevorzuge beim Refactoring das MV-Muster und führe ViewModels nur bei Bedarf ein.

Besonders geeignet für

  • Sehr große SwiftUI-Dateien, in denen sich der Code einer Ansicht nur schwer überprüfen lässt, weil `body` Layout, Verzweigungen, asynchrone Aufgaben und direkt eingebettete Aktionen vereint
  • Bestehende iOS-Funktionen, deren Code leichter zu warten sein soll, ohne dass sich Aussehen oder Verhalten ändern
  • Ansichten mit berechneten `some View`-Fragmenten, optionalen ViewModels oder umständlicher Zustandsweitergabe, die sich durch explizite Eingaben und Callbacks für Subviews vereinfachen lassen

Inhalt

    ← Alle Anwendungsfälle

    SwiftUI-Ansichten refaktorieren

    Teile eine zu große SwiftUI-Ansicht mit Codex in kleine Subviews auf, ohne ihr Verhalten oder Layout zu ändern.

    Teile eine umfangreiche SwiftUI-Ansicht mit Codex und dem Plugin „Build iOS Apps“ in eigene Views für die einzelnen Abschnitte auf. Verschiebe Seiteneffekte aus body in eigene Methoden, stabilisiere die Zustandsverwaltung und setze Observation konsistent ein. Bevorzuge beim Refactoring das MV-Muster und führe ViewModels nur bei Bedarf ein.

    Advanced
    1h

    Teile eine umfangreiche SwiftUI-Ansicht mit Codex und dem Plugin „Build iOS Apps“ in eigene Views für die einzelnen Abschnitte auf. Verschiebe Seiteneffekte aus body in eigene Methoden, stabilisiere die Zustandsverwaltung und setze Observation konsistent ein. Bevorzuge beim Refactoring das MV-Muster und führe ViewModels nur bei Bedarf ein.

    Advanced
    1h

    Besonders geeignet für

    • Sehr große SwiftUI-Dateien, in denen sich der Code einer Ansicht nur schwer überprüfen lässt, weil `body` Layout, Verzweigungen, asynchrone Aufgaben und direkt eingebettete Aktionen vereint
    • Bestehende iOS-Funktionen, deren Code leichter zu warten sein soll, ohne dass sich Aussehen oder Verhalten ändern
    • Ansichten mit berechneten `some View`-Fragmenten, optionalen ViewModels oder umständlicher Zustandsweitergabe, die sich durch explizite Eingaben und Callbacks für Subviews vereinfachen lassen

    Skills und Plug-ins

    • Nutze den Skill für das Refactoring von SwiftUI-Ansichten, damit Codex beim Bearbeiten großer Ansichten einzelne Abschnitte in eigene Subviews auslagert und den Einsatz von Observation vereinfacht. Dabei bleiben der Datenfluss stabil und das Verhalten der Ansicht erhalten.
    Skill Nutzen
    Build iOS Apps Nutze den Skill für das Refactoring von SwiftUI-Ansichten, damit Codex beim Bearbeiten großer Ansichten einzelne Abschnitte in eigene Subviews auslagert und den Einsatz von Observation vereinfacht. Dabei bleiben der Datenfluss stabil und das Verhalten der Ansicht erhalten.

    Prompt für den Einstieg

    Überarbeite [NameOfScreen.swift] mit dem Plugin „Build iOS Apps“ und seinem Skill für das Refactoring von SwiftUI-Ansichten. Behalte das Verhalten und Aussehen der Ansicht bei. Vorgaben: - Behalte Verhalten, Layout, Navigation und Geschäftslogik bei. Falls du auf einen Fehler stößt, der eine Abweichung erfordert, weise gesondert darauf hin. - Nutze standardmäßig MV statt MVVM. Bevorzuge `@State`, `@Environment`, `@Query`, `.task`, `.task(id:)` und `onChange`, bevor du ein neues ViewModel einführst. Behalte ein ViewModel nur bei, wenn die Funktion es eindeutig benötigt. - Ordne die Bestandteile der Ansicht so an, dass sie beim Lesen von oben nach unten leicht zu finden sind: gespeicherte Eigenschaften, berechnete Zustandswerte, `init`, `body`, Hilfselemente für die Darstellung und Hilfsmethoden. - Lagere zusammengehörige Abschnitte in eigene `View`-Typen mit wenigen expliziten Eingaben, `@Binding`-Eigenschaften und Callbacks aus. Verteile einen großen `body` dabei nicht einfach auf mehrere große berechnete Eigenschaften vom Typ `some View`. - Verschiebe komplexere Button-Aktionen und Seiteneffekte aus `body` in kleine Methoden. Lagere die eigentliche Geschäftslogik in Dienste oder Modelle aus. - Halte die View-Hierarchie an der Wurzel stabil. Vermeide `if/else`-Verzweigungen auf oberster Ebene, die zwischen völlig unterschiedlichen Ansichten wechseln, wenn Bedingungen für einzelne Abschnitte oder Modifier ausreichen. - Korrigiere beim Refactoring, welche View die mit Observation beobachteten Modelle verwaltet. Verwende ab iOS 17 `@State` für `@Observable`-Modelle, die der Root-View gehören. Verwende optionale oder erst später initialisierte ViewModels nur, wenn die Oberfläche diese Form der Zustandsverwaltung tatsächlich benötigt. - Führe nach jedem ausgelagerten Abschnitt den kleinsten aussagekräftigen Build oder Test aus, mit dem du nachweisen kannst, dass sich die Ansicht weiterhin genauso verhält. Liefere folgende Ergebnisse: - die überarbeitete Ansicht und alle ausgelagerten Subviews - eine kurze Erklärung, welche Abschnitte jetzt zu welcher Subview gehören und wie die Daten zwischen den Views fließen - alle Stellen, an denen du bewusst ein ViewModel beibehalten hast, mit einer kurzen Begründung - die Prüfungen, mit denen du das unveränderte Verhalten der Ansicht nachgewiesen hast
    Überarbeite [NameOfScreen.swift] mit dem Plugin „Build iOS Apps“ und seinem Skill für das Refactoring von SwiftUI-Ansichten. Behalte das Verhalten und Aussehen der Ansicht bei. Vorgaben: - Behalte Verhalten, Layout, Navigation und Geschäftslogik bei. Falls du auf einen Fehler stößt, der eine Abweichung erfordert, weise gesondert darauf hin. - Nutze standardmäßig MV statt MVVM. Bevorzuge `@State`, `@Environment`, `@Query`, `.task`, `.task(id:)` und `onChange`, bevor du ein neues ViewModel einführst. Behalte ein ViewModel nur bei, wenn die Funktion es eindeutig benötigt. - Ordne die Bestandteile der Ansicht so an, dass sie beim Lesen von oben nach unten leicht zu finden sind: gespeicherte Eigenschaften, berechnete Zustandswerte, `init`, `body`, Hilfselemente für die Darstellung und Hilfsmethoden. - Lagere zusammengehörige Abschnitte in eigene `View`-Typen mit wenigen expliziten Eingaben, `@Binding`-Eigenschaften und Callbacks aus. Verteile einen großen `body` dabei nicht einfach auf mehrere große berechnete Eigenschaften vom Typ `some View`. - Verschiebe komplexere Button-Aktionen und Seiteneffekte aus `body` in kleine Methoden. Lagere die eigentliche Geschäftslogik in Dienste oder Modelle aus. - Halte die View-Hierarchie an der Wurzel stabil. Vermeide `if/else`-Verzweigungen auf oberster Ebene, die zwischen völlig unterschiedlichen Ansichten wechseln, wenn Bedingungen für einzelne Abschnitte oder Modifier ausreichen. - Korrigiere beim Refactoring, welche View die mit Observation beobachteten Modelle verwaltet. Verwende ab iOS 17 `@State` für `@Observable`-Modelle, die der Root-View gehören. Verwende optionale oder erst später initialisierte ViewModels nur, wenn die Oberfläche diese Form der Zustandsverwaltung tatsächlich benötigt. - Führe nach jedem ausgelagerten Abschnitt den kleinsten aussagekräftigen Build oder Test aus, mit dem du nachweisen kannst, dass sich die Ansicht weiterhin genauso verhält. Liefere folgende Ergebnisse: - die überarbeitete Ansicht und alle ausgelagerten Subviews - eine kurze Erklärung, welche Abschnitte jetzt zu welcher Subview gehören und wie die Daten zwischen den Views fließen - alle Stellen, an denen du bewusst ein ViewModel beibehalten hast, mit einer kurzen Begründung - die Prüfungen, mit denen du das unveränderte Verhalten der Ansicht nachgewiesen hast

    Einen Bildschirm refaktorieren und sein Verhalten beibehalten

    Wenn eine SwiftUI-Datei einen ganzen Bildschirm abbildet und so groß geworden ist, dass selbst kleine Änderungen riskant erscheinen, lohnt sich ein Refactoring. Dafür brauchst du weder ein neues Design für die Funktion noch eine neue Architektur. Bitte Codex, Verhalten und Layout beizubehalten und den Bildschirm in kleine Views mit klar erkennbarem Datenfluss aufzuteilen. So lässt sich die nächste Änderung leichter prüfen.

    Verwende dafür das Plugin „Build iOS Apps“. Der enthaltene Skill für das Refactoring von SwiftUI-Views gibt klare Empfehlungen. Bevorzuge standardmäßig MV gegenüber MVVM, belasse die Geschäftslogik in Services oder Modellen und nutze zunächst den lokalen Zustand der View und Abhängigkeiten aus der Umgebung. Behalte ein ViewModel nur dann bei, wenn die Funktion es eindeutig braucht.

    Den Auftrag für Codex formulieren

    Nenne zuerst die konkrete Datei, die den Bildschirm implementiert. Bitte Codex, ihre Struktur zu verbessern und dabei das Verhalten beizubehalten. Nimm die folgenden Regeln direkt in deinen Prompt auf:

    • Ordne die Datei so, dass du sie von oben nach unten leicht überblicken kannst. Beginne mit den Abhängigkeiten aus der Umgebung, gefolgt von gespeicherten Eigenschaften und berechneten Zustandswerten, die keine Views sind. Danach folgen init, body, Hilfsfunktionen für Views und Hilfsmethoden.
    • Lagere inhaltlich zusammengehörige Abschnitte in eigene View-Typen aus. Gib ihnen nur die wenigen Eingabewerte, die sie brauchen, und verwende explizite Parameter, @Binding und Callbacks.
    • Verwende berechnete Eigenschaften vom Typ some View sparsam und halte sie kurz. Vermeide es, einen großen Bildschirm durch eine lange Liste privater berechneter Eigenschaften zu ersetzen, die jeweils ein View-Fragment liefern.
    • Lagere komplexere Schaltflächenaktionen und Seiteneffekte aus body aus. Verschiebe die eigentliche Geschäftslogik in Services oder Modelle.
    • Halte die Struktur des View-Baums an der Wurzel stabil. Verwende Bedingungen möglichst innerhalb einzelner Abschnitte oder in Modifikatoren. Vermeide if/else-Verzweigungen auf oberster Ebene, die ganze Bildschirme austauschen.
    • Prüfe beim Refactoring auch, welche View bei Observation für den Lebenszyklus eines Modells verantwortlich ist, und korrigiere die Zuordnung bei Bedarf. Ab iOS 17 sollte die zuständige View ein @Observable-Modell auf oberster Ebene in @State speichern. Verwende ältere Wrapper für beobachtbare Modelle nur, wenn deine iOS-Mindestversion das erfordert.

    Nach jedem Schritt kurz prüfen lassen

    Bei einem Refactoring solltest du belegen können, dass sich der Bildschirm weiterhin wie zuvor verhält. Bitte Codex, nach jedem größeren Auslagerungsschritt die kleinste passende Prüfung durchzuführen, die den betroffenen Bildschirm abdeckt. Das kann ein Build, eine Vorschau, ein Test oder eine Prüfung im Simulator sein. Lass Codex anschließend zusammenfassen, wie sich die Struktur geändert hat und was bewusst gleich geblieben ist.

    Praktische Tipps

    Erst den Bildschirm aufteilen, dann über die Architektur entscheiden

    Wenn ein Bildschirm zu groß ist, lass Codex zunächst einzelne Abschnitte in eigene Views auslagern, bevor du eine neue Abstraktionsschicht einführst. Bei einem kleineren, übersichtlicheren View-Baum erübrigt sich ein zusätzliches ViewModel oft ganz.

    Die Schnittstelle jeder untergeordneten View möglichst klein halten

    Übergib jeder untergeordneten View möglichst nur die benötigten let-Werte, Bindungen über @Binding und Callbacks mit jeweils einer klaren Aufgabe. So braucht die View keinen Zugriff auf das gesamte übergeordnete Modell. Für jeden ausgelagerten Abschnitt lässt sich dann leichter eine Vorschau erstellen. Auch sinkt das Risiko, ihn versehentlich wieder an den gesamten Bildschirm zu koppeln.

    Codex benennen lassen, was bewusst gleich geblieben ist

    Bitte Codex bei einem Refactoring ausdrücklich aufzulisten, was es beibehalten hat. Dazu gehören die Geschäftsregeln, das Navigationsverhalten, die Persistenz, die Bedeutung der erfassten Analysedaten und das sichtbare Layout. So kannst du die Änderungen deutlich schneller prüfen.

    Tech-Stack

    Was du brauchst

    UI-Architektur

    Standardoptionen

    SwiftUI nach dem MV-Muster mit @State, @Environment und kleinen View-Typen für einzelne Abschnitte

    Warum du es brauchst

    Große Ansichten lassen sich meist leichter warten, wenn Codex zunächst die View-Hierarchie und die Weitergabe von Zustandsdaten vereinfacht, bevor eine weitere Schicht aus ViewModels hinzukommt.

    Was du brauchst

    Vorgehen beim Refactoring

    Warum du es brauchst

    Der Skill des Plugins gibt Codex klare Regeln für das Refactoring von SwiftUI-Ansichten. So kann Codex Abschnitte in eigene Subviews auslagern, Observation gezielt einsetzen und den Code für Seiteneffekte aufräumen, ohne das Verhalten der Ansicht zu ändern.

    Was du brauchst

    Validierung

    Standardoptionen

    xcodebuild, Vorschauen und gezielte UI-Prüfungen

    Warum du es brauchst

    Wenn du nach jedem ausgelagerten Abschnitt einen kleinen Build ausführst oder die Ansicht im Simulator prüfst, kannst du zuverlässiger beurteilen, ob ihr Verhalten gleich geblieben ist, als bei einer One-Shot-Neufassung.

    Was du brauchst Standardoptionen Warum du es brauchst
    UI-Architektur SwiftUI nach dem MV-Muster mit @State , @Environment und kleinen View -Typen für einzelne Abschnitte Große Ansichten lassen sich meist leichter warten, wenn Codex zunächst die View-Hierarchie und die Weitergabe von Zustandsdaten vereinfacht, bevor eine weitere Schicht aus ViewModels hinzukommt.
    Vorgehen beim Refactoring Plugin „Build iOS Apps“ Der Skill des Plugins gibt Codex klare Regeln für das Refactoring von SwiftUI-Ansichten. So kann Codex Abschnitte in eigene Subviews auslagern, Observation gezielt einsetzen und den Code für Seiteneffekte aufräumen, ohne das Verhalten der Ansicht zu ändern.
    Validierung xcodebuild , Vorschauen und gezielte UI-Prüfungen Wenn du nach jedem ausgelagerten Abschnitt einen kleinen Build ausführst oder die Ansicht im Simulator prüfst, kannst du zuverlässiger beurteilen, ob ihr Verhalten gleich geblieben ist, als bei einer One-Shot-Neufassung.

    Verwandte Anwendungsfälle