Communitygithub.com

ComeOnOliver/skillshub

Utilisez cette compétence pour séparer la logique des vues SwiftUI, choisir des patrons d'architecture, refactoriser des fichiers de vue, ou lorsque vous vous demandez « où mettre ce code », « comment organiser mon app SwiftUI », « MVVM vs TCA vs SwiftUI vanilla », « comment rendre SwiftUI testable ». Propose des patrons d'architecture complets avec des workflows de refactorisation pour iOS 26+.

Qu'est-ce que skillshub ?

Cette compétence fournit un guide complet sur les patrons d'architecture SwiftUI pour iOS 26+, en s'appuyant sur les dernières présentations WWDC (2023-2025). Elle couvre quatre approches principales : les patrons natifs d'Apple (avec @Observable et State-as-Bridge), MVVM en tant qu'adaptateur de présentation, TCA (Composable Architecture) pour les applications complexes, et le patron Coordinator pour la navigation avancée. Pour chaque approche, elle propose des arbres de décision, des exemples de code concrets, et des anti-patrimoines à éviter. La compétence insiste sur la testabilité, la séparation des préoccupations et les workflows de refactorisation, aidant les développeurs à organiser leur codebase SwiftUI pour le travail en équipe. Elle est idéale pour les développeurs iOS qui cherchent à améliorer la structure de leurs applications SwiftUI, que ce soit pour un nouveau projet ou une refactorisation.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Architecture SwiftUI

Quand utiliser cette compétence

Utilisez cette compétence lorsque :

  • Vous avez de la logique dans vos fichiers de vue SwiftUI et souhaitez l'extraire
  • Vous choisissez entre MVVM, TCA, les patrons SwiftUI vanilla, ou Coordinator
  • Vous refactorisez des vues pour séparer les responsabilités
  • Vous voulez rendre le code SwiftUI testable
  • Vous vous demandez « où doit aller ce code ? »
  • Vous décidez quel property wrapper utiliser (@State, @Environment, @Bindable)
  • Vous organisez une base de code SwiftUI pour un développement en équipe

Exemples de requêtes

Ce que vous pourriez demanderPourquoi cette compétence aide
« Il y a pas mal de code dans mes fichiers de vue modèle concernant la logique. Comment l'extraire ? »Fournit un workflow de refactorisation avec des arbres de décision pour savoir où placer la logique
« Dois-je utiliser MVVM, TCA ou les patrons vanilla d'Apple ? »Critères de décision basés sur la complexité de l'app, la taille de l'équipe, les besoins de testabilité
« Comment rendre mon code SwiftUI testable ? »Montre des patrons de séparation qui permettent le test sans imports SwiftUI
« Où placer les formateurs et les calculs ? »La section anti-patrons empêche la logique dans les corps de vue
« Quel property wrapper dois-je utiliser ? »Arbre de décision pour @State, @Environment, @Bindable, ou propriétés simples

Arbre de décision rapide pour l'architecture

Qu'est-ce qui motive votre choix d'architecture ?
│
├─ Vous partez de zéro, appli petite/moyenne, vous voulez les patrons d'Apple ?
│  └─ Utilisez les Patrons Natifs d'Apple (Partie 1)
│     - Modèles @Observable pour la logique métier
│     - State-as-Bridge pour les frontières asynchrones
│     - Arbre de décision des property wrappers
│
├─ Vous connaissez MVVM depuis UIKit ?
│  └─ Utilisez le Patron MVVM (Partie 2)
│     - ViewModels comme adaptateurs de présentation
│     - Séparation claire View/ViewModel/Model
│     - Fonctionne bien avec @Observable
│
├─ Application complexe, besoin de testabilité rigoureuse, cohérence d'équipe ?
│  └─ Envisagez TCA (Partie 3)
│     - Architecture State/Action/Reducer/Store
│     - Excellente histoire de test
│     - Compromis courbe d'apprentissage + code boilerplate
│
└─ Navigation complexe, deep linking, points d'entrée multiples ?
   └─ Ajoutez le Patron Coordinator (Partie 4)
      - Peut être combiné avec n'importe lequel des précédents
      - Extrait la logique de navigation des vues
      - NavigationPath + objets Coordinator

Partie 1 : Patrons natifs d'Apple (iOS 26+)

Principe de base

« Un modèle de données assure la séparation entre les données et les vues qui interagissent avec elles. Cette séparation favorise la modularité, améliore la testabilité et facilite la compréhension du fonctionnement de l'application. » — Documentation développeur Apple

Les patrons SwiftUI modernes d'Apple (WWDC 2023-2025) sont centrés sur :

  1. @Observable pour les modèles de données (remplace ObservableObject)
  2. State-as-Bridge pour les frontières asynchrones (WWDC 2025)
  3. Trois property wrappers : @State, @Environment, @Bindable
  4. Mises à jour d'interface utilisateur synchrones pour les animations

Le patron State-as-Bridge

Problème

Les fonctions asynchrones créent des points de suspension qui peuvent casser les animations :

// ❌ Problématique : L'animation pourrait manquer la deadline de l'image
struct ColorExtractorView: View {
    @State private var isLoading = false

    var body: some View {
        Button("Extract Colors") {
            Task {
                isLoading = true  // Synchrone ✅
                await extractColors()  // ⚠️ Point de suspension !
                isLoading = false  // ❌ Pourrait arriver trop tard
            }
        }
        .scaleEffect(isLoading ? 1.5 : 1.0)  // ⚠️ Timing de l'animation incertain
    }
}

Solution : Utiliser State comme un pont

« Trouvez les frontières entre le code d'interface utilisateur qui nécessite des changements sensibles au temps, et la logique asynchrone de longue durée. »

// ✅ Correct : State fait le pont entre l'interface utilisateur et le code asynchrone
@Observable
class ColorExtractor {
    var isLoading = false
    var colors: [Color] = []

    func extract(from image: UIImage) async {
        // Cette méthode est asynchrone et peut vivre dans le modèle
        let extracted = await heavyComputation(image)
        // Mutation synchrone pour la mise à jour de l'interface utilisateur
        self.colors = extracted
    }
}

struct ColorExtractorView: View {
    let extractor: ColorExtractor

    var body: some View {
        Button("Extract Colors") {
            // Changement d'état synchrone pour l'animation
            withAnimation {
                extractor.isLoading = true
            }

            // Lance le travail asynchrone
            Task {
                await extractor.extract(from: currentImage)

                // Changement d'état synchrone pour l'animation
                withAnimation {
                    extractor.isLoading = false
                }
            }
        }
        .scaleEffect(extractor.isLoading ? 1.5 : 1.0)
    }
}

Avantages :

  • La logique d'interface utilisateur reste synchrone (les animations fonctionnent correctement)
  • Le code asynchrone vit dans le modèle (testable sans SwiftUI)
  • Frontière claire entre l'interface utilisateur sensible au temps et le travail de longue durée

Arbre de décision des Property Wrappers

Il suffit de répondre à 3 questions :

Quel property wrapper dois-je utiliser ?
│
├─ Ce modèle doit-il être L'ÉTAT DE LA VUE ELLE-MÊME ?
│  └─ OUI → Utilisez @State
│     Exemples : Entrées de formulaire, toggles locaux, présentations de feuilles
│     Durée de vie : Gérée par la durée de vie de la vue
│
├─ Ce modèle doit-il faire partie de L'ENVIRONNEMENT GLOBAL ?
│  └─ OUI → Utilisez @Environment
│     Exemples : Compte utilisateur, paramètres de l'application, injection de dépendances
│     Durée de vie : Vit au niveau de l'application/scène
│
├─ Ce modèle a-t-il BESOIN DE BINDINGS UNIQUEMENT ?
│  └─ OUI → Utilisez @Bindable
│     Exemples : Édition d'un modèle passé par le parent
│     Léger : Active uniquement la syntaxe $ pour les bindings
│
└─ AUCUN DE CES CAS ?
   └─ Utilisez comme propriété simple
      Exemples : Données immuables, modèles possédés par le parent
      Aucun wrapper nécessaire : @Observable gère l'observation

Exemples

// ✅ @State — La vue possède le modèle
struct DonutEditor: View {
    @State private var donutToAdd = Donut()  // État propre de la vue

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

// ✅ @Environment — Modèle à l'échelle de l'application
struct MenuView: View {
    @Environment(Account.self) private var account  // Global

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

// ✅ @Bindable — A besoin de bindings vers un modèle possédé par le parent
struct DonutRow: View {
    @Bindable var donut: Donut  // Le parent le possède

    var body: some View {
        TextField("Name", text: $donut.name)  // A besoin d'un binding
    }
}

// ✅ Propriété simple — Juste pour la lecture
struct DonutRow: View {
    let donut: Donut  // Le parent le possède, pas besoin de binding

    var body: some View {
        Text(donut.name)  // Juste pour la lecture
    }
}

Patron de modèle @Observable

Utilisez @Observable pour la logique métier qui doit déclencher des mises à jour de l'interface utilisateur :

// ✅ Modèle de domaine avec logique métier
@Observable
class FoodTruckModel {
    var orders: [Order] = []
    var donuts = Donut.all

    var orderCount: Int {
        orders.count  // Les propriétés calculées fonctionnent automatiquement
    }

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

// ✅ La vue suit automatiquement les propriétés accédées
struct DonutMenu: View {
    let model: FoodTruckModel  // Pas de wrapper nécessaire !

    var body: some View {
        List {
            Section("Donuts") {
                ForEach(model.donuts) { donut in
                    Text(donut.name)  // Suit model.donuts
                }
                Button("Ajouter") {
                    model.addDonut()
                }
            }
            Section("Commandes") {
                Text("Nombre : \(model.orderCount)")  // Suit model.orders
            }
        }
    }
}

Comment ça fonctionne (WWDC 2023/10149) :

  • SwiftUI suit quelles propriétés sont accédées pendant l'exécution du body
  • Seules ces propriétés déclenchent des mises à jour de la vue lorsqu'elles sont modifiées
  • Suivi granulaire des dépendances = meilleure performance

Patron ViewModel Adapter

Utilisez les ViewModels comme adaptateurs de présentation lorsque vous avez besoin de filtrage, de tri ou d'une logique spécifique à la vue :

// ✅ ViewModel comme adaptateur de présentation
@Observable
class PetStoreViewModel {
    let petStore: PetStore  // Modèle de domaine
    var searchText: String = ""

    // Propriété calculée spécifique à la vue
    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)
    }
}

Quand utiliser un ViewModel adaptateur :

  • Filtrage, tri, regroupement pour l'affichage
  • Mise en forme pour la présentation (mais PAS de calculs lourds)
  • État spécifique à la vue qui n'appartient pas au modèle de domaine
  • Faire le pont entre le modèle de domaine et les conventions SwiftUI

Quand NE PAS utiliser de ViewModel :

  • Vues simples qui affichent juste les données du modèle
  • Logique qui appartient au modèle de domaine
  • Sur-extraction juste pour la « pureté du patron »

Partie 2 : Patron MVVM

Quand utiliser MVVM

MVVM (Model-View-ViewModel) est approprié lorsque :

✅ Vous le connaissez depuis UIKit — Intégration plus facile pour l'équipe ✅ Vous voulez une séparation explicite View/ViewModel — Contrats clairs ✅ Vous avez une logique de présentation complexe — Opérations multiples de filtrage/tri ✅ Vous migrez depuis UIKit — Modèle mental familier

❌ Évitez MVVM quand :

  • Les vues sont simples (juste l'affichage de données)
  • Vous partez de zéro avec SwiftUI (les patrons d'Apple sont plus simples)
  • Vous créez des couches d'abstraction inutiles

Structure MVVM pour SwiftUI

// Model — Données de domaine et logique métier
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 — Logique de présentation
@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 — Interface utilisateur uniquement
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)
    }
}

Erreurs MVVM courantes dans SwiftUI

❌ Erreur 1 : Dupliquer @Observable dans la Vue et le ViewModel

// ❌ @State + @Observable est redondant — @State crée son propre stockage
struct MyView: View {
    @State private var viewModel = MyViewModel()  // ❌ Wrapper redondant
}

// ✅ Passez @Observable directement — utilisez @State uniquement si la vue POSSÈDE le cycle de vie
struct MyView: View {
    let viewModel: MyViewModel  // ✅ Ou @State si la vue le crée
}

❌ Erreur 2 : ViewModel fourre-tout

// ❌ Ne faites pas ceci
@Observable
class AppViewModel {
    // Paramètres
    var isDarkMode = false
    var notificationsEnabled = true

    // Utilisateur
    var userName = ""
    var userEmail = ""

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

    // ... 50 propriétés de plus
}
// ✅ Correct : Séparez les responsabilités
@Observable
class SettingsViewModel {
    var isDarkMode = false
    var notificationsEnabled = true
}

@Observable
class UserProfileViewModel {
    var user: User
}

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

❌ Erreur 3 : Logique métier dans le ViewModel

// ❌ Les règles métier appartiennent au Model, pas au ViewModel
@Observable class OrderViewModel {
    func calculateDiscount(for order: Order) -> Double { /* ... */ }  // ❌ Logique métier
}

// ✅ Le Model possède la logique métier ; le ViewModel formate uniquement pour l'affichage
struct Order {
    func calculateDiscount() -> Double { /* règles métier */ }
}
@Observable class OrderViewModel {
    let order: Order
    var displayDiscount: String {
        "$\(order.calculateDiscount(), specifier: "%.2f")"  // ✅ Juste du formatage
    }
}

Partie 3 : TCA (Composable Architecture)

Quand envisager TCA

TCA est une architecture tierce de Point-Free. Envisagez-la lorsque :

✅ La testabilité rigoureuse est critique — TestStore rend les tests déterministes ✅ Une grande équipe a besoin de cohérence — Des patrons stricts réduisent la variabilité ✅ La gestion d'état complexe — Effets secondaires, dépendances, composition ✅ Vous appréciez les patrons Redux — Flux de données unidirectionnel

❌ Évitez TCA quand :

  • Application petite ou prototype (trop de surcharge)
  • L'équipe n'est pas familière avec la programmation fonctionnelle
  • Vous avez besoin d'itérations rapides (le code boilerplate ralentit le développement)
  • Vous voulez un minimum de dépendances

Concepts de base de TCA

TCA a 4 blocs de construction — State (données), Action (événements), Reducer (évolution de l'état), et Store (moteur d'exécution). Les voici dans une seule fonctionnalité :

// STATE — Données dont votre fonctionnalité a besoin
@ObservableState
struct CounterFeature {
    var count = 0
    var fact: String?
    var isLoading = false
}

// ACTION — Tous les événements possibles
enum Action {
    case incrementButtonTapped
    case decrementButtonTapped
    case factButtonTapped
    case factResponse(String)
}

// REDUCER — Comment l'état évolue en réponse aux actions
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.isLoading = false
                state.fact = fact
                return .none
            }
        }
    }
}

// STORE — Le moteur d'exécution qui connecte tout
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("Obtenir un fait") { store.send(.factButtonTapped) }
            if let fact = store.fact {
                Text(fact)
            }
        }
    }
}

Test avec TCA

@Test
func testIncrement() async {
    let store = await TestStore(initialState: CounterFeature()) {
        CounterFeature()
    }

    await store.send(.incrementButtonTapped) {
        $0.count = 1
    }
}

@Test
func testFactFlow() async {
    let store = await TestStore(initialState: CounterFeature()) {
        CounterFeature()
    } withDependencies: {
        $0.factClient.fetch = { _ in "Un fait cool" }
    }

    await store.send(.factButtonTapped) {
        $0.isLoading = true
    }
    await store.receive(\.factResponse) {
        $0.isLoading = false
        $0.fact = "Un fait cool"
    }
}

Quand TCA est exagéré

// ❌ TCA pour un simple compteur — les patrons natifs d'Apple sont plus simples
struct CounterView: View {
    @State private var count = 0
    var body: some View {
        Button("Compteur : \(count)") { count += 1 }
    }
}

Partie 4 : Patron Coordinator

Quand ajouter un Coordinator

✅ Navigation complexe — Flux profonds, conditionnels ✅ Deep linking — États d'écran profonds via URL/notification ✅ Points d'entrée multiples — Widgets, raccourcis, différentes tabs ✅ Navigation réutilisable — Mêmes flux depuis différents endroits

❌ Évitez Coordinator quand :

  • Application à onglets simples avec navigation linéaire
  • Écrans hiérarchiques simples (push/pop)
  • Moins de 5 écrans

Coordinator de base

@Observable
class AppCoordinator {
    var path = NavigationPath()
    var presentedSheet: Sheet?

    enum Sheet: Hashable, Identifiable {
        case settings
        case createDonut
        var id: Self { self }
    }

    func showSettings() {
        presentedSheet = .settings
    }

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

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

    var body: some View {
        NavigationStack(path: $coordinator.path) {
            HomeView(coordinator: coordinator)
                .navigationDestination(for: Donut.self) { donut in
                    DonutDetailView(donut: donut, coordinator: coordinator)
                }
        }
        .sheet(item: $coordinator.presentedSheet) { sheet in
            switch sheet {
            case .settings: SettingsView()
            case .createDonut: CreateDonutView()
            }
        }
        .environment(coordinator)
    }
}

Anti-patrons des Coordinators

❌ Coordinator avec trop de responsabilités

// ❌ Ne faites pas cela
@Observable
class SuperCoordinator {
    var path = NavigationPath()
    var userSettings = UserSettings() // ❌ La gestion de l'utilisateur n'est pas de la navigation
    var networkManager = NetworkManager() // ❌ Le réseau n'est pas de la navigation

    func saveAndNavigate() { /* ... */ } // ❌ Trop de responsabilités
}

✅ Correct : Coordinator uniquement pour la navigation

@Observable
class AppCoordinator {
    var path = NavigationPath()  // Navigation uniquement

    func navigateToOrders() { path.append(AppRoute.orders) }
    func navigateToDonut(_ donut: Donut) { path.append(donut) }
}

// Les modèles de données et services sont séparés

Anti-patrons courants

❌ Logique dans le corps de la vue

// ❌ Évitez : Logique complexe dans le corps de la vue
struct DonutListView: View {
    let donuts: [Donut]
    @State private var searchText = ""

    var body: some View {
        List {
            // ❌ Filtrage et tri logique ici
            ForEach(donuts
                .filter { $0.name.contains(searchText) }
                .sorted { $0.name < $1.name }
            ) { donut in
                DonutRow(donut: donut)
            }
        }
    }
}
// ✅ Préférez : Propriété calculée ou modèle séparé
struct DonutListView: View {
    let donuts: [Donut]
    @State private var searchText = ""

    var filteredSortedDonuts: [Donut] {
        donuts
            .filter { searchText.isEmpty || $0.name.contains(searchText) }
            .sorted { $0.name < $1.name }
    }

    var body: some View {
        List {
            ForEach(filteredSortedDonuts) { donut in
                DonutRow(donut: donut)
            }
        }
    }
}

❌ Sur-extraction

// ❌ Évitez : Service pour une simple opération
class StringFormatterService {
    func capitalize(_ string: String) -> String { string.capitalized }
}

struct GreetingView: View {
    let formatter = StringFormatterService()
    let name: String

    var body: some View {
        Text(formatter.capitalize("Bonjour, \(name)"))
    }
}
// ✅ Préférez : Simple et direct
struct GreetingView: View {
    let name: String

    var body: some View {
        Text("Bonjour, \(name)")
            .textCase(.uppercase) // ✅ Utilisez directement SwiftUI
    }
}

❌ Trop de ViewModels

// ❌ Évitez : ViewModel pour chaque vue, même les plus simples
struct ProfileHeaderView: View {
    @Bindable var viewModel: ProfileHeaderViewModel
}

@Observable
class ProfileHeaderViewModel {
    var user: User
    // Ne fait rien d'autre que de contenir l'utilisateur
}
// ✅ Préférez : Vue simple avec modèle
struct ProfileHeaderView: View {
    let user: User
    var body: some View {
        HStack {
            AvatarView(user: user)
            Text(user.name)
        }
    }
}

Liste de vérification pour la refactorisation

Utilisez cette liste lorsque vous extrayez la logique des vues :

  • Le corps de la vue a-t-il moins de 20 lignes ?
  • Y a-t-il des boucles if, switch, for complexes dans la vue ? → Extraire
  • Les mises en forme et les calculs se trouvent-ils dans le corps de la vue ? → Extraire dans une propriété calculée ou un modèle
  • La vue appelle-t-elle directement un service réseau ou une base de données ? → Déplacer dans un modèle
  • La navigation est-elle intégrée dans la vue ? → Envisager un Coordinator
  • La logique métier peut-elle être testée sans importer SwiftUI ? → Si non, extraire
  • Les propriétés utilisent-elles le property wrapper le plus simple ? (@State si la vue possède, @Bindable si parent, etc.)
  • L'architecture est-elle cohérente dans toute la base de code ?
  • Un nouveau membre d'équipe peut-il comprendre la structure ?
  • Avez-vous besoin de cette abstraction ? (Voir la section sur la sur-extraction)

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

Skills associés