Communitygithub.com

ComeOnOliver/skillshub

Verwenden Sie dies, um Logik von SwiftUI-Views zu trennen, Architekturmuster auszuwählen, View-Dateien umzugestalten oder wenn Sie fragen: 'Wo soll dieser Code hin?', 'Wie organisiere ich meine SwiftUI-App?', 'MVVM vs. TCA vs. Vanilla SwiftUI', 'Wie mache ich SwiftUI testbar?' – umfassende Architekturmuster mit Refactoring-Workflows für iOS 26+.

Was ist skillshub?

Diese Fähigkeit bietet Entwicklern einen strukturierten Leitfaden zur Organisation von SwiftUI-Code, wobei der Schwerpunkt auf der Trennung von Belangen, Testbarkeit und der Auswahl des richtigen Architekturmusters liegt. Sie behandelt die nativen Muster von Apple (iOS 26+), einschließlich `@Observable` und "State-as-Bridge", MVVM, die Composable Architecture (TCA) und Coordinator-Muster. Die Entscheidungsbäume helfen bei der Auswahl von Property Wrappern (`@State`, `@Environment`, `@Bindable`), wo Geschäftslogik platziert werden soll und wann ViewModel-Adapter sinnvoll sind. Anti-Patterns verhindern häufige Fehler, wie z. B. Logik in View-Bodies oder überladene ViewModels. Die Fähigkeit richtet sich an Entwickler, die in SwiftUI-Apps für iOS 26+ mit der Code-Organisation, dem Refactoring vorhandener Views oder der strukturellen Entscheidungsfindung für die Teamarbeit kämpfen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-swiftui-architecture

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

SwiftUI-Architektur

Wann diese Fähigkeit verwendet werden sollte

Verwenden Sie diese Fähigkeit, wenn:

  • Sie Logik in Ihren SwiftUI-View-Dateien haben und diese extrahieren möchten
  • Sie zwischen MVVM, TCA, Vanilla-SwiftUI-Mustern oder Coordinator wählen
  • Sie Views umgestalten, um Belange zu trennen
  • Sie SwiftUI-Code testbar machen möchten
  • Sie fragen: "Wo soll dieser Code hin?"
  • Sie entscheiden, welchen Property Wrapper Sie verwenden sollen (@State, @Environment, @Bindable)
  • Sie eine SwiftUI-Codebasis für die Teamarbeit organisieren

Beispiel-Prompts

Was Sie fragen könntenWarum diese Fähigkeit hilft
"In meinen Model-View-Dateien gibt es ziemlich viel Code zu Logik-Themen. Wie extrahiere ich ihn?"Bietet einen Refactoring-Workflow mit Entscheidungsbäumen, wohin die Logik gehört
"Sollte ich MVVM, TCA oder die Vanilla-Muster von Apple verwenden?"Entscheidungskriterien basierend auf App-Komplexität, Teamgröße, Testbarkeitsanforderungen
"Wie mache ich meinen SwiftUI-Code testbar?"Zeigt Trennungsmuster, die Tests ohne SwiftUI-Imports ermöglichen
"Wo sollen Formatierungen und Berechnungen hin?"Der Abschnitt Anti-Patterns verhindert Logik in View-Bodies
"Welchen Property Wrapper verwende ich?"Entscheidungsbaum für @State, @Environment, @Bindable oder einfache Eigenschaften

Schnell-Entscheidungsbaum für die Architektur

Was treibt Ihre Architekturwahl an?
│
├─ Sie beginnen neu, kleine/mittlere App, möchten Apples Muster?
│  └─ Verwenden Sie Apples native Muster (Teil 1)
│     - @Observable-Modelle für Geschäftslogik
│     - State-as-Bridge für asynchrone Grenzen
│     - Entscheidungsbaum für Property Wrapper
│
├─ Sie kennen MVVM von UIKit?
│  └─ Verwenden Sie das MVVM-Muster (Teil 2)
│     - ViewModels als Präsentationsadapter
│     - Klare Trennung von View/ViewModel/Model
│     - Funktioniert gut mit @Observable
│
├─ Komplexe App, strenge Testbarkeit, Teamkonsistenz erforderlich?
│  └─ Ziehen Sie TCA in Betracht (Teil 3)
│     - State/Action/Reducer/Store-Architektur
│     - Hervorragende Testmöglichkeiten
│     - Lernkurve vs. Boilerplate-Kompromiss
│
└─ Komplexe Navigation, Deep Linking, mehrere Einstiegspunkte?
   └─ Fügen Sie das Coordinator-Muster hinzu (Teil 4)
      - Kann mit allen oben genannten kombiniert werden
      - Extrahiert Navigationslogik aus Views
      - NavigationPath + Coordinator-Objekte

Teil 1: Apples native Muster (iOS 26+)

Kernprinzip

"Ein Datenmodell bietet eine Trennung zwischen den Daten und den Views, die mit den Daten interagieren. Diese Trennung fördert Modularität, verbessert die Testbarkeit und hilft, das Verständnis dafür zu erleichtern, wie die App funktioniert." — Apple-Entwicklerdokumentation

Apples moderne SwiftUI-Muster (WWDC 2023–2025) konzentrieren sich auf:

  1. @Observable für Datenmodelle (ersetzt ObservableObject)
  2. State-as-Bridge für asynchrone Grenzen (WWDC 2025)
  3. Drei Property Wrapper: @State, @Environment, @Bindable
  4. Synchrone UI-Updates für Animationen

Das State-as-Bridge-Muster

Problem

Asynchrone Funktionen erzeugen Unterbrechungspunkte, die Animationen stören können:

// ❌ Problematisch: Animation könnte Frame-Frist verpassen
struct ColorExtractorView: View {
    @State private var isLoading = false

    var body: some View {
        Button("Farben extrahieren") {
            Task {
                isLoading = true  // Synchron ✅
                await extractColors()  // ⚠️ Unterbrechungspunkt!
                isLoading = false  // ❌ Könnte zu spät passieren
            }
        }
        .scaleEffect(isLoading ? 1.5 : 1.0)  // ⚠️ Animationszeitpunkt unsicher
    }
}

Lösung: Verwenden Sie State als Brücke

"Finden Sie die Grenzen zwischen UI-Code, der zeitkritische Änderungen erfordert, und langlebiger asynchroner Logik."

// ✅ Korrekt: State überbrückt UI und asynchronen Code
@Observable
class ColorExtractor {
    var isLoading = false
    var colors: [Color] = []

    func extract(from image: UIImage) async {
        // Diese Methode ist asynchron und kann im Modell leben
        let extracted = await heavyComputation(image)
        // Synchrone Mutation für UI-Update
        self.colors = extracted
    }
}

struct ColorExtractorView: View {
    let extractor: ColorExtractor

    var body: some View {
        Button("Farben extrahieren") {
            // Synchrone Zustandsänderung für Animation
            withAnimation {
                extractor.isLoading = true
            }

            // Asynchrone Arbeit starten
            Task {
                await extractor.extract(from: currentImage)

                // Synchrone Zustandsänderung für Animation
                withAnimation {
                    extractor.isLoading = false
                }
            }
        }
        .scaleEffect(extractor.isLoading ? 1.5 : 1.0)
    }
}

Vorteile:

  • UI-Logik bleibt synchron (Animationen funktionieren korrekt)
  • Asynchroner Code lebt im Modell (testbar ohne SwiftUI)
  • Klare Grenze zwischen zeitkritischer UI und langlebiger Arbeit

Entscheidungsbaum für Property Wrapper

Es gibt nur 3 Fragen zu beantworten:

Welchen Property Wrapper soll ich verwenden?
│
├─ Muss dieses Modell ein ZUSTAND DER VIEW SELBST sein?
│  └─ JA → Verwenden Sie @State
│     Beispiele: Formulareingaben, lokale Umschalter, Sheet-Präsentationen
│     Lebensdauer: Verwaltet durch die Lebensdauer der View
│
├─ Muss dieses Modell Teil der GLOBALEN UMGEBUNG sein?
│  └─ JA → Verwenden Sie @Environment
│     Beispiele: Benutzerkonto, App-Einstellungen, Abhängigkeitsinjektion
│     Lebensdauer: Lebt auf App-/Scene-Ebene
│
├─ Benötigt dieses Modell NUR BINDUNGEN?
│  └─ JA → Verwenden Sie @Bindable
│     Beispiele: Bearbeiten eines von der übergeordneten View übergebenen Modells
│     Leichtgewichtig: Aktiviert nur die $-Syntax für Bindungen
│
└─ NICHTS DAVON?
   └─ Verwenden Sie es als einfache Eigenschaft
      Beispiele: Unveränderliche Daten, von der übergeordneten View besessene Modelle
      Kein Wrapper erforderlich: @Observable übernimmt die Beobachtung

Beispiele

// ✅ @State — View besitzt das Modell
struct DonutEditor: View {
    @State private var donutToAdd = Donut()  // Eigener Zustand der View

    var body: some View {
        TextField("Name", text: $donutToAdd.name)
    }
}

// ✅ @Environment — App-weites Modell
struct MenuView: View {
    @Environment(Account.self) private var account  // Global

    var body: some View {
        Text("Willkommen, \(account.userName)")
    }
}

// ✅ @Bindable — Benötigt Bindungen zu einem von der übergeordneten View besessenen Modell
struct DonutRow: View {
    @Bindable var donut: Donut  // Übergeordnete View besitzt es

    var body: some View {
        TextField("Name", text: $donut.name)  // Benötigt Bindung
    }
}

// ✅ Einfache Eigenschaft — Nur lesen
struct DonutRow: View {
    let donut: Donut  // Übergeordnete View besitzt, keine Bindung erforderlich

    var body: some View {
        Text(donut.name)  // Nur lesen
    }
}

Das @Observable-Modell-Muster

Verwenden Sie @Observable für Geschäftslogik, die UI-Updates auslösen muss:

// ✅ Domänenmodell mit Geschäftslogik
@Observable
class FoodTruckModel {
    var orders: [Order] = []
    var donuts = Donut.all

    var orderCount: Int {
        orders.count  // Berechnete Eigenschaften funktionieren automatisch
    }

    func addDonut() {
        donuts.append(Donut())
    }
}

// ✅ View verfolgt automatisch aufgerufene Eigenschaften
struct DonutMenu: View {
    let model: FoodTruckModel  // Kein Wrapper erforderlich!

    var body: some View {
        List {
            Section("Donuts") {
                ForEach(model.donuts) { donut in
                    Text(donut.name)  // Verfolgt model.donuts
                }
                Button("Hinzufügen") {
                    model.addDonut()
                }
            }
            Section("Bestellungen") {
                Text("Anzahl: \(model.orderCount)")  // Verfolgt model.orders
            }
        }
    }
}

Wie es funktioniert (WWDC 2023/10149):

  • SwiftUI verfolgt, welche Eigenschaften während der Ausführung von body aufgerufen werden
  • Nur diese Eigenschaften lösen View-Updates aus, wenn sie geändert werden
  • Granulare Abhängigkeitsverfolgung = bessere Leistung

ViewModel-Adapter-Muster

Verwenden Sie ViewModels als Präsentationsadapter, wenn Sie Filter-, Sortier- oder Viewspezifische Logik benötigen:

// ✅ ViewModel als Präsentationsadapter
@Observable
class PetStoreViewModel {
    let petStore: PetStore  // Domänenmodell
    var searchText: String = ""

    // Viewspezifische berechnete Eigenschaft
    var filteredPets: [Pet] {
        guard !searchText.isEmpty else { return petStore.myPets }
        return petStore.myPets.filter { $0.name.contains(searchText) }
    }
}

struct PetListView: View {
    @Bindable var viewModel: PetStoreViewModel

    var body: some View {
        List {
            ForEach(viewModel.filteredPets) { pet in
                PetRowView(pet: pet)
            }
        }
        .searchable(text: $viewModel.searchText)
    }
}

Wann ein ViewModel-Adapter verwendet werden sollte:

  • Filtern, Sortieren, Gruppieren für die Anzeige
  • Formatieren für die Präsentation (aber KEINE schweren Berechnungen)
  • Viewspezifischer Zustand, der nicht in das Domänenmodell gehört
  • Brücke zwischen Domänenmodell und SwiftUI-Konventionen

Wann KEIN ViewModel verwendet werden sollte:

  • Einfache Views, die nur Modelldaten anzeigen
  • Logik, die in das Domänenmodell gehört
  • Übermäßige Extraktion nur aus "Musterreinheit"

Teil 2: MVVM-Muster

Wann MVVM verwendet werden sollte

MVVM (Model-View-ViewModel) ist geeignet, wenn:

✅ Sie es von UIKit kennen — Einfachere Einarbeitung für das Team ✅ Sie eine explizite View/ViewModel-Trennung wünschen — Klare Verträge ✅ Sie komplexe Präsentationslogik haben — Mehrere Filter-/Sortiervorgänge ✅ Sie von UIKit migrieren — Vertrautes mentales Modell

❌ MVVM vermeiden, wenn:

  • Views einfach sind (nur Daten anzeigen)
  • Sie frisch mit SwiftUI beginnen (Apples Muster sind einfacher)
  • Sie unnötige Abstraktionsebenen erstellen

MVVM-Struktur für SwiftUI

// Model — Domänendaten und Geschäftslogik
struct Pet: Identifiable {
    let id: UUID
    var name: String
    var kind: Kind
    var trick: String
    var hasAward: Bool = false

    mutating func giveAward() {
        hasAward = true
    }
}

// ViewModel — Präsentationslogik
@Observable
class PetListViewModel {
    private let petStore: PetStore

    var pets: [Pet] { petStore.myPets }
    var searchText: String = ""
    var selectedSort: SortOption = .name

    var filteredSortedPets: [Pet] {
        let filtered = pets.filter { pet in
            searchText.isEmpty || pet.name.contains(searchText)
        }
        return filtered.sorted { lhs, rhs in
            switch selectedSort {
            case .name: lhs.name < rhs.name
            case .kind: lhs.kind.rawValue < rhs.kind.rawValue
            }
        }
    }

    init(petStore: PetStore) {
        self.petStore = petStore
    }

    func awardPet(_ pet: Pet) {
        petStore.awardPet(pet.id)
    }
}

// View — Nur UI
struct PetListView: View {
    @Bindable var viewModel: PetListViewModel

    var body: some View {
        List {
            ForEach(viewModel.filteredSortedPets) { pet in
                PetRow(pet: pet) {
                    viewModel.awardPet(pet)
                }
            }
        }
        .searchable(text: $viewModel.searchText)
    }
}

Häufige MVVM-Fehler in SwiftUI

❌ Fehler 1: @Observable in View und ViewModel duplizieren

// ❌ @State + @Observable ist redundant — @State erzeugt seinen eigenen Speicher
struct MyView: View {
    @State private var viewModel = MyViewModel()  // ❌ Redundanter Wrapper
}

// ✅ @Observable direkt übergeben — @State nur verwenden, wenn die View den LEBENSZYKLUS BESITZT
struct MyView: View {
    let viewModel: MyViewModel  // ✅ Oder @State, wenn die View es erstellt
}

❌ Fehler 2: Gott-ViewModel

// ❌ Nicht so machen
@Observable
class AppViewModel {
    // Einstellungen
    var isDarkMode = false
    var notificationsEnabled = true

    // Benutzer
    var userName = ""
    var userEmail = ""

    // Inhalt
    var posts: [Post] = []
    var comments: [Comment] = []

    // ... 50 weitere Eigenschaften
}
// ✅ Korrekt: Belange trennen
@Observable
class SettingsViewModel {
    var isDarkMode = false
    var notificationsEnabled = true
}

@Observable
class UserProfileViewModel {
    var user: User
}

@Observable
class FeedViewModel {
    var posts: [Post] = []
}

❌ Fehler 3: Geschäftslogik im ViewModel

// ❌ Geschäftsregeln gehören in das Modell, nicht in das ViewModel
@Observable class OrderViewModel {
    func calculateDiscount(for order: Order) -> Double { /* ... */ }  // ❌ Geschäftslogik
}

// ✅ Das Modell besitzt die Geschäftslogik; das ViewModel formatiert nur für die Anzeige
struct Order {
    func calculateDiscount() -> Double { /* Geschäftsregeln */ }
}
@Observable class OrderViewModel {
    let order: Order
    var displayDiscount: String {
        "$\(order.calculateDiscount(), specifier: "%.2f")"  // ✅ Nur Formatierung
    }
}

Teil 3: TCA (Composable Architecture)

Wann TCA in Betracht gezogen werden sollte

TCA ist eine Drittanbieter-Architektur von Point-Free. Ziehen Sie sie in Betracht, wenn:

✅ Strenge Testbarkeit ist kritisch — TestStore macht Tests deterministisch ✅ Ein großes Team benötigt Konsistenz — Strenge Muster reduzieren Abweichungen ✅ Komplexes Zustandsmanagement — Nebenwirkungen, Abhängigkeiten, Komposition ✅ Sie mögen Redux-ähnliche Muster — Unidirektionaler Datenfluss

❌ TCA vermeiden, wenn:

  • Kleine App oder Prototyp (zu viel Overhead)
  • Team mit funktionaler Programmierung nicht vertraut
  • Sie schnelle Iteration benötigen (Boilerplate verlangsamt die Entwicklung)
  • Sie minimale Abhängigkeiten wünschen

TCA-Kernkonzepte

TCA hat 4 Bausteine — State (Daten), Action (Ereignisse), Reducer (Zustandsentwicklung) und Store (Laufzeit-Engine). Hier sind sie in einer einzigen Funktion:

// STATE — Daten, die Ihre Funktion benötigt
@ObservableState
struct CounterFeature {
    var count = 0
    var fact: String?
    var isLoading = false
}

// ACTION — Alle möglichen Ereignisse
enum Action {
    case incrementButtonTapped
    case decrementButtonTapped
    case factButtonTapped
    case factResponse(String)
}

// REDUCER — Wie sich der Zustand als Reaktion auf Aktionen entwickelt
struct CounterFeature: Reducer {
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .incrementButtonTapped:
                state.count += 1
                return .none
            case .decrementButtonTapped:
                state.count -= 1
                return .none
            case .factButtonTapped:
                state.isLoading = true
                return .run { send in
                    let fact = await getFact(state.count)
                    await send(.factResponse(fact))
                }
            case let .factResponse(fact):
                state.fact = fact
                state.isLoading = false
                return .none
            }
        }
    }
}

// STORE — Verbindet alles
struct CounterView: View {
    let store: StoreOf<CounterFeature>

    var body: some View {
        Form {
            Text("\(store.count)")
            HStack {
                Button("-") { store.send(.decrementButtonTapped) }
                Button("+") { store.send(.incrementButtonTapped) }
            }
            Button("Fakt") { store.send(.factButtonTapped) }
                .disabled(store.isLoading)
            if let fact = store.fact {
                Text(fact)
            }
        }
    }
}

TCA im Vergleich zu nativen Mustern

AspektNative Muster (iOS 26+)TCA
BoilerplateMinimalErheblich (Reducer, Actions, Store)
TestbarkeitGut (Modelle unabhängig testen)Hervorragend (TestStore, deterministisch)
LernkurveNiedrig (vertraute Swift-Muster)Hoch (Redux-Muster, Effekte)
TeamkonsistenzVariabel (Interpretationsspielraum)Hoch (strenge Muster)
NebenwirkungenTask/async/awaitEffect-Runner, testbar
AbhängigkeitenKeine (nur SwiftUI)Point-Free-Bibliotheken
Beste fürKleine bis mittlere AppsKomplexe Apps, große Teams

Teil 4: Coordinator-Muster

Wann ein Coordinator verwendet werden sollte

Verwenden Sie Coordinator, wenn:

✅ Komplexe Navigationsabläufe — Tiefe Verschachtelung, bedingte Pfade ✅ Deep Linking — Verarbeitung externer URLs/Benachrichtigungen zu korrekten Bildschirmen ✅ Mehrere Einstiegspunkte — Widgets, Shortcuts, Spotlight ✅ Navigation testen — Navigation von View-Logik trennen

❌ Coordinator vermeiden, wenn:

  • Einfache Push/Pop-Navigation (< 5 Bildschirme)
  • Sie native NavigationStack-Deep-Links verwenden (ausreichend)
  • Sie die zusätzliche Indirektionsebene nicht benötigen

Coordinator-Implementierung

// NavigationPath + Coordinator
@Observable
class AppCoordinator {
    var path = NavigationPath()

    func showSettings() {
        path.append(AppRoute.settings)
    }

    func showDonutDetail(_ donut: Donut) {
        path.append(AppRoute.donutDetail(donut))
    }

    func handleDeepLink(_ url: URL) {
        // Deep-Link-Logik zentralisiert
        guard let route = DeepLinkParser.parse(url) else { return }
        path.append(route)
    }

    func goBack() {
        path.removeLast()
    }
}

enum AppRoute: Hashable {
    case settings
    case donutDetail(Donut)
    case orderHistory
}

struct AppView: View {
    @State private var coordinator = AppCoordinator()

    var body: some View {
        NavigationStack(path: $coordinator.path) {
            HomeView()
                .navigationDestination(for: AppRoute.self) { route in
                    switch route {
                    case .settings:
                        SettingsView()
                    case .donutDetail(let donut):
                        DonutDetailView(donut: donut)
                    case .orderHistory:
                        OrderHistoryView()
                    }
                }
        }
        .environment(coordinator)
    }
}

Coordinator mit MVVM oder nativen Mustern

// Coordinator + ViewModel
@Observable
class DonutListViewModel {
    private let coordinator: AppCoordinator
    let donutStore: DonutStore

    var donuts: [Donut] { donutStore.all }

    init(coordinator: AppCoordinator, donutStore: DonutStore) {
        self.coordinator = coordinator
        self.donutStore = donutStore
    }

    func selectDonut(_ donut: Donut) {
        coordinator.showDonutDetail(donut)
    }
}

struct DonutListView: View {
    @Bindable var viewModel: DonutListViewModel

    var body: some View {
        List(viewModel.donuts) { donut in
            Button(donut.name) {
                viewModel.selectDonut(donut)
            }
        }
    }
}

Allgemeine Anti-Patterns

❌ Anti-Pattern 1: Logik in View-Bodies

// ❌ Keine Logik in View-Bodies
struct DonutDetailView: View {
    let donut: Donut

    var body: some View {
        let discount = donut.price * 0.10  // ❌ Logik im Body
        Text("Ermäßigt: \(discount)")
    }
}
// ✅ Logik in berechnete Eigenschaften oder das Modell extrahieren
struct DonutDetailView: View {
    let donut: Donut

    var discount: Double {
        donut.price * 0.10  // ✅ Berechnete Eigenschaft
    }

    var body: some View {
        Text("Ermäßigt: \(discount)")
    }
}

❌ Anti-Pattern 2: Übermäßige Extraktion

// ❌ Kein ViewModel für einen einfachen View benötigt
@Observable class WelcomeViewModel {
    let userName: String
}

// ✅ Nur das Modell direkt verwenden
struct WelcomeView: View {
    let user: User
    var body: some View { Text("Willkommen, \(user.name)") }
}

❌ Anti-Pattern 3: @State für von der übergeordneten View besessene Modelle

// ❌ @State erzeugt einen neuen Speicher; die übergeordnete View verliert die Kontrolle
struct ChildView: View {
    @State var model: MyModel  // ❌ Erzeugt eine Kopie
}

// ✅ @Bindable verwenden, um den Speicher der übergeordneten View zu teilen
struct ChildView: View {
    @Bindable var model: MyModel  // ✅ Teilt denselben Speicher
}

❌ Anti-Pattern 4: Asynchrone Logik in View-Structs

// ❌ Asynchrone Logik gehört nicht in View-Structs
struct DonutListView: View {
    @State private var donuts: [Donut] = []

    var body: some View {
        List(donuts) { ... }
            .task {
                donuts = await api.fetchDonuts()  // ❌ Netzwerkaufruf im View
            }
    }
}
// ✅ In ein @Observable-Modell extrahieren
@Observable
class DonutStore {
    var donuts: [Donut] = []

    func load() async {
        donuts = await api.fetchDonuts()  // ✅ Im Modell
    }
}

struct DonutListView: View {
    let store: DonutStore
    var body: some View {
        List(store.donuts) { ... }
            .task { await store.load() }
    }
}

Reale Entscheidungsszenarien

Szenario 1: Sie haben einen vorhandenen MVVM-Code und möchten zu nativen Mustern wechseln

  1. Entfernen Sie ObservableObject -> wechseln Sie zu @Observable
  2. Entfernen Sie @StateObject in Views -> wechseln Sie zu let/@Bindable
  3. Verschieben Sie Formatierungslogik in berechnete Eigenschaften
  4. Verschieben Sie Geschäftslogik zurück in das Modell
  5. ViewModel als Präsentationsadapter beibehalten, falls noch benötigt

Szenario 2: Neue App, kleines Team, Start-up

Start: Apple Native Muster (Teil 1)

  • Minimale Einrichtungszeit
  • Keine Drittanbieter-Abhängigkeiten
  • Einfach umzustrukturieren, wenn die App wächst
  • Fügen Sie Coordinator hinzu, wenn die Navigation komplex wird

Szenario 3: Große App, 10+ Entwickler, strenge Testanforderungen

Erwägen Sie: TCA (Teil 3)

  • Strenge Muster halten das Team konsistent
  • Hervorragende Testwerkzeuge
  • Lernkurve im Voraus in Kauf nehmen für langfristige Wartbarkeit

Szenario 4: App mit tiefen Navigationsabläufen, Deep Linking

Fügen Sie hinzu: Coordinator-Muster (Teil 4)

  • Kombinieren Sie mit Ihrem bevorzugten Architekturmuster
  • Zentralisieren Sie Deep-Link-Verarbeitung
  • NavigationPath + Coordinator Objekt

Zusammenfassung: Wählen Sie Ihren Ansatz

  1. Standardmäßig: Apple Native Muster (@Observable + State-as-Bridge)
  2. Wenn Sie mit MVVM vertraut sind: Strukturierte ViewModels als Adapter hinzufügen
  3. Wenn die App komplex wird: Erwägen Sie TCA für strenge Muster
  4. Wenn die Navigation komplex wird: Coordinator-Muster hinzufügen

Denken Sie daran: Der beste Ansatz ist der, den Ihr Team konsistent anwenden kann. Perfekte Muster nützen nichts, wenn niemand sie befolgt. Fangen Sie einfach an, entwickeln Sie weiter und extrahieren Sie nach Bedarf.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills