Communitygithub.com

ComeOnOliver/skillshub

ロジックをSwiftUIビューから分離する際、アーキテクチャパターンを選択する際、ビューファイルをリファクタリングする際、または「このコードはどこに置くべき?」「SwiftUIアプリをどう整理する?」「MVVM vs TCA vs バニラSwiftUI」「SwiftUIをテスト可能にするには?」といった質問に答える際に使用します。iOS 26+向けの包括的なアーキテクチャパターンとリファクタリングワークフローを提供します。

skillshub とは?

このスキルは、iOS 26+向けSwiftUIアプリケーションにおけるアーキテクチャパターンとリファクタリングの包括的なガイドです。ビューからビジネスロジックを分離する方法、MVVM、TCA、Appleのネイティブパターン、そしてコーディネーターパターンの中から適切なものを選択するための判断基準を提供します。また、@State、@Environment、@Bindableといったプロパティラッパーの使用判断ツリーや、State-as-Bridgeパターンを用いた非同期処理とアニメーションの調和、さらにテスト容易性を高めるための具体的なリファクタリング手法を解説します。このスキルはClaude CodeなどのAIエージェントが、開発者の質問に基づいて最適なアーキテクチャを提案したり、コードのリファクタリングを支援するために設計されています。

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

お気に入りのAIに質問する

このエージェントスキルを事前に読み込んだ状態で新しいチャットを開きます。

ドキュメント

SwiftUIアーキテクチャ

このスキルを使用するタイミング

以下のような場合にこのスキルを使用してください:

  • SwiftUIのビューファイルにロジックが含まれており、それを抽出したい場合
  • MVVM、TCA、バニラSwiftUIパターン、またはコーディネーターの間で選択する場合
  • 関心事を分離するためにビューをリファクタリングする場合
  • SwiftUIのコードをテスト可能にする場合
  • 「このコードはどこに置くべき?」と質問する場合
  • どのプロパティラッパー(@State、@Environment、@Bindable)を使用するかを決定する場合
  • チーム開発のためにSwiftUIコードベースを整理する場合

プロンプト例

聞くかもしれないことこのスキルが役立つ理由
「モデルビューファイルにロジック関連のコードがかなりあるんだけど、どうやって抽出すればいい?」ロジックの所属先を決定するための決定木を含むリファクタリングワークフローを提供
「MVVM、TCA、それともAppleのバニラパターンを使うべき?」アプリの複雑さ、チーム規模、テスト容易性のニーズに基づく判断基準
「SwiftUIのコードをテスト可能にするには?」SwiftUIのインポートを必要としないテストを可能にする分離パターンを提示
「フォーマッターや計算はどこに置くべき?」アンチパターンセクションでビュー本文内にロジックを置かないように防止
「どのプロパティラッパーを使えばいい?」@State、@Environment、@Bindable、またはプレーンなプロパティのための決定木

クイックアーキテクチャ決定木

何がアーキテクチャの選択を動機づけていますか?
│
├─ 新規プロジェクト、小規模/中規模アプリ、Appleのパターンを使いたい?
│  └─ Appleのネイティブパターンを使用(パート1)
│     - @Observableモデルでビジネスロジック
│     - 非同期境界にはState-as-Bridge
│     - プロパティラッパー決定木
│
├─ UIKitでMVVMに慣れている?
│  └─ MVVMパターンを使用(パート2)
│     - ViewModelをプレゼンテーションアダプターとして
│     - 明確なView/ViewModel/Modelの分離
│     - @Observableとの相性が良い
│
├─ 複雑なアプリ、厳密なテスト容易性、チームの一貫性が必要?
│  └─ TCAを検討(パート3)
│     - State/Action/Reducer/Storeアーキテクチャ
│     - 優れたテストのしやすさ
│     - 学習曲線とボイラープレートのトレードオフ
│
└─ 複雑なナビゲーション、ディープリンク、複数のエントリーポイントがある?
   └─ コーディネーターパターンを追加(パート4)
      - 上記のいずれかと組み合わせることが可能
      - ナビゲーションロジックをビューから抽出
      - NavigationPath + Coordinatorオブジェクト

パート1:Appleのネイティブパターン(iOS 26+)

中核となる原則

「データモデルは、データとそのデータを操作するビューとの間の分離を提供します。この分離はモジュール性を促進し、テスト容易性を向上させ、アプリの動作について推論しやすくするのに役立ちます。」 — Apple Developer Documentation

AppleのモダンなSwiftUIパターン(WWDC 2023-2025)は以下を中心としています:

  1. @Observable データモデル用(ObservableObjectを置き換え)
  2. State-as-Bridge 非同期境界用(WWDC 2025)
  3. 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)  // ⚠️ アニメーションのタイミングが不確か
    }
}

解決策:Stateをブリッジとして使用する

「時間に敏感な変更を必要とする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つの質問です:

どのプロパティラッパーを使うべきか?
│
├─ このモデルはVIEW ITSELFのSTATEである必要があるか?
│  └─ YES → @Stateを使用
│     例:フォーム入力、ローカルトグル、シート表示
│     ライフタイム:ビューのライフタイムによって管理される
│
├─ このモデルはGLOBAL ENVIRONMENTの一部である必要があるか?
│  └─ YES → @Environmentを使用
│     例:ユーザーアカウント、アプリ設定、依存性注入
│     ライフタイム:アプリ/シーンレベルで生存
│
├─ このモデルはBINDINGSだけが必要か?
│  └─ YES → @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を始める場合(Appleのパターンの方がシンプル)
  • 不必要な抽象化レイヤーを作成している場合

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 getFact(state.count)
                    await send(.factResponse(fact))
                }
            case let .factResponse(fact):
                state.fact = fact
                state.isLoading = false
                return .none
            }
        }
    }
}

テスト容易性:

// 完全に決定論的なテスト
@MainActor
func testIncrement() async {
    let store = TestStore(initialState: CounterFeature()) {
        CounterFeature()
    }

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

TCAのトレードオフ

利点欠点
決定論的テストボイラープレート量が多い
厳格な状態管理学習曲線が急
依存性注入の容易さプロトタイプが遅くなる
チームの一貫性SwiftUIのシンプルさを弱める

パート4:コーディネーターパターン

コーディネーターとは何か?

コーディネーターはビューからナビゲーションロジックを抽出するオブジェクトです。これは以下のような場合に役立ちます:

  • 複雑なフロー(例:サインアップウィザード)
  • ディープリンク
  • 複数のエントリーポイント(例:Apple Payから、プッシュ通知から)
  • 画面遷移の追跡(分析)

コーディネーターの実装

// 各画面のケース
enum Route: Hashable {
    case petList
    case petDetail(Pet.ID)
    case addPet
}

// ナビゲーションロジックを処理するコーディネーター
@Observable
class PetCoordinator {
    var path = NavigationPath()

    func showPetList() {
        path.append(Route.petList)
    }

    func showPetDetail(_ petID: Pet.ID) {
        path.append(Route.petDetail(petID))
    }

    func showAddPet() {
        path.append(Route.addPet)
    }

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

// アプリ構造
struct AppView: View {
    @State private var coordinator = PetCoordinator()

    var body: some View {
        NavigationStack(path: $coordinator.path) {
            PetListView(coordinator: coordinator)
                .navigationDestination(for: Route.self) { route in
                    switch route {
                    case .petList:
                        PetListView(coordinator: coordinator)
                    case .petDetail(let petID):
                        PetDetailView(petID: petID, coordinator: coordinator)
                    case .addPet:
                        AddPetView(coordinator: coordinator)
                    }
                }
        }
    }
}

コーディネーターアンチパターン

❌ ナビゲーションコードの重複

// ❌ すべてのビューにナビゲーションロジックを書かない
struct PetListView: View {
    @State private var showDetail = false
    @State private var selectedPetID: Pet.ID?

    var body: some View {
        List(pets) { pet in
            Button(pet.name) {
                selectedPetID = pet.id
                showDetail = true
            }
        }
        .navigationDestination(isPresented: $showDetail) {
            if let id = selectedPetID {
                PetDetailView(petID: id)
            }
        }
    }
}
// ✅ ナビゲーションロジックをコーディネーターに委譲
struct PetListView: View {
    let coordinator: PetCoordinator

    var body: some View {
        List(pets) { pet in
            Button(pet.name) {
                coordinator.showPetDetail(pet.id)  // ✅ 委譲
            }
        }
    }
}

❌ 単一の巨大なコーディネーター

// ❌ すべてを管理するコーディネーター
@Observable class AppCoordinator {
    var path = NavigationPath()
    // アプリ全体のすべてのルートをここに…
}

// ✅ 機能ごとに分離されたコーディネーター
@Observable class AuthCoordinator { /* ... */ }
@Observable class PetCoordinator { /* ... */ }
@Observable class SettingsCoordinator { /* ... */ }

リファクタリングワークフロー

ロジックを抽出するためのステップバイステップ

ステップ1:ロジックがビュー内にあるかどうかを特定する

// ⚠️ リファクタリングが必要:ビュー内のロジック
struct PetListView: View {
    @State private var pets: [Pet] = []
    @State private var searchText = ""

    var body: some View {
        List {
            // ❌ フィルタリングロジックがビュー内にある
            ForEach(pets.filter { $0.name.contains(searchText) }) { pet in
                PetRow(pet: pet)
            }
        }
        .searchable(text: $searchText)
    }
}

// ✅ リファクタリング後:ロジックを@Observableモデルに抽出
@Observable
class PetStore {
    var pets: [Pet] = []
    var searchText = ""

    var filteredPets: [Pet] {
        guard !searchText.isEmpty else { return pets }
        return pets.filter { $0.name.contains(searchText) }
    }
}

struct PetListView: View {
    @State private var store = PetStore()

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

ステップ2:ロジックの種類を決定する

ロジックの種類抽出先
表示データ(フィルタリング、フォーマット)ViewModelアダプター
ビジネスルール(計算、検証)@Observableモデル
非同期操作(ネットワーク、データベース)サービス/リポジトリ層
ナビゲーション(画面遷移)コーディネーター

ステップ3:境界を設ける

  1. 問題のロジックを含むメソッド/プロパティを特定する
  2. 新しい@Observableクラスまたは構造体を作成する
  3. ロジックを新しいタイプに移動する
  4. ビューで新しいタイプをインスタンス化し、ロジックを使用するように更新する
  5. ビューがデータアクセスにプロパティラッパーを正しく使用していることを確認する

共通アンチパターン

❌ View Body内のロジック

// ❌ ビュー本文内での計算やフォーマット
struct DonutView: View {
    let donut: Donut

    var body: some View {
        VStack {
            // ❌ ビュー内のフォーマッティング
            Text("$\(donut.price, specifier: "%.2f")")
            // ❌ ビュー内のスタイル適用
            Text(donut.name).font(donut.isPremium ? .title : .body)
        }
    }
}

// ✅ 計算プロパティまたはモデルに委譲
extension Donut {
    var formattedPrice: String {
        "$\(price, specifier: "%.2f")"
    }

    var displayFont: Font {
        isPremium ? .title : .body
    }
}

❌ @Stateでの過剰なラッピング

// ❌ 不必要な@State
struct MyView: View {
    @State private var user = User()  // ユーザーが頻繁に変わらない場合

// ✅ 不変データにはプレーンプロパティ
struct MyView: View {
    let user: User  // 親から渡される

❌ 過剰なViewModel化

// ❌ 単純すぎるViewModel
@Observable
class DonutViewModel {
    let donut: Donut  // プレゼンテーションロジックなし
}

// ✅ 代わりにプレーンなモデルを使用
struct DonutView: View {
    let donut: Donut

テスト戦略

SwiftUIなしでテスト可能にする

// ✅ テスト可能な@Observableモデル
@Observable
class PetStore {
    var pets: [Pet] = []

    func addPet(_ pet: Pet) {
        pets.append(pet)
    }
}

// テストはSwiftUIをインポートしない
import Testing
@Test func addPet() {
    let store = PetStore()
    let pet = Pet(name: "マックス")
    store.addPet(pet)
    #expect(store.pets.count == 1)
    #expect(store.pets.first?.name == "マックス")
}

依存関係の注入

// ✅ テスト可能なサービス層
protocol PetService {
    func fetchPets() async throws -> [Pet]
}

@Observable
class PetStore {
    private let service: PetService

    init(service: PetService = DefaultPetService()) {
        self.service = service
    }

    func loadPets() async {
        do {
            self.pets = try await service.fetchPets()
        } catch {
            self.error = error
        }
    }
}

// テストではモックサービスを使用
struct MockPetService: PetService {
    func fetchPets() async throws -> [Pet] {
        [Pet(name: "テスト")]
    }
}

クイックリファレンス

パターン使用すべき場合iOS 26+ 向けの考慮事項
Appleネイティブデフォルトの選択肢@ObservableとState-as-Bridgeを使用
MVVMUIKitからの移行、複雑なプレゼンテーションViewModelはプレゼンテーションアダプターのみ
TCA厳格なテスト、大規模チーム、複雑な状態学習曲線とボイラープレートを考慮
コーディネーター複雑なナビゲーション、ディープリンクNavigationPathベースの実装

ワークフローチェックリスト

  1. ロジックの種類を特定する(ビジネス、プレゼンテーション、ナビゲーション)
  2. 適切なアーキテクチャパターンを選択する
  3. @Observableを使用してモデルを抽出する
  4. 正しいプロパティラッパー(@State、@Environment、@Bindable)を選択する
  5. アニメーションのためにState-as-Bridgeを適用する
  6. 必要な場合にViewModelアダプターを追加する
  7. コーディネーターにナビゲーションを委譲する
  8. SwiftUIなしでテストを書く

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

関連スキル