Communitygithub.com

yazzang-homelab/motion-studio

Planeje filmes de longa duração ou noturnos: briefing do diretor (PLANEJAR PRIMEIRO ou IR, orçamento, definição de pronto), GUIA DE ANIMAÇÃO + STORYBOARD, subagentes de capítulo, portões, renderização em blocos. Use para 'filme noturno', 'videoclipe', 'filme de 2 minutos'.

O que é motion-studio?

Esta skill transforma a ideia de um usuário em um briefing de produção completo e executa a produção através de portões de aprovação, permitindo a criação de filmes longos (como videoclipes noturnos ou filmes de 2 minutos) de forma estruturada e automatizada. Ela suporta a criação de um plano detalhado (briefing, storyboard, guia de animação), a distribuição do trabalho para subagentes especializados em cada capítulo e a renderização em segmentos retomáveis. A skill é ideal para produções que exigem alta coordenação e qualidade, pois cada etapa (do briefing à renderização final) é verificada por portões que garantem que o projeto atenda aos critérios de sucesso definidos. Ela é particularmente útil para desenvolvedores que desejam criar animações codificadas com consistência visual e sincronia precisa com a trilha sonora, oferecendo modos como 'PLANEJAR PRIMEIRO' para aprovação do plano ou 'IR' para execução contínua. O custo em tokens é alto, especialmente na fase de planejamento, mas é otimizado para evitar retrabalho em longas produções autônomas.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/yazzang-homelab/motion-studio/tree/HEAD/skills/director-brief

Perguntar na sua IA favorita

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

Documentação

Briefing do diretor (passo 10 do curso)

Filmes longos são produções. Os briefings por trás dos filmes noturnos no curso não descrevem um vídeo; eles contratam uma equipe: uma logline para verificar cada decisão, referências, ferramentas e orçamento, uma bíblia de personagens, uma pauta de ritmo, regras de texto na tela, portões, um ciclo de crítica e entregáveis. Esta skill transforma a ideia do usuário nesse briefing e executa a produção através de seus portões. Para clipes de até cerca de 45 segundos sem capítulos, use /motion-studio:motion-reel (o mesmo limite que essa skill usa para passar um filme mais longo para esta).

Argumentos, mostrados uma vez:

Os arquivos desta skill residem em ${CLAUDE_SKILL_DIR} (o modelo de briefing é ${CLAUDE_SKILL_DIR}/assets/brief-template.md, assets/brief-template.md).

Custo desta skill

Ela é executada com esforço max: o raciocínio mais profundo e o maior uso de tokens de qualquer skill do motion-studio. Erros de planejamento se acumulam ao longo de horas de trabalho autônomo, então o plano é onde esse gasto compensa. Defina expectativas com o usuário antes de começar. Pontos de dados relatados do curso: um videoclipe noturno durou cerca de 12 horas e usou cerca de 80% do uso de um plano Max mais $75 de crédito de API de imagem/vídeo; um curta de 45 segundos pintado à mão levou 163 chamadas de modelo, 62,7 milhões de tokens (96% leituras de cache), cerca de $34 aos preços de lista da API e cerca de 6,75 horas. Mantenha o resto mais barato: animadores de capítulo executam com seu próprio esforço (alto), e correções e re-renderizações são trabalhos de esforço médio. Diga ao usuário para reduzir o esforço da sessão com /model assim que o plano for aprovado, se o orçamento for importante.

1. Coletar as entradas

Apenas a sessão principal pode fazer perguntas ao usuário (subagentes não podem). Se o usuário ditou um briefing longo, analise-o em vez de perguntar novamente. Caso contrário, pergunte uma vez, em uma mensagem, sobre o que está faltando:

EntradaPor quê
logline, e o que o espectador deve sentir no finalcada decisão é verificada contra ela
duração, formatos, onde será publicadocontagem de capítulos, tempo de renderização, áreas seguras
referências (vídeo, quadros, biblioteca de imagens, repositório anteriorgramática a adotar, conteúdo a evitar
música: uma faixa (e sua licença) ou "sintetizar"a grade rítmica à qual tudo se prende
rota (A padrão; B apenas se eles nomearem Remotion/HyperFrames; C gerar-depois-traçar) e chaves de API por nome de variávelferramentas e gastos
orçamento: uso de modelo, APIs pagas, tempo realquando parar de gerar
modo: PLANEJAR PRIMEIRO ou IRse deve parar após o plano

2. Escrever docs/brief.md

  1. Se não houver studio.json, execute /motion-studio:studio-init primeiro (defina --duration, --bpm, --formats).
  2. Copie ${CLAUDE_SKILL_DIR}/assets/brief-template.md para docs/brief.md. Preencha a parte A com as respostas do usuário; mantenha a parte B como está.
  3. Atualize studio.json para corresponder (título, duração, fps, bpm, formatos, marca, loop).
  4. PLANEJAR PRIMEIRO: mostre o briefing preenchido e pare até que o usuário aprove. IR: registre cada decisão que você tomou para o usuário em docs/decisions.md e continue.

3. Portão 1: documentos do plano

ArquivoConteúdoQuem escreve
docs/style_guide.mdpaleta, tipo, ritmo, transições, textura, looks proibidossubagente style-analyst a partir de referências (/motion-studio:reference-style), ou você
docs/STORYBOARD.mda ideia, elenco, o que une tudo, capítulos com tomadas cronometradas e transiçõessubagente motion-director, ou você
docs/shotlist.mdcada tomada na grade rítmica (barras), câmera, texto, SFXmotion-director
plano do capítulo (no STORYBOARD)limites do capítulo nos downbeats, proprietário por capítulovocê

Meça ou sintetize a música antes de cronometrar qualquer coisa (/motion-studio:sound-design): os tempos dos capítulos e das tomadas são valores de grid.bar(n), não palpites. Mantenha os capítulos entre 8 e 30 segundos para que um subagente possa terminar e verificar um em uma sessão. O motion-director escreve apenas docs/** (o hook de guarda de função impõe isso).

4. Portão 2: rig e guia

  1. Escreva docs/ANIMATION_GUIDE.md a partir do modelo no docs/ do projeto antes de qualquer animador de capítulo começar, para que cada capítulo codifique no mesmo estilo: como um capítulo funciona, propriedade, layout e bandas reservadas, a API compartilhada, elementos compartilhados, regras de estilo com um orçamento de tempo de pintura e os comandos de verificação exatos.
  2. Construa você mesmo elementos compartilhados (herói, kit de UI, ajudantes de paleta) em film/scenes/shared_<nome>.js. Os animadores de capítulo os importam e nunca os editam. Renderize stills de cada elemento em cada estado.
  3. Faça o stub de cada capítulo para que o filme seja renderizado de ponta a ponta enquanto os capítulos estão em andamento:
// film/scenes/ch03_build.js (stub escrito pela sessão principal; o animador do capítulo substitui as tomadas)
import { chapter } from '../../lib/timeline.js';
export const BARS = [12, 20];                          // extensão em barras de docs/STORYBOARD.md (null = até o fim)
export default function ch03(ctx) {
  const FROM = BARS[0] === 0 ? 0 : ctx.grid.bar(BARS[0]);
  const TO = BARS[1] == null ? ctx.dur : ctx.grid.bar(BARS[1]);
  return chapter({ name: 'ch03_build', from: FROM, to: TO, shots: [], cues: [] });   // sem tomadas = cartão de placeholder
}
  1. Conecte film/film.js uma vez. buildFilm aceita resultados de chapter() dentro de scenes, achata suas cenas e mescla suas deixa. Camadas de filme inteiro (legendas, transições de emenda) vão nas overlays: Scene[] da fábrica: elas pintam após cada cena, na ordem do array, na mesma regra de from <= t < to (inclusivo no final no último quadro do filme), e elas nunca contam como tomadas, então os rótulos de stills, os limites de tomada de crítica e a faixa de visualização da lista de capítulos apenas tomadas. O código do capítulo permanece intocado; não envolva ou corrige funções draw do capítulo. Arrays aninhados, null e resultados de chapter() são aceitos em overlays também, então um capítulo pode enviar suas próprias cenas de overlay. Para empilhar cenas comuns, dê a uma cena um número layer (padrão 0): as cenas pintam por (layer, from).
import { defineFilm, scene } from '../lib/timeline.js';
import ch01 from './scenes/ch01_hook.js';
import ch02 from './scenes/ch02_problem.js';
import ch03 from './scenes/ch03_build.js';

const CHAPTERS = [ch01, ch02, ch03];

export default defineFilm((ctx) => ({
  scenes: CHAPTERS.map((make) => make(ctx)),
  overlays: [
    scene(0, ctx.dur, 'legendas', (g, lt, c) => { /* legendas do filme inteiro: desenhar a partir do tempo do filme c.t */ }),
    // uma cena curta por emenda de capítulo que precisa de uma transição, cronometrada a partir da grade
    scene(ctx.grid.bar(12) - 0.2, ctx.grid.bar(12) + 0.2, 'emenda-ch02-ch03', (g, lt, c) => { /* transição ou flash */ }),
  ],
  cues: (grid) => [{ t: grid.bar(0), type: 'hit' }],   // deixa do nível do filme; as deixa do capítulo são mescladas automaticamente
}));

5. Distribuir os capítulos

Gere um subagente chapter-animator (motion-studio:chapter-animator) por capítulo, vários em paralelo. Faça o briefing de cada um com: seu arquivo (film/scenes/chNN_<nome>.js), sua extensão (a exportação BARS em seu stub, mais a mesma extensão em segundos para os comandos de verificação), sua seção do STORYBOARD e "siga docs/ANIMATION_GUIDE.md". O hook de guarda de função permite que um animador de capítulo escreva apenas film/scenes/** (exceto film/scenes/shared_*, que permanecem somente leitura para animadores de capítulo, que relatam bugs em arquivos compartilhados) e out/check/**. Cada um retorna um relatório: o que construiu, verifica stills, problemas conhecidos e bugs que encontrou em arquivos compartilhados. Você corrige arquivos compartilhados, re-executa as verificações de filme inteiro e faz um novo briefing de um capítulo quando seu relatório mostra um problema.

As extensões dos capítulos são barras, computadas com ctx.grid dentro da fábrica do capítulo, para que capítulos consecutivos sempre se encontrem e sigam uma faixa medida. Os tempos das tomadas são segundos absolutos do filme obtidos da grade (shots: [{ at: grid.bar(13), name: 'montar', draw }, ...]); cada tomada vai até o at da próxima, e seu draw(g, lt, c) recebe lt do início da tomada. Uma tomada fora da extensão do capítulo faz chapter() lançar um erro e o filme para de carregar (por exemplo, um TO = 4 literal rejeita uma tomada em grid.bar(1) = 4,003 s assim que uma faixa medida coloca o primeiro downbeat em 2,0 s).

6. Portões 3 a 8

PortãoFaçaVerifique
3 stillsnode tools/stills.mjs --shots (um still por tomada)rodada de crítica (/motion-studio:critique-loop)
4 animaticnpm run animatic (meia escala, 30 qps, sem desfoque) com a faixa real ou placeholderritmo: cada leitura chega antes da próxima batida
5 amostra mais difícilnode tools/render.mjs --from A --to B --out out/check nos 2 a 4 s mais difíceisnode tools/critique.mjs --strip-at <t>; determinismo; sincronia
6 passagem completanenhum placeholder restante (nenhum rótulo de tomada em node tools/stills.mjs --shots termina em /placeholder)rodada de crítica em todo o filme
7 polimento e som/motion-studio:sound-design: trilha ou batidas, deixa, SFX, vozmétrica de sincronia, eixo de som
8 finalnpm run builda definição de pronto no briefing B6

Filmes longos são renderizados em segmentos retomáveis: node tools/render.mjs --format all --final --chunk 10 escreve out/<fmt>/.parts/seg_<a>_<b>.mp4 e pula segmentos finalizados quando reexecutado após uma interrupção. Execute renderizações longas em segundo plano (a ferramenta Bash run_in_background, ou um arquivo de log que você consulta) em vez de bloquear a sessão, e nunca espere em primeiro plano por mais de cerca de 2 minutos. Orce cerca de 20 s de tempo real por segundo de filme para três formatos a 60 qps e 4 subquadros (um filme de 2 minutos leva cerca de 40 minutos de renderização); o runbook do pipeline de /motion-studio:motion-reel tem o padrão e o tempo esperado de todos os outros comandos. Um chapter-animator ou qualquer outro subagente não deve retornar enquanto um comando que iniciou ainda estiver em execução.

7. Rota C: gerar-depois-traçar (opcional)

Apenas quando o briefing seleciona a rota C e lista as chaves (por nome de variável: FAL_KEY, ELEVENLABS_API_KEY em .env) e um orçamento. Modelos de vídeo fornecem física, tempo e rostos que são difíceis de codificar manualmente; a camada de código fornece uma aparência consistente que o usuário possui. Os espectadores veem a camada de código.

  1. Gere folhas de personagens e tomadas base com o serviço escolhido pelo usuário, seguindo seus próprios documentos. Salve cada resultado sob refs/base/ com uma linha de manifesto (serviço, modelo, prompt, semente, custo, licença). Pare no orçamento.
  2. Extraia quadros para estudar: node tools/refs.mjs extract refs/base/shot01.mp4 --every 0.1 --out refs/base/shot01.
  3. Redesenhe cada tomada em código em cima desse tempo (olhe para os quadros, reconstrua o movimento com molas e trilhas). A filmagem base nunca é carregada em tempo de renderização da rede; se uma tomada compõe um quadro base, carregue-o de um arquivo local em setup().
  4. Verifique a sincronia: stills da camada de código ao lado dos quadros base nos mesmos tempos, e as deixa de áudio na grade. Repita a etapa para qualquer tomada que se desvie.

Chaves: nunca imprima, ecoe, registre ou cole. As ferramentas leem .env por conta própria; nomeie a variável em prompts e documentos.

8. Definição de pronto e relatório

O B6 do briefing é o contrato: loudness -14 LUFS +-0,5 e <= -1 dBTP no MP4 entregue, pelo menos 3 rodadas de crítica com cada eixo >= 8 e nenhum P0 (npm run gate), uma re-renderização fornece quadros idênticos (verificação de determinismo de crítica mais valores framesDigest iguais de duas renderizações --hash), duração e quadros exatos em cada formato, e todos os entregáveis presentes (npm run deliver verifica a maior parte disso e escreve docs/production.json). Termine com o relatório B7: entregáveis, pontuações por rodada, gastos reais, defeitos conhecidos, o que você melhoraria na próxima.

Créditos: o esqueleto do briefing segue o passo 10 do curso; a divisão preencher / manter como está, PLANEJAR PRIMEIRO vs IR e uma definição de pronto seguem um padrão de modelo público de @pradeepXkapoor (reformulado); os portões de aceitação são adaptados de athemeroy/awesome-opus-5-5-videos docs/production-brief.md (CC BY 4.0); o padrão de subagente guia-mais-storyboard foi estudado em JohnHeibel/PDoomVideo (apenas ideias, nenhum texto reutilizado).

Próximo: /motion-studio:critique-loop após cada portão a partir do 3, então /motion-studio:ship-formats para entregar.

Individual skills in this repo

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

yazzang-homelab/motion-studio

Make Claude watch its own frames: critique.mjs evidence, harsh 7-axis scores, timestamped P0/P1/P2 problems in docs/review_log.md, fix the 3 worst, re-check, pass the gate. Use for 'critique it', 'review the frames', 'is it good'.

yazzang-homelab/motion-studio

Make a launch video, app or product reel, explainer or motion ad from code, end to end: brand assets from a URL, beat-grid shot list, synced sound, critique loop, all formats. Default for new video requests; not footage edits.

yazzang-homelab/motion-studio

Brand-asset stage of a product film (motion-reel runs the whole film): capture real screenshots, logo, colors and fonts from a URL, never redraw UI; brand story beats; voice + mascot. Use to grab or fix a brand's assets.

yazzang-homelab/motion-studio

Turn a reference (a frame, a video or an image library) into docs/style_guide.md and a beat-grid shot list: measure cuts, palette and pace, take grammar not content, wait for OK. Use when the user supplies or names a look.

yazzang-homelab/motion-studio

Build, debug or speed up the seek(t) render engine: render contract, canvas vs page capture, workers/subframes/chunks, determinism fixes, Remotion or HyperFrames handoff. Use for 'render is slow', 'frames differ', 'use Remotion'.

yazzang-homelab/motion-studio

Ship every format from one timeline, then package it: layout() reframing (never crop), render all formats, per-format checks, deliver.mjs, a brand skill, a service offer. Use for 'export 9:16 and 16:9', 'deliver', 'make a skill'.

yazzang-homelab/motion-studio

The viral one-line 'showreel for a résumé' prompt: why it works (anatomy), the credited quote, and seeded variants that avoid look-alike reels; runs it as an engine test. Use for that prompt, its variations, or a showreel.

yazzang-homelab/motion-studio

Score a film to its beat grid: measure a track (beats.mjs) or synthesize one (score.mjs), cue SFX from the film, add voice, mix to -14 LUFS / -1 dBTP at exact length. Use for 'add music', 'sync to the beat', 'SFX', 'loudness'.

yazzang-homelab/motion-studio

Make motion feel physical with closed-form springs from lib/motion.js: presets, springFromFeel, track() for multi-target values, loopTrack loops, indicators, text swaps. Use for 'feels linear', 'add bounce', 'easing to springs'.

yazzang-homelab/motion-studio

Scaffold a motion-studio film project (seek(t) renderer, springs, beat grid, synthesized sound, critique tools), install it, set up the browser, run doctor. Use for 'set up the motion studio', 'new film project', 'init studio'.

yazzang-homelab/motion-studio

Write a six-part XML state spec for a one-shape UI morph film (inputs, direction, structure, build, gotchas, start): states on downbeats, cursor-driven changes, seamless loop, approval gate. Use for 'UI morph', 'state list'.

Habilidades Relacionadas