Frontends com Vibecoding · Capítulo 32 de 33 · 38 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. Para marcar como concluído e salvar o progresso, abra este capítulo na página do curso.
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.
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
Explore os conceitos e compare abordagens em outros cursos. As conexões indicam assuntos relacionados; a sequência de estudo continua no índice do curso.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Astra profundoProjetar um vídeo a partir da experiência desejadaExaminar conexões de Projetar um vídeo a partir da experiência desejada
- Do Agile ao Agentic Operating ModelGastar modelo caro só onde ele paga e isolar agentes paralelosExaminar conexões de Gastar modelo caro só onde ele paga e isolar agentes paralelos
- Bastidores: Como Este Portal Foi ConstruídoAgentes em worktrees: produção em paraleloExaminar conexões de Agentes em worktrees: produção em paralelo
- Segundo cérebro com IAComeçar pequeno e crescer sem refazer o segundo cérebroExaminar conexões de Começar pequeno e crescer sem refazer o segundo cérebro
Voltar ao capítulo anterior: Construir as cenas do orquestrador, do paralelismo e do robô
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