Communitygithub.com

IGTA-Tech/claude-skills-research

Úsalo al implementar animaciones en SwiftUI, comprender VectorArithmetic, usar la macro @Animatable, elegir entre animaciones con resorte o curvas de tiempo, o depurar el comportamiento de animaciones: referencia completa de animaciones desde iOS 13 hasta iOS 26.

¿Qué es claude-skills-research?

Este skill es una guía integral del sistema de animación de SwiftUI, que cubre desde conceptos fundamentales hasta técnicas avanzadas. Está diseñado para desarrolladores que trabajan con animaciones en aplicaciones iOS, ya sea que estén depurando un comportamiento extraño, optimizando el rendimiento o implementando animaciones personalizadas complejas. El skill enfatiza el principio central de que la animación en SwiftUI es interpolación matemática a lo largo del tiempo, impulsada por el protocolo VectorArithmetic. Entender esto es clave para dominar el sistema declarativo de animación. El skill explica detalladamente el protocolo Animatable, cómo usarlo para animar propiedades personalizadas y la diferencia fundamental entre los valores de modelo (el valor objetivo) y los valores de presentación (lo que realmente se ve en pantalla durante la animación). También cubre AnimatablePair para combinar datos multidimensionales y ofrece una advertencia importante sobre el rendimiento: la conformancia personalizada a Animatable provoca que el cuerpo de la vista se renderice en cada fotograma, a diferencia de los efectos incorporados que son más eficientes. La parte más destacada es la explicación de la macro @Animatable (iOS 26+), que elimina gran parte del código repetitivo necesario para conformar al protocolo, reduciendo el código hasta en un 40%. Incluye el uso de @AnimatableIgnored para excluir propiedades de la animación y muestra ejemplos del mundo real en aplicaciones fintech, de salud, juegos y productividad. Finalmente, el skill proporciona una guía completa sobre tipos de animación (resortes, curvas de tiempo), el sistema de Transactions, cómo animar caminos (Paths), animación de layouts, animación de capas, sombras, gestos, y las mejores prácticas para el rendimiento y la depuración.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/IGTA-Tech/claude-skills-research/tree/HEAD/Axiom/.claude-plugin/plugins/axiom/skills/swiftui-animation-ref

Preguntar en tu IA favorita

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

Documentación

Animación SwiftUI

Descripción General

Guía completa del sistema de animación de SwiftUI, desde conceptos fundamentales hasta técnicas avanzadas. Este skill cubre el protocolo Animatable, la macro @Animatable de iOS 26, los tipos de animación y el sistema de Transactions.

Principio fundamental La animación en SwiftUI es interpolación matemática a lo largo del tiempo, impulsada por el protocolo VectorArithmetic. Comprender esta base desbloquea todo el poder del sistema de animación declarativa de SwiftUI.

Cuándo Usar Este Skill

  • Implementar vistas o formas animadas personalizadas
  • Entender por qué una propiedad no se anima (Int vs Float/Double)
  • Elegir entre animaciones con resorte y curvas de tiempo
  • Usar la macro @Animatable (iOS 26+)
  • Hacer que las vistas se conformen al protocolo Animatable
  • Depurar el comportamiento de fusión de animaciones
  • Optimizar el rendimiento de las animaciones
  • Crear animaciones complejas o de múltiples pasos
  • Comprender los valores de modelo vs. presentación
  • Implementar algoritmos de animación personalizados

Requisitos del Sistema

iOS 13+ para el protocolo Animatable

iOS 17+ para animaciones con resorte predeterminadas, animaciones con ámbito

iOS 26+ para la macro @Animatable


Parte 1: Comprender la Animación

¿Qué es la Interpolación?

La animación es el proceso de generar valores intermedios entre un estado inicial y uno final.

Ejemplo: Animación de opacidad

.opacity(0) → .opacity(1)

Mientras esta animación se ejecuta, SwiftUI calcula valores intermedios:

0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0

Cómo se distribuyen los valores

  • Determinado por la curva de tiempo o la función de velocidad de la animación
  • Las animaciones con resorte usan simulación física
  • Las curvas de tiempo usan curvas de Bézier
  • Cada tipo de animación calcula los valores de manera diferente

Protocolo VectorArithmetic

SwiftUI requiere que los datos animados se ajusten a VectorArithmetic, que proporciona:

protocol VectorArithmetic {
    // Calcula la diferencia entre dos valores
    static func - (lhs: Self, rhs: Self) -> Self

    // Escala valores
    static func * (lhs: Self, rhs: Double) -> Self

    // Suma valores
    static func + (lhs: Self, rhs: Self) -> Self

    // Valor cero
    static var zero: Self { get }
}

Tipos incorporados que se ajustan

  • 1-dimensional: CGFloat, Double, Float, Angle
  • 2-dimensional: CGPoint, CGSize
  • 4-dimensional: CGRect

Información clave La aritmética vectorial abstrae la dimensionalidad de los datos animados. SwiftUI puede animar todos estos tipos con una única implementación genérica.

Por Qué Int No Se Puede Animar

Int no se ajusta a VectorArithmetic porque:

  1. No hay valores intermedios fraccionarios — No existe un "3.5" entre 3 y 4
  2. No es continuo — Los enteros son valores discretos
  3. Escalar no tiene sentido — ¿Qué significa 5 × 0.5 para un entero?

¿Qué sucede cuando lo intentas?

struct CounterView: View {
    @State private var count: Int = 0

    var body: some View {
        Text("\(count)")
            .animation(.spring, value: count)
    }
}

Resultado: SwiftUI simplemente reemplaza el texto anterior por el nuevo. No ocurre interpolación.

Solución: Usa Float o Double

struct AnimatedCounterView: View {
    @State private var count: Float = 0

    var body: some View {
        Text("\(Int(count))")
            .animation(.spring, value: count)
    }
}

Resultado: SwiftUI interpola 0.0 → ... → 100.0, y muestras el entero redondeado en cada fotograma.

Valores de Modelo vs. Presentación

Los atributos animables tienen conceptualmente dos valores:

Valor de Modelo

  • El valor objetivo establecido por tu código
  • Se actualiza inmediatamente cuando cambia el estado
  • Es lo que escribes en el cuerpo de tu vista

Valor de Presentación

  • El valor interpolado actual que se está renderizando
  • Se actualiza fotograma a fotograma durante la animación
  • Es lo que el usuario ve realmente

Ejemplo

.scaleEffect(selected ? 1.5 : 1.0)

Cuando selected se convierte en true:

  • Valor de modelo: Inmediatamente se convierte en 1.5
  • Valor de presentación: Interpola 1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5 a lo largo del tiempo

Parte 2: Protocolo Animatable

Descripción General

El protocolo Animatable permite que las vistas animen sus propiedades definiendo qué datos deben interpolarse.

protocol Animatable {
    associatedtype AnimatableData: VectorArithmetic

    var animatableData: AnimatableData { get set }
}

SwiftUI construye un atributo animable para cualquier vista que se ajuste a este protocolo.

Vistas Animables Incorporadas

Muchos modificadores de SwiftUI se ajustan a Animatable:

Efectos Visuales

  • .scaleEffect() — Anima la transformación de escala
  • .rotationEffect() — Anima la rotación
  • .offset() — Anima el desplazamiento de posición
  • .opacity() — Anima la transparencia
  • .blur() — Anima el radio de desenfoque
  • .shadow() — Anima las propiedades de la sombra

Todos los tipos Shape

  • Circle, Rectangle, RoundedRectangle
  • Capsule, Ellipse, Path
  • Implementaciones personalizadas de Shape

AnimatablePair para Datos Multidimensionales

Al animar múltiples propiedades, usa AnimatablePair para combinar vectores.

Ejemplo: Implementación de scaleEffect

struct ScaleEffectModifier: ViewModifier, Animatable {
    var scale: CGSize
    var anchor: UnitPoint

    // Combina dos vectores 2D en un vector 4D
    var animatableData: AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData> {
        get {
            AnimatablePair(scale.animatableData, anchor.animatableData)
        }
        set {
            scale.animatableData = newValue.first
            anchor.animatableData = newValue.second
        }
    }

    func body(content: Content) -> some View {
        content.scaleEffect(scale, anchor: anchor)
    }
}

Cómo funciona

  • CGSize tiene 2 dimensiones (ancho, alto)
  • UnitPoint tiene 2 dimensiones (x, y)
  • AnimatablePair los fusiona en un vector de 4 dimensiones
  • SwiftUI interpola los 4 valores juntos

Conformancia Personalizada a Animatable

Cuándo usarla

  • Animar un diseño personalizado (como RadialLayout)
  • Animar código de dibujo personalizado
  • Animar propiedades que afectan las rutas de las formas

Ejemplo: Vista de número animado

struct AnimatableNumberView: View, Animatable {
    var number: Double

    var animatableData: Double {
        get { number }
        set { number = newValue }
    }

    var body: some View {
        Text("\(Int(number))")
            .font(.largeTitle)
    }
}

// Uso
AnimatableNumberView(number: value)
    .animation(.spring, value: value)

Cómo funciona

  1. number cambia de 0 a 100
  2. SwiftUI llama a body por cada fotograma de la animación
  3. Cada fotograma obtiene un nuevo valor de number: 0 → 5 → 15 → 30 → 55 → 80 → 100
  4. El texto se actualiza para mostrar el entero interpolado

Advertencia de Rendimiento

La conformancia personalizada a Animatable puede ser costosa.

Cuando haces que una vista se ajuste a Animatable:

  • SwiftUI llama al body de tu vista por cada fotograma de la animación
  • El diseño se vuelve a ejecutar en cada fotograma
  • Esto ocurre en el hilo principal

Los efectos animables incorporados (como .scaleEffect(), .opacity()) son mucho más eficientes:

  • Se ejecutan fuera del hilo principal
  • No llaman al body de tu vista
  • Actualizan solo la capa de renderizado

Directriz

  • Usa efectos incorporados siempre que sea posible
  • Solo usa conformancia personalizada a Animatable si no puedes lograr el efecto con modificadores incorporados
  • Perfila con Instruments si tienes problemas de rendimiento

Ejemplo: Animación de diseño circular

// Esto es costoso pero necesario para animar a lo largo de una trayectoria circular
@Animatable
struct RadialLayout: Layout {
    var offsetAngle: Angle

    var animatableData: Angle.AnimatableData {
        get { offsetAngle.animatableData }
        set { offsetAngle.animatableData = newValue }
    }

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        proposal.replacingUnspecifiedDimensions()
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let radius = min(bounds.width, bounds.height) / 2
        let center = CGPoint(x: bounds.midX, y: bounds.midY)
        let angleStep = Angle.degrees(360.0 / Double(subviews.count))

        for (index, subview) in subviews.enumerated() {
            let angle = offsetAngle + angleStep * Double(index)
            let x = center.x + radius * cos(angle.radians)
            let y = center.y + radius * sin(angle.radians)

            subview.place(at: CGPoint(x: x, y: y), anchor: .center, proposal: .unspecified)
        }
    }
}

Por qué es necesario: Animar offsetAngle requiere recalcular las posiciones en cada fotograma. Ningún modificador incorporado puede hacer esto.


Parte 3: Macro @Animatable (iOS 26+)

Descripción General

La macro @Animatable elimina el código repetitivo de ajustarse manualmente al protocolo Animatable.

Antes de iOS 26, tenías que:

  1. Ajustarte manualmente a Animatable
  2. Escribir el getter y setter de animatableData
  3. Usar AnimatablePair para múltiples propiedades
  4. Excluir propiedades no animables manualmente

iOS 26+, solo añades @Animatable:

@MainActor
@Animatable
struct MyView: View {
    var scale: CGFloat
    var opacity: Double

    var body: some View {
        // ...
    }
}

La macro automáticamente:

  • Genera la conformancia a Animatable
  • Inspecciona todas las propiedades almacenadas
  • Crea animatableData a partir de propiedades que se ajustan a VectorArithmetic
  • Maneja datos multidimensionales con AnimatablePair

Comparación Antes/Después

Antes de la macro @Animatable

struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double
    var drawingDirection: Bool // No quieres animar esto

    // Declaración tediosa y manual de animatableData
    var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
                        AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
        get {
            AnimatablePair(
                AnimatablePair(startPoint.x, startPoint.y),
                AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
            )
        }
        set {
            startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
            elevation = newValue.second.first
            endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
        }
    }

    func path(in rect: CGRect) -> Path {
        // Código de dibujo
    }
}

Después de la macro @Animatable

@Animatable
struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    @AnimatableIgnored
    var drawingDirection: Bool // Excluida de la animación

    func path(in rect: CGRect) -> Path {
        // Código de dibujo
    }
}

Líneas de código: 20 → 12 (reducción del 40%)

@AnimatableIgnored

Usa @AnimatableIgnored para excluir propiedades de la animación.

Cuándo usarlo

  • Valores de depuración — Banderas solo para desarrollo
  • IDs — Identificadores que no deberían animarse
  • Marcas de tiempo — Cuándo se creó/actualizó la vista
  • Estado interno — Contabilidad no visual
  • Tipos que no se ajustan a VectorArithmetic — Colores, cadenas, booleanos

Ejemplo

@MainActor
@Animatable
struct ProgressView: View {
    var progress: Double // Animado
    var totalItems: Int // Animado (si es Float, no si es Int)

    @AnimatableIgnored
    var title: String // No animado

    @AnimatableIgnored
    var startTime: Date // No animado

    @AnimatableIgnored
    var debugEnabled: Bool // No animado

    var body: some View {
        VStack {
            Text(title)
            ProgressBar(value: progress)
            if debugEnabled {
                Text("Iniciado: \(startTime.formatted())")
            }
        }
    }
}

Casos de Uso del Mundo Real

Las animaciones numéricas son extremadamente comunes en todas las categorías de aplicaciones:

Aplicaciones Fintech

@MainActor
@Animatable
struct StockPriceView: View {
    var price: Double
    var changePercent: Double

    var body: some View {
        VStack(alignment: .trailing) {
            Text("$\(price, format: .number.precision(.fractionLength(2)))")
                .font(.title)
            Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
                .foregroundColor(changePercent > 0 ? .green : .red)
        }
    }
}

Caso de uso: Animar cambios en el precio de acciones, valor de cartera, transiciones de saldo de cuenta

Salud y Bienestar

@MainActor
@Animatable
struct HeartRateView: View {
    var bpm: Double

    @AnimatableIgnored
    var timestamp: Date

    var body: some View {
        VStack {
            Text("\(Int(bpm))")
                .font(.system(size: 60, weight: .bold))
            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
    }
}

Caso de uso: Indicadores de frecuencia cardíaca, contadores de pasos, cálculos de calorías, distancia recorrida

Juegos

@MainActor
@Animatable
struct ScoreView: View {
    var score: Float
    var multiplier: Float

    var body: some View {
        HStack {
            Text("\(Int(score))")
                .font(.largeTitle)
            Text("×\(multiplier, format: .number.precision(.fractionLength(1)))")
                .font(.title2)
                .foregroundColor(.orange)
        }
    }
}

Caso de uso: Animaciones de puntuación, transiciones de XP, progreso de nivel, multiplicadores de combo

Aplicaciones de Productividad

@MainActor
@Animatable
struct TimerView: View {
    var remainingSeconds: Double

    var body: some View {
        VStack {
            Text(formattedTime)
                .font(.system(size: 48, design: .monospaced))
            Text("segundos restantes")
                .font(.caption)
        }
    }

    var formattedTime: String {
        let minutes = Int(remainingSeconds) / 60
        let seconds = Int(remainingSeconds) % 60
        return String(format: "%02d:%02d", minutes, seconds)
    }
}

Caso de uso: Temporizadores Pomodoro, animaciones de cuenta regresiva, seguimiento de tiempo de tareas, fechas límite de proyectos


Parte 4: Tipos de Animación

Animaciones con Resorte (Spring)

Las animaciones con resorte son el tipo de animación predeterminado en SwiftUI desde iOS 17. Simulan física: un resorte conectado al valor objetivo.

Spring (iOS 17+)

// Sintaxis moderna
.animation(.spring, value: value) // Usa la configuración predeterminada del resorte del sistema
.animation(.spring(duration: 0.5, bounce: 0.3), value: value)
.animation(.spring(duration: 0.5, bounce: 0.7), value: value) // Más rebote
.animation(.spring(duration: 1.0, bounce: 0.0), value: value) // Sin rebote

Configuración:

  • duration: Cuánto dura la animación (período de oscilación)
  • bounce: Cuánto rebota (0=sin rebote, 1=máximo rebote)

Spring (antes de iOS 17)

// Sintaxis heredada
.animation(.spring(), value: value)
.animation(.interpolatingSpring(mass: 1, stiffness: 100, damping: 10), value: value)

Curvas de Tiempo (Timing Curves)

Las curvas de tiempo ofrecen control preciso sobre la aceleración de la animación.

// Duración fija (en segundos)
.animation(.easeInOut(duration: 1.0), value: value)
.animation(.easeIn(duration: 0.5), value: value)
.animation(.easeOut(duration: 0.3), value: value)
.animation(.linear(duration: 2.0), value: value)

// Curva de Bézier cúbica personalizada
.animation(.timingCurve(0.2, 0.8, 0.4, 1.0, duration: 1.0), value: value)

Cuándo Usar Cada Tipo

TipoMejor ParaEjemplo
SpringInteracciones naturales, elementos UI, retroalimentación táctilBotones emergentes, cambios de tamaño de vista
EaseInOutMovimiento suave general, animaciones de pantallaTransiciones de opacidad, desplazamiento de vistas
EaseOutMovimiento que se desacelera naturalmenteApertura de menús, diapositivas de notificaciones
LinearMovimiento constante, barras de progresoBarras de progreso indeterminadas, desplazamiento continuo
TimingCurveControl preciso de la aceleraciónAnimaciones de iconos de carga, gráficos de movimiento

Parte 5: Sistema de Transactions

Las Transactions son el mecanismo de SwiftUI para agrupar y controlar animaciones. Te permiten anular las animaciones predeterminadas, deshabilitar animaciones o pasar opciones de animación a través de la jerarquía de vistas.

Uso Básico

withAnimation(.spring(duration: 0.5)) {
    // Todos los cambios de estado aquí se animan con un resorte
    isExpanded.toggle()
}

// Sin animación
withTransaction(Transaction(animation: nil)) {
    isExpanded.toggle()
}

Transacciones Explícitas

Crear y modificar una Transaction directamente:

var transaction = Transaction()
transaction.animation = .spring(duration: 0.5, bounce: 0.3)
transaction.disablesAnimations = true // Deshabilita todas las animaciones hijas
transaction.isContinuous = true // Para animaciones continuas como arrastrar

withTransaction(transaction) {
    isExpanded.toggle()
}

Fusión de Transacciones

Cuando las animaciones están anidadas, SwiftUI fusiona las transacciones:

withAnimation(.spring) {
    withAnimation(.easeInOut(duration: 1.0)) {
        // ¿Qué animación gana?
        isExpanded.toggle()
    }
}

Regla de fusión: La transacción más externa tiene prioridad. En este caso, .spring reemplaza a .easeInOut.


Parte 6: Animaciones de Ruta (Path)

Animación de Formas Personalizadas

Puedes animar los puntos de control de una ruta de Bézier a lo largo del tiempo.

Requisito: La forma debe ajustarse a Animatable.

Ejemplo: Forma de ola con altura animada

struct WaveForm: Shape {
    var height: Double

    var animatableData: Double {
        get { height }
        set { height = newValue }
    }

    func path(in rect: CGRect) -> Path {
        var path = Path()
        let midY = rect.midY
        let width = rect.width

        path.move(to: CGPoint(x: 0, y: midY))
        path.addCurve(
            to: CGPoint(x: width, y: midY),
            control1: CGPoint(x: width * 0.25, y: midY - height),
            control2: CGPoint(x: width * 0.75, y: midY + height)
        )
        return path
    }
}

// Uso
WaveForm(height: animatableHeight)
    .stroke(.blue, lineWidth: 2)
    .animation(.spring, value: animatableHeight)

Parte 7: Animación de Layout

Animación del Layout de una Jerarquía de Vistas

Para animar un layout personalizado, haz que tu tipo Layout se ajuste a Animatable.

Ejemplo: Animación de un layout de cuadrícula

@Animatable
struct AnimatedGridLayout: Layout {
    var spacing: Double
    var columns: Int

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        // Calcular el tamaño basado en el número de columnas
        // ...
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        // Colocar subvistas basadas en el espaciado y columnas actuales
        // ...
    }
}

Parte 8: Animación de Capas y Sombra

Animación de Capas

Las vistas de capa (como Color, Image, Rectangle) pueden animar sus propiedades:

Color.blue
    .opacity(0.5)
    .animation(.easeInOut, value: opacity)

Image(systemName: "star")
    .scaleEffect(scale)
    .animation(.spring, value: scale)

Animación de Sombras

Rectangle()
    .shadow(color: .black.opacity(shadowOpacity), radius: shadowRadius, x: shadowX, y: shadowY)
    .animation(.spring, value: shadowOpacity)
    .animation(.easeInOut, value: shadowRadius)

Parte 9: Animaciones con Gestos

Animación Basada en Gestos

Combina gestos con animaciones para crear interacciones receptivas.

struct DraggableCard: View {
    @State private var offset: CGSize = .zero
    @State private var isDragging = false

    var body: some View {
        RoundedRectangle(cornerRadius: 20)
            .fill(.blue)
            .frame(width: 200, height: 300)
            .offset(offset)
            .scaleEffect(isDragging ? 1.05 : 1.0)
            .gesture(
                DragGesture()
                    .onChanged { value in
                        withAnimation(.interactiveSpring) {
                            offset = value.translation
                            isDragging = true
                        }
                    }
                    .onEnded { _ in
                        withAnimation(.spring) {
                            offset = .zero
                            isDragging = false
                        }
                    }
            )
    }
}

Parte 10: Mejores Prácticas y Rendimiento

Consejos de Rendimiento

  • Usa .drawingGroup() cuando tengas muchas vistas animadas para renderizar en una imagen fuera de pantalla
  • Limita el número de vistas animadas simultáneamente
  • Evita animar propiedades de layout (como frame, padding) ya que son costosas
  • Prefiere .scaleEffect() sobre .frame() para animaciones de tamaño
  • Usa .animation(nil, value:) para deshabilitar animaciones donde no sean necesarias

Depuración

  • View Profiler en Instruments para ver el costo de las animaciones
  • Usa modificadores ${ } en vistas para inspeccionar valores durante la animación
  • Imprime valores en el getter de animatableData durante la depuración

Conclusión

Entender cómo SwiftUI maneja la animación a través de VectorArithmetic, el protocolo Animatable y la macro @Animatable te permite crear animaciones fluidas y eficientes. Comienza siempre con los efectos incorporados, usa @Animatable para simplificar la conformancia y recurre a la conformancia manual solo cuando necesites un control preciso sobre los datos interpolados.


Documentación creada para desarrolladores de SwiftUI que quieren dominar las animaciones.

Individual skills in this repo

This repo contains 7 individual skills — each has its own dedicated page.

IGTA-Tech/claude-skills-research

Use when localizing apps, using String Catalogs, generating type-safe symbols (Xcode 26+), handling plurals, RTL layouts, locale-aware formatting, or migrating from .strings files - comprehensive i18n patterns for Xcode 15-26

IGTA-Tech/claude-skills-research

Use when CAAnimation completion handler doesn't fire, spring physics look wrong on device, animation duration mismatches actual time, gesture + animation interaction causes jank, or timing differs between simulator and real hardware - systematic CAAnimation diagnosis with CATransaction patterns, frame rate awareness, and device-specific behavior

IGTA-Tech/claude-skills-research

This skill should be used when comparing two videos to analyze compression results or quality differences. Generates interactive HTML reports with quality metrics (PSNR, SSIM) and frame-by-frame visual comparisons. Triggers when users mention "compare videos", "video quality", "compression analysis", "before/after compression", or request quality assessment of compressed videos.

IGTA-Tech/claude-skills-research

Download YouTube videos and HLS streams (m3u8) from platforms like Mux, Vimeo, etc. using yt-dlp and ffmpeg. Use this skill when users request downloading videos, extracting audio, handling protected streams with authentication headers, or troubleshooting download issues like nsig extraction failures, 403 errors, or cookie extraction problems.

IGTA-Tech/claude-skills-research

Write high-converting landing page copy using proven frameworks like PAS (Problem-Agitate-Solution), AIDA, and StoryBrand. Creates headlines, value propositions, CTAs, and full page sections optimized for conversion. Use when users need landing page copy, sales page content, or marketing website text.

IGTA-Tech/claude-skills-research

Downloads videos from YouTube and other platforms for offline viewing, editing, or archival. Handles various formats and quality options.

IGTA-Tech/claude-skills-research

Download YouTube video transcripts when user provides a YouTube URL or asks to download/get/fetch a transcript from YouTube. Also use when user wants to transcribe or get captions/subtitles from a YouTube video.

Skills relacionados