Frontends com Vibecoding · Capítulo 32 de 33 · 41 min
Especificar, medir e produzir as cenas da máquina
Segundo capítulo do bônus: a ficha de dez campos que o agente recebe antes de construir, quatro agentes em raias trocando mensagens, o medidor de quadros com a gravação da própria cena em vídeo, e a esteira de imagem e vídeo gerados por IA com os três caminhos da imersão.
Este capítulo faz parte do curso gratuito Frontends com Vibecoding.
Uma cena que ensina nasce de uma ficha de dez campos preenchida antes do primeiro pedido ao agente, e uma cena que só impressiona nasce de uma frase solta. A ficha é o contrato entre quem pede e quem constrói. Ela cabe numa página, leva vinte minutos e é o que separa a demonstração do enfeite.
O que separa as duas é o número de rodadas de crítica que a cena atravessa. Um modelo mediano dentro de um laço com print, lista de conferência e correção entrega mais que um modelo de topo respondendo uma vez. Por isso a ficha termina num campo de crítica, e é justamente esse campo que o dono do negócio costuma cortar primeiro.
A metáfora que funciona é a ordem de serviço da oficina, e a que atrapalha é o briefing criativo. A ordem de serviço diz o que medir para dar a peça por pronta; o briefing diz o que sentir. O agente executa bem a primeira e improvisa na segunda.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Os dez campos vêm em ordem de decisão. O objetivo didático diz, em uma frase, o que a pessoa leiga percebe em dez segundos. A metáfora nomeia a imagem de negócio e a imagem a evitar, porque o maestro, o cérebro brilhante e o robô genérico entram sozinhos quando ninguém os proíbe. O roteiro divide os 10 a 20 s em quadros com o que aparece e o que a pessoa percebe.
O dado real carrega valor, fonte, data e rótulo, e o rótulo é a parte que viaja com o número: medido, anunciado ou cenário ilustrativo. A biblioteca entra pelo degrau mais barato que resolve, com a razão de não ficar no degrau de baixo escrita em uma frase.
Os quatro estados obrigatórios são a metade que os pedidos esquecem. Sem JavaScript, a figura estática conta a mesma história. Com movimento reduzido, nada anda sozinho e a pessoa avança por botão. Sem WebGL ou sem a API, o aviso aparece e a alternativa fica. No celular fraco, o teto de partículas, corpos e quadros já está decidido.
O orçamento traz o peso antes e depois do clique e o quadro de 16,7 ms a 60 Hz, com zero quadros longos durante a interação. A acessibilidade fixa o rótulo do palco, a região de status única, o teclado e o contraste AA. O critério de aceite é a lista do que se mede, e o prompt-contêiner é o pedido pronto, montado com tudo isso.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
As sete cenas do bônus já têm a ficha rascunhada, e a tabela abaixo traz o essencial de cada uma: o objetivo, a metáfora e o degrau. O dado real de cada linha está na aula que a constrói, com fonte e data, e a ficha completa da primeira cena está no arquivo para download no fim desta aula.
As sete cenas do bônus em uma linha cada
| Cena | O que a pessoa percebe em dez segundos | Metáfora (e a que evitar) | Degrau que resolve |
|---|---|---|---|
| Orquestrador | O tempo de parede é o do mais lento, e não a soma | Balcão de despacho (evitar o maestro) | React Flow; figura em SVG |
| Harness | O resultado reprovado volta ao começo antes de virar resposta | Anel da esteira com portão (evitar o gênio que acerta de primeira) | SVG à mão; Motion para destacar etapas |
| Paralelismo | Mil tarefas terminam quase juntas e a soma no fim não encolhe | Porto com guindastes (evitar o caminhão mais veloz) | Canvas 2D com Web Workers |
| Velocidade | Espera pela primeira palavra e ritmo de geração são medidas distintas | Atender o telefone e ditar (evitar o cronômetro único) | GSAP com number-flow |
| Agentes em paralelo | Cada raia anda no próprio ritmo e a mensagem cruza de raia em raia | Raias de piscina (evitar a fila reta) | Motion; SVG estático |
| Robô | A garra obedece a um alvo e o cubo obedece à gravidade | Ensaio numa réplica digital (evitar o filme de robô) | Three.js com Rapier, só depois do botão |
| Imersão | A perspectiva responde à cabeça e a mão toca o objeto | Sala de demonstração (evitar o vídeo em 360 graus) | model-viewer; WebXR; elemento model |
O dado real, os estados obrigatórios e o critério de aceite de cada cena estão na aula correspondente e na ficha para download.
Escrita em YAML, um formato de texto com campos e recuos que o agente lê sem esforço, a ficha vira parte do pedido. O trecho abaixo é a ficha da primeira cena, encurtada para caber; a versão inteira e o modelo em branco estão no download. O pedido em si, com assunto, restrições pelo nome, componentes, cenário fixo e a crítica com print, está em prompt-conteiner-cena.txt.
cena: orquestrador com harness
objetivo_didatico: a pessoa percebe que o tempo de parede é o do modelo mais lento e que a verificação devolve o reprovado ao começo
metafora: balcão de despacho de transportadora; evitar o maestro, que esconde a volta
roteiro:
- 0-3 s: o pedido entra e o orquestrador parte em cinco tarefas; cinco arestas acendem juntas
- 3-12 s: as cinco correm; a barra de parede cresce; a soma cresce cinco vezes mais rápido
- 12-15 s: a verificação reprova uma resposta; a aresta de volta fica vermelha; a tarefa reexecuta
- 15-20 s: a resposta sai; a leitura compara 221 s de parede com 360 s de soma
dado_real: { valor: "parede 221 s; soma 360 s; US$ 0,48", fonte: "geo-orchestrator, board de 5 modelos", data: "25/09/2026", rotulo: medido }
biblioteca: { degrau: "React Flow", pacote: "@xyflow/react ^12.11.3", por_que_nao_o_de_baixo: "o grafo tem estado por nó, zoom e toque" }
estados_obrigatorios:
sem_javascript: figura em SVG do anel do harness com legenda que afirma a volta
movimento_reduzido: sem aresta animada; botão "Avançar etapa"
celular_fraco: nove nós; grade 3 mais 2 abaixo de 1150 px
orcamento: { antes_do_clique_kb: 0, depois_kb: 45, quadro_ms: 16.7, quadros_longos: 0 }
acessibilidade: { palco: 'role="img" com resumo', status: "uma região, narração por etapa", toque_px: 44 }
criterio_de_aceite:
- no modo paralelo a leitura de parede é igual à maior duração, nunca à soma
- com a verificação ligada existe exatamente uma volta e a leitura conta uma reexecução
- com movimento reduzido nenhuma aresta se move e a cena avança só por botãoAntes de mandar o pedido, releia os campos 4 e 9. Se o dado real não tem fonte e data, ele vira cenário ilustrativo e o rótulo entra colado ao número. Se o critério de aceite não pode ser medido por alguém que não construiu a cena, ele ainda é desejo. Com os dois em ordem, o agente recebe um contrato, e a cena volta explicando em vez de decorando.
Mostrar vários agentes trabalhando e trocando mensagens
A ficha já diz o que cada cena precisa provar, e a primeira cena que ela encomenda é a dos agentes em paralelo, em raias que vêm do rastro e não da memória.
Vários agentes trabalhando ao mesmo tempo se mostram em raias, uma por agente, com as mensagens cruzando de raia em raia e o relógio parando quando o mais lento termina. Raia é a faixa horizontal que os painéis de rastro usam para dizer quem fez o quê e quando. Um desenho de fila, um agente depois do outro, ensina o contrário do que aconteceu.
A cena precisa distinguir seis coisas: agente, tarefa, tentativa, ferramenta, mensagem e estado. Sem isso, duas tarefas lado a lado no desenho podem ter acontecido em sequência, e o visitante não tem como saber. Por isso a raia nasce de eventos com hora de início e fim, e não de uma ilustração feita de memória.
Esses eventos já têm nome padronizado. As convenções da OpenTelemetry para IA generativa nomeiam três trechos de um rastro: a chamada ao modelo, a execução de ferramenta e a invocação de um agente. Langfuse, Arize Phoenix e outros rastreadores as adotaram em 2026, e cada trecho traz entradas, saídas, tokens e tempo. A cena didática é a leitura desse rastro em forma de raias.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
As ferramentas de 2026 mostram o mesmo padrão em versões próprias. O Claude Code passou, em junho e julho de 2026, a exibir a árvore de subagentes crescendo e estados coloridos por linha, com os subagentes rodando em segundo plano por padrão. O Codex ganhou, em 9 de setembro de 2026, pastas de trabalho isoladas por sessão, e a visão geral de agentes mostra quem é dono de cada uma.
A pasta isolada é o detalhe que a cena precisa carregar. Cada agente edita a própria cópia dos arquivos, e o principal junta tudo no fim; sem isso, dois agentes gravam no mesmo lugar e um apaga o outro. Na raia, um rótulo pequeno diz pasta isolada, e a fusão aparece como a última barra do principal.
Quatro formas de mostrar agentes e o que cada uma responde
| Forma | Responde a | Regra de desenho | Quando falha |
|---|---|---|---|
| Raias (swimlane) | Quem fez o quê, quando, e quem falou com quem | Uma raia por agente; mensagem liga dois eventos com hora | Acima de oito agentes a tela vira macarrão |
| Gantt de agentes | Quanto durou, quanto sobrepôs, quem esperou | Barra do início ao fim, vinda do rastro, escala de tempo visível | Esconde as mensagens e a reprovação |
| Árvore de subagentes | Quem delegou para quem e em que profundidade | Nó filho abaixo do pai, estado colorido por nó | Não mostra o tempo nem o paralelismo |
| Grafo de mensagens | Quem depende de quem | Nó por agente, aresta por mensagem com direção | Perde a ordem temporal; vira o orquestrador da aula 1 |
A raia é a única que mostra tempo, autoria e mensagem ao mesmo tempo; as outras servem de complemento.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
O laboratório abaixo monta essa cena com o Motion, o pacote de animação declarativa para React que a trilha de movimento ensina. Quatro raias, sete barras e nove mensagens seguem um roteiro fixo de 60 s de modelo, e cada mensagem é um cartão que voa da raia de origem à de destino por mola. Reproduza, pause e percorra o tempo pelo controle deslizante; depois esconda as mensagens e repare como a leitura piora.
Ver quatro agentes em raias trocando mensagens e a revisão devolvendo um trecho
Reproduza os 60 s de modelo, percorra o tempo pelo controle e esconda as mensagens para comparar a leitura; repare no tempo de parede contra a soma.
Demonstração com o Motion de quatro agentes em raias, um principal e três de trabalho, numa linha do tempo de 60 s de modelo: barras de execução por agente, mensagens que voam de raia em raia, um pedido de dado da redação ao principal, uma reprovação da revisão que volta à redação em vermelho e a montagem final. Controles de reproduzir, pausar, reiniciar, percorrer o tempo e esconder as mensagens; a leitura mostra agentes ativos, mensagens trocadas e o tempo de parede contra a soma das barras. Com movimento reduzido ativo, nada voa e o controle deslizante percorre a cena.
A demonstração interativa carrega quando este trecho entra na tela.
Quatro erros didáticos aparecem em quase todo pedido. A fila reta, que apaga o paralelismo. A mensagem escondida, que deixa a raia parecer trabalho solitário. A ausência de reprovação, que ensina que agente é sinônimo de acerto. E a fusão sem pasta isolada, que faz o visitante pensar que dois agentes editam o mesmo arquivo ao mesmo tempo sem conflito.
O trecho abaixo mostra a peça que o Motion acrescenta ao desenho. O cartão de mensagem sai de uma raia e chega à outra por mola, e a mesma configuração respeita quem pediu menos movimento. O componente inteiro está no download.
import { AnimatePresence, MotionConfig, motion, useReducedMotion } from "motion/react";
type Mensagem = { id: string; de: Raia; para: Raia; t: number; tipo: "pedido" | "dado" | "reprovado" | "entrega" };
const ALTURA_RAIA = 72, LARGURA_SEGUNDO = 14;
const y = (raia: Raia) => RAIAS.indexOf(raia) * ALTURA_RAIA + 20;
function Cartao({ m }: { m: Mensagem }) {
const reduzido = useReducedMotion() === true;
const voo = reduzido ? { duration: 0 } : { type: "spring" as const, stiffness: 260, damping: 26 };
return (
<motion.div className={estilos.cartao} data-tipo={m.tipo}
initial={{ x: m.t * LARGURA_SEGUNDO, y: y(m.de), opacity: reduzido ? 1 : 0 }}
animate={{ x: m.t * LARGURA_SEGUNDO, y: y(m.para), opacity: 1 }}
exit={{ opacity: 0 }} transition={voo}>
{m.tipo === "reprovado" ? "reprovado: refaz" : m.tipo}
</motion.div>
);
}
export function Mensagens({ agora }: { agora: number }) { // agora = segundos de modelo
const visiveis = MENSAGENS.filter((m) => m.t <= agora && agora < m.t + 4);
return (
<MotionConfig reducedMotion="user">
<AnimatePresence initial={false}>{visiveis.map((m) => <Cartao key={m.id} m={m} />)}</AnimatePresence>
</MotionConfig>
);
}Antes de aprovar a cena de agentes, peça o rastro que a alimenta. Se as barras não vêm de eventos com hora, a cena é ilustração e precisa do rótulo.
Se vêm, confira três coisas na tela: a mensagem de volta da revisão existe, a raia mais lenta manda no relógio, e a pasta isolada aparece onde dois agentes escrevem. Com as três, a cena explica o paralelismo de verdade, e não a versão bonita dele.
Medir a velocidade da cena e gravá-la em vídeo
Com as raias desenhadas, a cena precisa provar a própria velocidade e chegar a quem não pode rodá-la: entram o medidor de quadros e a gravação em vídeo.
Uma cena que demonstra velocidade precisa provar a própria velocidade, e a prova cabe em dois instrumentos: um medidor de quadros ao lado do palco e uma gravação em vídeo da cena rodando. O medidor mostra se a cena cabe no orçamento do quadro. O vídeo leva a cena a quem não pode rodá-la: a página de venda, o e-mail e o celular fraco.
O orçamento do quadro é uma conta simples. A tela comum redesenha 60 vezes por segundo, então cada quadro tem 16,7 ms para script, estilo, layout e pintura. Telas de 120 Hz cortam isso para 8,3 ms. Quadro que passa de 50 ms é quadro longo, o limiar que a API Long Animation Frames do Chrome registra desde a versão 123, com o quanto do tempo foi bloqueio.
A métrica que o Google usa para responsividade se chama INP, o tempo entre o toque e o próximo quadro pintado, e boa é até 200 ms. A cena que trava 300 ms ao disparar perde 18 quadros e estoura essa métrica sozinha. O medidor existe para a pessoa ver esse estouro antes do visitante.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Medir é ler três coisas, e cada uma tem um instrumento. Os quadros por segundo e o pior tempo de quadro saem de requestAnimationFrame, o relógio que o navegador oferece a cada redesenho. Os quadros longos saem da API Long Animation Frames, com o observador de desempenho. E a interação real sai do INP medido em campo, pela biblioteca web-vitals, porque o laboratório mostra o pior caso e o campo mostra o caso comum.
O painel Performance do Chrome fecha a conta quando o número acusa mas não explica. Ele separa tempo de script, de layout e de pintura por quadro, e diz em qual dos três a cena estourou. Safari e Firefox não expõem a API de quadros longos em setembro de 2026, então o medidor cai para requestAnimationFrame e avisa.
Três provas de velocidade e o instrumento de cada uma
| O que provar | Instrumento | Leitura boa | Onde falha |
|---|---|---|---|
| A cena cabe no quadro | requestAnimationFrame: quadros por segundo e pior quadro em janela de 1 s | 60 por segundo, pior quadro abaixo de 16,7 ms | Não diz por que o quadro estourou |
| Nada bloqueia a pessoa | Long Animation Frames API pelo PerformanceObserver | Zero quadros de 50 ms ou mais durante a interação | Só Chrome e Edge desde a versão 123 |
| O visitante real responde rápido | INP em campo pela web-vitals | Até 200 ms no percentil 75 | Mede depois de publicar, e não antes |
| Onde está o gargalo | Painel Performance do Chrome DevTools | Script, layout e pintura separados por quadro | Exige gravar uma interação de verdade |
O laboratório abaixo traz os dois primeiros instrumentos ao lado da cena; o terceiro entra depois de publicar; o quarto é o painel do navegador.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Gravar a cena no próprio navegador pede duas APIs da plataforma. O canvas oferece um fluxo de vídeo por captureStream, e o MediaRecorder grava esse fluxo em pedaços até virar um arquivo. O codec, que é o formato de compressão do vídeo, muda por navegador. O Chrome grava VP8, VP9 e H.264, com AV1 onde o aparelho acelera. O Safari só passou a gravar WebM, VP9, HEVC e AV1 na versão 18.4.
Por isso a cena pergunta antes de gravar, com isTypeSupported, e pede os formatos em ordem: AV1, VP9, VP8 e H.264. Vídeo gerado assim pesa e não responde ao toque. Ele substitui a cena ao vivo na página de venda, no e-mail e no celular fraco, e nunca onde a pessoa precisa mexer, pausar estados ou ler mensagens.
O laboratório abaixo faz as duas provas na mesma tela. O primeiro painel roda partículas entre três estações com o medidor ao lado: mude a quantidade, aperte o botão que sobrecarrega 300 ms e veja o quadro longo aparecer. O segundo grava seis segundos da cena, mostra o codec escolhido, toca a gravação e oferece o arquivo para baixar.
Medir o quadro da cena e gravar seis segundos dela em vídeo
Suba as partículas, force um bloqueio de 300 ms e leia o medidor; depois grave seis segundos, veja o codec escolhido e baixe o arquivo.
Demonstração em dois painéis, só com APIs do navegador. No primeiro, uma cena em Canvas 2D com 120 a 5.000 partículas correndo entre três estações, e um medidor que lê quadros por segundo, tempo médio e pior tempo do quadro, quadros longos pela API Long Animation Frames e o orçamento de 16,7 ms; um botão sobrecarrega o quadro por 300 ms para o medidor registrar. No segundo, um botão grava seis segundos da cena por captureStream e MediaRecorder, informa o codec escolhido por isTypeSupported, exibe a gravação e oferece o arquivo WebM ou MP4 para baixar. Sem MediaRecorder, aparece o aviso com a alternativa. Com movimento reduzido ativo, a cena abre parada e anda só por botão.
A demonstração interativa carrega quando este trecho entra na tela.
Quando a cena é 3D pesada ou precisa repetir a mesma sequência sem variação, a gravação sai do navegador do visitante e vai para o servidor. O Remotion transforma componentes React em vídeo quadro a quadro, com renderização em servidor ou em esteira de integração. O Playwright e o Puppeteer gravam a tela de um navegador controlado, com versão de navegador, fontes e parâmetros fixados.
O trecho abaixo é a espinha do laboratório: a escolha do codec em ordem, o gravador com os pedaços e o observador de quadros longos. O componente inteiro está no download.
// 1. O codec em ordem de preferência: o primeiro que o navegador aceita entra.
const PREFERIDOS = ["video/webm;codecs=av1", "video/webm;codecs=vp9", "video/webm;codecs=vp8",
"video/mp4;codecs=avc1.42E01E", "video/mp4"];
const mimeType = PREFERIDOS.find((m) => MediaRecorder.isTypeSupported(m));
// 2. Seis segundos da cena: o canvas vira fluxo, o gravador junta os pedaços num Blob.
const fluxo = canvas.captureStream(30);
const gravador = new MediaRecorder(fluxo, mimeType ? { mimeType, videoBitsPerSecond: 4_000_000 } : undefined);
const pedacos: Blob[] = [];
gravador.ondataavailable = (e) => { if (e.data.size) pedacos.push(e.data); };
gravador.onstop = () => {
const blob = new Blob(pedacos, { type: gravador.mimeType });
video.src = URL.createObjectURL(blob); // toca a gravação feita agora
link.download = gravador.mimeType.includes("mp4") ? "cena.mp4" : "cena.webm";
fluxo.getTracks().forEach((t) => t.stop());
};
gravador.start(500);
setTimeout(() => gravador.stop(), 6000);
// 3. Quadros longos: a API registra o que passou de 50 ms e quanto foi bloqueio.
interface QuadroLongo extends PerformanceEntry { blockingDuration: number }
if (PerformanceObserver.supportedEntryTypes.includes("long-animation-frame")) {
new PerformanceObserver((lista) => {
for (const q of lista.getEntries() as QuadroLongo[]) registrar(q.duration, q.blockingDuration);
}).observe({ type: "long-animation-frame", buffered: true });
}Antes de aprovar uma cena de velocidade, exija as duas provas juntas. A primeira é o print do medidor sem quadro longo ao disparar a cena no celular de referência. A segunda é o arquivo de vídeo gravado dela, com o codec e o peso anotados. Quem entrega só a cena está pedindo que você acredite. Quem entrega as provas está mostrando, e mostrar é o assunto deste capítulo.
Gerar imagem e vídeo por IA e oferecer a imersão certa
Medida e gravada, a cena ainda pede as ilustrações e o clipe gerados com o estilo da casa, e a decisão sobre qual caminho de imersão oferecer.
Imagem e vídeo gerados por IA entram na cena da máquina com três regras: estilo fixo escrito uma vez, nenhum texto dentro da imagem e o dado sempre na legenda. As ilustrações deste capítulo e o clipe desta aula saíram dessa esteira, e o pedido inteiro está no download. A imersão fecha a aula, porque é a decisão que mais gente erra ao confundir vídeo em 360 graus com cena.
A esteira de imagem tem quatro peças. O estilo fixo é um parágrafo que vai na frente de todo pedido: isometria suave, paleta da casa, pessoas brasileiras estilizadas, nada de robô genérico nem cérebro brilhante.
A encomenda é um arquivo com cena, texto alternativo e legenda por imagem. O script gera pelo modelo gemini-3-pro-image, o Nano Banana Pro, e converte para WebP de 1280 px com teto de 90 kB. O manifesto guarda largura, altura e bytes de cada saída.
A proibição de texto na imagem é a regra que mais economiza. Número, marca e legenda ficam no HTML, onde têm fonte, data e podem ser corrigidos sem gerar a imagem de novo. Imagem com número vira print, e o print viaja sem a fonte.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
O vídeo segue a mesma lógica, com um custo a mais. O clipe abaixo foi pedido ao Veo 3.1 Fast em 25 de setembro de 2026: oito segundos, 1280 por 720, 24 quadros por segundo. O preço publicado da Gemini API é de US$ 0,10 por segundo em 720p, ou seja, US$ 0,80 pelo clipe. A espera foi de cerca de três minutos e o arquivo chegou com 3,49 MB, em H.264 com áudio.
A conversão para a web tirou o áudio, porque a peça é decorativa e toca muda. Saíram duas versões, WebM em VP9 com 1,78 MB e MP4 em H.264 com 1,34 MB, mais um pôster em WebP de 93 kB. Com movimento reduzido ativo, o pôster aparece no lugar do vídeo. Vídeo com fala ou com dado pediria o player completo, legenda e transcrição; este não tem nem um nem outro.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Duas linhas do pedido explicam o resultado. A paleta e o estilo isométrico vieram do mesmo parágrafo das imagens, o que faz o clipe parecer irmão das ilustrações. E a lista do que não pode aparecer, pessoas, texto, números, logotipos e legendas, evita a marca de terceiro no meio da sua página.
Toda saída do Veo e do Nano Banana Pro carrega a marca d'água invisível SynthID e credenciais de conteúdo C2PA assinadas pela Google. Elas dizem que a peça foi gerada, e só isso. Licença de uso é outra coisa: os termos comerciais são os do plano da API, conferidos na data.
O trecho abaixo é o pedido real ao modelo de vídeo, como foi enviado. O download traz o estilo fixo, a encomenda das imagens, o pedido e os comandos de conversão.
POST https://generativelanguage.googleapis.com/v1beta/models/veo-3.1-fast-generate-preview:predictLongRunning
x-goog-api-key: <chave da Gemini API>
{
"instances": [{
"prompt": "Clean 3D rendered animation, soft isometric look with flat colors and gentle shading, palette of blue #0070CA, graphite #1F2937 and a few coral #F2635B accents on an off-white #F7F7F5 background. A modern container port seen from above at a slight angle: dozens of identical blue gantry cranes move hundreds of identical containers at the same time onto a grid of graphite container stacks, all cranes cycling in a steady synchronized rhythm; a large white analog stopwatch with a blue hand sits in the foreground, its hand barely moving. Smooth slow camera push-in, steady lighting, no people, no text, no letters, no numbers, no logos, no watermarks, no captions."
}],
"parameters": { "aspectRatio": "16:9", "resolution": "720p", "durationSeconds": 8 }
}
// A resposta é uma operação: GET /v1beta/<name> a cada 10 s até "done": true,
// depois baixe response.generateVideoResponse.generatedSamples[0].video.uri com ?alt=media.
// Conversão para a web, sem áudio (ffmpeg 8.1):
// ffmpeg -i veo.mp4 -an -c:v libvpx-vp9 -b:v 0 -crf 34 -row-mt 1 saida.webm (1,78 MB)
// ffmpeg -i veo.mp4 -an -c:v libx264 -preset slow -crf 26 -movflags +faststart saida.mp4 (1,34 MB)
// ffmpeg -ss 1.5 -i veo.mp4 -frames:v 1 -vf scale=1280:-2 poster.webp (93 kB)A imersão tem três caminhos em setembro de 2026, e a escolha depende do que a pessoa vai fazer. Para mostrar um objeto pronto, o model-viewer do Google, na versão 4.3.1 de junho de 2026, exibe um arquivo GLB na página. A realidade aumentada abre pelo WebXR ou pelo Scene Viewer no Android e pelo Quick Look no iPhone.
Para a pessoa mexer numa cena própria, com física e visor, o caminho é o WebXR com Three.js, como no robô do capítulo anterior.
O terceiro caminho é novo. No Safari 27 do visionOS 27, o elemento model exibe um arquivo USDZ em escala real, e a Immersive API, parecida com a de tela cheia, abre um ambiente em volta da página inteira. Com o elemento escondido até o pedido, o arquivo só desce para quem entra.
Um vídeo em 360 graus não é nenhum dos três: a perspectiva precisa responder à cabeça e a mão precisa tocar o objeto.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Que caminho de imersão para que pedido
| Quando | Caminho | Aparelhos em setembro de 2026 | Peso e custo |
|---|---|---|---|
| Mostrar um produto ou modelo pronto, com realidade aumentada no celular | model-viewer 4.3.1 com GLB e USDZ gerado | Android por WebXR ou Scene Viewer; iPhone por Quick Look; qualquer navegador para ver | Componente mais o modelo; o GLB costuma pesar mais que o código |
| A pessoa mexe numa cena própria, com física, e entra com o visor | WebXR com Three.js, React Three Fiber e @react-three/xr | Quest Browser; Chrome no Android XR; visor conectado ao computador | Cerca de 2,5 MB, só depois do botão que declara o peso |
| Um ambiente em volta da página inteira | Elemento model e Immersive API do Safari 27 | Só visionOS 27; o elemento fica escondido até o pedido | Um arquivo USDZ, baixado só por quem entra |
| Ilustrar sem interação | Vídeo gerado e convertido, com pôster | Todos | 1 a 2 MB por oito segundos em 720p |
Comece pelo caminho de mostrar; suba para mexer só quando a interação for o que ensina, e ofereça o ambiente em volta como extra para quem tem o visor.
Antes de aprovar imagem, vídeo ou imersão gerados, cobre três coisas de quem entregou. A primeira é o arquivo da encomenda, com o estilo fixo e a proibição de texto. A segunda é o manifesto com peso e dimensões de cada saída. A terceira é a legenda com o dado, a fonte e a data.
Se o número estiver dentro da imagem ou do vídeo, peça de novo: a peça envelhece na primeira correção, e a legenda não.
Guia prático: a fórmula do pedido de quadro e de vídeo
A ficha de cena diz o que a cena precisa ensinar; falta a fórmula do pedido que gera a imagem e o clipe. O acervo de técnicas de cinema estudado em 07/10/2026 tem 424 técnicas, cada uma com três exemplos, 1.272 no total, e todos os pedidos de quadro seguem quatro blocos na mesma ordem.
| Bloco | O que leva | Palavras em média |
|---|---|---|
| Técnica | Enquadramento, luz, lente ou efeito | cerca de 16 |
| Sujeito | Quem, roupa, ação, lugar e hora do dia | 19 |
| Ambiente | Cinco ou seis itens concretos: fonte de luz, material, fumaça, reflexo | 18 |
| Fecho de estilo | O mesmo em todos os pedidos, com a proporção | 4 |
O pedido de quadro tem 57 palavras em média (de 45 a 81). O de vídeo tem 31 e é outro texto: só o movimento de câmera e o sujeito, sem ambiente e sem proporção, que já vieram do quadro. Dos 136 modelos de vídeo, 92% têm uma frase só, com uma ação de câmera. Onde há duração, 9 em 12 usam 6 segundos. Em 15% a câmera fica fixa por escrito e 13% dizem o que não pode acontecer, como zoom ou tremor. A documentação do Veo confirma o fluxo: a imagem enviada vira o primeiro quadro do vídeo, e os clipes saem com 4, 6 ou 8 segundos.
A revisão também tem fórmula. Em 423 das 424 técnicas, o acervo descreve o sinal de que a imagem saiu errada e, em 346, o ajuste que corrige. Em 362, nomeia a técnica vizinha que costuma sair no lugar da pedida, como o zoom que aparece quando se pede câmera andando.
QUADRO (cerca de 60 palavras)
[técnica: enquadramento, luz ou lente], [sujeito: quem, roupa, ação, lugar,
hora do dia], [ambiente: 5 ou 6 itens concretos de luz, material e textura],
[fecho fixo da série: estilo da casa, proporção].
VÍDEO (cerca de 30 palavras, a partir do quadro aprovado)
[um movimento de câmera], [o mesmo sujeito, com uma ação], [o que a câmera
NÃO faz: sem zoom, sem corte, sem tremor], [duração: 6 segundos].
REVISÃO
Sinal: [o que está errado na imagem, em uma frase].
Ajuste: [o que muda no bloco da técnica ou do ambiente].Do campo da ficha ao quadro e ao clipe aprovados
Cinco passos. Primeiro o quadro parado; o movimento só entra sobre um quadro aprovado.
Passo 1: Fixe o fecho de estilo da série
Escreva uma vez o fecho que vai em todos os pedidos: estilo da casa, paleta e proporção. É ele que faz o topo, os cartões e o clipe parecerem da mesma família.
Deu certo quando: Todas as imagens da página usam o mesmo fecho, palavra por palavra.
Erro comum: Reescrever o estilo a cada pedido e receber cinco imagens que não combinam.
Passo 2: Monte o quadro em quatro blocos
Técnica, sujeito, ambiente e fecho, nessa ordem, com cerca de 60 palavras. O ambiente leva coisas que se veem, e não adjetivos: janela à esquerda, bancada de madeira, vapor no ar.
Deu certo quando: O pedido tem os quatro blocos e o ambiente lista cinco itens concretos.
Erro comum: Escrever "cena bonita e profissional" no lugar do ambiente.
Passo 3: Aprove o quadro antes do movimento
Gere de três a cinco quadros, escolha um e só então peça o vídeo, usando o quadro como primeiro quadro. Erro de luz ou de rosto se corrige parado, que custa menos.
Deu certo quando: O vídeo parte de um quadro que você já aprovou.
Erro comum: Pedir o vídeo direto do texto e pagar várias gerações de clipe para acertar a luz.
Passo 4: Escreva o vídeo com uma ação e uma negação
Um movimento de câmera, o mesmo sujeito, o que a câmera não faz e 6 segundos. Precisa de dois movimentos? São dois clipes.
Deu certo quando: O pedido de vídeo tem uma frase e cerca de 30 palavras.
Erro comum: Pedir aproximação, giro e corte no mesmo clipe e receber uma câmera indecisa.
Passo 5: Revise pelo sinal e pelo ajuste
Diante de uma saída ruim, escreva o sinal do erro em uma frase e mude só o bloco responsável. Confira se não saiu a técnica vizinha: no zoom, o fundo não desliza; quando a câmera anda, desliza.
Deu certo quando: Cada nova tentativa muda um bloco só, com o motivo anotado.
Erro comum: Reescrever o pedido inteiro a cada tentativa e não saber o que resolveu.
No fim você tem: Quadros e clipes da cena gerados por fórmula, com estilo constante e uma revisão que muda uma coisa por vez.
Designer de uma marca de café especial de Minas Gerais que monta a página de uma linha nova
Alimentos, loja online
Dor
As imagens geradas para o topo e os cartões saíam em estilos diferentes, e o clipe de fundo mudava a luz e o rosto da barista no meio do movimento.
Solução
Ela fixou um fecho de estilo para a série, montou cada quadro em quatro blocos com luz de janela e vapor no ambiente e só pediu o vídeo sobre o quadro aprovado: aproximação lenta, câmera sem tremor, 6 segundos.
Resultado
Topo, cartões e clipe passaram a parecer da mesma sessão de fotos, e o clipe manteve a luz e o rosto do quadro aprovado.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. Nos vídeos e áudios, use Anotar este momento. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Conexões deste capítulo
Veja o que estudar antes e para onde seguir depois, explore os conceitos e compare abordagens em outros cursos. Sugestões marcadas como “sugerido pelo grafo” vêm dos assuntos em comum, não do índice do curso.
Estude antes
- CursoClaude Code CLI: Programação com IA
- Montar vídeo em React com Remotion e renderizar na sua máquina ou na AWSsugerido pelo grafoApresenta o conceito “React”, usado em “Especificar, medir e produzir as cenas da máquina”.
- CursoVídeo com IA: Claude Code, Codex e ElevenLabssugerido pelo grafo20 capítulos de “Frontends com Vibecoding” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
- CursoNode.js: JavaScript no Servidorsugerido pelo grafo20 capítulos de “Frontends com Vibecoding” usam conceitos apresentados em “Node.js: JavaScript no Servidor”.
Depois, siga para
- CursoPrompt Engineering para Executivossugerido pelo grafo7 capítulos de “Prompt Engineering para Executivos” usam conceitos apresentados em “Frontends com Vibecoding”.
- CursoLLM FinOps: o custo da IA para quem assina o orçamentosugerido pelo grafo3 capítulos de “LLM FinOps: o custo da IA para quem assina o orçamento” usam conceitos apresentados em “Frontends com Vibecoding”.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Vídeo com IA: Claude Code, Codex e ElevenLabsParalelizar cenas com subagentes sem estourar o limite das APIsExaminar conexões de Paralelizar cenas com subagentes sem estourar o limite das APIs
- Astra profundoProjetar um vídeo a partir da experiência desejadaExaminar conexões de Projetar um vídeo a partir da experiência desejada
Voltar ao capítulo anterior: Construir as cenas do orquestrador, do paralelismo e do robô
Leve uma ideia para a prática
Escolha uma atividade no painel e volte a este curso quando quiser.
Atividades e evolução ficam reunidas no painel da sua conta.
Laboratórios ao vivo deste curso
Cada laboratório monta a biblioteca real dentro da aula, com controles para você mexer e o código do exemplo para copiar. O texto de reserva descreve a demonstração para quem lê sem JavaScript. O link abre o capítulo já no ponto do laboratório.
Base UI
Prenda o foco num diálogo sem escrever o comportamento
Abra a janela Agendar visita, percorra os campos com Tab, feche com Esc e acompanhe no painel onde o foco está e para onde ele volta.
Pacote
Abrir no capítuloConstruir componentes, usar o registro e publicar o catálogo@base-ui/reactLucide e Iconify
Mantenha uma família de ícones coerente e nomeie cada botão
Mude tamanho, traço e cor da barra, veja o símbolo do Iconify acompanhar o Lucide e rode a auditoria de nomes acessíveis.
Pacote
Abrir no capítuloProjetar uma linguagem de ícones e ilustraçãolucide-react, @iconify/reactMotion
Testar os três sinais que autorizam o terceiro degrau
Reproduza a entrada em sequência, aperte o botão com mola e arraste o cartão; ajuste rigidez e amortecimento e veja o que muda.
Pacote
Abrir no capítuloProjetar movimento, assinatura e narrativas por rolagemmotionVidstack
Ver o que separa um player de um vídeo cru
Dê o play, troque a velocidade e ligue a legenda; o painel ao lado mostra o estado que o player publica e que a etiqueta crua esconde.
Pacote
Abrir no capítuloProjetar movimento, assinatura e narrativas por rolagem@vidstack/reactcmdk
Achar um destino entre quarenta digitando três letras
Abra a paleta, digite fat e escolha um item só pelo teclado; o painel embaixo conta o que o filtro deixou passar e quanto tempo levou.
Pacote
Abrir no capítuloConstruir formulários e estados de interaçãocmdknumber-flow
Animar indicadores que mudam ao vivo com formato pt-BR
Veja três indicadores fictícios rolarem a cada troca e compare com o número em texto puro. Pause, reinicie e observe o separador de milhar.
Pacote
Abrir no capítuloProjetar gráficos e painéis pela decisão@number-flow/reactApache ECharts
Medir o custo de desenhar 200 mil pontos com o ECharts
Troque o tipo de gráfico e o volume de pontos, leia o tempo de desenho e alterne o eixo em zero. Mude o tema do site e veja as cores refazerem.
Pacote
Abrir no capítuloProjetar gráficos e painéis pela decisãoechartssharp e svgo
Escolher a variante certa da imagem e conferir o teto de 150 KB
Arraste a largura da tela simulada, troque a densidade entre 1x e 2x e veja qual arquivo o navegador escolhe, quanto ele pesa e se cabe no orçamento.
Pacote
Abrir no capítuloValidar desempenho, autenticação e segurançasharp, svgoReact Flow (xyflow)
Disparar um pedido e ver o orquestrador distribuir, conferir e responder
Alterne paralelo e sequencial, ligue e desligue a verificação e use a medição real; observe o tempo de parede em cada combinação.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robô@xyflow/reactGSAP, Web Workers e number-flow
Dividir mil tarefas entre trabalhadores reais e correr três ritmos de geração
Execute com um trabalhador, depois com quatro e oito, e compare o tempo; em seguida percorra a corrida e separe a espera inicial do ritmo.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robôgsap, @number-flow/reactThree.js com React Three Fiber, drei, Rapier e XR
Carregar o braço robótico, ver a física trabalhar e entrar na cena com o visor
Carregue a cena pelo botão, inicie o ciclo, mostre os ângulos das juntas, troque a câmera e a velocidade; com visor, entre em realidade virtual.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robôthree, @react-three/fiber, @react-three/drei, @react-three/rapier, @react-three/xrMotion
Ver quatro agentes em raias trocando mensagens e a revisão devolvendo um trecho
Reproduza os 60 s de modelo, percorra o tempo pelo controle e esconda as mensagens para comparar a leitura; repare no tempo de parede contra a soma.
Pacote
Abrir no capítuloEspecificar, medir e produzir as cenas da máquinamotionMediaRecorder, Canvas 2D e Long Animation Frames (plataforma)
Medir o quadro da cena e gravar seis segundos dela em vídeo
Suba as partículas, force um bloqueio de 300 ms e leia o medidor; depois grave seis segundos, veja o codec escolhido e baixe o arquivo.
Pacote
Abrir no capítuloEspecificar, medir e produzir as cenas da máquinasem pacotesigma.js, graphology com ForceAtlas2 e cosmos.gl
Ver o grafo real do curso e um grafo de milhares de nós se organizarem em aglomerados
Rode o layout no grafo real, passe o mouse pelos nós e busque uma entidade; troque para 20 mil nós e leia o medidor; depois carregue o modo massivo na placa de vídeo.
Pacote
Abrir no capítuloAnimar um grafo de conhecimento amplo em movimentosigma, graphology, graphology-layout-forceatlas2, graphology-generators, @cosmos.gl/graph
Capítulos vizinhos em Frontends com Vibecoding
- 29Construir um aplicativo instalável e resiliente
- 30Produzir apresentações e PDF com critérios de entrega
- 31Construir as cenas do orquestrador, do paralelismo e do robô
- 32Especificar, medir e produzir as cenas da máquina
- 33Animar um grafo de conhecimento amplo em movimento