Communitygithub.com

SwiftUI 아키텍처

iOS 26+ 앱을 위한 포괄적인 아키텍처 패턴, 리팩토링 워크플로우, 그리고 SwiftUI 코드를 테스트 가능하게 만드는 방법을 제공합니다.

SwiftUI 아키텍처란 무엇인가요?

이 스킬은 iOS 26+를 대상으로 하는 SwiftUI 앱 개발자에게 아키텍처 패턴 선택과 코드 리팩토링에 대한 명확한 지침을 제공합니다. Apple의 네이티브 패턴(@Observable, State-as-Bridge), MVVM, TCA, Coordinator 등 네 가지 주요 아키텍처를 다루며, 앱의 복잡성, 팀 규모, 테스트 용이성 등의 기준에 따라 적합한 패턴을 선택할 수 있는 의사 결정 트리를 제시합니다. 특히, @State, @Environment, @Bindable과 같은 프로퍼티 래퍼 사용에 대한 구체적인 지침과 함께 비동기 작업으로 인한 애니메이션 중단 문제를 해결하는 'State-as-Bridge' 패턴을 상세히 설명합니다. 비즈니스 로직과 프레젠테이션 로직을 분리하고, 불필요한 추상화를 피하는 방법, 그리고 일반적인 MVVM 실수(예: God ViewModel, ViewModel에 비즈니스 로직 배치)를 방지하는 방법을 실제 코드 예제와 함께 제시하여 SwiftUI 코드베이스의 유지보수성과 테스트 가능성을 높이는 데 중점을 둡니다.

지원 대상~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 패턴, 또는 Coordinator 중에서 선택해야 하는 경우
  • 관심사를 분리하기 위해 뷰를 리팩토링하는 경우
  • 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 아키텍처
│     - 훌륭한 테스팅 환경
│     - 학습 곡선 + 보일러플레이트 트레이드오프
│
└─ 복잡한 탐색, 딥 링킹, 여러 진입점이 필요하신가요?
   └─ Coordinator 패턴 추가 (파트 4)
      - 위의 어떤 패턴과도 결합 가능
      - 뷰에서 탐색 로직 분리
      - NavigationPath + Coordinator 객체

파트 1: Apple 네이티브 패턴 (iOS 26+)

핵심 원칙

"데이터 모델은 데이터와 데이터와 상호작용하는 뷰 사이의 분리를 제공합니다. 이러한 분리는 모듈성을 촉진하고, 테스트 용이성을 향상시키며, 앱이 어떻게 작동하는지 추론하기 쉽게 만듭니다." — Apple 개발자 문서

Apple의 현대적인 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)  // ⚠️ 애니메이션 타이밍 불확실
    }
}

해결책: 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 자체의 STATE가 되어야 하나요?
│  └─ 예 → @State 사용
│     예시: 폼 입력, 로컬 토글, 시트 표시
│     수명: 뷰의 수명에 의해 관리됨
│
├─ 이 모델이 GLOBAL ENVIRONMENT의 일부가 되어야 하나요?
│  └─ 예 → @Environment 사용
│     예시: 사용자 계정, 앱 설정, 의존성 주입
│     수명: 앱/씬 레벨에서 유지
│
├─ 이 모델이 BINDINGS만 필요하나요?
│  └─ 예 → @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: God 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 (Composable Architecture)

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

// VIEW — Store를 통해 액션 전송
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("사실 가져오기") { store.send(.factButtonTapped) }
                .disabled(store.isLoading)
        }
    }
}

State, Action, Reducer, Store만 기억하세요

구성 요소설명예시
State기능에 필요한 데이터count, fact, isLoading
Action기능이 처리하는 모든 이벤트버튼 탭, 네트워크 응답
Reducer액션에 응답하여 상태를 진화시키는 순수 함수비즈니스 로직, 부수 효과
StoreReducer를 실행하는 런타임 (주입된 의존성 포함)뷰와 테스트 모두에서 실행

의존성 관리

TCA는 의존성을 명시적으로 관리하여 테스트를 쉽게 만듭니다:

// 의존성 등록
struct NumberFactClient {
    var fetch: @Sendable (Int) async throws -> String
}

extension NumberFactClient: DependencyKey {
    static let liveValue = Self(
        fetch: { number in
            let url = URL(string: "http://numbersapi.com/\(number)")!
            let (data, _) = try await URLSession.shared.data(from: url)
            return String(decoding: data, as: UTF8.self)
        }
    )
}

// Reducer에서 사용
@Dependency(\.numberFact) var numberFact

// 테스트에서 재정의
let store = TestStore(initialState: CounterFeature.State()) {
    CounterFeature()
} withDependencies: {
    $0.numberFact.fetch = { _ in "0은 숫자입니다" }
}

TCA 대 Apple 네이티브 패턴

측면Apple 네이티브TCA
보일러플레이트최소더 많음 (Action, Reducer, Store)
테스트 용이성수동 설정기본 제공 (TestStore)
학습 곡선낮음중간-높음
팀 일관성느슨함엄격함
부수 효과수동 관리구조화됨, 취소 가능
의존성주입 패턴선언적, 검증 가능
적합한 앱 규모소규모-중간중간-대규모

파트 4: Coordinator 패턴

Coordinator를 사용할 때

Coordinator는 앱이 다음과 같은 경우 특히 유용합니다:

✅ 복잡한 탐색 — 깊게 중첩된 뷰 계층 ✅ 딥 링킹 — 특정 기능으로의 외부 URL 처리 ✅ 멀티 윈도우/씬 — 여러 진입점 ✅ 조건부 온보딩 — 사용자 상태에 따른 흐름 ✅ 탐색 테스트 — 뷰에서 탐색 로직 분리

기본 Coordinator

// Coordinator가 탐색 상태 관리
@Observable
class AppCoordinator {
    var path = NavigationPath()

    func showDetail(for item: Item) {
        path.append(AppRoute.detail(item))
    }

    func showSettings() {
        path.append(AppRoute.settings)
    }

    func goBack() {
        path.removeLast()
    }
}

어떤 패턴과도 결합

Coordinator는 단일 패턴이 아닌 추가 기능입니다. 위의 모든 패턴과 결합할 수 있습니다.


참고 자료

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

관련 스킬