Communitygithub.com

SwiftUI Navigation

Verwenden Sie diese Fähigkeit bei der Implementierung von Navigationsmustern, der Wahl zwischen NavigationStack und NavigationSplitView, der Handhabung von Deep Links, der Einführung von Koordinatormustern oder bei der Code-Review von Navigationsimplementierungen – sie verhindert Korruption des Navigationszustands, fehlgeschlagene Deep Links und Fehler bei der Statuswiederherstellung für iOS 18+.

Was ist SwiftUI Navigation?

Diese Fähigkeit bietet eine umfassende Anleitung zur Navigation in SwiftUI, die es Entwicklern ermöglicht, korrekte und robuste Navigationsmuster zu implementieren. Sie behandelt die Entscheidungsfindung zwischen NavigationStack, NavigationSplitView und TabView basierend auf Gerätezielen und Inhaltshierarchie. Die Fähigkeit umfasst praktische Implementierungen für Deep Linking, programmatische Navigation mit NavigationPath, Statuswiederherstellung mithilfe von SceneStorage und Codable NavigationPath sowie Tab-/Sidebar-Muster für iOS 18+. Sie identifiziert auch kritische Anti-Patterns, die zu Navigationsfehlern führen können, wie die Verwendung der veralteten NavigationView, das Platzieren von navigationDestination in lazy Containern oder das Speichern vollständiger Modellobjekte im NavigationPath. Die Fähigkeit enthält einen Entscheidungsbaum, um die beste Navigationsstruktur auszuwählen, und detaillierte Muster mit Codebeispielen für gängige Szenarien.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht SwiftUI Navigation?

Wann Sie diese Fähigkeit verwenden sollten

Verwenden Sie sie, wenn:

  • Sie eine Navigationsarchitektur auswählen (NavigationStack vs. NavigationSplitView vs. TabView)
  • Sie programmatische Navigation mit NavigationPath implementieren
  • Sie Deep Linking und URL-Routing einrichten
  • Sie die Statuswiederherstellung für die Navigation implementieren
  • Sie Tab-/Sidebar-Muster (iOS 18+) einführen
  • Sie Koordinator-/Router-Muster einführen
  • Sie eine Code-Review einer Navigationsimplementierung vor dem Ausliefern anfordern

Verwandte Fähigkeiten

  • Verwenden Sie axiom-swiftui-nav-diag zur systematischen Fehlerbehebung bei Navigationsproblemen
  • Verwenden Sie axiom-swiftui-nav-ref für eine umfassende API-Referenz (einschließlich Tab-Anpassung, iOS 26+-Funktionen) mit allen WWDC-Beispielen

Beispielaufforderungen

Dies sind echte Fragen von Entwicklern, die diese Fähigkeit beantworten soll:

1. „Sollte ich NavigationStack oder NavigationSplitView für meine App verwenden?“

-> Die Fähigkeit bietet einen Entscheidungsbaum basierend auf Gerätezielen, Inhaltshierarchietiefe und Multiplattform-Anforderungen

2. „Wie navigiere ich programmatisch in SwiftUI?“

-> Die Fähigkeit zeigt Muster zur NavigationPath-Manipulation für Push, Pop, Pop-to-Root und Deep Linking

3. „Meine Deep Links funktionieren nicht. Die App öffnet sich, zeigt aber den falschen Bildschirm.“

-> Die Fähigkeit deckt URL-Parsing-Muster, Pfadkonstruktionsreihenfolge und zeitliche Probleme mit onOpenURL ab

4. „Der Navigationsstatus geht verloren, wenn meine App in den Hintergrund geht.“

-> Die Fähigkeit zeigt Codable NavigationPath, SceneStorage-Persistenz und absturzsichere Wiederherstellung

5. „Wie implementiere ich ein Koordinator-Muster in SwiftUI?“

-> Die Fähigkeit bietet Router-Musterbeispiele zusammen mit einer Anleitung, wann Koordinatoren einen Mehrwert bieten vs. Komplexität erhöhen


Rote Flaggen — Anti-Patterns, die es zu verhindern gilt

Wenn Sie IRGENDEINES von diesen tun, HALTEN SIE INNEN und verwenden Sie die Muster in dieser Fähigkeit:

❌ KRITISCH — Tun Sie dies niemals

1. Verwendung der veralteten NavigationView unter iOS 16+

// ❌ FALSCH — Veraltet, unterschiedliches Verhalten ab iOS 16+
NavigationView {
    List { ... }
}
.navigationViewStyle(.stack)

Warum dies fehlschlägt NavigationView ist seit iOS 16 veraltet. Es fehlt die NavigationPath-Unterstützung, was programmatische Navigation und Deep Linking unzuverlässig macht. Unterschiedliches Verhalten zwischen iOS-Versionen verursacht Fehler.

2. Verwendung von ansichtsbasiertem NavigationLink für programmatische Navigation

// ❌ FALSCH — Kann nicht programmatisch gesteuert werden
NavigationLink("Recipe") {
    RecipeDetail(recipe: recipe)  // View-Ziel, kein Wert
}

Warum dies fehlschlägt Ansichtsbasierte Links können nicht programmatisch gesteuert werden. Keine Möglichkeit, per Deep Link zu navigieren oder zu diesem Ziel zu springen. Seit iOS 16 veraltet.

3. Platzieren von navigationDestination in lazy Containern

// ❌ FALSCH — Wird möglicherweise nicht geladen, wenn benötigt
LazyVGrid(columns: columns) {
    ForEach(items) { item in
        NavigationLink(value: item) { ... }
            .navigationDestination(for: Item.self) { item in  // Tun Sie dies nicht
                ItemDetail(item: item)
            }
    }
}

Warum dies fehlschlägt Lazy-Container laden nicht alle Ansichten sofort. navigationDestination ist möglicherweise nicht für NavigationStack sichtbar, was zu stillem Fehlschlagen der Navigation führt.

4. Speichern vollständiger Modellobjekte im NavigationPath für die Wiederherstellung

// ❌ FALSCH — Dupliziert Daten, bei Wiederherstellung veraltet
class NavigationModel: Codable {
    var path: [Recipe] = []  // Vollständige Recipe-Objekte
}

Warum dies fehlschlägt Dupliziert Daten, die bereits in Ihrem Modell vorhanden sind. Bei der Wiederherstellung können Recipe-Daten veraltet sein (anderswo bearbeitet/gelöscht). Verwenden Sie IDs und lösen Sie diese in aktuelle Daten auf.

5. Ändern von NavigationPath außerhalb von MainActor

// ❌ FALSCH — UI-Update außerhalb des Hauptthreads
Task.detached {
    await viewModel.path.append(recipe)  // Hintergrundthread
}

Warum dies fehlschlägt NavigationPath ist an die UI gebunden. Änderungen müssen auf MainActor erfolgen, sonst wird der Navigationszustand beschädigt. Kann zu Abstürzen oder stillem Fehlschlagen führen.

6. Fehlende @MainActor-Isolation für Navigationszustand

// ❌ FALSCH — Nicht MainActor-isoliert
class Router: ObservableObject {
    @Published var path = NavigationPath()  // Kein @MainActor
}

Warum dies fehlschlägt In der strengen Nebenläufigkeit von Swift 6 erfordern @Published-Eigenschaften, auf die von SwiftUI-Ansichten zugegriffen wird, eine MainActor-Isolation. Verursacht Datenrennen-Warnungen und potenzielle Abstürze.

7. Nichtbehandlung des Navigationszustands in Multi-Tab-Apps

// ❌ FALSCH — Gemeinsamer NavigationPath über Tabs hinweg
TabView {
    Tab("Home") { HomeView() }
    Tab("Settings") { SettingsView() }
}
// Alle Tabs teilen denselben NavigationStack — falsch!

Warum dies fehlschlägt Jeder Tab sollte seinen eigenen NavigationStack haben, um den Navigationszustand beim Wechseln der Tabs zu erhalten. Ein gemeinsamer Zustand führt zu einer verwirrenden Benutzererfahrung.

8. Ignorieren von NavigationPath-Decodierungsfehlern

// ❌ FALSCH — Stürzt bei ungültigen Daten ab
let path = NavigationPath(try! decoder.decode(NavigationPath.CodableRepresentation.self, from: data))

Warum dies fehlschlägt Der Benutzer hat möglicherweise Elemente gelöscht, die sich im Pfad befanden. Das Schema könnte sich geändert haben. Ein erzwungenes Entpacken führt beim Wiederherstellen zu einem Absturz.


Obligatorische erste Schritte

Führen Sie diese Schritte IMMER durch, bevor Sie die Navigation implementieren:

// Schritt 1: Identifizieren Sie Ihre Navigationsstruktur
// Fragen: Einzelner Stack? Mehrspaltig? Tab-basiert mit Navigation pro Tab?
// Notieren Sie die Antwort, bevor Sie Code schreiben

// Schritt 2: Wählen Sie den Container basierend auf der Struktur
// Einzelner Stack (iPhone-primär): NavigationStack
// Mehrspaltig (iPad/Mac-primär): NavigationSplitView
// Tab-basiert: TabView mit NavigationStack pro Tab

// Schritt 3: Definieren Sie Ihre Werttypen für die Navigation
// Alle auf NavigationStack geschobenen Werte müssen Hashable sein
// Für Deep Linking/Wiederherstellung auch Codable
struct Recipe: Hashable, Codable, Identifiable { ... }

// Schritt 4: Planen Sie Deep-Link-URLs (falls erforderlich)
// myapp://recipe/{id}
// myapp://category/{name}/recipe/{id}

// Schritt 5: Planen Sie die Statuswiederherstellung (falls erforderlich)
// Werden Sie SceneStorage verwenden? Welche Daten müssen Codable sein?

Schnellentscheidungsbaum

Navigation erforderlich?
├─ Mehrspaltige Oberfläche (iPad/Mac primär)?
│  └─ NavigationSplitView
│     ├─ Drill-Down in der Detailspalte erforderlich?
│     │  └─ NavigationStack im Detail (Muster 3)
│     └─ Nur Auswahl im Detail?
│        └─ Nur Auswahl-Binding (Muster 2)
├─ Tab-basierte App?
│  └─ TabView
│     ├─ Jeder Tab benötigt Drill-Down?
│     │  └─ NavigationStack pro Tab (Muster 4)
│     └─ iPad-Sidebar-Erfahrung?
│        └─ .tabViewStyle(.sidebarAdaptable) (Muster 5)
└─ Einspaltiger Stack?
   └─ NavigationStack
      ├─ Benötigt Deep Linking?
      │  └─ NavigationPath verwenden (Muster 1b)
      └─ Einfaches Push/Pop?
         └─ Typisiertes Array Path (Muster 1a)

Statuswiederherstellung erforderlich?
└─ SceneStorage + Codable NavigationPath (Muster 6)

Koordinator-Abstraktion erforderlich?
├─ Komplexe bedingte Abläufe?
├─ Tests der Navigationslogik erforderlich?
├─ Navigation über viele Bildschirme teilen?
└─ JA zu irgendeinem → Router-Muster (Muster 7)
   NEIN zu allen → NavigationPath direkt verwenden

Muster 1a: Einfacher NavigationStack

Wann: Einfaches Push/Pop, alle Ziele vom gleichen Typ

Zeitaufwand: 5-10 Min

struct RecipeList: View {
    @State private var path: [Recipe] = []

    var body: some View {
        NavigationStack(path: $path) {
            List(recipes) { recipe in
                NavigationLink(recipe.name, value: recipe)
            }
            .navigationTitle("Recipes")
            .navigationDestination(for: Recipe.self) { recipe in
                RecipeDetail(recipe: recipe)
            }
        }
    }

    // Programmatische Navigation
    func showRecipe(_ recipe: Recipe) {
        path.append(recipe)
    }

    func popToRoot() {
        path.removeAll()
    }
}

Wichtige Punkte:

  • Typisiertes Array [Recipe], wenn alle Werte vom gleichen Typ sind
  • Wertbasiertes NavigationLink(title, value:)
  • navigationDestination(for:) außerhalb von lazy Containern

Muster 1b: NavigationStack mit Deep Linking

Wann: Mehrere Zieltypen, URL-basiertes Deep Linking

Zeitaufwand: 15-20 Min

struct ContentView: View {
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            HomeView()
                .navigationDestination(for: Category.self) { category in
                    CategoryView(category: category)
                }
                .navigationDestination(for: Recipe.self) { recipe in
                    RecipeDetail(recipe: recipe)
                }
        }
        .onOpenURL { url in
            handleDeepLink(url)
        }
    }

    func handleDeepLink(_ url: URL) {
        // URL: myapp://category/desserts/recipe/apple-pie
        path.removeLast(path.count)  // Zuerst zur Wurzel springen

        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return }
        let segments = components.path.split(separator: "/").map(String.init)

        var index = 0
        while index < segments.count - 1 {
            switch segments[index] {
            case "category":
                if let category = Category(rawValue: segments[index + 1]) {
                    path.append(category)
                }
                index += 2
            case "recipe":
                if let recipe = dataModel.recipe(named: segments[index + 1]) {
                    path.append(recipe)
                }
                index += 2
            default:
                index += 1
            }
        }
    }
}

Wichtige Punkte:

  • NavigationPath für heterogene Typen
  • Vor dem Aufbau des Deep-Link-Pfades zur Wurzel springen
  • Pfad in der richtigen Reihenfolge aufbauen (Eltern → Kind)

Muster 2: NavigationSplitView auswahlbasiert

Wann: Mehrspaltiges Layout, bei dem das Detail das ausgewählte Element anzeigt

Zeitaufwand: 10-15 Min

struct MultiColumnView: View {
    @State private var selectedCategory: Category?
    @State private var selectedRecipe: Recipe?

    var body: some View {
        NavigationSplitView {
            List(Category.allCases, selection: $selectedCategory) { category in
                NavigationLink(category.name, value: category)
            }
            .navigationTitle("Categories")
        } content: {
            if let category = selectedCategory {
                List(recipes(in: category), selection: $selectedRecipe) { recipe in
                    NavigationLink(recipe.name, value: recipe)
                }
                .navigationTitle(category.name)
            } else {
                Text("Select a category")
            }
        } detail: {
            if let recipe = selectedRecipe {
                RecipeDetail(recipe: recipe)
            } else {
                Text("Select a recipe")
            }
        }
    }
}

Wichtige Punkte:

  • selection: $binding in der List verbindet sich mit der Spaltenauswahl
  • Wertpräsentierende Links aktualisieren die Auswahl automatisch
  • Passt sich auf dem iPhone an einen einzelnen Stack an

Muster 3: NavigationSplitView mit Stack im Detail

Wann: Mehrspaltig mit Drill-Down-Fähigkeit im Detail

Zeitaufwand: 20-25 Min

struct GridWithDrillDown: View {
    @State private var selectedCategory: Category?
    @State private var path: [Recipe] = []

    var body: some View {
        NavigationSplitView {
            List(Category.allCases, selection: $selectedCategory) { category in
                NavigationLink(category.name, value: category)
            }
            .navigationTitle("Categories")
        } detail: {
            NavigationStack(path: $path) {
                if let category = selectedCategory {
                    RecipeGrid(category: category)
                        .navigationDestination(for: Recipe.self) { recipe in
                            RecipeDetail(recipe: recipe)
                        }
                } else {
                    Text("Select a category")
                }
            }
        }
    }
}

Wichtige Punkte:

  • NavigationStack in der Detailspalte
  • Grid → Detail Drill-Down unter Beibehaltung der Sidebar
  • Separater Pfad für Drill-Down, Auswahl für die Sidebar

Muster 4: TabView mit NavigationStack pro Tab

Wann: Tab-basierte App, bei der jeder Tab seine eigene Navigation hat

Zeitaufwand: 15-20 Min

struct TabBasedApp: View {
    var body: some View {
        TabView {
            Tab("Home", systemImage: "house") {
                NavigationStack {
                    HomeView()
                        .navigationDestination(for: Item.self) { item in
                            ItemDetail(item: item)
                        }
                }
            }

            Tab("Search", systemImage: "magnifyingglass") {
                NavigationStack {
                    SearchView()
                }
            }

            Tab("Settings", systemImage: "gear") {
                NavigationStack {
                    SettingsView()
                }
            }
        }
    }
}

Wichtige Punkte:

  • Jeder Tab hat seinen eigenen NavigationStack
  • Navigationszustand bleibt beim Wechseln der Tabs erhalten
  • iOS 18+ Tab-Syntax mit systemImage

Muster 5: Sidebar-adaptierbare TabView (iOS 18+)

Wann: Tab-Leiste auf dem iPhone, Sidebar auf dem iPad

Zeitaufwand: 20-25 Min

struct AdaptableApp: View {
    var body: some View {
        TabView {
            Tab("Watch Now", systemImage: "play") {
                WatchNowView()
            }
            Tab("Library", systemImage: "books.vertical") {
                LibraryView()
            }

            TabSection("Collections") {
                Tab("Favorites", systemImage: "star") {
                    FavoritesView()
                }
                Tab("Recently Added", systemImage: "clock") {
                    RecentView()
                }
            }

            Tab(role: .search) {
                SearchView()
            }
        }
        .tabViewStyle(.sidebarAdaptable)
    }
}

Wichtige Punkte:

  • .tabViewStyle(.sidebarAdaptable) aktiviert die Sidebar auf dem iPad
  • TabSection erstellt zusammenklappbare Gruppen in der Sidebar
  • Tab(role: .search) erhält eine spezielle Platzierung

Muster 6: Statuswiederherstellung

Wann: Wiederherstellung der Navigation, nachdem die App beendet wurde

Zeitaufwand: 20-25 Min

struct RestorableApp: View {
    @SceneStorage("navigationPath") private var pathData: Data?
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            ContentView()
                .navigationDestination(for: Recipe.self) { recipe in
                    RecipeDetail(recipe: recipe)
                }
        }
        .onAppear {
            restorePath()
        }
        .onChange(of: path) { _, newPath in
            savePath()
        }
    }

    private func savePath() {
        guard let representation = path.codable else { return }
        pathData = try? JSONEncoder().encode(representation)
    }

    private func restorePath() {
        guard let data = pathData,
              let representation = try? JSONDecoder().decode(
                  NavigationPath.CodableRepresentation.self, from: data
              ) else { return }
        path = NavigationPath(representation)
    }
}

Wichtige Punkte:

  • SceneStorage ist ideal für die Persistenz von NavigationPath
  • NavigationPath.CodableRepresentation ermöglicht Codierung
  • Behandeln Sie Decodierungsfehler mit Guard, nicht mit Force-Unwrap
  • Bei Fehlern wird ein leerer Pfad verwendet, kein Absturz

Muster 7: Router-Muster

Wann: Komplexe bedingte Navigation, testbare Navigationslogik

Zeitaufwand: 30-45 Min (erhöhte Abstraktion)

@MainActor
@Observable
final class Router {
    var path = NavigationPath()

    func navigate(to destination: AppDestination) {
        path.append(destination)
    }

    func navigateBack() {
        path.removeLast()
    }

    func popToRoot() {
        path.removeLast(path.count)
    }

    func handleDeepLink(_ url: URL) {
        popToRoot()
        // ... Deep-Link-Parsing und Navigation
    }
}

enum AppDestination: Hashable {
    case recipeDetail(Recipe)
    case categoryList(Category)
    case settings
    case profile(User)
}

struct AppView: View {
    @State private var router = Router()

    var body: some View {
        NavigationStack(path: $router.path) {
            HomeView(router: router)
                .navigationDestination(for: AppDestination.self) { destination in
                    switch destination {
                    case .recipeDetail(let recipe):
                        RecipeDetail(recipe: recipe)
                    case .categoryList(let category):
                        CategoryView(category: category)
                    case .settings:
                        SettingsView()
                    case .profile(let user):
                        ProfileView(user: user)
                    }
                }
        }
        .environment(router)
    }
}

Wichtige Punkte:

  • Router ist @MainActor für die Sicherheit der Nebenläufigkeit
  • @Observable für moderne SwiftUI-Beobachtung
  • Aufzählungsziele bieten Typsicherheit und dokumentierte Routen
  • Alle Navigationslogik an einem Ort für einfaches Testen

Zusammenfassung der häufigsten Fehler

FehlerSymptomLösung
Verwendung von NavigationViewSelektiv fehlerhafte Deep LinksAuf NavigationStack umsteigen
navigationDestination in lazy ContainerNavigation schlägt still fehlnavigationDestination auf die oberste Ebene des NavigationStack verschieben
NavigationPath außerhalb von @MainActor geändertAbgestürzter/verlorener NavigationszustandIn @MainActor-Funktionen einschließen
Vollständige Objekte im Pfad gespeichertVeraltete/wiederhergestellte DatenIDs speichern, bei der Navigation in Objekte auflösen
Force-Unwrap von wiederhergestelltem PfadAbsturz bei der WiederherstellungGuard/optional entpacken, bei Fehlern leeren Pfad
Gemeinsamer NavigationStack in TabsVerlorener Tab-VerlaufEigenen NavigationStack pro Tab

Wann sollte auf einen Koordinator/Router umgestiegen werden

Verwenden Sie direkten NavigationPath...Wechseln Sie zum Router-Muster...
Einfaches Push/Pop von einem BildschirmKomplexe bedingte Abläufe (Onboarding, Bezahlung)
Ein oder zwei ZieltypenViele Zieltypen (5+)
Kein Deep LinkingTiefe/komplexe Deep-Link-Strukturen
Kein Bedarf an Tests der NavigationslogikTests der Navigationslogik erforderlich
Wenige Bildschirme teilen NavigationViele Bildschirme teilen Navigation

Nützliche Informationen

  • NavigationStack und NavigationSplitView sind die einzigen unterstützten Container ab iOS 16
  • NavigationPath unterstützt jeden Hashable-Typ, auch gemischte Arrays
  • Für TabView wickeln Sie jeden Tab in seinen eigenen NavigationStack
  • SceneStorage ist der empfohlene Mechanismus für die NavigationPath-Persistenz
  • Der Router auf Enum-Basis bietet Typsicherheit und Testbarkeit
  • Verwenden Sie den Entscheidungsbaum zu Beginn jeder Implementierung

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