Communitygithub.com

ComeOnOliver/skillshub

Úsalo al separar la lógica de las vistas de SwiftUI, elegir patrones de arquitectura, refactorizar archivos de vista o preguntar '¿dónde va este código?', '¿cómo organizo mi app SwiftUI?', '¿MVVM vs TCA vs SwiftUI puro?', '¿cómo hago testable mi código SwiftUI?' — Patrones de arquitectura integrales con flujos de trabajo de refactorización para iOS 26+.

¿Qué es skillshub?

Esta skill para agentes de IA (como Claude Code, Cursor, Codex) proporciona una guía completa sobre patrones de arquitectura SwiftUI para iOS 26+. Está diseñada para desarrolladores que buscan separar la lógica de las vistas, elegir entre arquitecturas como MVVM, TCA o los patrones nativos de Apple, y mejorar la testabilidad de su código. La skill cubre desde la toma de decisiones arquitectónicas hasta la implementación de patrones específicos, incluyendo el patrón 'State-as-Bridge', el árbol de decisión para property wrappers, y flujos de trabajo de refactorización. También incluye ejemplos de código y antipatrones para evitar errores comunes. Es útil tanto para proyectos nuevos como para refactorizar bases de código existentes.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Arquitectura SwiftUI

Cuándo Usar Esta Skill

Usa esta skill cuando:

  • Tienes lógica en tus archivos de vista SwiftUI y quieres extraerla
  • Estás eligiendo entre MVVM, TCA, los patrones nativos de SwiftUI o Coordinator
  • Refactorizas vistas para separar responsabilidades
  • Quieres hacer que el código SwiftUI sea testable
  • Te preguntas "¿dónde debería ir este código?"
  • Decides qué property wrapper usar (@State, @Environment, @Bindable)
  • Organizas una base de código SwiftUI para desarrollo en equipo

Ejemplos de Prompt

Lo Que Podrías PreguntarPor Qué Esta Skill Ayuda
"Hay bastante código en mis archivos de vista sobre cosas de lógica. ¿Cómo lo extraigo?"Proporciona un flujo de trabajo de refactorización con árboles de decisión sobre dónde pertenece la lógica
"¿Debería usar MVVM, TCA o los patrones nativos de Apple?"Criterios de decisión basados en la complejidad de la app, tamaño del equipo, necesidades de testabilidad
"¿Cómo hago testable mi código SwiftUI?"Muestra patrones de separación que permiten pruebas sin importar SwiftUI
"¿Dónde deberían ir los formateadores y cálculos?"La sección de antipatrones previene la lógica en los cuerpos de las vistas
"¿Qué property wrapper uso?"Árbol de decisión para @State, @Environment, @Bindable o propiedades simples

Árbol de Decisión de Arquitectura Rápido

¿Qué impulsa tu elección de arquitectura?
│
├─ ¿Empiezas desde cero, app pequeña/mediana, quieres los patrones de Apple?
│  └─ Usa los Patrones Nativos de Apple (Parte 1)
│     - Modelos @Observable para la lógica de negocio
│     - State-as-Bridge para límites asíncronos
│     - Árbol de decisión de property wrappers
│
├─ ¿Estás familiarizado con MVVM de UIKit?
│  └─ Usa el Patrón MVVM (Parte 2)
│     - ViewModels como adaptadores de presentación
│     - Separación clara Vista/ViewModel/Modelo
│     - Funciona bien con @Observable
│
├─ ¿App compleja, necesitas testabilidad rigurosa, consistencia en el equipo?
│  └─ Considera TCA (Parte 3)
│     - Arquitectura Estado/Acción/Reducer/Store
│     - Excelente soporte para pruebas
│     - Compensación: curva de aprendizaje + boilerplate
│
└─ ¿Navegación compleja, deep linking, múltiples puntos de entrada?
   └─ Añade el Patrón Coordinator (Parte 4)
      - Se puede combinar con cualquiera de los anteriores
      - Extrae la lógica de navegación de las vistas
      - NavigationPath + objetos Coordinator

Parte 1: Patrones Nativos de Apple (iOS 26+)

Principio Central

"Un modelo de datos proporciona separación entre los datos y las vistas que interactúan con los datos. Esta separación promueve la modularidad, mejora la testabilidad y ayuda a razonar más fácilmente sobre cómo funciona la app." — Documentación para Desarrolladores de Apple

Los patrones modernos de SwiftUI de Apple (WWDC 2023-2025) se centran en:

  1. @Observable para modelos de datos (reemplaza ObservableObject)
  2. State-as-Bridge para límites asíncronos (WWDC 2025)
  3. Tres property wrappers: @State, @Environment, @Bindable
  4. Actualizaciones de UI síncronas para animaciones

El Patrón State-as-Bridge

Problema

Las funciones asíncronas crean puntos de suspensión que pueden romper las animaciones:

// ❌ Problemático: La animación podría perder el plazo del frame
struct ColorExtractorView: View {
    @State private var isLoading = false

    var body: some View {
        Button("Extraer Colores") {
            Task {
                isLoading = true  // Síncrono ✅
                await extractColors()  // ⚠️ ¡Punto de suspensión!
                isLoading = false  // ❌ Podría ocurrir demasiado tarde
            }
        }
        .scaleEffect(isLoading ? 1.5 : 1.0)  // ⚠️ Tiempo de animación incierto
    }
}

Solución: Usa State como un Puente

"Encuentra los límites entre el código de UI que requiere cambios sensibles al tiempo y la lógica asíncrona de larga duración."

// ✅ Correcto: State une la UI y el código asíncrono
@Observable
class ColorExtractor {
    var isLoading = false
    var colors: [Color] = []

    func extract(from image: UIImage) async {
        // Este método es asíncrono y puede vivir en el modelo
        let extracted = await heavyComputation(image)
        // Mutación síncrona para la actualización de UI
        self.colors = extracted
    }
}

struct ColorExtractorView: View {
    let extractor: ColorExtractor

    var body: some View {
        Button("Extraer Colores") {
            // Cambio de estado síncrono para la animación
            withAnimation {
                extractor.isLoading = true
            }

            // Inicia el trabajo asíncrono
            Task {
                await extractor.extract(from: currentImage)

                // Cambio de estado síncrono para la animación
                withAnimation {
                    extractor.isLoading = false
                }
            }
        }
        .scaleEffect(extractor.isLoading ? 1.5 : 1.0)
    }
}

Beneficios:

  • La lógica de UI permanece síncrona (las animaciones funcionan correctamente)
  • El código asíncrono vive en el modelo (testable sin SwiftUI)
  • Límite claro entre UI sensible al tiempo y trabajo de larga duración

Árbol de Decisión de Property Wrappers

Solo hay 3 preguntas que responder:

¿Qué property wrapper debería usar?
│
├─ ¿Este modelo necesita ser ESTADO DE LA VISTA MISMA?
│  └─ SÍ → Usa @State
│     Ejemplos: Entradas de formulario, interruptores locales, presentaciones de hojas
│     Ciclo de vida: Gestionado por el ciclo de vida de la vista
│
├─ ¿Este modelo necesita ser parte del ENTORNO GLOBAL?
│  └─ SÍ → Usa @Environment
│     Ejemplos: Cuenta de usuario, configuración de la app, inyección de dependencias
│     Ciclo de vida: Vive a nivel de app/escena
│
├─ ¿Este modelo SOLO NECESITA BINDINGS?
│  └─ SÍ → Usa @Bindable
│     Ejemplos: Editar un modelo pasado desde el padre
│     Ligero: Solo habilita la sintaxis $ para bindings
│
└─ ¿NINGUNO DE LOS ANTERIORES?
   └─ Úsalo como propiedad simple
      Ejemplos: Datos inmutables, modelos propiedad del padre
      Sin wrapper necesario: @Observable maneja la observación

Ejemplos

// ✅ @State — La vista es dueña del modelo
struct DonutEditor: View {
    @State private var donutToAdd = Donut()  // Estado propio de la vista

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

// ✅ @Environment — Modelo de toda la app
struct MenuView: View {
    @Environment(Account.self) private var account  // Global

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

// ✅ @Bindable — Necesitas bindings a un modelo propiedad del padre
struct DonutRow: View {
    @Bindable var donut: Donut  // El padre es dueño

    var body: some View {
        TextField("Nombre", text: $donut.name)  // Necesita binding
    }
}

// ✅ Propiedad simple — Solo lectura
struct DonutRow: View {
    let donut: Donut  // El padre es dueño, no se necesita binding

    var body: some View {
        Text(donut.name)  // Solo lectura
    }
}

Patrón de Modelo @Observable

Usa @Observable para la lógica de negocio que necesita activar actualizaciones de UI:

// ✅ Modelo de dominio con lógica de negocio
@Observable
class FoodTruckModel {
    var orders: [Order] = []
    var donuts = Donut.all

    var orderCount: Int {
        orders.count  // Las propiedades computadas funcionan automáticamente
    }

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

// ✅ La vista rastrea automáticamente las propiedades accedidas
struct DonutMenu: View {
    let model: FoodTruckModel  // ¡No se necesita wrapper!

    var body: some View {
        List {
            Section("Donas") {
                ForEach(model.donuts) { donut in
                    Text(donut.name)  // Rastrea model.donuts
                }
                Button("Añadir") {
                    model.addDonut()
                }
            }
            Section("Pedidos") {
                Text("Conteo: \(model.orderCount)")  // Rastrea model.orders
            }
        }
    }
}

Cómo funciona (WWDC 2023/10149):

  • SwiftUI rastrea qué propiedades se acceden durante la ejecución de body
  • Solo esas propiedades activan actualizaciones de vista cuando cambian
  • Seguimiento de dependencias granular = mejor rendimiento

Patrón de Adaptador ViewModel

Usa ViewModels como adaptadores de presentación cuando necesites filtrado, ordenamiento o lógica específica de vista:

// ✅ ViewModel como adaptador de presentación
@Observable
class PetStoreViewModel {
    let petStore: PetStore  // Modelo de dominio
    var searchText: String = ""

    // Propiedad computada específica de vista
    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)
    }
}

Cuándo usar un adaptador ViewModel:

  • Filtrar, ordenar, agrupar para mostrar
  • Formatear para presentación (pero NO cálculos pesados)
  • Estado específico de vista que no pertenece al modelo de dominio
  • Unir el modelo de dominio con las convenciones de SwiftUI

Cuándo NO usar un ViewModel:

  • Vistas simples que solo muestran datos del modelo
  • Lógica que pertenece al modelo de dominio
  • Sobre-extracción solo por "pureza del patrón"

Parte 2: Patrón MVVM

Cuándo Usar MVVM

MVVM (Modelo-Vista-ViewModel) es apropiado cuando:

✅ Estás familiarizado con él de UIKit — Incorporación más fácil para el equipo ✅ Quieres una separación explícita Vista/ViewModel — Contratos claros ✅ Tienes lógica de presentación compleja — Múltiples operaciones de filtrado/ordenamiento ✅ Estás migrando desde UIKit — Modelo mental familiar

❌ Evita MVVM cuando:

  • Las vistas son simples (solo muestran datos)
  • Empiezas desde cero con SwiftUI (los patrones de Apple son más simples)
  • Estás creando capas de abstracción innecesarias

Estructura MVVM para SwiftUI

// Modelo — Datos de dominio y lógica de negocio
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 — Lógica de presentación
@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)
    }
}

// Vista — Solo 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)
    }
}

Errores Comunes de MVVM en SwiftUI

❌ Error 1: Duplicar @Observable en Vista y ViewModel

// ❌ @State + @Observable es redundante — @State crea su propio almacenamiento
struct MyView: View {
    @State private var viewModel = MyViewModel()  // ❌ Wrapper redundante
}

// ✅ Pasa @Observable directamente — usa @State solo si la vista es DUEÑA del ciclo de vida
struct MyView: View {
    let viewModel: MyViewModel  // ✅ O @State si la vista lo crea
}

❌ Error 2: ViewModel Dios

// ❌ No hagas esto
@Observable
class AppViewModel {
    // Configuración
    var isDarkMode = false
    var notificationsEnabled = true

    // Usuario
    var userName = ""
    var userEmail = ""

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

    // ... 50 propiedades más
}
// ✅ Correcto: Separa responsabilidades
@Observable
class SettingsViewModel {
    var isDarkMode = false
    var notificationsEnabled = true
}

@Observable
class UserProfileViewModel {
    var user: User
}

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

❌ Error 3: Lógica de Negocio en el ViewModel

// ❌ Las reglas de negocio pertenecen al Modelo, no al ViewModel
@Observable class OrderViewModel {
    func calculateDiscount(for order: Order) -> Double { /* ... */ }  // ❌ Lógica de negocio
}

// ✅ El Modelo es dueño de la lógica de negocio; el ViewModel solo formatea para mostrar
struct Order {
    func calculateDiscount() -> Double { /* reglas de negocio */ }
}
@Observable class OrderViewModel {
    let order: Order
    var displayDiscount: String {
        "$\(order.calculateDiscount(), specifier: \"%.2f\")"  // ✅ Solo formateo
    }
}

Parte 3: TCA (Arquitectura Componible)

Cuándo Considerar TCA

TCA es una arquitectura de terceros de Point-Free. Considérelo cuando:

✅ La testabilidad rigurosa es crítica — TestStore hace que las pruebas sean deterministas ✅ Un equipo grande necesita consistencia — Patrones estrictos reducen la variación ✅ Manejo de estado complejo — Efectos secundarios, dependencias, composición ✅ Valoras los patrones tipo Redux — Flujo de datos unidireccional

❌ Evita TCA cuando:

  • App pequeña o prototipo (demasiada sobrecarga)
  • El equipo no está familiarizado con la programación funcional
  • Necesitas iteración rápida (el boilerplate ralentiza el desarrollo)
  • Quieres dependencias mínimas

Conceptos Centrales de TCA

TCA tiene 4 bloques de construcción — Estado (datos), Acción (eventos), Reducer (evolución del estado) y Store (motor de ejecución). Aquí están en una sola característica:

// ESTADO — Datos que tu característica necesita
@ObservableState
struct CounterFeature {
    var count = 0
    var fact: String?
    var isLoading = false
}

// ACCIÓN — Todos los eventos posibles
enum Action {
    case incrementButtonTapped
    case decrementButtonTapped
    case factButtonTapped
    case factResponse(String)
}

// REDUCER — Cómo evoluciona el estado en respuesta a las acciones
struct CounterFeature: Reducer {
    @Dependency(\.continuousClock) var clock
    @Dependency(\.factClient) var factClient

    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 { [count = state.count] send in
                    let fact = try await factClient.fetch(count)
                    await send(.factResponse(fact))
                }

            case let .factResponse(fact):
                state.isLoading = false
                state.fact = fact
                return .none
            }
        }
    }
}

// VISTA — Solo observa el estado y envía acciones
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("Obtener Dato") { store.send(.factButtonTapped) }
            if let fact = store.fact {
                Text(fact)
            }
        }
        .disabled(store.isLoading)
    }
}

El Patrón Store

TCA's Store es el único lugar que ejecuta eventos:

struct App: View {
    let store = Store(initialState: CounterFeature()) {
        CounterFeature()
    }

    var body: some View {
        CounterView(store: store)
    }
}

Cuándo Usar Efectos (y Cuándo No)

Usa efectos para:

  • Llamadas a API
  • Timers, suscripciones a notificaciones
  • Persistencia
  • Cualquier cosa async fuera del reducer

No uses efectos para:

  • Sincronizar múltiples stores (usa @Presents o composición)
  • Lógica de UI (gestos, animaciones — mantén en la vista)

Parte 4: Patrón Coordinator

Cuándo Usar un Coordinator

Usa un Coordinator cuando:

✅ Navegación compleja — Múltiples pantallas, flujos profundos ✅ Deep linking — Enlaces que necesitan construir una pila de navegación ✅ Múltiples puntos de entrada — Diferentes formas de llegar a la misma pantalla ✅ Pruebas — Quieres probar la lógica de navegación sin renderizar vistas

NO uses un Coordinator cuando:

  • Tienes 2-3 pantallas con navegación push simple
  • Navegación basada en pestañas plana
  • Prototipos o apps pequeñas

Coordinator con NavigationStack

// Coordinator gestiona la navegación
@Observable
class AppCoordinator {
    var path = NavigationPath()

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

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

    func handleDeepLink(_ url: URL) {
        // Lógica de deep linking centralizada
        switch parseDeepLink(url) {
        case .item(let id):
            path = NavigationPath()  // Reinicia
            path.append(DetailDestination.item(Item(id: id)))
        case .profile:
            path.append(ModalDestination.profile)
        }
    }
}

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

    var body: some View {
        NavigationStack(path: $coordinator.path) {
            HomeView(coordinator: coordinator)
                .navigationDestination(for: DetailDestination.self) { dest in
                    switch dest {
                    case .item(let item): ItemDetailView(item: item)
                    }
                }
                .sheet(item: $coordinator.modalDestination) { dest in
                    switch dest {
                    case .settings: SettingsView()
                    case .profile: ProfileView()
                    }
                }
        }
    }
}

Coordinator con Enumeraciones de Destino

// Enumera todos los destinos de navegación
enum DetailDestination: Hashable {
    case item(Item)
    case list([Item])
}

enum ModalDestination: Identifiable {
    case settings
    case profile

    var id: String { "\(self)" }
}

Beneficios Clave de los Coordinators

  • Navegación centralizada — No dispersa en las vistas
  • Deep linking — Un lugar para analizar y manejar
  • Pruebas — Prueba la lógica de navegación sin SwiftUI
  • Reutilización — Cambia la navegación sin cambios en las vistas

Refactorización: Dónde Poner la Lógica

Árbol de Decisión de Colocación de Código

¿Dónde debería ir este código?
│
├─ ¿Es un cálculo o transformación de datos?
│  ├─ Sí, reglas de negocio → Modelo (@Observable)
│  └─ Sí, formato de presentación → ViewModel (si existe)
│
├─ ¿Maneja eventos de UI o navegación?
│  ├─ Gestos/animaciones → Vista (body o modifiers)
│  └─ Lógica de navegación → Coordinator
│
├─ ¿Requiere trabajo asíncrono?
│  ├─ Con actualizaciones de UI sensibles al tiempo → State-as-Bridge
│  └─ Sin sensibilidad al tiempo → Modelo (@Observable)
│
└─ ¿Es estado efímero de la vista?
   └─ @State directamente en la vista

Antipatrón: Lógica en el Cuerpo de la Vista

// ❌ Antipatrón: Cálculos pesados en el cuerpo de la vista
struct OrderSummary: View {
    let orders: [Order]

    var body: some View {
        let total = orders.reduce(0) { $0 + $1.total }  // ❌ Cálculo en el cuerpo
        let discount = orders.count > 5 ? 0.1 : 0.0  // ❌ Reglas de negocio
        let final = total * (1 - discount)  // ❌ Lógica de presentación

        Text("Total: $\(final, specifier: \"%.2f\")")
    }
}
// ✅ Correcto: Lógica extraída
@Observable
class OrderService {
    func calculateTotal(for orders: [Order]) -> Double {
        // Reglas de negocio y cálculos
    }
}

struct OrderSummary: View {
    let orders: [Order]
    let orderService: OrderService

    var body: some View {
        let total = orderService.calculateTotal(for: orders)
        Text("Total: $\(total, specifier: \"%.2f\")")
    }
}

Modificadores y Sub-vistas

Para lógica específica de UI que es demasiado compleja para el cuerpo:

// Extrae lógica compleja de UI en un modificador
struct ListStyleModifier: ViewModifier {
    @Environment(\.horizontalSizeClass) var sizeClass

    func body(content: Content) -> some View {
        content
            .listStyle(sizeClass == .regular ? .insetGrouped : .plain)
            .scrollContentBackground(.hidden)
    }
}

extension View {
    func adaptiveListStyle() -> some View {
        modifier(ListStyleModifier())
    }
}

Plantilla de Refactorización

Al refactorizar una vista, sigue estos pasos:

  1. Identifica la lógica que no es de UI — Cálculos, transformaciones, llamadas de red
  2. Clasifícala — ¿Regla de negocio, formato de presentación o estado de vista?
  3. Extráela — Al modelo apropiado, ViewModel o modificador
  4. Agrega pruebas — La lógica extraída ahora es fácil de probar
  5. Actualiza la vista — Solo UI y delegación

Laboratorio de Arquitectura SwiftUI

¿Qué es esto?

Esta es una práctica guiada para aplicar los patrones de arquitectura que has aprendido. Cada sección te guía en la refactorización o construcción de una característica específica.

Laboratorio 1: Refactorizar una Vista con Lógica Mezclada

Característica: Una vista de perfil de usuario que actualmente mezcla lógica de negocios, formato y UI.

// Código de inicio: Todo mezclado
struct ProfileView: View {
    let user: User
    @State private var isFollowing = false

    var body: some View {
        VStack {
            // Lógica de negocios
            let isPremium = user.purchaseHistory.total > 100 &&
                            user.subscriptionStatus == .active

            // Formato
            let joinedDate = user.joinDate.formatted(date: .long, time: .omitted)
            let initials = user.name.components(separatedBy: " ")
                .compactMap(\.first)
                .map(String.init)
                .joined()

            // UI
            Text(initials)
                .font(.largeTitle)
            Text(user.name)
            Text("Miembro desde: \(joinedDate)")
            if isPremium {
                BadgeView("Premium")
            }
            Button(isFollowing ? "Siguiendo" : "Seguir") {
                isFollowing.toggle()
            }
        }
    }
}

Tu Tarea

Refactoriza ProfileView siguiendo estos pasos:

  1. Extrae la lógica de negocios (isPremium) a un modelo
  2. Extrae el formato a un ViewModel o computada
  3. Mantén solo UI en la vista

Solución

// Modelo
@Observable
class UserProfile {
    let user: User
    var isFollowing = false

    var isPremium: Bool {
        user.purchaseHistory.total > 100 &&
        user.subscriptionStatus == .active
    }

    var formattedJoinDate: String {
        user.joinDate.formatted(date: .long, time: .omitted)
    }

    var initials: String {
        user.name.components(separatedBy: " ")
            .compactMap(\.first)
            .map(String.init)
            .joined()
    }
}

// Vista — Solo UI
struct ProfileView: View {
    @Bindable var profile: UserProfile

    var body: some View {
        VStack {
            Text(profile.initials)
                .font(.largeTitle)
            Text(profile.user.name)
            Text("Miembro desde: \(profile.formattedJoinDate)")
            if profile.isPremium {
                BadgeView("Premium")
            }
            Button(profile.isFollowing ? "Siguiendo" : "Seguir") {
                profile.isFollowing.toggle()
            }
        }
    }
}

Trabajo Futuro

Esta skill es mantenida activamente. El trabajo futuro incluye:

  • Agregar más laboratorios prácticos de refactorización
  • Cubrir arquitectura de pruebas (Unit, Swift Testing, XCTest)
  • Incluir más guías de PartyKit/CloudKit
  • Agregar patrones de manejo de errores
  • Cubrir estrategias de migración de UIKit a SwiftUI

Más Información

Para más información, contacta al mantenedor o consulta el README del proyecto.

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 relacionados