Communitygithub.com

ComeOnOliver/skillshub

Úsalo al escribir pruebas de UI, grabar interacciones, cuando las pruebas tienen condiciones de carrera, dependencias de tiempo, comportamiento inconsistente de aprobación/fallo, o las pruebas XCTest de UI son inestables. Cubre la grabación de automatización de UI (WWDC 2025), espera basada en condiciones, condicionamiento de red, pruebas multifactor, depuración de fallos y patrones de prueba centrados en accesibilidad.

¿Qué es skillshub?

Este skill proporciona una guía completa para escribir pruebas de UI robustas y fiables en el ecosistema de Apple (iOS, iPadOS, macOS, watchOS, tvOS y visionOS). Su principio fundamental es reemplazar los `sleep()` y tiempos de espera arbitrarios por una espera basada en condiciones, utilizando técnicas como `waitForExistence()`, `XCTestExpectation` y predicados. Esto elimina las condiciones de carrera y las pruebas inestables (flaky tests) que varían entre entornos de desarrollo local y CI. Además, cubre en detalle la nueva funcionalidad de grabación de automatización de UI presentada en WWDC 2025 y Xcode 26, que permite grabar interacciones, reproducirlas en múltiples dispositivos e idiomas, y revisar grabaciones de vídeo de las ejecuciones. El skill también enfatiza la importancia de la accesibilidad como base, ofreciendo patrones para usar identificadores de accesibilidad en lugar de etiquetas textuales para crear pruebas robustas y localizables.

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

Preguntar en tu IA favorita

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

Documentación

Pruebas de UI

Descripción general

Espera condiciones, no tiempos de espera arbitrarios. Principio fundamental Las pruebas inestables provienen de adivinar cuánto tiempo tardan las operaciones. La espera basada en condiciones elimina las condiciones de carrera.

NUEVO en WWDC 2025: La grabación de automatización de UI te permite grabar interacciones, reproducirlas en diferentes dispositivos/idiomas y revisar grabaciones de vídeo de las ejecuciones de las pruebas.

Ejemplos de Prompts

Estas son preguntas reales que los desarrolladores hacen y para las que este skill está diseñado:

1. "Mis pruebas de UI pasan localmente en mi Mac pero fallan en CI. ¿Cómo las hago más fiables?"

→ El skill muestra patrones de espera basada en condiciones que funcionan en diferentes dispositivos/velocidades, eliminando las diferencias de temporización en CI.

2. "Mis pruebas usan sleep(2) y sleep(5) pero siguen siendo inestables. ¿Cómo reemplazo los tiempos de espera arbitrarios con condiciones reales?"

→ El skill demuestra patrones de waitForExistence, XCTestExpectation y sondeo (polling) para cargas de datos, solicitudes de red y animaciones.

3. "Acabo de grabar una prueba usando la grabación de automatización de UI de Xcode 26. ¿Cómo reviso el vídeo y depuro los fallos?"

→ El skill cubre los flujos de trabajo de depuración por vídeo para analizar las grabaciones y encontrar el paso exacto donde fallan las pruebas.

4. "Mi prueba falla en iPad pero pasa en iPhone. ¿Cómo escribo pruebas que funcionen en todos los tamaños de dispositivo?"

→ El skill explica estrategias de pruebas multifactor y predicados independientes del dispositivo para pruebas robustas entre dispositivos.

5. "Quiero escribir pruebas que no sean inestables. ¿Cuáles son los patrones críticos que necesito conocer?"

→ El skill proporciona plantillas de espera basada en condiciones, patrones centrados en accesibilidad y el árbol de decisiones para una arquitectura de pruebas fiable.


Señales de Alerta — Problemas de Fiabilidad en Pruebas

Si ves ALGUNA de estas, sospecha problemas de temporización:

  • Las pruebas pasan localmente, fallan en CI (diferencias de temporización)
  • Las pruebas a veces pasan, a veces fallan (condiciones de carrera)
  • Las pruebas usan sleep() o Thread.sleep() (retrasos arbitrarios)
  • Las pruebas fallan con "Elemento de UI no encontrado" y luego pasan al reintentar
  • Ejecuciones de pruebas largas (esperando los peores escenarios)

Árbol de Decisiones Rápido

¿La prueba falla?
├─ ¿Elemento no encontrado?
│  └─ Usa waitForExistence(timeout:) no sleep()
├─ ¿Pasa localmente, falla en CI?
│  └─ Reemplaza sleep() con sondeo de condiciones
├─ ¿La animación causa problemas?
│  └─ Espera a que la animación termine, no la deshabilites
└─ ¿Temporización de solicitud de red?
   └─ Usa XCTestExpectation o waitForExistence

Patrón Principal: Espera Basada en Condiciones

❌ INCORRECTO (Tiempo de Espera Arbitrario):

func testButtonAppears() {
    app.buttons["Login"].tap()
    sleep(2)  // ❌ Adivinando que tarda 2 segundos
    XCTAssertTrue(app.buttons["Dashboard"].exists)
}

✅ CORRECTO (Esperar una Condición):

func testButtonAppears() {
    app.buttons["Login"].tap()
    let dashboard = app.buttons["Dashboard"]
    XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}

Patrones Comunes de Pruebas de UI

Patrón 1: Esperar Elementos

// Esperar a que un elemento aparezca
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    return element.waitForExistence(timeout: timeout)
}

// Uso
XCTAssertTrue(waitForElement(app.buttons["Submit"]))

Patrón 2: Esperar que un Elemento Desaparezca

func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "exists == false")
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Uso
XCTAssertTrue(waitForElementToDisappear(app.activityIndicators["Loading"]))

Patrón 3: Esperar un Estado Específico

func waitForButton(_ button: XCUIElement, toBeEnabled enabled: Bool, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "isEnabled == %@", NSNumber(value: enabled))
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: button)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Uso
let submitButton = app.buttons["Submit"]
XCTAssertTrue(waitForButton(submitButton, toBeEnabled: true))
submitButton.tap()

Patrón 4: Identificadores de Accesibilidad

Establecer en la app:

Button("Enviar") {
    // acción
}
.accessibilityIdentifier("submitButton")

Usar en pruebas:

func testSubmitButton() {
    let submitButton = app.buttons["submitButton"]  // Usa el identificador, no la etiqueta
    XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
    submitButton.tap()
}

Por qué: Los identificadores de accesibilidad no cambian con la localización y se mantienen estables ante actualizaciones de la UI.

Patrón 5: Retrasos por Solicitudes de Red

func testDataLoads() {
    app.buttons["Refresh"].tap()

    // Esperar a que el indicador de carga desaparezca
    let loadingIndicator = app.activityIndicators["Loading"]
    XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))

    // Ahora verificar que los datos se cargaron
    XCTAssertTrue(app.cells.count > 0)
}

Patrón 6: Manejo de Animaciones

func testAnimatedTransition() {
    app.buttons["Next"].tap()

    // Esperar a que la vista de destino aparezca
    let destinationView = app.otherElements["DestinationView"]
    XCTAssertTrue(destinationView.waitForExistence(timeout: 2))

    // Opcional: Esperar un poco más para que la animación se asiente
    // Solo si es absolutamente necesario
    RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}

Lista de Verificación para Pruebas

Antes de Escribir Pruebas

  • Usa identificadores de accesibilidad para todos los elementos interactivos
  • Evita etiquetas codificadas (usa identificadores en su lugar)
  • Planifica los retrasos de red y las animaciones
  • Elige tiempos de espera apropiados (2s UI, 10s red)

Al Escribir Pruebas

  • Usa waitForExistence() no sleep()
  • Usa predicados para condiciones complejas
  • Prueba tanto caminos de éxito como de fallo
  • Haz las pruebas independientes (pueden ejecutarse en cualquier orden)

Después de Escribir Pruebas

  • Ejecuta las pruebas 10 veces localmente (detecta inestabilidad)
  • Ejecuta las pruebas en el dispositivo soportado más lento
  • Ejecuta las pruebas en el entorno de CI
  • Revisa la duración de la prueba (si >30s por prueba, optimiza)

Consejos para Pruebas de UI en Xcode

Argumentos de Lanzamiento para Pruebas

func testExample() {
    let app = XCUIApplication()
    app.launchArguments = ["UI-Testing"]
    app.launch()
}

En el código de la app:

if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
    // Usar datos simulados, omitir onboarding, etc.
}

Ejecución de Pruebas Más Rápida

override func setUpWithError() throws {
    continueAfterFailure = false  // Detenerse en el primer fallo
}

Depuración de Pruebas Fallidas

func testExample() {
    // Tomar captura de pantalla al fallar
    addUIInterruptionMonitor(withDescription: "Alerta") { alert in
        alert.buttons["OK"].tap()
        return true
    }

    // Imprimir la jerarquía de elementos
    print(app.debugDescription)
}

Errores Comunes

❌ Usar sleep() para Todo

sleep(5)  // ❌ Pierde tiempo si la operación se completa en 1s

❌ No Manejar Animaciones

app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists)  // ❌ Puede fallar durante la animación

❌ Etiquetas de Texto Codificadas

app.buttons["Submit"].tap()  // ❌ Se rompe con la localización

❌ Pruebas Dependientes Entre Sí

// ❌ La prueba 2 asume que la prueba 1 se ejecutó primero
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* asume que ha iniciado sesión */ }

❌ Sin Estrategia de Tiempo de Espera

element.waitForExistence(timeout: 100)  // ❌ Demasiado largo
element.waitForExistence(timeout: 0.1)  // ❌ Demasiado corto

Usa tiempos de espera apropiados:

  • Animaciones de UI: 2-3 segundos
  • Solicitudes de red: 10 segundos
  • Operaciones complejas: 30 segundos como máximo

Impacto en el Mundo Real

Antes (usando sleep()):

  • Suite de pruebas: 15 minutos (esperando el peor caso)
  • Pruebas inestables: 20% de tasa de fallo
  • Fallos en CI: 50% requieren reintento

Después (espera basada en condiciones):

  • Suite de pruebas: 5 minutos (espera solo cuando es necesario)
  • Pruebas inestables: <2% de tasa de fallo
  • Fallos en CI: <5% requieren reintento

Conclusión clave Las pruebas terminan más rápido Y son más fiables cuando se esperan condiciones reales en lugar de adivinar tiempos.


Grabación de Automatización de UI

Descripción General

NUEVO en Xcode 26: Graba, reproduce y revisa pruebas de automatización de UI con grabaciones de vídeo.

Tres Fases:

  1. Grabar — Captura interacciones (toques, deslizamientos, pulsaciones de botones de hardware) como código Swift
  2. Reproducir — Ejecutar en múltiples dispositivos, idiomas, regiones, orientaciones
  3. Revisar — Ver grabaciones de vídeo, analizar fallos, ver superposiciones de elementos de UI

Plataformas Soportadas: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Diseñado para iPad)

Cómo Funciona la Automatización de UI

Principios Clave:

  • La automatización de UI interactúa con tu app como lo haría una persona usando gestos y eventos de hardware
  • Se ejecuta completamente independiente de tu app (los modelos/datos de la app no son directamente accesibles)
  • Utiliza el marco de accesibilidad como tecnología subyacente
  • Le dice al SO qué gestos realizar, luego espera a que se completen de forma síncrona, uno a la vez

Las acciones incluyen:

  • Lanzar tu app
  • Interactuar con botones y navegación
  • Establecer el estado del sistema (Modo Oscuro, axiom-localization, etc.)
  • Establecer una ubicación simulada

La Accesibilidad es la Base

Comprensión Crítica: La accesibilidad proporciona información directamente a la automatización de UI.

Lo que la accesibilidad ve:

  • Tipos de elementos (botón, texto, imagen, etc.)
  • Etiquetas (texto visible)
  • Valores (estado actual para casillas de verificación, etc.)
  • Marcos (posiciones de los elementos)
  • Identificadores (identificadores de accesibilidad — NO localizados)

Mejor Práctica: Una gran experiencia de accesibilidad = una gran experiencia de automatización de UI.

Preparando tu App para la Grabación

Paso 1: Agregar Identificadores de Accesibilidad

SwiftUI:

Button("Enviar") {
    // acción
}
.accessibilityIdentifier("submitButton")

// Haz los identificadores específicos para cada instancia
List(landmarks) { landmark in
    LandmarkRow(landmark)
        .accessibilityIdentifier("landmark-\(landmark.id)")
}

UIKit:

let button = UIButton()
button.accessibilityIdentifier = "submitButton"

// Usa índice para celdas de tabla
cell.accessibilityIdentifier = "cell-\(indexPath.row)"

Los buenos identificadores son:

  • ✅ Únicos dentro de toda la app
  • ✅ Descriptivos del contenido del elemento
  • ✅ Estáticos (no reaccionan a cambios de contenido)
  • ✅ No localizados (iguales en todos los idiomas)

Por qué importan los identificadores:

  • Los títulos/descripciones pueden cambiar, los identificadores permanecen estables
  • Funcionan con cadenas localizadas
  • Identifican de forma única elementos con contenido dinámico

Consejo Profesional: Usa el asistente de codificación de Xcode para agregar identificadores:

Prompt: "Agrega identificadores de accesibilidad a las partes relevantes de esta vista"

Paso 2: Revisar la Accesibilidad con Accessibility Inspector

Iniciar Accessibility Inspector:

  • Menú Xcode → Abrir Developer Tool → Accessibility Inspector
  • O: Iniciar desde Spotlight

Características:

  1. Inspector de Elementos — Lista los valores de accesibilidad para cualquier vista
  2. Detalles de la propiedad — Haz clic en el nombre de la propiedad para obtener documentación
  3. Soporte de plataforma — Funciona en todas las plataformas Apple

Qué verificar:

  • Los elementos tienen etiquetas
  • Los elementos interactivos tienen tipos (botón, no solo texto)
  • Los valores están establecidos para elementos con estado (casillas de verificación, conmutadores)
  • Los identificadores están establecidos para elementos con contenido dinámico/localizado

Referencia de Código de Muestra: Ofrecer una experiencia de accesibilidad excepcional

Paso 3: Agregar un Target de Pruebas de UI

  1. Abre la configuración del proyecto en Xcode
  2. Haz clic en "+" debajo de la lista de targets
  3. Selecciona UI Testing Bundle
  4. Haz clic en Finalizar

Resultado: Se agrega una nueva carpeta de pruebas de UI con pruebas de plantilla al proyecto.

Grabando Interacciones

Iniciar una Grabación (Xcode 26)

  1. Abre el archivo fuente de la prueba de UI
  2. Aparece un popover explicando cómo iniciar la grabación (solo la primera vez)
  3. Haz clic en el botón "Start Recording" en el margen del editor
  4. Xcode compila e inicia la app en el Simulador/dispositivo

Durante la Grabación:

  • Interactúa con la app normalmente (toques, deslizamientos, entrada de texto, etc.)
  • El código que representa las interacciones aparece en el editor de código fuente en tiempo real
  • La grabación se actualiza mientras escribes (por ejemplo, entradas en campos de texto)

Detener la Grabación:

  • Haz clic en el botón "Stop Run" en Xcode

Ejemplo de Sesión de Grabación

func testCreateAustralianCollection() {
    let app = XCUIApplication()
    app.launch()

    // Tocar la pestaña "Collections" (grabado automáticamente)
    app.tabBars.buttons["Collections"].tap()

    // Tocar "+" para agregar nueva colección
    app.navigationBars.buttons["Add"].tap()

    // Tocar el botón "Edit"
    app.buttons["Edit"].tap()

    // Escribir nombre de la colección
    app.textFields.firstMatch.tap()
    app.textFields.firstMatch.typeText("Max's Australian Adventure")

    // Tocar "Edit Landmarks"
    app.buttons["Edit Landmarks"].tap()

    // Agregar lugares emblemáticos
    app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
    app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()

    // Tocar la marca de verificación para guardar
    app.navigationBars.buttons["Done"].tap()
}

Revisando el Código Grabado

Después de grabar, revisa y ajusta las consultas:

Múltiples Opciones: Cada línea tiene un menú desplegable que muestra formas alternativas de abordar el elemento.

Recomendaciones de Selección:

  1. Para cadenas localizadas (texto, etiquetas de botones): Elige el identificador de accesibilidad si está disponible
  2. Para vistas profundamente anidadas: Elige la consulta más corta (se mantiene resistente a medida que la app cambia)
  3. Para contenido dinámico (marcas de tiempo, temperatura): Usa una consulta genérica o identificador

Ejemplo:

// Opciones grabadas para un campo de texto:
app.textFields["Collection Name"]              // ❌ Se rompe si la etiqueta se localiza
app.textFields["collectionNameField"]          // ✅ Usa el identificador
app.textFields.element(boundBy: 0)             // ✅ Basado en posición
app.textFields.firstMatch                      // ✅ Genérico, el más corto

Reproduciendo y Verificando Resultados

Requisitos Mínimos: Un destino y esquema que ejecute las pruebas.

Proceso de Reproducción:

  • La automatización de UI reproduce la secuencia completa de acciones grabadas
  • Puedes introducir afirmaciones (assertions) para verificar que el estado del modelo y la UI son correctos
  • Importante: Las reproducciones se limitan a acciones y UI. Las comprobaciones de estado del modelo deben hacerse con afirmaciones

Opciones de Reproducción:

  • Ejecutar en múltiples dispositivos/simuladores: Para verificar la capacidad de respuesta de la UI
  • Cambiar el idioma/región: Para verificar localizaciones
  • Orientación: Para verificar rotaciones

Agregar Afirmaciones

func testCreateAustralianCollection() {
    let app = XCUIApplication()
    app.launch()

    // Interacciones grabadas...
    app.tabBars.buttons["Collections"].tap()
    app.navigationBars.buttons["Add"].tap()
    app.buttons["Edit"].tap()
    app.textFields.firstMatch.tap()
    app.textFields.firstMatch.typeText("Max's Australian Adventure")
    app.buttons["Edit Landmarks"].tap()
    app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
    app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()
    app.navigationBars.buttons["Done"].tap()

    // Afirmación de la UI: Las colecciones deben aparecer
    let collections = app.tables.cells
    let newCollection = collections.staticTexts["Max's Australian Adventure"]
    XCTAssertTrue(newCollection.waitForExistence(timeout: 5))
    XCTAssertEqual(collections.count, 1) // asumiendo que empezó vacío

    // Afirmación del modelo: Verificar datos de la colección
    // Nota: Usar APIs del modelo directamente, no a través de UI
    let collection = Collection(name: "Max's Australian Adventure")
    // Asume que la app tiene una API para obtener la colección (setup de prueba necesario)
    // XCTAssertEqual(collection.landmarks.count, 2)
}

Revisando Fallos con Vídeo

Cuando falla una reproducción, la revisión de vídeo es una herramienta de depuración clave:

Cómo revisar el vídeo:

  1. El Resultado de la Prueba (Test Result) incluye un enlace a la grabación de vídeo del fallo
  2. Haz clic en el enlace para ver la grabación
  3. El vídeo se reproduce automáticamente desde el inicio de la ejecución de la prueba
  4. Ver la línea de tiempo del vídeo: Marcada para mostrar la interacción actual y el resultado de la afirmación
  5. La UI del reproductor de vídeo muestra iconos para cada paso de la prueba junto con el código

Superposiciones:

  • Para cada acción de prueba, la UI está resaltada con superposiciones para ayudar a ver exactamente en qué elemento se estaba operando
  • Si la afirmación falla, el vídeo puede mostrar la UI en el momento del fallo, permitiéndote ver qué se mostró realmente

Comparar con Capturas de Pantalla:

  • Las capturas de pantalla de la UI se generan automáticamente para cada ejecución de prueba
  • Esta información combinada ayuda a aislar problemas

Consejos de Depuración

Problemas Comunes

ProblemaSíntomaSolución
Identificador no encontradoNo matches foundVerifica que el identificador existe en la jerarquía de accesibilidad
Múltiples coincidenciasFound multiple matchesHace que la consulta sea más específica o única
Elemento no hittable (tocable)Elemento existe pero no se puede tocarEspera a que la animación termine o desplázate al elemento
La reproducción falla en otro dispositivoLa prueba pasa en un dispositivo pero falla en otroUsa tiempo de espera basado en condiciones, no tiempos fijos
Fallo de localizaciónLa prueba falla al cambiar el idiomaUsa identificadores de accesibilidad en lugar de etiquetas de texto

Estados de la Aplicación

Simular configuraciones del sistema:

app.launchArguments = ["UI-Testing"]

// Configurar para la prueba
app.launchEnvironment = [
    "AXIM_LOCALE": "en",
    "AXIM_ORIENTATION": "portrait",
    "AXIM_DARK_MODE": "true"
]
app.launch()

Nota: No es necesario para la reproducción, pero puedes usarlo para probar diferentes configuraciones desde el código.

Resumen

Conclusiones Clave

  1. Usa espera basada en condiciones — Reemplaza sleep() con waitForExistence(), XCTestExpectation o predicados
  2. Usa identificadores de accesibilidad — Son estables, no localizados y hacen que las pruebas sean más fiables
  3. Prueba en múltiples dispositivos — Ejecuta en al menos un dispositivo simulado y uno real, y en diferentes tamaños
  4. Piensa en la accesibilidad primero — Una buena accesibilidad lleva a una mejor automatización de pruebas
  5. Usa la grabación de vídeo — Revisa los fallos viendo la grabación de la reproducción para encontrar el paso exacto

Comprobación Rápida

  • ¿Todas las interacciones esperan condiciones? (no se usa sleep())
  • ¿Los elementos interactivos tienen identificadores de accesibilidad únicos?
  • ¿Las pruebas se ejecutan de forma fiable en diferentes dispositivos e idiomas?
  • ¿Las pruebas se ejecutan en menos de 30 segundos cada una?
  • ¿Menos del 5% de las ejecuciones fallan?

Referencias

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