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.
Ao fim, você confere se uma cena animada trava no navegador e pede uma versão em vídeo para a página de venda e o celular fraco. Tempo de leitura: cerca de 49 minutos, e a medição no Chrome, mais 15.
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.

Ver como texto
Prancheta com uma ficha de dez campos em branco, cada um com uma barra de cor, ao lado de um notebook que mostra um fluxo abstrato de nós e setas; uma pessoa aponta com a caneta para um campo da ficha e outra observa a tela.
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.
Ver como texto
Dez campos da ficha de cena em duas colunas, numerados: objetivo didático, metáfora, roteiro quadro a quadro, dado real com fonte, biblioteca e degrau, estados obrigatórios, orçamento de peso e quadros, acessibilidade, critério de aceite e prompt-contêiner. Embaixo, a regra: os campos 4 e 9 é que separam a cena que explica da cena que decora.
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.
| 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.

Ver como texto
Piscina vista de cima com quatro raias, uma pessoa nadando em cada raia em ritmo diferente, envelopes azuis e coral cruzando entre as raias sobre boias, e na borda um relógio de parede sem números e uma pessoa com prancheta.
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.
| 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.
Ver como texto
Quatro raias horizontais, uma por agente: principal, pesquisa, redação e revisão, sobre uma régua de tempo de zero a sessenta segundos. A raia do principal tem barras curtas no começo e no fim. Pesquisa e redação têm barras longas que começam juntas; revisão começa quando as duas terminam. Setas verticais representam mensagens: duas do principal para as raias de trabalho no início, uma da redação ao principal no meio, e uma em vermelho da revisão de volta à redação, com o rótulo reprovado. Embaixo, tempo de parede cinquenta e oito segundos contra soma de oitenta.
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.
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.
Ver como texto
Três barras horizontais que representam o tempo de um quadro. A primeira, de dezesseis vírgula sete milissegundos, é o orçamento a sessenta hertz e cabe inteira: script, estilo e layout, pintura e composição. A segunda, de oito vírgula três milissegundos, é o orçamento a cento e vinte hertz, metade do tamanho. A terceira mostra um quadro de cinquenta milissegundos, três vezes o orçamento, marcado em vermelho como quadro longo, que é o limiar da API Long Animation Frames e o que a métrica de interação captura.
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.
| 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.

Ver como texto
Estúdio com um monitor exibindo partículas azuis correndo entre três círculos, uma câmera de cinema no tripé apontada para o monitor com luz coral acesa, um cronômetro e um velocímetro ao lado, uma pessoa ajustando a câmera e um rolo de filme que vira um cartão de vídeo com botão de reproduzir.
Gravar a cena no próprio navegador pede duas APIs da plataforma. Neste exemplo, a cena é desenhada em canvas: captureStream produz o MediaStream que o MediaRecorder recebe e grava em pedaços. Uma animação feita apenas com elementos HTML não vira esse fluxo automaticamente; ela exige uma captura de tela autorizada ou outro processo de renderização documentado. 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.
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. Peça sempre as provas.
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.

Ver como texto
Piscina vista de cima com quatro raias, uma pessoa nadando em cada raia em ritmo diferente, envelopes azuis e coral cruzando entre as raias sobre boias, e na borda um relógio de parede sem números e uma pessoa com prancheta.
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.

Ver como texto
Quadro do clipe gerado por IA: porto isométrico com guindastes azuis, contêineres azuis, grafite e coral e um cronômetro branco com ponteiro azul em primeiro plano
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.
Ver como texto
Três cartões lado a lado. Primeiro: model-viewer, um modelo GLB ou USDZ na página, com realidade aumentada por WebXR no Android, Scene Viewer e Quick Look no iPhone, para mostrar um objeto. Segundo: WebXR com Three.js e React Three Fiber, cena própria com física e visor, botão de entrar só quando o aparelho oferece a sessão, para a pessoa mexer. Terceiro: elemento model e Immersive API do Safari 27 no visionOS 27, arquivo USDZ e um pedido de imersão parecido com o de tela cheia, para o ambiente em volta da página. Embaixo, a regra: comece pelo primeiro; suba só quando a interação for o que ensina.
| 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 do exemplo
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.
Guia prático: alimentar a cena de agentes com o rastro de verdade e publicá-la sem pesar a página
Entre agosto e outubro de 2026 os agentes ganharam fluxos que disparam dezenas de subagentes, esforço por subagente e rastro padronizado de ponta a ponta. Isso dá à cena de raias eventos reais para desenhar. O guia mostra cada função, como a página /geo-orchestrator deste portal monta as cenas só quando chegam perto da tela e o pedido que faz o mesmo numa página de campanha.
Funções, casos de uso e aplicações
Funções
| Função ou recurso | O que faz | Quando usar | Desde |
|---|---|---|---|
| Fluxos dinâmicos nos Claude Managed Agents (beta) | O agente escreve um programa que roda muitos agentes em fases, no servidor da Anthropic | Pesquisa ou revisão em lote que se divide em etapas paralelas | 09/10/2026 |
| Esforço por subagente no Claude Code (v2.1.292) | A ferramenta Agent recebe o parâmetro effort, e cada subagente pensa no nível pedido | Esforço alto só na raia que decide; as demais em nível baixo | 06/10/2026 |
| CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL (v2.1.296) | Roda todos os agentes de um fluxo num mesmo modelo, sem mudar os demais subagentes | Fluxo de volume que deve usar o modelo barato de ponta a ponta | 09/10/2026 |
| Mensagens entre sessões do Claude Code | Uma sessão passa um achado ou uma decisão para outra, no macOS e no Linux | Duas frentes de trabalho que precisam combinar uma interface sem você repetir a explicação | Semana de 03/08/2026 |
| Multiagente no GPT-6.1 Sol (beta) | A OpenAI lançou o modelo com execução multiagente em beta | Comparar o mesmo roteiro de raias entre dois fornecedores | 29/09/2026 |
| Spans invoke_workflow e plan da OpenTelemetry para IA | Nomeiam o trecho do rastro que representa um fluxo inteiro e o que representa o planejamento, ao lado de invoke_agent e create_agent | Desenhar a barra do fluxo e a etapa de plano como raias próprias | Em desenvolvimento, lidos em 12/10/2026 |
| traceparent no _meta do MCP 2026-07-28 | Leva o identificador do rastro do agente até o servidor MCP chamado | Ligar na mesma raia a chamada de ferramenta e o que o servidor fez | 28/07/2026 |
Span é cada trecho de um rastro, com início, fim e atributos; rastro é o conjunto desses trechos ligados por um mesmo identificador.
Fonte: Anthropic, notas de versão da plataforma e changelog do Claude Code; OpenAI, changelog da API; OpenTelemetry, semantic-conventions-genai; MCP, especificação 2026-07-28
Casos de uso
Diretora de uma agência de conteúdo em Florianópolis
Marketing digital, proposta comercial com demonstração
Dor
A proposta dizia que a agência produz pautas com agentes em paralelo, e o cliente via só um parágrafo e um desenho genérico de robô.
Solução
A equipe exportou o rastro de uma rodada real de pautas, com os trechos invoke_workflow, invoke_agent e execute_tool, e montou a cena de raias a partir dele. Cada barra tem hora de início e fim; a revisão que devolveu um texto aparece como mensagem de volta.
Resultado do exemplo
O que observar: nas reuniões do trimestre, se o cliente consegue dizer em uma frase o que cada agente fez, e quantas perguntas sobre prazo deixam de aparecer.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Coordenador de comunicação de uma escola técnica de tecnologia em Campinas
Educação, divulgação de curso de IA por e-mail
Dor
A cena interativa do orquestrador funcionava na página, mas não cabia no e-mail de divulgação nem rodava bem no celular fraco de parte dos alunos.
Solução
A página manteve a cena montada só perto da tela, com a figura estática como reserva. Para o e-mail, a mesma cena foi gravada em seis segundos pelo MediaRecorder, com o codec e o peso anotados.
Resultado do exemplo
O que observar: na campanha seguinte, o clique do e-mail com o vídeo contra o e-mail só com texto, e o INP da página com a cena.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Na prática
A página /geo-orchestrator deste portal usa seis cenas da máquina, em src/components/geo-orchestrator/anim/: Ondas em corrida, Harness ao vivo, Grafo de roteamento, Cascata de custo, Linha do tempo viva e Plano ao vivo. Todas seguem o mesmo invólucro. O HTML do servidor traz uma reserva legível; a cena de verdade, com GSAP, Web Workers e number-flow, só desce quando o invólucro chega a 200 px da área visível. Quem imprime a página também recebe a cena, porque o evento beforeprint dispara a montagem.
É a ficha de cena aplicada: estado sem JavaScript e peso só depois do sinal de interesse, sem custo para quem não rola até ali.
const ROOT_MARGIN = "200px 0px";
const Cena = dynamic(() => import("./OndasEmCorridaGsap"), { ssr: false, loading: () => <Fallback carregando /> });
export default function OndasEmCorrida() {
const ref = useRef<HTMLDivElement>(null);
const [montar, setMontar] = useState(false);
useEffect(() => {
if (montar) return;
const el = ref.current;
if (!el) return;
const abrir = () => setMontar(true);
window.addEventListener("beforeprint", abrir);
const io = new IntersectionObserver(
(entradas) => {
if (entradas.some((e) => e.isIntersecting)) {
io.disconnect();
abrir();
}
},
{ rootMargin: ROOT_MARGIN },
);
io.observe(el);
return () => {
io.disconnect();
window.removeEventListener("beforeprint", abrir);
};
}, [montar]);
return (
<div ref={ref} data-anim={ID_CENA} className={styles.moldura}>
{montar ? <Cena /> : <Fallback />}
</div>
);
}Do rastro à cena publicada
Quatro passos que mantêm a cena fiel ao que aconteceu e leve para quem visita.
Passo 1: Antes de desenhar, exporte o rastro
Peça ao rastreador os spans da rodada, com hora de início e fim. Sem rastro, a cena leva o rótulo de cenário ilustrativo.
Deu certo quando: Cada barra da cena aponta para um span com identificador.
Erro comum: Desenhar raias de memória e mostrar como paralelo o que rodou em fila.
Passo 2: Separe fluxo, agente e ferramenta
invoke_workflow é o fluxo inteiro, invoke_agent é cada agente, execute_tool é cada chamada de ferramenta. Cada um ganha um desenho próprio.
Deu certo quando: A pessoa distingue na tela quem pensou e quem só consultou uma ferramenta.
Erro comum: Tudo vira barra igual e a cena perde a leitura de autoria.
Passo 3: Monte a cena só perto da tela
Reserva legível no HTML do servidor, import dinâmico sem SSR e IntersectionObserver com margem de 200 px.
Deu certo quando: Quem não rola até a cena não baixa a biblioteca dela.
Erro comum: Importar a cena no topo da página e pagar o peso no primeiro carregamento.
Passo 4: A prova vai junto
Print do medidor sem quadro longo e o vídeo gravado, com codec e peso anotados, acompanham a entrega.
Deu certo quando: Quem aprova vê a medição ao lado da animação.
Erro comum: Aprovar pela impressão no computador rápido de quem fez.
No fim você tem: Uma cena de agentes desenhada a partir do que de fato rodou e carregada só para quem chega até ela, com a medição ao lado.
Armadilhas
Raia sem rastro é ilustração
Toda barra de agente nasce de um evento com hora; o que não tem evento leva o rótulo de cenário ilustrativo.
- Atributos gen_ai de agente ainda estão em desenvolvimento: guarde a versão lida
- Fluxo dinâmico gera dezenas de raias: agrupe acima de oito por etapa
- Esforço alto em toda raia multiplica o custo da rodada que a cena mostra
- Cena importada no topo pesa para quem nunca chega até ela
- Sem traceparent, a chamada ao servidor MCP aparece solta, fora da raia
O teste: Aponte qualquer barra da cena: alguém precisa achar o span dela em menos de um minuto.
alexandrecaramaschi.com/educacao/frontends-com-vibecoding
O que mudou de agosto a outubro de 2026
O model-viewer, componente do Google para mostrar objeto 3D na página, lançou a versão 4.4.0 em 09/10/2026. A realidade aumentada do iPhone passou a abrir também em navegadores de terceiros sem um arquivo extra para iOS. O capítulo cita a versão 4.3.1, de junho; para objeto 3D com botão de realidade aumentada, a recomendação agora é a 4.4.0.

Ver como texto
Página Long Animation Frames API da documentação do Chrome, de Barry Pollard e Noam Rosenthal. O texto explica que a API é uma atualização da Long Tasks API para entender atualizações lentas da interface, útil para achar quadros de animação lentos que afetam o INP. Na seção de status, o suporte mostra Chrome 123 e Edge 123, sem suporte no Firefox e no Safari.

Ver como texto
Página MediaRecorder do MDN com o selo Baseline Widely available e os ícones dos quatro navegadores principais marcados. O texto diz que a interface grava mídia a partir de um fluxo, que o construtor aceita opções como o formato do contêiner, por exemplo video/webm ou video/mp4, e a taxa de bits do áudio e do vídeo.

Ver como texto
Página inicial do model-viewer, com o título Easily display interactive 3D models on the web and in AR, um trecho de código que importa o componente na versão 4.4.0 e usa a tag model-viewer com texto alternativo, arquivo do modelo, imagem de ambiente, sombra e controles de câmera, os selos de tamanho de 71,2 KB e versão v4.4.0, e à direita o traje espacial de Neil Armstrong em 3D.
| Prova | Instrumento | Onde vale | Sinal de problema |
|---|---|---|---|
| A cena não trava | Painel Performance do Chrome e Long Animation Frames | Chrome e Edge | Quadros acima de 50 ms em sequência |
| O toque responde | INP nos dados reais de visita | Todos os navegadores | INP acima de 200 ms |
| Existe versão leve | Vídeo gravado com MediaRecorder | Todos os navegadores | Celular fraco recebe a cena pesada |
Fonte: Chrome for Developers, MDN e web.dev, consultados em 24/10/2026.
Faça agora: meça uma cena e peça a versão em vídeo
Passo 1: Abra a página com a cena no Chrome do computador, aperte F12 e vá à aba Performance.
Deu certo quando: O painel abre com o botão de gravar.
Passo 2: Grave cinco segundos enquanto a cena roda e pare.
Deu certo quando: Uma linha do tempo com os quadros desenhados.
Erro comum: Gravar com outras abas pesadas abertas e culpar a cena.
Passo 3: Procure blocos vermelhos de tarefa longa e anote quantos aparecem.
Deu certo quando: Zero ou poucos blocos isolados; muitos seguidos indicam travamento.
Passo 4: Peça ao time um vídeo de seis segundos da cena para o celular fraco e para a página de venda.
Deu certo quando: Um arquivo de vídeo leve que substitui a cena onde ela pesa.
No fim você tem: Um laudo curto da cena: trava ou não, e a versão em vídeo para onde ela não cabe.
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ê.
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.
- CursoClaude Code: do zero à prática
- CursoSíntese e didática com IAsugerido pelo grafoDepois de escolher a informação essencial e desenhar hierarquia, gráficos e fluxos compreensíveis, o aluno pode aplicar esses critérios às interfaces do curso de frontend. A ponte conecta clareza da mensagem, acessibilidade e decisões de apresentação.
- CursoNode.js: JavaScript no Servidorsugerido pelo grafo8 capítulos de “Frontends com Vibecoding” usam conceitos apresentados em “Node.js: JavaScript no Servidor”.
- CursoSkills e delegação com IAsugerido pelo grafo9 capítulos de “Frontends com Vibecoding” usam conceitos apresentados em “Skills e delegação com IA”.
- Vídeo com IA: do roteiro à publicaçãoDivida as cenas entre vários agentes sem estourar limite nem custoExaminar conexões de Divida as cenas entre vários agentes sem estourar limite nem custo
- Síntese e didática com IAMonte storyboard e roteiro de vídeo concisoExaminar conexões de Monte storyboard e roteiro de vídeo conciso
- Astra profundoEscolher a forma de explorar uma cena 3DExaminar conexões de Escolher a forma de explorar uma cena 3D
Terminou a leitura?
Você está aqui: capítulo 34 de 35
0 de 35 concluídos
- Próximo · Capítulo 35 de 35 · 21 minAnimar um grafo de conhecimento amplo em movimentoLer o capítulo 35 sem concluir
Marque como concluído para o capítulo contar no seu painel e no certificado.
- Anterior · Capítulo 33 de 35 · 36 minConstruir as cenas do orquestrador, do paralelismo e do robôVoltar para o capítulo 33
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.
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ãoechartsApache ECharts
Painel grande com visões coordenadas
Clique num canal para filtrar todas as visões, troque a densidade entre 6, 9 e 12 visões, alterne tema e movimento e abra a tela cheia.
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 e Rapier
Carregar o braço robótico, ver a física trabalhar e orbitar a câmera
Carregue a cena pelo botão, inicie o ciclo, mostre os ângulos das juntas, troque a câmera e a velocidade.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robôthree, @react-three/fiber, @react-three/drei, @react-three/rapierMotion
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
- 31Construir um aplicativo instalável e resiliente
- 32Produzir apresentações e PDF com critérios de entrega
- 33Construir as cenas do orquestrador, do paralelismo e do robô
- 34Especificar, medir e produzir as cenas da máquina
- 35Animar um grafo de conhecimento amplo em movimento