Communitygithub.com

SwiftUI 架构模式

在将逻辑从 SwiftUI 视图中分离、选择架构模式、重构视图文件,或询问‘这段代码应该放哪里’、‘如何组织我的 SwiftUI 应用’、‘MVVM vs TCA vs 原生 SwiftUI’、‘如何让 SwiftUI 可测试’时使用——为 iOS 26+ 提供全面的架构模式与重构工作流。

SwiftUI 架构模式 是什么?

这个技能提供了一套完整的 SwiftUI 架构指导,专注于为 iOS 26+ 应用选择和组织架构模式。它涵盖了苹果原生模式(包括 @Observable、State-as-Bridge 和属性包装器决策树)、MVVM 模式、TCA(可组合架构)以及 Coordinator 导航模式。该技能特别强调通过将异步逻辑从视图中分离来提升应用的可测试性,并提供了清晰的决策树来帮助开发者根据项目复杂度、团队规模以及测试需求来选择合适的架构。此外,它还包含了实用的重构工作流示例,用于解决逻辑分离、属性包装器选择、常见反模式等实际问题,并且所有代码示例都使用最新的 Swift 和 SwiftUI API。

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

在你喜欢的 AI 中提问

打开一个已预加载此 Agent Skill 的新对话。

文档

SwiftUI 架构

何时使用此技能

在以下情况使用此技能:

  • 你的 SwiftUI 视图文件中包含逻辑,并希望将其提取出来
  • 在 MVVM、TCA、原生 SwiftUI 模式或 Coordinator 之间做出选择
  • 重构视图以分离关注点
  • 让 SwiftUI 代码可测试
  • 询问“这段代码应该放哪里?”
  • 决定使用哪个属性包装器(@State、@Environment、@Bindable)
  • 为团队开发组织 SwiftUI 代码库

示例提示

你可能问的问题此技能的帮助
“我的模型视图文件中有很多关于逻辑的代码。如何提取它们?”提供包含决策树的重构工作流,指导逻辑应放在何处
“我应该使用 MVVM、TCA 还是苹果的原生模式?”基于应用复杂性、团队规模、测试需求提供决策标准
“如何让我的 SwiftUI 代码可测试?”展示无需 SwiftUI 导入即可实现测试的分离模式
“格式化和计算应该放在哪里?”反模式部分防止逻辑出现在视图主体中
“我应该使用哪个属性包装器?”针对 @State、@Environment、@Bindable 或普通属性的决策树

快速架构决策树

什么驱动你的架构选择?
│
├─ 从零开始,中小型应用,想要苹果的模式?
│  └─ 使用苹果原生模式(第 1 部分)
│     - @Observable 模型用于业务逻辑
│     - State-as-Bridge 用于异步边界
│     - 属性包装器决策树
│
├─ 熟悉 UIKit 中的 MVVM?
│  └─ 使用 MVVM 模式(第 2 部分)
│     - ViewModel 作为表现层适配器
│     - 清晰的 View/ViewModel/Model 分离
│     - 与 @Observable 配合良好
│
├─ 复杂应用,需要严格的测试性和团队一致性?
│  └─ 考虑 TCA(第 3 部分)
│     - State/Action/Reducer/Store 架构
│     - 出色的测试能力
│     - 学习曲线与样板代码的权衡
│
└─ 复杂导航、深度链接、多个入口点?
   └─ 添加 Coordinator 模式(第 4 部分)
      - 可以与其他任何模式结合
      - 将导航逻辑从视图中提取
      - NavigationPath + Coordinator 对象

第 1 部分:苹果原生模式(iOS 26+)

核心原则

“数据模型提供了数据与交互数据的视图之间的分离。这种分离促进模块化、提高可测试性,并有助于更容易地推理应用的工作原理。” — 苹果开发者文档

苹果现代的 SwiftUI 模式(WWDC 2023-2025)聚焦于:

  1. @Observable 用于数据模型(替代 ObservableObject)
  2. State-as-Bridge 用于异步边界(WWDC 2025)
  3. 三个属性包装器:@State、@Environment、@Bindable
  4. 同步 UI 更新 用于动画

State-as-Bridge 模式

问题

异步函数会创建可能导致动画中断的暂停点:

// ❌ 问题:动画可能错过帧截止时间
struct ColorExtractorView: View {
    @State private var isLoading = false

    var body: some View {
        Button("提取颜色") {
            Task {
                isLoading = true  // 同步 ✅
                await extractColors()  // ⚠️ 暂停点!
                isLoading = false  // ❌ 可能发生得太晚
            }
        }
        .scaleEffect(isLoading ? 1.5 : 1.0)  // ⚠️ 动画时机不确定
    }
}

解决方案:将状态用作桥梁

“找到需要时间敏感性变化的 UI 代码与长时间运行的异步逻辑之间的边界。”

// ✅ 正确:State 桥接了 UI 和异步代码
@Observable
class ColorExtractor {
    var isLoading = false
    var colors: [Color] = []

    func extract(from image: UIImage) async {
        // 此方法是异步的,可以存在于模型中
        let extracted = await heavyComputation(image)
        // 用于 UI 更新的同步赋值
        self.colors = extracted
    }
}

struct ColorExtractorView: View {
    let extractor: ColorExtractor

    var body: some View {
        Button("提取颜色") {
            // 用于动画的同步状态更改
            withAnimation {
                extractor.isLoading = true
            }

            // 启动异步工作
            Task {
                await extractor.extract(from: currentImage)

                // 用于动画的同步状态更改
                withAnimation {
                    extractor.isLoading = false
                }
            }
        }
        .scaleEffect(extractor.isLoading ? 1.5 : 1.0)
    }
}

优势:

  • UI 逻辑保持同步(动画正常工作)
  • 异步代码存在于模型中(无需 SwiftUI 即可测试)
  • 时间敏感性 UI 与长时间运行工作之间的清晰边界

属性包装器决策树

只需回答 3 个问题:

我应该使用哪个属性包装器?
│
├─ 这个模型需要是视图本身的状态吗?
│  └─ 是 → 使用 @State
│     示例:表单输入、局部开关、弹出式展示
│     生命周期:由视图的生命周期管理
│
├─ 这个模型需要成为全局环境的一部分吗?
│  └─ 是 → 使用 @Environment
│     示例:用户账户、应用程序设置、依赖注入
│     生命周期:存在于应用/场景级别
│
├─ 这个模型只需要绑定吗?
│  └─ 是 → 使用 @Bindable
│     示例:编辑从父视图传入的模型
│     轻量:仅启用 $ 语法用于绑定
│
└─ 以上都不是?
   └─ 作为普通属性使用
      示例:不可变数据、父视图拥有的模型
      不需要包装器:@Observable 已处理观察

示例

// ✅ @State — 视图拥有模型
struct DonutEditor: View {
    @State private var donutToAdd = Donut()  // 视图自己的状态

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

// ✅ @Environment — 应用级别的模型
struct MenuView: View {
    @Environment(Account.self) private var account  // 全局

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

// ✅ @Bindable — 需要绑定到父视图拥有的模型
struct DonutRow: View {
    @Bindable var donut: Donut  // 父视图拥有

    var body: some View {
        TextField("名称", text: $donut.name)  // 需要绑定
    }
}

// ✅ 普通属性 — 仅读取
struct DonutRow: View {
    let donut: Donut  // 父视图拥有,不需要绑定

    var body: some View {
        Text(donut.name)  // 仅读取
    }
}

@Observable 模型模式

对需要触发 UI 更新的业务逻辑使用 @Observable:

// ✅ 包含业务逻辑的领域模型
@Observable
class FoodTruckModel {
    var orders: [Order] = []
    var donuts = Donut.all

    var orderCount: Int {
        orders.count  // 计算属性自动生效
    }

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

// ✅ 视图自动追踪已访问的属性
struct DonutMenu: View {
    let model: FoodTruckModel  // 不需要包装器!

    var body: some View {
        List {
            Section("甜甜圈") {
                ForEach(model.donuts) { donut in
                    Text(donut.name)  // 追踪 model.donuts
                }
                Button("添加") {
                    model.addDonut()
                }
            }
            Section("订单") {
                Text("数量:\(model.orderCount)")  // 追踪 model.orders
            }
        }
    }
}

工作原理(WWDC 2023/10149):

  • SwiftUI 追踪在 body 执行期间访问了哪些属性
  • 只有那些属性在更改时会触发视图更新
  • 细粒度的依赖追踪 = 更好的性能

ViewModel 适配器模式

当你需要过滤、排序或视图特定逻辑时,使用 ViewModel 作为表现层适配器:

// ✅ ViewModel 作为表现层适配器
@Observable
class PetStoreViewModel {
    let petStore: PetStore  // 领域模型
    var searchText: String = ""

    // 视图特定的计算属性
    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)
    }
}

何时使用 ViewModel 适配器:

  • 为显示进行过滤、排序、分组
  • 为表现层进行格式化(但不要进行重计算)
  • 不属于领域模型的视图特定状态
  • 在领域模型与 SwiftUI 约定之间搭建桥梁

何时不使用 ViewModel:

  • 仅显示模型数据的简单视图
  • 属于领域模型的逻辑
  • 仅为“模式纯洁性”而过度提取

第 2 部分:MVVM 模式

何时使用 MVVM

MVVM(Model-View-ViewModel)在以下情况适用:

✅ 你从 UIKit 就很熟悉它 — 团队成员学习曲线更平坦 ✅ 你想要显式的 View/ViewModel 分离 — 清晰的契约 ✅ 你有复杂的表现层逻辑 — 多种过滤/排序操作 ✅ 你正在从 UIKit 迁移 — 熟悉的心智模型

❌ 在以下情况避免 MVVM:

  • 视图很简单(只展示数据)
  • 你从零开始使用 SwiftUI(苹果原生模式更简单)
  • 你在创建不必要的抽象层

SwiftUI 的 MVVM 结构

// Model — 领域数据和业务逻辑
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 — 表现层逻辑
@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 — 仅 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)
    }
}

SwiftUI 中常见的 MVVM 错误

❌ 错误 1:在 View 和 ViewModel 中重复 @Observable

// ❌ @State + @Observable 是冗余的— @State 会创建自己的存储
struct MyView: View {
    @State private var viewModel = MyViewModel()  // ❌ 冗余包装器
}

// ✅ 直接传递 @Observable— 仅当视图拥有生命周期时才使用 @State
struct MyView: View {
    let viewModel: MyViewModel  // ✅ 如果视图创建它,则使用 @State
}

❌ 错误 2:上帝 ViewModel

// ❌ 不要这样做
@Observable
class AppViewModel {
    // 设置
    var isDarkMode = false
    var notificationsEnabled = true

    // 用户
    var userName = ""
    var userEmail = ""

    // 内容
    var posts: [Post] = []
    var comments: [Comment] = []

    // ... 还有 50 个属性
}
// ✅ 正确:分离关注点
@Observable
class SettingsViewModel {
    var isDarkMode = false
    var notificationsEnabled = true
}

@Observable
class UserProfileViewModel {
    var user: User
}

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

❌ 错误 3:业务逻辑在 ViewModel 中

// ❌ 业务规则应放在 Model 中,而不是 ViewModel
@Observable class OrderViewModel {
    func calculateDiscount(for order: Order) -> Double { /* ... */ }  // ❌ 业务逻辑
}

// ✅ Model 拥有业务逻辑;ViewModel 仅进行显示格式化
struct Order {
    func calculateDiscount() -> Double { /* 业务规则 */ }
}
@Observable class OrderViewModel {
    let order: Order
    var displayDiscount: String {
        "$\(order.calculateDiscount(), specifier: "%.2f")"  // ✅ 仅格式化
    }
}

第 3 部分:TCA(可组合架构)

何时考虑 TCA

TCA 是来自 Point-Free 的第三方架构。在以下情况考虑它:

✅ 严格的测试性至关重要 — TestStore 使测试确定性强 ✅ 大型团队需要一致性 — 严格的模式减少差异 ✅ 复杂的状态管理 — 副作用、依赖、组合 ✅ 你重视类似 Redux 的模式 — 单向数据流

❌ 在以下情况避免 TCA:

  • 小型应用或原型(开销太大)
  • 团队不熟悉函数式编程
  • 你需要快速迭代(样板代码拖慢开发速度)
  • 你想要最小依赖

TCA 核心概念

TCA 有 4 个构建块— State(数据)、Action(事件)、Reducer(状态演化)和 Store(运行时引擎)。以下是单个功能中的它们:

// STATE — 功能所需的数据
@ObservableState
struct CounterFeature {
    var count = 0
    var fact: String?
    var isLoading = false
}

// ACTION — 所有可能的事件
enum Action {
    case incrementButtonTapped
    case decrementButtonTapped
    case factButtonTapped
    case factResponse(String)
}

// REDUCER — 状态如何响应动作而演化
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 numberFact(state.count)
                    await send(.factResponse(fact))
                }
            case let .factResponse(fact):
                state.fact = fact
                state.isLoading = false
                return .none
            }
        }
    }
}

// STORE — 运行时的 State 和 Action 引擎
struct CounterView: View {
    @Bindable var store: StoreOf<CounterFeature>

    var body: some View {
        List {
            Section {
                Text("\(store.count)")
                
                HStack {
                    Button("减少") { store.send(.decrementButtonTapped) }
                    Button("增加") { store.send(.incrementButtonTapped) }
                }
                
                Button("获取趣闻") { store.send(.factButtonTapped) }
            }
            
            if store.isLoading {
                ProgressView()
            }
            if let fact = store.fact {
                Section {
                    Text(fact)
                }
            }
        }
        .navigationTitle("计数器")
    }
}

第 4 部分:Coordinator 导航模式

何时使用 Coordinator

Coordinator 模式将导航逻辑从视图中提取。在以下情况使用它:

✅ 复杂的导航流程 — 多步注册、向导 ✅ 深度链接 — 从外部链接直接导航到深层页面 ✅ 多个入口点 — 推送通知、快捷方式、快捷指令 ✅ 需要导航重用的应用程序 — 从不同上下文中呈现相同的流程

❌ 在以下情况避免 Coordinator:

  • 简单的层级导航(List → Detail)
  • 小型应用,或有一次性的导航需求
  • 你正在使用 NavigationStack 和 NavigationLink,这已经足够了

使用 NavigationPath 的 Coordinator

// Coordinator 管理导航路径
@Observable
class AppCoordinator {
    var path = NavigationPath()
    
    func navigateToOrder(_ order: Order) {
        path.append(AppRoute.orderDetail(order))
    }
    
    func navigateToPayment(for order: Order) {
        path.append(AppRoute.payment(order.id))
    }
    
    func navigateToSettings() {
        path.append(AppRoute.settings)
    }
    
    func popToRoot() {
        path.removeLast(path.count)
    }
}

// Route 枚举定义了所有可能的导航目的地
enum AppRoute: Hashable {
    case orderDetail(Order)
    case payment(UUID)
    case settings
    case about
    case profile(User)
}

// 视图通过 Coordinator 进行导航
struct ContentView: View {
    @Environment(AppCoordinator.self) private var coordinator
    
    var body: some View {
        NavigationStack(path: Bindable(coordinator).path) {
            HomeView()
                .navigationDestination(for: AppRoute.self) { route in
                    switch route {
                    case .orderDetail(let order):
                        OrderDetailView(order: order)
                    case .payment(let orderId):
                        PaymentView(orderId: orderId)
                    case .settings:
                        SettingsView()
                    case .about:
                        AboutView()
                    case .profile(let user):
                        ProfileView(user: user)
                    }
                }
        }
    }
}

第 5 部分:常见反模式与重构

❌ 反模式:视图主体中的格式化

// ❌ 不好的做法:格式化和计算在视图中
struct OrderView: View {
    let order: Order
    
    var body: some View {
        let total = order.items.reduce(0) { $0 + $1.price * Double($1.quantity) }
        let tax = total * 0.08
        let finalTotal = total + tax
        
        VStack {
            Text("小计:$\(total, specifier: "%.2f")")
            Text("税费:$\(tax, specifier: "%.2f")")
            Text("总计:$\(finalTotal, specifier: "%.2f")")
        }
    }
}
// ✅ 好的做法:逻辑在模型中
@Observable
class Order {
    var items: [OrderItem] = []
    
    var subtotal: Double {
        items.reduce(0) { $0 + $1.price * Double($1.quantity) }
    }
    var tax: Double { subtotal * 0.08 }
    var total: Double { subtotal + tax }
}

struct OrderView: View {
    let order: Order  // 不需要包装器
    
    var body: some View {
        VStack {
            Text("小计:$\(order.subtotal, specifier: "%.2f")")
            Text("税费:$\(order.tax, specifier: "%.2f")")
            Text("总计:$\(order.total, specifier: "%.2f")")
        }
    }
}

❌ 反模式:不需要时创建 ViewModel

// ❌ 过度提取:添加 ViewModel 只是为显示数据
struct UserView: View {
    let user: User
    
    var body: some View {
        VStack {
            Text(user.name)
            Text(user.email)
        }
    }
}

❌ 反模式:在视图中混合异步和同步

// ❌ 视图尝试自行管理工作
struct UserListView: View {
    @State private var users: [User] = []
    @State private var isLoading = false
    
    var body: some View {
        List(users) { user in
            Text(user.name)
        }
        .task {
            isLoading = true
            let result = await api.fetchUsers()
            users = result
            isLoading = false
        }
    }
}
// ✅ 模型管理自己数据的获取
@Observable
class UserListModel {
    var users: [User] = []
    var isLoading = false
    
    @MainActor
    func loadUsers() async {
        isLoading = true
        users = await api.fetchUsers()
        isLoading = false
    }
}

struct UserListView: View {
    let model: UserListModel
    
    var body: some View {
        List(model.users) { user in
            Text(user.name)
        }
        .task {
            await model.loadUsers()
        }
    }
}

重构清单

将逻辑从视图移至模型时,对每一行代码使用此清单:

  1. 这是 UI 逻辑吗? → 保持在视图中

    • 过渡、动画、布局计算
    • 拖放手势处理
    • 本地 UI 状态(菜单展开/折叠)
  2. 这是表现层逻辑吗? → ViewModel(可选)

    • 格式化日期/货币
    • 过滤/排序列表
    • 组合来自不同模型的数据
  3. 这是领域逻辑吗? → 领域模型

    • 业务规则和计算
    • 数据验证
    • API 调用和数据处理
  4. 这是异步工作吗? → 模型

    • async/await 函数
    • 长时间运行的任务
    • 网络请求

资源

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

相关技能