Communitygithub.com

SwiftUI-Debugging

Verwendung beim Debuggen von SwiftUI-View-Updates, Preview-Abstürzen oder Layout-Problemen – Diagnose-Entscheidungsbäume, um Ursachen schnell zu identifizieren und Fehldiagnosen unter Druck zu vermeiden.

Was ist SwiftUI-Debugging?

Diese Fähigkeit bietet einen strukturierten Ansatz zur Fehlerdiagnose in SwiftUI-Apps und deckt die drei häufigsten Problemkategorien ab: Views, die sich nicht aktualisieren, Preview-Abstürze und Layout-Probleme. Sie führt den Benutzer durch Entscheidungsbäume, die systematisch die Grundursachen identifizieren, einschließlich Struct-Mutation, verlorene Binding-Identität, versehentliche View-Neuerstellung und fehlende Observer-Muster. Die Fähigkeit enthält praktische Codebeispiele und Erklärungen für iOS 17+ mit dem `@Observable`-Makro sowie abwärtskompatible Lösungen für iOS 14-16. Sie hebt den Einsatz von Diagnosetools wie `Self._printChanges()` und bewährte Praktiken hervor, um häufige Fallstricke wie Band-Aid-Reparaturen mit übermäßigem `@ObservedObject`-Einsatz zu vermeiden. Die Fähigkeit ist auf Xcode 26+ und iOS 17+ ausgelegt und kann mit ergänzenden Fähigkeiten wie `axiom-xcode-debugging` für Laufzeitabstürze und `axiom-swift-concurrency` für Concurrency-Probleme kombiniert werden.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht SwiftUI-Debugging?

Übersicht

SwiftUI-Debugging lässt sich in drei Kategorien unterteilen, jede mit einem eigenen Diagnoseansatz:

  1. Aktualisierung eines Views – Du hast etwas geändert, aber der View hat sich nicht neu gezeichnet. Entscheidungsbaum zur Identifikation, ob es sich um eine Struct-Mutation, verlorene Binding-Identität, versehentliche View-Neuerstellung oder ein fehlendes Observer-Muster handelt.
  2. Preview-Abstürze – Dein Preview lässt sich nicht kompilieren oder stürzt sofort ab. Entscheidungsbaum zur Unterscheidung zwischen fehlenden Abhängigkeiten, fehlgeschlagenen Zustand-Initialisierungen und Xcode-Cache-Korruption.
  3. Layout-Probleme – Views erscheinen an falschen Positionen, in falschen Größen oder überlappen unerwartet. Kurzreferenzmuster für häufige Szenarien.

Kernprinzip: Beginne mit beobachtbaren Symptomen, teste systematisch und schließe Ursachen eine nach der anderen aus. Rate nicht.

Erfordert: Xcode 26+, iOS 17+ (iOS 14-16-Muster sind weiterhin gültig, siehe Hinweise) Verwandte Fähigkeiten: axiom-xcode-debugging (Cache-Korruptionsdiagnose), axiom-swift-concurrency (Observer-Muster), axiom-swiftui-performance (Profiling mit Instruments), axiom-swiftui-layout (adaptive Layout-Muster)

Beispiel-Prompts

Dies sind echte Fragen von Entwicklern, die diese Fähigkeit zu beantworten bestimmt ist:

1. „Mein Listenelement aktualisiert sich nicht, wenn ich auf den Favoriten-Button tippe, obwohl sich die Daten geändert haben“

→ Die Fähigkeit führt durch den Entscheidungsbaum, um Struct-Mutation vs. verlorenes Binding vs. fehlenden Observer zu identifizieren

2. „Preview stürzt ab mit ‚AppModel nicht im Gültigkeitsbereich gefunden‘, aber es kompiliert einwandfrei“

→ Die Fähigkeit zeigt, wie fehlende Abhängigkeiten mit .environment() oder .environmentObject() bereitgestellt werden

3. „Mein Zähler wird jedes Mal auf 0 zurückgesetzt, wenn ich einen Boolean umschalte. Warum?“

→ Die Fähigkeit identifiziert versehentliche View-Neuerstellung durch Bedingungen und zeigt die .opacity()-Lösung

4. „Ich verwende @Observable, aber der View aktualisiert sich trotzdem nicht, wenn ich die Eigenschaft ändere“

→ Die Fähigkeit erklärt, wann @State vs. einfache Eigenschaften mit @Observable-Objekten verwendet werden sollten

5. „Textfeld verliert den Fokus, sobald ich tippe. Sehr frustrierend“

→ Die Fähigkeit identifiziert ForEach-Identitätsprobleme und zeigt, wie stabile IDs verwendet werden

Wann SwiftUI-Debugging verwenden

Verwende diese Fähigkeit bei

  • ✅ Ein View wird nicht aktualisiert, obwohl du es erwartest
  • ✅ Preview stürzt ab oder lädt nicht
  • ✅ Layout sieht auf bestimmten Geräten falsch aus
  • ✅ Du bist versucht, es mit @ObservedObject überall notdürftig zu reparieren

Verwende stattdessen axiom-xcode-debugging bei

  • App-Abstürzen zur Laufzeit (nicht Preview)
  • Vollständig fehlschlagendem Build
  • Benötigter Umgebungsdiagnose

Verwende stattdessen axiom-swift-concurrency bei

  • Fragen zu async/await oder MainActor
  • Datenrennwarnungen

Debugging-Werkzeuge

Self._printChanges()

SwiftUI bietet eine Debug-only-Methode, um zu verstehen, warum der Body eines Views aufgerufen wurde.

Verwendung in LLDB:

// Haltepunkt im View-Body setzen
// In der LLDB-Konsole:
(lldb) expression Self._printChanges()

Temporär im Code (vor dem Versenden entfernen):

var body: some View {
    let _ = Self._printChanges() // Nur zum Debuggen

    Text("Hallo")
}

Ausgabe interpretieren:

MyView: @self changed
  - Bedeutet, dass der View-Wert selbst geändert wurde (an den View übergebene Parameter)

MyView: count changed
  - Bedeutet, dass die @State-Eigenschaft "count" die Aktualisierung ausgelöst hat

MyView: (no output)
  - Body wird nicht aufgerufen; View wird überhaupt nicht aktualisiert

⚠️ Wichtig:

  • Mit Unterstrich vorangestellt → Kann in zukünftigen Versionen entfernt werden
  • NIEMALS im App Store einreichen mit _printChanges-Aufrufen
  • Auswirkung auf die Leistung → Nur während des Debuggens verwenden

Wann verwenden:

  • Notwendigkeit, den genauen Auslöser für ein View-Update zu verstehen
  • Untersuchung unerwarteter Aktualisierungen
  • Überprüfung von Abhängigkeiten nach einem Refactoring

Querverweis: Für komplexe Aktualisierungsmuster das SwiftUI-Instrument verwenden → siehe Fähigkeit axiom-swiftui-performance


Entscheidungsbaum: View aktualisiert sich nicht

Die häufigste Frustration: Du hast @State geändert, aber der View hat sich nicht neu gezeichnet. Die Grundursache ist immer eine von vier Möglichkeiten.

Schritt 1: Kannst du es in einem minimalen Preview reproduzieren?

#Preview {
  YourView()
}

JA → Das Problem liegt in deinem Code. Fahre mit Schritt 2 fort.

NEIN → Es handelt sich wahrscheinlich um einen Xcode-Zustand oder Cache-Korruption. Springe zum Abschnitt Preview-Abstürze.

Schritt 2: Diagnostiziere die Grundursache

Grundursache 1: Struct-Mutation

Symptom: Du änderst einen @State-Wert direkt, aber der View aktualisiert sich nicht.

Warum es passiert: SwiftUI erkennt direkte Mutationen an Structs nicht. Du musst den gesamten Wert neu zuweisen.

// ❌ FALSCH: Direkte Mutation löst keine Aktualisierung aus
@State var items: [String] = []

func addItem(_ item: String) {
    items.append(item)  // SwiftUI erkennt diese Änderung nicht
}

// ✅ RICHTIG: Neuzuweisung löst Aktualisierung aus
@State var items: [String] = []

func addItem(_ item: String) {
    var newItems = items
    newItems.append(item)
    self.items = newItems  // Vollständige Neuzuweisung
}

// ✅ AUCH RICHTIG: Ein Binding verwenden
@State var items: [String] = []

var itemsBinding: Binding<[String]> {
    Binding(
        get: { items },
        set: { items = $0 }
    )
}

Behebung: Weise immer den gesamten Wert des Structs neu zu, nicht nur Teile davon.


Grundursache 2: Verlorene Binding-Identität

Symptom: Du übergibst ein Binding an einen Child-View, aber Änderungen im Child aktualisieren den Parent nicht.

Warum es passiert: Du übergibst .constant() oder erstellst jedes Mal ein neues Binding, was die bidirektionale Verbindung unterbricht.

// ❌ FALSCH: Constant Binding ist schreibgeschützt
@State var isOn = false

ToggleChild(value: .constant(isOn))  // Änderungen werden ignoriert

// ❌ FALSCH: Bei jeder Darstellung wird ein neues Binding erstellt
@State var name = ""

TextField("Name", text: Binding(
    get: { name },
    set: { name = $0 }
))  // Neues Binding-Objekt bei jeder Parent-Darstellung

// ✅ RICHTIG: Das eigentliche Binding übergeben
@State var isOn = false

ToggleChild(value: $isOn)

// ✅ RICHTIG (iOS 17+): @Bindable für @Observable-Objekte verwenden
@Observable class Book {
    var title = "Beispiel"
    var isAvailable = true
}

struct EditView: View {
    @Bindable var book: Book  // Ermöglicht $book.title-Syntax

    var body: some View {
        TextField("Titel", text: $book.title)
        Toggle("Verfügbar", isOn: $book.isAvailable)
    }
}

// ✅ AUCH RICHTIG (iOS 17+): @Bindable als lokale Variable
struct ListView: View {
    @State private var books = [Book(), Book()]

    var body: some View {
        List(books) { book in
            @Bindable var book = book  // Inline-Binding
            TextField("Titel", text: $book.title)
        }
    }
}

// ✅ RICHTIG (vor iOS 17): Binding einmal erstellen, nicht im Body
@State var name = ""
@State var nameBinding: Binding<String>?

var body: some View {
    if nameBinding == nil {
        nameBinding = Binding(
            get: { name },
            set: { name = $0 }
        )
    }
    return TextField("Name", text: nameBinding!)
}

Behebung: Übergebe möglichst direkt $state. Verwende für @Observable-Objekte (iOS 17+) @Bindable. Wenn du benutzerdefinierte Bindings erstellst (vor iOS 17), erstelle sie im init oder zwischenspeichere sie, nicht im body.


Grundursache 3: Versehentliche View-Neuerstellung

Symptom: Der View aktualisiert sich, aber @State-Werte werden auf den Anfangszustand zurückgesetzt. Du siehst kurze Einblendungen der Anfangswerte.

Warum es passiert: Der View hat eine neue Identität erhalten (aus einer Bedingung entfernt, in einem Container verschoben oder der Container selbst wurde neu erstellt), was dazu führt, dass SwiftUI ihn als neuen View behandelt.

// ❌ FALSCH: Die View-Identität ändert sich, wenn die Bedingung umschaltet
@State var count = 0

var body: some View {
    VStack {
        if showCounter {
            Counter()  // Erhält jedes Mal eine neue Identität, wenn showCounter sich ändert
        }
        Button("Umschalten") {
            showCounter.toggle()
        }
    }
}

// Counter wird neu erstellt, @State count wird auf 0 zurückgesetzt

// ✅ RICHTIG: Identität mit Opazität oder Ausblenden bewahren
@State var count = 0

var body: some View {
    VStack {
        Counter()
            .opacity(showCounter ? 1 : 0)
        Button("Umschalten") {
            showCounter.toggle()
        }
    }
}

// ✅ AUCH RICHTIG: Verwende id(), falls du es bedingt anzeigen musst
@State var count = 0

var body: some View {
    VStack {
        if showCounter {
            Counter()
                .id("counter")  // Stabile Identität
        }
        Button("Umschalten") {
            showCounter.toggle()
        }
    }
}

Behebung: Bewahre die View-Identität, indem du .opacity() anstelle von Bedingungen verwendest oder .id() mit einem stabilen Identifikator anwendest.


Grundursache 4: Fehlendes Observer-Muster

Symptom: Ein Objekt wurde geändert, aber Views, die es beobachten, wurden nicht aktualisiert.

Warum es passiert: SwiftUI weiß nicht, dass es auf Änderungen im Objekt achten muss.

// ❌ FALSCH: Eigenschaftsänderungen lösen keine Aktualisierung aus
class Model {
    var count = 0  // Nicht beobachtbar
}

struct ContentView: View {
    let model = Model()  // Neue Instanz bei jeder Darstellung, nicht beobachtbar

    var body: some View {
        Text("\(model.count)")
        Button("Erhöhen") {
            model.count += 1  // View aktualisiert sich nicht
        }
    }
}

// ✅ RICHTIG (iOS 17+): @Observable mit @State verwenden
@Observable class Model {
    var count = 0  // Kein @Published erforderlich
}

struct ContentView: View {
    @State private var model = Model()  // @State, nicht @StateObject

    var body: some View {
        Text("\(model.count)")
        Button("Erhöhen") {
            model.count += 1  // View aktualisiert sich
        }
    }
}

// ✅ RICHTIG (iOS 17+): Injizierte @Observable-Objekte
struct ContentView: View {
    var model: Model  // Nur eine einfache Eigenschaft

    var body: some View {
        Text("\(model.count)")  // View aktualisiert sich, wenn count sich ändert
    }
}

// ✅ RICHTIG (iOS 17+): @Observable mit der Umgebung
@Observable class AppModel {
    var count = 0
}

@main
struct MyApp: App {
    @State private var model = AppModel()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(model)  // Zur Umgebung hinzufügen
        }
    }
}

struct ContentView: View {
    @Environment(AppModel.self) private var model  // Aus der Umgebung lesen

    var body: some View {
        Text("\(model.count)")
    }
}

// ✅ RICHTIG (vor iOS 17): @StateObject/ObservableObject verwenden
class Model: ObservableObject {
    @Published var count = 0
}

struct ContentView: View {
    @StateObject var model = Model()  // Für eigene Instanzen

    var body: some View {
        Text("\(model.count)")
        Button("Erhöhen") {
            model.count += 1  // View aktualisiert sich
        }
    }
}

// ✅ RICHTIG (vor iOS 17): @ObservedObject für injizierte Instanzen
struct ContentView: View {
    @ObservedObject var model: Model  // Vom Parent übergeben

    var body: some View {
        Text("\(model.count)")
    }
}

Behebung (iOS 17+): Verwende das @Observable-Makro für deine Klasse, dann @State zum Speichern. Views verfolgen automatisch Abhängigkeiten von Eigenschaften, die sie lesen.

Behebung (vor iOS 17): Verwende @StateObject, wenn du das Objekt besitzt, @ObservedObject, wenn es injiziert wird, oder @EnvironmentObject, wenn es im gesamten Baum gemeinsam genutzt wird.

Warum @Observable besser ist (iOS 17+):

  • Automatische Abhängigkeitsverfolgung (nur Lesezugriffe lösen Aktualisierungen aus)
  • Kein @Published-Wrapper erforderlich
  • Funktioniert mit @State anstelle von @StateObject
  • Kann als einfache Eigenschaft anstelle von @ObservedObject übergeben werden

Siehe auch: Verwalten von Modelldaten in deiner App


Zusammenfassung des Entscheidungsbaums

graph view_not_updating {
    start [label="View aktualisiert sich nicht?" shape=diamond];
    reproduce [label="Kann im Preview reproduziert werden?" shape=diamond];
    cause [label="Was hat sich geändert?" shape=diamond];

    start -> reproduce;
    reproduce -> cause [label="ja: Fehler im Code"];
    reproduce -> "Cache/Xcode-Zustand → Preview-Abstürze" [label="nein"];

    cause -> "Struct-Mutation" [label="Struct direkt geändert"];
    cause -> "Verlorene Binding-Identität" [label="Binding an Child übergeben"];
    cause -> "Versehentliche Neuerstellung" [label="View innerhalb einer Bedingung"];
    cause -> "Fehlender Observer" [label="Objekt geändert, View nicht"];
}

Entscheidungsbaum: Preview-Abstürze

Wenn dein Preview nicht lädt oder sofort abstürzt, liegen drei verschiedene Grundursachen vor.

Schritt 1: Was ist der Fehler?

Fehlertyp 1: „Nicht im Gültigkeitsbereich gefunden“ oder „Kein solches Modul“

Grundursache: Im Preview fehlt eine erforderliche Abhängigkeit (@EnvironmentObject, @Environment, importiertes Modul).

// ❌ FALSCH: ContentView benötigt ein Modell, der Preview stellt es nicht bereit
struct ContentView: View {
    @EnvironmentObject var model: AppModel

    var body: some View {
        Text(model.title)
    }
}

#Preview {
    ContentView()  // Stürzt ab: Modell nicht gefunden
}

// ✅ RICHTIG: Die Abhängigkeit bereitstellen
#Preview {
    ContentView()
        .environmentObject(AppModel())
}

// ✅ AUCH RICHTIG: Auf fehlende Imports prüfen
// Bei Verwendung benutzerdefinierter Typen sicherstellen, dass sie in der Preview-Datei importiert werden

#Preview {
    MyCustomView()  // Sicherstellen, dass MyCustomView definiert oder importiert ist
}

Behebung: Verfolge den Fehler, finde heraus, was fehlt, und stelle es dem Preview zur Verfügung.


Fehlertyp 2: Schwerwiegender Fehler oder stiller Absturz (keine Fehlermeldung)

Grundursache: Die Zustandsinitialisierung ist zur Laufzeit fehlgeschlagen. Der View hat versucht, auf Daten zuzugreifen, die nicht existieren.

// ❌ FALSCH: Index außerhalb des gültigen Bereichs zur Laufzeit
struct ListView: View {
    @State var selectedIndex = 10
    let items = ["a", "b", "c"]

    var body: some View {
        Text(items[selectedIndex])  // Stürzt ab: Index 10 existiert nicht
    }
}

// ❌ FALSCH: Optionale erzwungene Entpackung schlägt fehl
struct DetailView: View {
    @State var data: Data?

    var body: some View {
        Text(data!.title)  // Stürzt ab, wenn data nil ist
    }
}

// ✅ RICHTIG: Sichere Standardwerte
struct ListView: View {
    @State var selectedIndex = 0  // Gültiger Index
    let items = ["a", "b", "c"]

    var body: some View {
        if selectedIndex < items.count {
            Text(items[selectedIndex])
        }
    }
}

// ✅ RICHTIG: Optionale behandeln
struct DetailView: View {
    @State var data: Data?

    var body: some View {
        if data != nil {
            Text(data!.title)
        } else {
            Text("Keine Daten")
        }
    }
}

Behebung: Validiere alle Indizes und handle Optionale sicher mit bedingten Prüfungen (if let, guard).


Fehlertyp 3: Kompilierungsfehler mit Modulen, die im Preview-Gerüst nicht verfügbar sind (AVFoundation, CoreLocation usw.)

Grundursache: Dein View importiert Frameworks, die in der Preview-Sandbox nicht verfügbar oder dort nicht korrekt verlinkt sind.

// ❌ FALSCH: AVFoundation direkt importiert
import AVFoundation

struct PlayerView: View {
    let player = AVPlayer()

    var body: some View {
        VideoPlayer(player: player)
    }
}

// ✅ RICHTIG: Schritt 1: Überprüfe die Zielmitgliedschaft
// Stelle sicher, dass die Preview-Datei dieselbe Zielmitgliedschaft hat wie die App

// ✅ RICHTIG: Schritt 2: Verwende bedingte Imports oder fasse die Abhängigkeit zusammen
import AVKit  // SwiftUI-freundlicher

struct PlayerView: View {
    let player = AVPlayer()

    var body: some View {
        VideoPlayer(player: player)
    }
}

// ✅ AUCH RICHTIG: Mock-Objekte für Preview-Dateien
#if DEBUG
import AVFoundation

class MockPlayer {
    // Mock-Implementierung für Preview
}
#endif

Behebung: Verwende nach Möglichkeit SwiftUI-spezifische Frameworks. Erwäge die Erstellung einfacherer Preview-spezifischer Ansichten, die keine spezialisierten Frameworks importieren.


Zusammenfassung des Entscheidungsbaums

graph preview_crashes {
    start [label="Preview stürzt ab?" shape=diamond];
    error_type [label="Fehlertyp?" shape=diamond];

    start -> error_type;
    error_type -> "Nicht gefunden" [label="'Nicht im Gültigkeitsbereich'"];
    error_type -> "Laufzeit" [label="Schwerwiegender Fehler / Stiller Absturz"];
    error_type -> "Kompilierung" [label="Modul nicht gefunden"];

    "Nicht gefunden" -> "Abhängigkeit bereitstellen\n(.environment/.environmentObject)" [label="Lösung"];
    "Laufzeit" -> "Zustand initialisieren\n(Optionale behandeln/Indizes validieren)" [label="Lösung"];
    "Kompilierung" -> "Mock/Framework prüfen\n(SwiftUI-Äquivalent/Import prüfen)" [label="Lösung"];
}

Layout-Probleme (Kurzreferenz)

Kein vollständiger Entscheidungsbaum, aber häufige Muster, die bei der Diagnose klassischer SwiftUI-Layout-Probleme helfen.

Muster 1: Überlappende Views, wenn Ränder verwendet werden

Symptom: Zwei Views in einem ZStack überlappen sich, obwohl du .padding() verwendet hast.

Grundursache: .padding() vergrößert den View, ändert aber nicht seinen Anchor-Point.

// ❌ FALSCH: Padding erwartet, dass es den Anchor verschiebt
ZStack {
    Text("Oben")
        .padding(.top, 20)
    Text("Unten")
        .padding(.bottom, 20)
}

// ✅ RICHTIG: VStack für übereinander gestapelte Elemente
VStack {
    Text("Oben")
    Spacer()
    Text("Unten")
}
.padding()

// ✅ AUCH RICHTIG: ZStack mit alignment-Zentrierung
ZStack(alignment: .top) {
    Text("Oben")
        .padding(.top, 20)
}

Muster 2: Text wird abgeschnitten

Symptom: Textkennzeichnungen werden abgeschnitten, normalerweise in Tabellenzeilen oder benutzerdefinierten Layouts.

Grundursachenlösung:

Text("Langer Text, der abgeschnitten wird")
    .lineLimit(nil)  // Zeilenbegrenzung aufheben
    .fixedSize(horizontal: false, vertical: true)  // Vertikal erweitern
    .frame(maxWidth: .infinity, alignment: .leading)  // Horizontal erweitern

Muster 3: Geometrie wird in ScrollViews falsch dargestellt

Symptom: GeometryReader innerhalb eines ScrollView liefert unerwartete Größen.

Grundursache: GeometryReader in ScrollViews misst den Content-Container, nicht die Bildschirmgröße.

// ❌ FALSCH: GeometryReader in ScrollView liefert Content-Container-Größe
ScrollView {
    GeometryReader { geo in
        Text("Breite: \(geo.size.width)")  // Zeigt Content-Container-Breite
    }
}

// ✅ RICHTIG: UIScreen als Fallback, oder GeometryReader außen platzieren
GeometryReader { geo in
    ScrollView {
        Text("Bildschirmbreite: \(geo.size.width)")  // Zeigt echte Bildschirmbreite
    }
}

Muster 4: Tabellenzeilenhöhe passt sich nicht an

Symptom: Dynamic-Typ-Text wird in Tabellenzeilen abgeschnitten.

Grundursachenlösung:

List(items) { item in
    Text(item.title)
}
.listRowInsets(EdgeInsets())  // Zeilenabstand entfernen

// Oder benutzerdefinierte Zeilenhöhe setzen
List(items) { item in
    Text(item.title)
}
.listRowInsets(EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))

Muster 5: Priorität der Layout-Anpassung

Symptom: Ein View nimmt mehr Platz ein als erwartet, andere werden gequetscht.

Grundursachenlösung:

HStack {
    Text("Wichtiger Text, der sichtbar bleiben muss")
        .layoutPriority(1)  // Höhere Priorität
    Text("Überlaufender Text...")
        .lineLimit(1)  // Kürzen, wenn nötig
}
PrioritätswertEffekt
0 (Standard)Gleichmäßig verteilen
1Diesem View Vorrang geben, andere können schrumpfen
-1Diesem View niedrigere Priorität geben

Wann verwenden: Wenn du sicherstellen möchtest, dass kritische Informationen (wie Beträge oder Namen) nie überlaufen.


Siehe auch

Fazit

Die drei Kategorien von SwiftUI-Debugging haben jeweils klare Muster:

  1. View aktualisiert sich nicht → Überprüfe in dieser Reihenfolge: Struct-Mutation → Verlorenes Binding → Versehentliche Neuerstellung → Fehlender Observer
  2. Preview-Abstürze → Überprüfe in dieser Reihenfolge: Fehlende Abhängigkeit → Fehlgeschlagene Initialisierung → Cache-Korruption
  3. Layout-Probleme → Wähle die Referenz aus der Kurzreferenz

Letzter Tipp: Beginne immer mit einem minimalen Preview. Wenn du es dort reproduzieren kannst, liegt es in deinem Code. Wenn nicht, liegt es wahrscheinlich am Xcode-Zustand. Teste jedes Symptom systematisch. Rate nie.

// Zusammenfassung:
// Wenn sich der View nicht aktualisiert: Bist du sicher, dass du @State verwendest?
// Wenn der Preview abstürzt: Hast du alle Abhängigkeiten bereitgestellt?
// Wenn das Layout falsch ist: Hast du die richtige Containerverschachtelung?

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