Communitygithub.com

David-Li0406/meta-skill-evloving

Animações SwiftUI, macro @Animatable, withAnimation, transições, PhaseAnimator, KeyframeAnimator e design de movimento interativo. Use quando o usuário perguntar sobre animações, transições, @Animatable, withAnimation, animações spring, keyframes ou design de movimento.

O que é meta-skill-evloving?

Este skill é um guia abrangente sobre animações e transições em SwiftUI, cobrindo desde os fundamentos até os recursos mais modernos introduzidos no iOS 17 e 26. Ele explica em detalhes o uso da nova macro `@Animatable` (iOS 26+), que elimina a necessidade de implementar manualmente o protocolo `Animatable`, automatizando a interpolação de propriedades animáveis como `CGFloat`, `Angle`, `CGSize` e `Color`. O guia também cobre o uso de `withAnimation` com diferentes tipos de animação e completion handlers, as várias opções de animação built-in (linear, ease, spring) e seus presets (bouncy, snappy, smooth), além do modificador de animação explícita `.animation(_:value:)` para controle preciso. Para transições, são apresentadas as built-in, combinadas, assimétricas e a criação de transições customizadas com `ViewModifier`. Por fim, o skill aborda os poderosos `PhaseAnimator` e `KeyframeAnimator` (iOS 17+), que permitem criar animações com múltiplas fases e animações complexas baseadas em keyframes, com exemplos práticos de uso e customização de curvas de animação por fase ou track.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/David-Li0406/meta-skill-evloving/tree/HEAD/skill-flow/data/skills-refined-36k/skillsmp/animations-transitions

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Animações e Transições SwiftUI

Guia abrangente sobre animações SwiftUI, a nova macro @Animatable (iOS 26), transições e melhores práticas de design de movimento para desenvolvimento iOS moderno.

Pré-requisitos

  • iOS 17+ para PhaseAnimator/KeyframeAnimator
  • iOS 26+ para a macro @Animatable
  • Xcode 26+

Macro @Animatable (iOS 26 - NOVO!)

A Revolução nas Animações Personalizadas

iOS 26 introduz a macro @Animatable, eliminando o tedioso boilerplate anteriormente necessário para animar formas e visualizações personalizadas.

Antes do iOS 26 (Abordagem Manual)

// FORMA ANTIGA - Muito boilerplate
struct FatiaDeTorta: Shape {
    var anguloInicial: Angle
    var anguloFinal: Angle

    // Implementação manual de animatableData necessária
    var animatableData: AnimatablePair<Double, Double> {
        get {
            AnimatablePair(anguloInicial.radians, anguloFinal.radians)
        }
        set {
            anguloInicial = Angle(radians: newValue.first)
            anguloFinal = Angle(radians: newValue.second)
        }
    }

    func path(in rect: CGRect) -> Path {
        var path = Path()
        let center = CGPoint(x: rect.midX, y: rect.midY)
        let radius = min(rect.width, rect.height) / 2
        path.move(to: center)
        path.addArc(center: center, radius: radius,
                    startAngle: anguloInicial, endAngle: anguloFinal,
                    clockwise: false)
        path.closeSubpath()
        return path
    }
}

Depois do iOS 26 (Com @Animatable)

// NOVA FORMA - Apenas adicione @Animatable
@Animatable
struct FatiaDeTorta: Shape {
    var anguloInicial: Angle
    var anguloFinal: Angle

    func path(in rect: CGRect) -> Path {
        var path = Path()
        let center = CGPoint(x: rect.midX, y: rect.midY)
        let radius = min(rect.width, rect.height) / 2
        path.move(to: center)
        path.addArc(center: center, radius: radius,
                    startAngle: anguloInicial, endAngle: anguloFinal,
                    clockwise: false)
        path.closeSubpath()
        return path
    }
}

@AnimatableIgnored

Exclua propriedades da animação:

@Animatable
struct FormaPersonalizada: Shape {
    var valorAnimado: CGFloat
    @AnimatableIgnored var configuracaoEstatica: Bool  // Não é animado

    func path(in rect: CGRect) -> Path {
        // Use ambos os valores, mas apenas valorAnimado será animado
    }
}

Tipos Suportados para Animação

A macro @Animatable lida automaticamente com:

  • CGFloat, Double, Float
  • Angle
  • CGSize, CGPoint, CGRect
  • UnitPoint
  • Color (interpolação de componentes)
  • Tipos personalizados que estejam em conformidade com VectorArithmetic

Exemplo Complexo com Múltiplas Propriedades

@Animatable
struct FormaMorfavel: Shape {
    var raioCanto: CGFloat
    var quantidadeInsercao: CGFloat
    var rotacao: Angle
    @AnimatableIgnored var corPreenchimento: Color

    func path(in rect: CGRect) -> Path {
        let rectInserido = rect.insetBy(dx: quantidadeInsercao, dy: quantidadeInsercao)
        var path = Path(roundedRect: rectInserido, cornerRadius: raioCanto)

        let transform = CGAffineTransform(rotationAngle: rotacao.radians)
        return path.applying(transform)
    }
}

// Uso
struct VisaoMorfavel: View {
    @State private var estaExpandido = false

    var body: some View {
        FormaMorfavel(
            raioCanto: estaExpandido ? 50 : 10,
            quantidadeInsercao: estaExpandido ? 20 : 50,
            rotacao: estaExpandido ? .degrees(45) : .zero,
            corPreenchimento: .blue
        )
        .fill(.blue)
        .frame(width: 200, height: 200)
        .onTapGesture {
            withAnimation(.spring(duration: 0.6, bounce: 0.3)) {
                estaExpandido.toggle()
            }
        }
    }
}

withAnimation

Uso Básico

struct ContentView: View {
    @State private var estaExpandido = false

    var body: some View {
        VStack {
            Rectangle()
                .frame(width: estaExpandido ? 200 : 100,
                       height: estaExpandido ? 200 : 100)

            Button("Alternar") {
                withAnimation {
                    estaExpandido.toggle()
                }
            }
        }
    }
}

Com Tipo de Animação

withAnimation(.spring(duration: 0.5, bounce: 0.3)) {
    estaExpandido.toggle()
}

withAnimation(.easeInOut(duration: 0.3)) {
    opacidade = 1.0
}

withAnimation(.linear(duration: 1.0)) {
    progresso = 1.0
}

Manipulador de Conclusão (iOS 17+)

withAnimation(.easeInOut(duration: 0.5)) {
    mostrarDetalhes = true
} completion: {
    // Chamado quando a animação termina
    print("Animação finalizada")
    buscarMaisDados()
}

Animações Aninhadas com Tempos Diferentes

Button("Animar") {
    withAnimation(.spring(duration: 0.4)) {
        estaExpandido = true
    }

    withAnimation(.easeOut(duration: 0.6).delay(0.2)) {
        opacidade = 1.0
    }
}

Tipos de Animação

Animações Embutidas

// Linear - velocidade constante
.linear(duration: 0.3)

// Variantes de Ease - aceleração/desaceleração
.easeIn(duration: 0.3)      // Início lento
.easeOut(duration: 0.3)     // Final lento
.easeInOut(duration: 0.3)   // Ambos lentos

// Padrão (ease in/out)
.default

Animações Spring (Modernas)

// Spring moderna com duração e bounce
.spring(duration: 0.5, bounce: 0.3)

// Valores de bounce:
// 0.0 = sem bounce (criticamente amortecido)
// 0.5 = bounce médio
// 1.0 = bounce máximo (nunca estabiliza)

// Parâmetro extra de bounce para ultrapassagem
.spring(duration: 0.5, bounce: 0.4, blendDuration: 0.2)

Presets Spring

// Bouncy - brincalhão, energético
.bouncy
.bouncy(duration: 0.4, extraBounce: 0.1)

// Snappy - rápido, responsivo
.snappy
.snappy(duration: 0.3, extraBounce: 0.05)

// Smooth - suave, elegante
.smooth
.smooth(duration: 0.5, extraBounce: 0.0)

Spring Interativo

// Para animações orientadas a gestos
.interactiveSpring()
.interactiveSpring(response: 0.3, dampingFraction: 0.7)

// Melhor para gestos de arrastar
.interactiveSpring(response: 0.15, dampingFraction: 0.86, blendDuration: 0.25)

Curvas de Tempo Personalizadas

// Curva Bezier de tempo
.timingCurve(0.2, 0.8, 0.2, 1.0, duration: 0.5)

// Parâmetros: (x1, y1, x2, y2)
// Início: (0, 0), Fim: (1, 1)
// Os pontos de controle definem a forma da curva

Modificadores de Animação

// Atraso antes de iniciar
.spring().delay(0.2)

// Multiplicador de velocidade
.spring().speed(2.0)  // 2x mais rápido

// Repetir
.linear(duration: 1.0).repeatCount(3)
.linear(duration: 1.0).repeatForever()

// Reversão automática
.easeInOut(duration: 0.5).repeatForever(autoreverses: true)

Modificador de Animação Explícita

Abordagem Preferida

struct ContentView: View {
    @State private var escala = 1.0

    var body: some View {
        Circle()
            .scaleEffect(escala)
            // Explícita: anima apenas quando a escala muda
            .animation(.spring, value: escala)
            .onTapGesture {
                escala = escala == 1.0 ? 1.5 : 1.0
            }
    }
}

Por que Explícita é Melhor

// EVITAR: Animação implícita (anima tudo)
Circle()
    .animation(.spring)  // Aviso de obsoleto em iOS mais recentes

// PREFERIR: Animação explícita (controle preciso)
Circle()
    .animation(.spring, value: valorEspecifico)

Múltiplas Animações Explícitas

struct VisaoMultiAnimada: View {
    @State private var escala = 1.0
    @State private var opacidade = 1.0
    @State private var rotacao = 0.0

    var body: some View {
        Rectangle()
            .scaleEffect(escala)
            .opacity(opacidade)
            .rotationEffect(.degrees(rotacao))
            // Animações diferentes para propriedades diferentes
            .animation(.bouncy, value: escala)
            .animation(.easeOut(duration: 0.2), value: opacidade)
            .animation(.spring(duration: 1.0), value: rotacao)
    }
}

Transições

Transições Básicas

struct ContentView: View {
    @State private var mostrarDetalhe = false

    var body: some View {
        VStack {
            if mostrarDetalhe {
                DetalheView()
                    .transition(.slide)
            }

            Button("Alternar") {
                withAnimation {
                    mostrarDetalhe.toggle()
                }
            }
        }
    }
}

Transições Embutidas

.transition(.opacity)           // Aparecer/desaparecer
.transition(.scale)             // Escalar do centro
.transition(.scale(scale: 0.5)) // Escalar de 50%
.transition(.slide)             // Deslizar da borda inicial
.transition(.move(edge: .top))  // Mover de uma borda específica
.transition(.push(from: .bottom)) // Empurrar com substituição
.transition(.offset(x: 100, y: 0))  // Deslocamento personalizado

Transições Combinadas

// Combinar múltiplas transições
.transition(.scale.combined(with: .opacity))

// Encadear combinações
.transition(
    .scale(scale: 0.8)
    .combined(with: .opacity)
    .combined(with: .offset(y: 20))
)

Transições Assimétricas

// Transições diferentes para inserção vs remoção
.transition(.asymmetric(
    insertion: .scale.combined(with: .opacity),
    removal: .slide
))

// Padrão comum: deslizar de um lado, sair pelo outro
.transition(.asymmetric(
    insertion: .push(from: .trailing),
    removal: .push(from: .leading)
))

Transições Personalizadas

extension AnyTransition {
    static var virarDeBaixo: AnyTransition {
        .modifier(
            active: ModificadorVirar(angulo: -90),
            identity: ModificadorVirar(angulo: 0)
        )
    }
}

struct ModificadorVirar: ViewModifier {
    let angulo: Double

    func body(content: Content) -> some View {
        content
            .rotation3DEffect(
                .degrees(angulo),
                axis: (x: 1, y: 0, z: 0)
            )
            .opacity(angulo == 0 ? 1 : 0)
    }
}

// Uso
DetalheView()
    .transition(.virarDeBaixo)

PhaseAnimator (iOS 17+)

Uso Básico

enum FaseAnimacao: CaseIterable {
    case inicial
    case medio
    case final

    var escala: CGFloat {
        switch self {
        case .inicial: return 1.0
        case .medio: return 1.2
        case .final: return 1.0
        }
    }

    var opacidade: Double {
        switch self {
        case .inicial: return 1.0
        case .medio: return 0.5
        case .final: return 1.0
        }
    }
}

struct VisaoPulsante: View {
    var body: some View {
        PhaseAnimator(FaseAnimacao.allCases) { fase in
            Circle()
                .fill(.blue)
                .scaleEffect(fase.escala)
                .opacity(fase.opacidade)
        }
    }
}

Animação Acionada

struct AnimacaoAcionavel: View {
    @State private var acionador = false

    var body: some View {
        VStack {
            PhaseAnimator(
                FaseAnimacao.allCases,
                trigger: acionador
            ) { fase in
                Star()
                    .scaleEffect(fase.escala)
                    .rotationEffect(.degrees(fase.rotacao))
            }

            Button("Animar") {
                acionador.toggle()
            }
        }
    }
}

Animação Personalizada Por Fase

PhaseAnimator(FaseAnimacao.allCases) { fase in
    ContentView(fase: fase)
} animation: { fase in
    switch fase {
    case .inicial: .spring(duration: 0.3)
    case .medio: .easeOut(duration: 0.2)
    case .final: .bouncy
    }
}

KeyframeAnimator (iOS 17+)

Animação Básica com Keyframes

struct ValoresAnimacao {
    var escala = 1.0
    var rotacao = 0.0
    var deslocamentoY = 0.0
}

struct VisaoQuicando: View {
    @State private var acionador = false

    var body: some View {
        Circle()
            .fill(.blue)
            .frame(width: 100, height: 100)
            .keyframeAnimator(
                initialValue: ValoresAnimacao(),
                trigger: acionador
            ) { content, valor in
                content
                    .scaleEffect(valor.escala)
                    .rotationEffect(.degrees(valor.rotacao))
                    .offset(y: valor.deslocamentoY)
            } keyframes: { _ in
                KeyframeTrack(\.escala) {
                    SpringKeyframe(1.2, duration: 0.2)
                    SpringKeyframe(0.9, duration: 0.15)
                    SpringKeyframe(1.0, duration: 0.15)
                }

                KeyframeTrack(\.rotacao) {
                    LinearKeyframe(0, duration: 0.1)
                    SpringKeyframe(10, duration: 0.15)
                    SpringKeyframe(-10, duration: 0.15)
                    SpringKeyframe(0, duration: 0.1)
                }

                KeyframeTrack(\.deslocamentoY) {
                    SpringKeyframe(-30, duration: 0.2)
                    SpringKeyframe(0, duration: 0.3)
                }
            }
            .onTapGesture {
                acionador.toggle()
            }
    }
}

Tipos de Keyframe

KeyframeTrack(\.valor) {
    // Interpolação linear
    LinearKeyframe(valorAlvo, duration: 0.3)

    // Interpolação baseada em spring
    SpringKeyframe(valorAlvo, duration: 0.3)
    SpringKeyframe(valorAlvo, duration: 0.3, spring: .bouncy)

    // Interpolação cúbica Bezier
    CubicKeyframe(valorAlvo, duration: 0.3)

    // Mover sem animação
    MoveKeyframe(valorAlvo)
}

Animação Complexa com Múltiplos Tracks

struct ValoresAnimacaoComplexa {
    var deslocamentoX = 0.0
    var deslocamentoY = 0.0
    var escala = 1.0
    var opacidade = 1.0
    var borrao = 0.0
}

struct AnimacaoComplexa: View {
    @State private var animando = false

    var body: some View {
        Image(systemName: "star.fill")
            .font(.system(size: 50))
            .keyframeAnimator(
                initialValue: ValoresAnimacaoComplexa(),
                repeating: animando
            ) { content, valor in
                content
                    .offset(x: valor.deslocamentoX, y: valor.deslocamentoY)
                    .scaleEffect(valor.escala)
                    .opacity(valor.opacidade)
                    .blur(radius: valor.borrao)
            } keyframes: { _ in
                KeyframeTrack(\.deslocamentoX) {
                    CubicKeyframe(50, duration: 0.4)
                    CubicKeyframe(-50, duration: 0.4)
                    CubicKeyframe(0, duration: 0.4)
                }
                KeyframeTrack(\.deslocamentoY) {
                    SpringKeyframe(30, duration: 0.3)
                    SpringKeyframe(-30, duration: 0.3)
                    SpringKeyframe(0, duration: 0.3)
                }
                KeyframeTrack(\.escala) {
                    LinearKeyframe(1.2, duration: 0.2)
                    LinearKeyframe(0.8, duration: 0.2)
                    LinearKeyframe(1.0, duration: 0.2)
                }
                KeyframeTrack(\.opacidade) {
                    LinearKeyframe(0.5, duration: 0.3)
                    LinearKeyframe(1.0, duration: 0.3)
                }
                KeyframeTrack(\.borrao) {
                    MoveKeyframe(0)
                    CubicKeyframe(10, duration: 0.5)
                    CubicKeyframe(0, duration: 0.5)
                }
            }
            .onTapGesture {
                animando.toggle()
            }
    }
}

Design de Movimento e Melhores Práticas

Princípios de Animação

  • Propósito: Animações devem ter um propósito, não apenas serem decorativas.
  • Feedback visual: Use animações para confirmar ações do usuário (toques, gestos, mudanças de estado).
  • Continuidade: Animações guiam o olhar do usuário e explicam mudanças na interface.
  • Desempenho: Prefira animações baseadas em hardware (opacidade, escala, posição, rotação). Evite animar frame ou offset em layouts complexos.

Durações Recomendadas

  • Micro-interações (toques, feedback): 100-200ms
  • Transições de elemento: 200-400ms
  • Mudanças de tela: 300-500ms
  • Animações expressivas: 500-800ms

Diretrizes de Spring

  • Use .snappy para elementos interativos (botões, gestos).
  • Use .smooth para transições de layout.
  • Use .bouncy para animações lúdicas.
  • Evite bounce excessivo em elementos sérios (alertas e formulários).

Considerações de Acessibilidade

struct ContentView: View {
    @Environment(\.accessibilityReduceMotion) var reduzirMovimento

    var body: some View {
        if reduzirMovimento {
            // Transições instantâneas sem animação
        } else {
            comAnimation { ... }
        }
    }
}

Marcos de Performance

AnimaçãoImpacto na GPUNotas
OpacidadeBaixoMais eficiente, prefira sempre
EscalaBaixoEficiente, evite escala >3x
Rotação 3DMédioPode causar rasterização em dispositivos mais antigos
BorrãoAltoEvite movimentar blur; use apenas para efeitos de foco
SombraMédioPrefira sombras pré-renderizadas

Guia de Referência Rápida

RecursoSDK MínimoUso Principal
withAnimationiOS 13Animações de estado declarativas
Modificador .animationiOS 13Controle de animação explícito
TransiçõesiOS 13Animação de entrada/saída de visualizações
Spring modernoiOS 17Animações spring físicas com bounce
PhaseAnimatoriOS 17Animações em múltiplas fases
KeyframeAnimatoriOS 17Animações complexas baseadas em keyframes
@AnimatableiOS 26Formas animáveis automáticas sem boilerplate

Armadilhas Comuns

  1. Usar animação implícita em vez de explícita: Sempre prefira .animation(_:value:).
  2. Animar muitas visualizações de uma vez: Mantenha o número de visualizações animadas simultâneas baixo.
  3. Ignorar redução de movimento: Sempre respeite as preferências de acessibilidade.
  4. Durações de animação inconsistentes: Use tempos consistentes para interações similares.
  5. Animar propriedades caras: Evite animar frame, offset ou shadow em loops de alta frequência.

Individual skills in this repo

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

David-Li0406/meta-skill-evloving

Browser automation with persistent page state. Use when users ask to navigate websites, fill forms, take screenshots, extract web data, test web apps, or automate browser workflows. Trigger phrases include "go to [url]", "click on", "fill out the form", "take a screenshot", "scrape", "automate", "test the website", "log into", or any browser interaction request.

David-Li0406/meta-skill-evloving

Create technical diagrams using Mermaid syntax for architecture, sequences, ERDs, flowcharts, and state machines. Use for visualizing system design, data flows, and processes. Triggers: diagram, mermaid, architecture diagram, sequence diagram, flowchart, ERD, entity relationship, state diagram, C4 model, component diagram, visualize, draw.

David-Li0406/meta-skill-evloving

Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks

David-Li0406/meta-skill-evloving

Complete color manipulation and green screen effects system. PROACTIVELY activate for: (1) Green screen/chromakey removal, (2) Color grading with LUTs, (3) Color correction (levels, curves, white balance), (4) Colorkey/color removal effects, (5) Hue/saturation manipulation, (6) Color space conversions (BT.709, BT.2020, HDR), (7) Color isolation effects, (8) Teal and orange look, (9) Vintage/film looks, (10) Color keying for transparency. Provides: chromakey and colorkey filters, LUT application (lut3d), curves and levels adjustment, color balance, selective color manipulation, color space handling, HDR tone mapping, professional color grading chains.

David-Li0406/meta-skill-evloving

Convert files and office documents to Markdown. Supports PDF, DOCX, PPTX, XLSX, images (with OCR), audio (with transcription), HTML, CSV, JSON, XML, ZIP, YouTube URLs, EPubs and more.

David-Li0406/meta-skill-evloving

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

David-Li0406/meta-skill-evloving

Build with OpenAI's stateless APIs - Chat Completions (GPT-5, GPT-4o), Embeddings, Images (DALL-E 3), Audio (Whisper + TTS), and Moderation. Includes Node.js SDK and fetch-based approaches for Cloudflare Workers. Use when: implementing chat completions with GPT-5/GPT-4o, streaming responses with SSE, using function calling/tools, creating structured outputs with JSON schemas, generating embeddings for RAG (text-embedding-3-small/large), generating images with DALL-E 3, editing images with GPT-Image-1, transcribing audio with Whisper, synthesizing speech with TTS (11 voices), moderating content (11 safety categories), or troubleshooting rate limits (429), invalid API keys (401), function calling failures, streaming parse errors, embeddings dimension mismatches, or token limit exceeded.

David-Li0406/meta-skill-evloving

Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.

David-Li0406/meta-skill-evloving

Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks

David-Li0406/meta-skill-evloving

Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas

David-Li0406/meta-skill-evloving

Download YouTube videos with customizable quality and format options. Use this skill when the user asks to download, save, or grab YouTube videos. Supports various quality settings (best, 1080p, 720p, 480p, 360p), multiple formats (mp4, webm, mkv), and audio-only downloads as MP3.

David-Li0406/meta-skill-evloving

Best practices for Remotion - Video creation in React

David-Li0406/meta-skill-evloving

Provides bidirectional translation (Chinese/English), grammar checking, and sentence polishing. Supports specific tense constraints, context-aware tone adjustment, and natural expression optimization. Outputs direct text without formatting.

David-Li0406/meta-skill-evloving

指导如何通过自定义注解(如@Unicom)标识Dubbo接口,利用BeanDefinitionRegistryPostProcessor在启动时扫描并动态注册ReferenceBean,实现RPC调用的封装。

David-Li0406/meta-skill-evloving

生成Python脚本,利用FFmpeg将图片序列按3x3布局合并,或将合并图拆分。要求使用subprocess模块执行命令,并支持用户交互式输入路径。

David-Li0406/meta-skill-evloving

SOP for extracting and analyzing promotional activity details, handling time formatting, location mapping, payment logic, and step-by-step process validation.

David-Li0406/meta-skill-evloving

Specializes in creating TikTok short video scripts using an anthropomorphic 'Chef' perspective to explain wildlife food chains and survival environments, utilizing real field footage.

David-Li0406/meta-skill-evloving

针对TikTok平台,以拟人化视角(如动物作为厨师)创作系列短视频脚本。重点介绍野生动物、食物链及生态环境,要求使用野外实拍素材,风格幽默且具有教育意义。

David-Li0406/meta-skill-evloving

Generates KWL (Know, Want to know, Learned) charts for educational videos, specifically BrainPOP, using simple 7th-grade language and short, concise bullet points.

David-Li0406/meta-skill-evloving

Tracks complex, multi-session work using the Beads issue tracker and dependency graphs, and provides persistent memory that survives conversation compaction. Use when work spans multiple sessions, has complex dependencies, or needs persistent context across compaction cycles. Trigger with phrases like "create task for", "what's ready to work on", "show task", "track this work", "what's blocking", or "update status".

Habilidades Relacionadas