Communitygithub.com

AlemTuzlak/skills

Transforma uma gravação bruta (cabeça falante ou captura de tela) em um vídeo finalizado, editado, anotado e um pacote de conteúdo completo. Remove silêncios, sinaliza erros para o usuário cortar, transcreve, adiciona sobreposições sincronizadas com a transcrição (código, destaque de código na tela, destaques de palavras, listas, comparações, diagramas, rótulos de seção, zoom de aproximação), renderiza com áudio original e gera conteúdo para blog/redes sociais/YouTube. Ativa com 'produzir um vídeo', 'editar meu vídeo', 'anotar minha gravação', '/produce-video'.

O que é skills?

Esta skill é uma solução completa de pós-produção de vídeo para desenvolvedores e criadores de conteúdo, transformando gravações brutas em vídeos profissionais e polidos. Ela automatiza todo o fluxo de trabalho: remoção de silêncios (P1), revisão visual de erros e ritmo (P2) com um preview interativo, transcrição final com timestamps (P3), design e construção de sobreposições animadas sincronizadas com a fala (P4), renderização com qualidade quase perfeita (P5) e geração de conteúdo para YouTube, blog e redes sociais (P6), delegando para skills especializadas como `youtube-copy`, `blog-post` e `social-copy`. A skill impõe portões de qualidade rigorosos e não negociáveis: toda manipulação do vídeo preserva a qualidade original usando CRF 12, a revisão de erros é sempre visual (nunca por terminal), o preview é sempre iniciado pelo agente, e a renderização só ocorre após um comando explícito do usuário. Ela integra-se perfeitamente com `hyperframes` para composição, `gsap` para animações e `transcribe-video` para transcrição, garantindo um resultado consistente e de alto nível.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AlemTuzlak/skills/tree/HEAD/skills/produce-video

Perguntar na sua IA favorita

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

Documentação

Produzir Vídeo

Receba uma gravação fornecida pelo usuário e transforme-a em um vídeo finalizado. A gravação é a espinha dorsal e dita a linha do tempo; esta skill edita (silêncio + erros/ritmo escolhidos) e aumenta (sobreposições), depois renderiza e gera conteúdo de lançamento. Ela NÃO cria um vídeo sintético — para vídeos promocionais sintéticos orientados a PR, use hyperframes-video.

Princípio de qualidade (innegociável): cada etapa de manipulação do vídeo preserva a qualidade original. Nunca deixe uma ferramenta re-codificar o vídeo em baixa qualidade. A remoção de silêncio e cortes são executados com CRF 12 quase sem perdas a partir do original (o auto-editor é usado apenas para DETECTAR silêncio, nunca para codificar — seu padrão esmaga o vídeo para ~0,6 Mbps), e a renderização é feita com CRF 12. CRF gera arquivos pequenos para screencasts estáticos; isso é qualidade total, não perda.

Relação com outras skills (delegue, não re-derive)

  • /transcribe-video — toda transcrição (retorna transcript.words.json em nível de palavra). Invoque-a; não transcreva manualmente.
  • hyperframes — regras de criação de composição (Portão de Identidade Visual, Layout Antes de Animação, contrato de linha do tempo, camadas de vídeo/sobreposição). Invoque antes de escrever/montar qualquer HTML de composição.
  • hyperframes-cli — todos os comandos npx hyperframes (init, lint, inspect, preview, render).
  • gsap — padrões de linha do tempo/easing GSAP para sobreposições.
  • youtube-copy — título/descrição/tags/capítulos do YouTube (P6).
  • blog-post — o post do blog (P6).
  • social-copy — cópia para X/Bluesky/LinkedIn/Reddit (P6).

Assets incluídos

  • scripts/desilence.mjs — remoção de silêncio do auto-editor + duração antes/depois.
  • scripts/extract-frame.mjs — captura de quadro único (detecção de enquadramento + destaque na tela).
  • scripts/bake-cuts.mjs — cortador ffmpeg trim/concat (keyframes densos) usado em P2.
  • templates/overlays/*.html — 9 modelos de sub-composição de sobreposição (preenchidos por instância; sub-comps são documentos HTML independentes na CLI instalada — leia o comentário de cabeçalho de cada arquivo).
  • templates/project/{DESIGN.md,styles.css} — Portão de Identidade Visual + tokens de marca var(--brand-*) que as sobreposições consomem.
  • references/ — mistake-detection.md, overlay-triggers.md, framing-safe-zones.md, frame-analysis.md.
  • A geração de conteúdo P6 é delegada às skills youtube-copy, blog-post e social-copy (nenhum script LLM interno).

Portões (innegociáveis)

  1. A revisão de erros P2 é VISUAL, nunca por terminal — sempre que ≥1 sinalizador existir, o agente SEMPRE constrói a prévia com marcadores do hyperframes (marcadores no vídeo em cada intervalo sinalizado) e a inicia, para que o usuário decida assistindo. NÃO apresente os sinalizadores como uma tabela de terminal/pergunta para o usuário decidir, e NÃO torne a prévia opcional ou pergunte "quer que eu mostre?" — apenas construa-a e abra-a. Um breve resumo no terminal dos sinalizadores é aceitável, mas a superfície de decisão é a prévia. Nunca aplique automaticamente um corte/rampa.
  2. Aprovação do plano de sobreposição P4 — apresente a tabela de sobreposições com timestamps; nenhuma construção até aprovação.
  3. Prévia sempre iniciada pelo agente — tanto para a revisão P2 quanto para a revisão P5, o agente inicia npx hyperframes preview e abre a aba do navegador por si mesmo. NUNCA peça ao usuário para executar a prévia ou abrir uma URL, e NUNCA substitua uma prévia ao vivo por um resumo apenas de terminal.
  4. PORTÃO DURO de renderização explícita — a renderização é executada SOMENTE mediante um comando explícito do usuário para renderizar ("renderizar", "pode mandar ver"). Após uma renderização, os pedidos de edição retornam ao loop de prévia e NÃO re-renderizam até que o usuário diga explicitamente novamente. Cada renderização precisa de seu próprio comando novo. Isso substitui qualquer fraseologia "use padrões sensatos / não interativo / apenas envie".

"Use padrões sensatos" / "não faça perguntas" pula as perguntas de configuração (P0) e a iteração de prompt — isso NUNCA pula os portões de aprovação, a prévia iniciada pelo agente ou o portão de renderização explícita.

Processo

Pré-voo — verifique dependências & skills (execute PRIMEIRO, antes de P0)

Verifique o ambiente antes de fazer qualquer trabalho; avise o usuário sobre qualquer coisa faltando e como corrigi-la.

  • auto-editor (obrigatório para P1 remoção de silêncio): execute auto-editor --version. Se não estiver instalado, PARE e diga ao usuário: "auto-editor não está instalado - instale com pipx install auto-editor (ou pip install auto-editor), depois execute novamente." Não tente P1 sem ele.
  • ffmpeg / ffprobe (OBRIGATÓRIO — cortes P2, análise de quadro P4, renderização P5, áudio): execute ffmpeg -version. Se estiver faltando, PARE e diga ao usuário para instalar o ffmpeg e adicioná-lo ao PATH. O pipeline não pode ser executado sem ele.
  • Docker (para /transcribe-video): docker info. Avise se o daemon estiver parado (inicie o Docker Desktop).
  • Node >= 22: node --version. Avise se for mais antigo.
  • Skills obrigatórias — confirme se estão disponíveis (tente invocar / verificar a lista de skills); avise para qualquer uma faltando e qual fase ela bloqueia:
    • transcribe-video (transcrição P2/P3), hyperframes + hyperframes-cli + gsap (composição e renderização P2/P4/P5), youtube-copy + social-copy (P6). blog-post apenas se o usuário optar por um blog (P6, opcional).
  • Resuma o resultado do pré-voo em um bloco curto (o que está presente, o que está faltando). Só prossiga além de uma dependência/skill obrigatória faltando se o usuário disser explicitamente para continuar sem ela (e observe o resultado degradado).

P0 — Entrada e configuração

  • Entrada: caminho para a gravação bruta (obrigatório).
  • Opcional: um repositório/arquivos para base de código real; estilo visual/marca (caso contrário, execute o Portão de Identidade Visual do hyperframes — detecte a partir do repositório, caso contrário, faça 3 perguntas de estilo; escreva templates/project/DESIGN.md + valores de marca em styles.css); densidade de sobreposição (esparsa / equilibrada / rica).
  • Pasta de saída única (<OUT>): tudo que esta skill produz reside em UMA pasta, por padrão <recording-dir>/<video-slug>-produced/ (substituível por um caminho fornecido pelo usuário). Crie-a agora. Estrutura final:
    <OUT>/
      final.mp4                 # vídeo renderizado (P5)
      hyperframes/              # o projeto HyperFrames: index.html, styles.css, DESIGN.md, compositions/, renders/ (P4–P5)
      transcript.txt            # transcrição final editada (P3 / P6)
      transcript.srt
      transcript.words.json
      youtube.md                # P6
      socials.md                # P6
      blog.md                   # P6
      .work/                    # intermediários: 01_desilenced.mp4, 02_edit_N.mp4, frames/ (removível em P7)
    
    Todas as fases subsequentes escrevem dentro de <OUT> — nunca espalhe saídas em outros lugares. <work> abaixo = <OUT>/.work.

P1 — Remoção de silêncio (sem perdas)

node scripts/desilence.mjs <input> --out <work>/01_desilenced.mp4 --margin 0.3s

desilence.mjs usa auto-editor APENAS para detectar os intervalos silenciosos (--export v3), depois corta o ORIGINAL com ffmpeg em CRF 12 quase sem perdas, mantendo o áudio original. NÃO deixe o auto-editor codificar a saída — sua re-codificação padrão esmaga o vídeo para ~0,6 Mbps e o desfoca permanentemente (rostos especialmente); nenhum bitrate downstream pode recuperar isso. Relate a duração antes/depois e os segundos removidos. Esta se torna a cópia de trabalho.

P2 — Loop de revisão de erros e ritmo (portão de aprovação)

  1. Transcreva a cópia de trabalho: invoque /transcribe-video em <work>/01_desilenced.mp4 com --out <work> → transcrição de trabalho (intermediária; substituída pela transcrição final P3).
  2. Detecte sinalizadores conforme references/mistake-detection.md (cortes + rampas de velocidade), ajustados aos limites de palavras.
  3. Sempre (quando ≥1 sinalizador existir) construa a prévia visual. Monte um projeto hyperframes leve com o vídeo sem silêncio como trilha base; coloque marcadores temporários visualmente distintos NO VÍDEO em cada intervalo sinalizado (corte = listra vermelha, rampa = avanço rápido âmbar, cada um rotulado com o trecho + seu índice). O agente inicia npx hyperframes preview e abre o navegador por si mesmo (conforme references/framing-safe-zones.md). Esta é a superfície de decisão — nunca a substitua por uma tabela de terminal. Uma nota de terminal de uma linha ("3 sinalizadores marcados na prévia — revise e me diga quais cortar/rampar/manter") é o máximo que o terminal deve conter.
  4. O usuário assiste à prévia marcada e escolhe por intervalo: cortar / rampa de velocidade (fator, padrão ~1,5–2×) / deixar / adicionar seus próprios intervalos.
  5. Aplique seleções → <work>/02_edit_N.mp4, depois re-prévia:
    • Cortes: use node scripts/bake-cuts.mjs <input> --out <work>/02_edit_N.mp4 --cut s,e --cut s,e … (ffmpeg trim/concat em CRF 12 quase sem perdas por padrão — corta vídeo+áudio identicamente em uma passada). NÃO use auto-editor --cut-out para os cortes de erro — seu argumento variádico atribui erroneamente o último intervalo como entrada posicional, re-codifica com perdas, e uma abordagem de filtro select dessincroniza o áudio.
    • Rampas de velocidade: auto-editor --set-speed-for-range speed,s,e (tom preservado); passe UM intervalo por invocação, ou coloque --set-speed-for-range por último na linha de comando, para evitar a mesma armadilha de argumento variádico.
    • Todos os timestamps de corte/rampa estão na linha do tempo sem silêncio (a transcrição de onde vieram os sinalizadores). Aplique cortes e rampas na mesma rodada contra essa linha do tempo.
  6. Looping até o usuário dizer "pronto". Guarda contra deriva: após ~10 rodadas, ofereça para redefinir para um intermediário anterior. Artefato final: <work>/final_cut.mp4.

Cortes e rampas são aplicados ao vídeo AQUI (antes de P3) para que os timestamps de palavra da transcrição final correspondam à linha do tempo editada.

P3 — Transcrição final

Invoque /transcribe-video em <work>/final_cut.mp4 com --out <OUT> para que transcript.txt / transcript.srt / transcript.words.json caiam no topo da pasta de saída. Esta transcrição com timestamps de palavra é a fonte de sincronia para todas as sobreposições (P4) e a entrada para a geração de conteúdo (P6).

P4 — Design e construção de sobreposição (portão de aprovação)

  1. Detecção de enquadramento (references/framing-safe-zones.md): amostre quadros com extract-frame.mjs, classifique fases, confirme fases + zonas seguras com o usuário.
  2. Detecção de gatilho de sobreposição (references/overlay-triggers.md): escaneie a transcrição com timestamps de palavra → linhas do plano de sobreposição {start, est_duration, type, content, safe_zone, why}. Para código na tela, use references/frame-analysis.md (extrair quadro → localizar → caixa normalizada → guarda de estabilidade). Para cartões de código, repositório-se-disponível-senão-sintetize (sinalize sintetizado).
  3. Passagem de autoaperfeiçoamento (≥2 iterações): respeite densidade, imponha intervalos mínimos + tempos de permanência mínimos, valide cada sobreposição contra a zona segura da fase ativa.
  4. Portão de aprovação: apresente a tabela com timestamps; o usuário edita/remove/re-temporiza/adiciona. Código sintetizado mostrado para verificação. Nenhuma construção até aprovação.
  5. Construção (invoque hyperframes + gsap primeiro):
    • npx hyperframes init <OUT>/hyperframes --video <OUT>/.work/final_cut.mp4 (o projeto vive em <OUT>/hyperframes; base: faixa de vídeo 0 muted playsinline; áudio em uma faixa separada no volume 1 para que a voz toque). Leia o index.html gerado para aprender a sintaxe de inclusão de sub-composição desta versão da CLI.
    • Copie templates/project/styles.css (com os valores de marca confirmados) para <OUT>/hyperframes.
    • Para cada linha aprovada: instancie o templates/overlays/*.html correspondente, dê a ele um id de composição único + data-composition-id, preencha seus {{tokens}}, defina data-start = o timestamp da transcrição e data-duration = o tempo de permanência, monte-o acima do vídeo. Zooms de aproximação escalam o div INVOLUCRO do vídeo (nunca o <video>).
    • Dimensões de saída herdam a gravação original.
    • Legibilidade (innegociável): todo texto de sobreposição deve ser claramente legível sobre QUALQUER fundo de vídeo. Cada grupo de texto repousa em um painel escuro quase opaco (rgba(8,10,14,0.92), arredondado, borda/sombra sutil); títulos/corpo são brancos (var(--brand-text)), secundário/kicker/meta são ardósia clara (#CBD5E1). NUNCA use var(--brand-accent)/var(--brand-primary) para texto de corpo/subtítulo/kicker — destaque é para barras, bordas, varreduras de marcador, ícones e palavras grandes de exibição apenas (e apenas quando atingirem ~4,5:1 no painel). Quando estiver em dúvida, torne o texto branco. npx hyperframes validate (contraste WCAG) deve passar com zero avisos de contraste.

P5 — Prévia e renderização (prévia iniciada pelo agente obrigatória + portão de renderização explícita)

  • npx hyperframes lint + npx hyperframes inspect (transbordamento + zonas seguras) + npx hyperframes validate (contraste). Corrija até ficar limpo.
  • O agente inicia npx hyperframes preview e abre o navegador. Loop de iteração livre sobre sobreposições.
  • Auditorias pré-renderização: cada sobreposição na zona segura de sua fase; tempos de permanência mínimos; nenhuma duas sobreposições disputando a mesma região simultaneamente; lint/inspect/validate limpos.
  • Somente mediante comando explícito do usuário para renderizar: renderize em CRF 12 quase sem perdas. A qualidade padrão standard codifica em ~1,4 Mbps e esmaga visivelmente o vídeo; sempre passe um CRF baixo:
    npx hyperframes render --output <OUT>/final.mp4 --crf 12
    
    (execute a partir de <OUT>/hyperframes. CRF 12 é quase sem perdas; NÃO use --video-bitrate esperando um arquivo grande — para screencasts estáticos, CRF produz um arquivo pequeno com qualidade total, e isso é correto, não baixa qualidade.) O mp4 final mantém o áudio original. Após a renderização, novas edições retornam ao loop e exigem um novo comando explícito de renderização.
  • Nota de qualidade: a captura do Chrome é uma captura de tela 1:1 sem perdas (verificado: entrada da renderização == saída tanto para texto quanto para rostos), então uma renderização com CRF baixo preserva o vídeo conforme fornecido. A ÚNICA coisa que destrói a qualidade é uma etapa upstream com perdas — e é por isso que a remoção de silêncio P1 e os cortes P2 são executados em CRF 12 quase sem perdas a partir do original. Não adicione passagens extras de re-codificação. Para vídeo com zero gerações absoluto, um caminho avançado é renderizar apenas sobreposições em um --format webm/mov transparente e compostá-los com ffmpeg sobre o vídeo cortado (zoom de aproximação então aplicado via ffmpeg) — raramente necessário.

P6 — Geração de conteúdo (delegada a skills especializadas)

Gere o conteúdo de lançamento invocando skills dedicadas, cada uma na transcrição final editada (P3 — passe o transcript.srt com timestamps para que os capítulos do YouTube obtenham tempos precisos), escrevendo cada saída em <OUT>:

  • youtube-copy → <OUT>/youtube.md (título, descrição, tags, capítulos).
  • social-copy → <OUT>/socials.md (postagens para X, Bluesky, LinkedIn, Reddit).
  • blog-post → <OUT>/blog.md (apenas se o usuário optar por um post de blog; sempre verifique primeiro). Confirme brevemente com o usuário se um post de blog é desejado ("Gostaria de um post de blog também?").

P7 — Relatório de resumo + limpeza

Imprima um resumo curto no terminal:

  • Caminho do vídeo final: <OUT>/final.mp4 (duração, resolução, taxa de bits).
  • Estatísticas de transcrição: palavras totais, duração falada, cortes manuais.
  • Contagem de sobreposições por tipo.
  • Caminhos para conteúdo gerado (youtube.md, socials.md, blog.md se criado).
  • Espaço em disco usado pela pasta de trabalho <OUT>/.work e sugestão: "Os intermediários em .work/ podem ser removidos com rm -rf <OUT>/.work para economizar espaço, mas se quiser regenerar transcrições ou ajustar a edição, mantenha-os."

Notas de implementação

Por que não usar auto-editor para codificar

O codificador libx264 padrão do auto-editor com seu perfil fast + crf 23 (ou pior, seu padrão de ~0,6 Mbps) produz vídeo permanentemente destruído: rostos tornam-se borrões, o texto fica ilegível. Nenhuma re-codificação downstream pode restaurar essa informação — é uma perda irreversível. O desilence.mjs usa auto-editor APENAS para detectar silêncio (--export v3), depois corta o original com ffmpeg em CRF 12. Esta é a única maneira de remover silêncio sem danificar o vídeo.

Por que CRF 12 para screencasts

Screencasts estáticos (IDE, terminal, slides) se beneficiam do controle de taxa de bits adaptável do CRF: cenas estáticas usam muito poucos bits, enquanto cenas de movimento (animações, transições de slides) usam mais. CRF 12 é visualmente sem perdas para screencasts; valores mais baixos (CRF 0) produzem arquivos enormes sem ganho perceptível. Um CRF alto (23, 28) introduz macro-bloqueio e artefatos de ringing em texto — inaceitável para vídeos de programação.

Por que colar cortes e rampas na mesma linha do tempo

Ambas as operações modificam a linha do tempo de maneiras que afetam os timestamps de palavra da transcrição. Aplicá-las em sequência (cortes primeiro, depois rampas) na mesma linha do tempo base garante que a transcrição final (P3) corresponda perfeitamente ao vídeo editado. Se as rampas fossem aplicadas após a transcrição, os timestamps de palavra não se alinhariam com o áudio acelerado.

Convenções de nomenclatura

  • IDs de composição: overlay-{type}-{N} (ex: overlay-section-0).
  • Marcadores de prévia P2: IDs marker-cut-{N} e marker-ramp-{N}, cada um com um atributo data-flag-index.
  • Nomes de arquivo no projeto hyperframes: <OUT>/hyperframes/compositions/overlay-{id}.html.

Gerenciamento de estado entre fases

A pasta <OUT> e seus conteúdos são a única fonte da verdade. Cada fase escreve artefatos em locais previsíveis dentro de <OUT>; fases posteriores os leem. Se uma fase falhar, as saídas escritas até o ponto da falha permanecem, permitindo retomar da última fase concluída, corrigindo a entrada e invocando a skill novamente.

Tratamento de erros

  • Falha na detecção de silêncio (P1): se desilence.mjs lançar, verifique se o arquivo de entrada existe e é um vídeo válido, se o auto-editor está instalado e se há espaço em disco suficiente. Tente novamente com --margin 0.2s (margem mais apertada).
  • Falha na transcrição (P3): se /transcribe-video falhar, tente novamente. Se falha persistente, ofereça transcrição usando Whisper local (whisper.cpp) como fallback.
  • Falha na renderização (P5): verifique espaço em disco, memória, e se o Chrome/Chromium está instalado (hyperframes usa Puppeteer). Tente npx hyperframes render --format webm como fallback (saída webm sem perdas).

Individual skills in this repo

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

AlemTuzlak/skills

Use when the user wants to write a blog post about a feature, product change, PR, git diff, or any technical topic - accepts marketing briefs, PRs, git refs, codebase paths, or freeform descriptions as input

AlemTuzlak/skills

Use when the user wants to generate a changelog, release notes, or document what changed between versions, tags, or PRs

AlemTuzlak/skills

Use when writing, editing, or organizing documentation, when planning what docs a feature needs, and whenever planning or implementing a new feature or change in a repo (docs ship with the code). Also use when tempted to write docs without showing the discovered readers to the user, without asking for tone, or without loading simple-english and i-have-adhd. Triggers on "write docs for X", "document this feature", "add a guide", "update the docs", "reorganize the docs", "plan feature X", "implement X", or /docs.

AlemTuzlak/skills

Use when a bug is in play: a test fails, CI is red, an API returns the wrong result, a stack trace appears, or the user says it is broken or fix this. Don't use for a new feature with no failure, for types-only work, or for docs.

AlemTuzlak/skills

Use when the user invokes /i-have-adhd, says they have ADHD, or asks for ADHD-friendly output. Also used as a required writing filter by the docs skill. Don't use for marketing copy or after the user says "stop adhd mode" or "normal mode".

AlemTuzlak/skills

Use when a settled change must be turned into an ordered stack of small blocks before anyone implements. Don't use for unsettled intent, typos, comments, formatting, docs-only work, or writing the implementation itself.

AlemTuzlak/skills

Use when the user wants to write a product update email, feature announcement newsletter, or digest email for users or subscribers

AlemTuzlak/skills

Use when the user runs /prove-it or says prove it, prove the changes, show me in the browser, or asks to prove a UI or API change. Don't use only because the agent is about to say done, for types-only work, or for docs with no behavior to prove.

AlemTuzlak/skills

Use when the user wants to write, draft, or author an RFC (Request for Comments) / technical design doc for a feature, change, or architectural decision. Interactively interviews the user, grounds the proposal in the actual codebase, presents 2-3 concrete API/code-snippet approaches to choose from, then writes a review-ready RFC. Triggers on "write an RFC", "draft an RFC", "RFC for X", "design doc for X", or /rfc.

AlemTuzlak/skills

Use when the user wants to deeply learn a new topic from scratch. Runs a pre-interview (current knowledge, end-goal proficiency, depth, practice load, background, scope), researches online (articles, niche-influencer blogs, canonical docs, subtopic landscape), then produces a structured markdown course with mandatory visual diagrams, evidence-based learning-science features (retrieval practice, spaced callbacks, worked-example fading, concept ledger, jargon gate, analogy hygiene), and a self-contained interactive HTML mini-course. Triggers on /teach-me, "teach me about X", "I want to learn X", "deep dive on X", "create a course on X", "study X with me".

AlemTuzlak/skills

Use when the change intent is already settled and the agent must map what a behavior change touches before an implementation plan or any code. Use for new features, bug fixes, and refactors that move a boundary. Don't use for typos, comments, formatting, lockfile-only diffs, docs with no code, or while the user is still deciding what they want.

AlemTuzlak/skills

Use when the user wants to transcribe a video or audio file to text with word-level timestamps — spins up a self-contained local Whisper (whisper.cpp) Docker service bundled in this skill and returns transcript.txt, transcript.srt, and word-level transcript.words.json. Also used as a building block by /produce-video. Triggers on "transcribe this video", "get a transcript", "transcribe-video".

AlemTuzlak/skills

Use when the user wants to write a video script for a product demo, feature walkthrough, launch video, or social media video about a feature or product change

AlemTuzlak/skills

Use when the user wants YouTube metadata for a video — a click-worthy title, an SEO/above-the-fold description, tags, and timestamped chapters. Accepts a transcript (ideally timestamped SRT), a topic, a PR, or a freeform description. Used standalone and by /produce-video. Triggers on "youtube title", "youtube description", "youtube chapters", "youtube tags", "youtube metadata", "youtube-copy".

Habilidades Relacionadas