No dia 13 de novembro de 2026, o CSS-Tricks publicou uma lista de descontos de Black Friday em cursos de front-end. No meio da lista, Geoff Graham aponta para um artigo que vale mais do que o cupom: Designing Stable Interfaces For Streaming Content, de Joas Pambou, publicado no Smashing Magazine em maio de 2026. Esse é o assunto deste texto. Não o curso, não o desconto, o problema de engenharia que o artigo descreve e que quase toda interface de agente de IA hoje erra.
A tese do Pambou é direta: streaming em si está praticamente resolvido, mas quando o conteúdo atualiza continuamente, coisas pequenas começam a importar, como comportamento de scroll, estabilidade de layout, timing de render e como a interface responde a ações do usuário. É aí que a maioria dos produtos quebra.
Por que Streaming Parece Fácil e Não É
Quando você vê ChatGPT, Claude ou qualquer agente cuspindo texto token a token, parece que o trabalho de front-end é só um fetch com ReadableStream e um element.textContent += chunk. Para um protótipo, é exatamente isso. Para um produto, não.
Pense numa esteira de supermercado. Enquanto a esteira anda e o caixa vai colocando produtos, você consegue pegar um item do meio para conferir o preço. Mas se cada vez que um produto novo chega a esteira pula pra trás um palmo, você nunca consegue segurar nada. A esteira ficou rápida demais em um sentido e inútil em outro. A analogia quebra num ponto: na esteira real o espaço é fixo, na UI o container cresce. E justamente o crescimento do container que empurra tudo e tira o leitor do lugar.
Os Quatro Pontos Onde a UI de Streaming Quebra
Lendo o artigo do Pambou, cruzando com a documentação de padrões de UX para LLM e com o que vejo em produção, os pontos são esses quatro.
1. Scroll que Sequestra o Leitor
Quando conteúdo está sendo transmitido, a maioria das interfaces mantém o viewport fixado no final. Streaming significa containers crescendo constantemente, e tudo abaixo deles desce junto. O problema aparece no segundo que o leitor decide rolar pra cima para reler alguma coisa: o layout pula, e ele é tirado do contexto atual.
O padrão certo, e isso aparece em todas as fontes que consultei, é auto-scroll condicional. Só segue o final se o usuário já estava no final. Assim que ele rolar pra cima, você para de seguir e mostra um botão pequeno tipo Jump to latest ancorado no canto. Quando ele clicar, você volta a seguir. Siga o leitor, não o arraste. Auto-scroll só enquanto o usuário já está no final do painel. No momento em que ele rolar pra cima, pare de seguir e mostre um botão pequeno de Jump to latest. Quando ele clicar, retome.
Na prática, você precisa de um estado isFollowing e de um listener que observa o scroll do container:
// pseudocódigo, framework-agnóstico
const THRESHOLD = 40; // px de tolerância no final
function onScroll() {
const distanciaDoFim = container.scrollHeight - container.scrollTop - container.clientHeight;
isFollowing = distanciaDoFim < THRESHOLD;
}
function onNewToken(texto) {
mensagemEl.textContent += texto;
if (isFollowing) {
container.scrollTop = container.scrollHeight;
}
}
2. Layout Shift Dentro da Mensagem
Streaming de markdown é um pesadelo de layout stability se você renderiza token a token. O modelo manda #, você vira H1. Chega o próximo token e era ## , vira H2. Chega o próximo e era ### Título. A altura mudou três vezes em 200ms.
A regra prática que aparece em vários lugares: renderize linhas completas, não tokens brutos. Buffere o texto até o fim de uma linha ou frase, depois pinte com a formatação já aplicada. Um par de asteriscos não fechado ou um sinal de sustenido solto nunca deve chegar na tela.
Para blocos de código o mesmo vale: renderize texto imediatamente mas segure o render do bloco de código até a crase tripla de fechamento chegar, mostre um indicador de streaming na mensagem, e exponha um botão de stop que cancela a chamada da API.
Outro truque que ajuda a conter o pulo: reservar espaço mínimo. Um min-height na bolha da mensagem evita que a primeira linha do assistente apareça a um pixel do input e empurre tudo pra cima.
.message-assistant {
min-height: 2.5rem; /* mais ou menos uma linha e meia */
contain: layout; /* isola cálculos de layout no container */
}
.message-assistant pre {
/* não deixe o bloco de código redimensionar vertical durante o stream */
min-height: 3rem;
overflow: auto;
}
3. Acessibilidade: o Leitor de Tela Não Escuta Nada
Esse é o ponto mais ignorado. Leitores de tela não anunciam automaticamente conteúdo que aparece sozinho. Então, numa UI de streaming, onde texto vai sendo construído ao longo do tempo, nada é anunciado. O conteúdo está lá, mas o usuário não ouve nada.
A solução é aria-live, mas do jeito certo. Se você põe aria-live="polite" num container que recebe um token por vez, o leitor de tela tenta anunciar cada token e vira ruído. Se você põe aria-live="assertive", pior ainda, interrompe tudo.
O padrão correto combina duas coisas: aria-atomic="false" garante que apenas o novo conteúdo seja anunciado, e você buferiza as inserções para anunciar em blocos semânticos (frase, parágrafo), não token a token.
<div
role="log"
aria-live="polite"
aria-atomic="false"
aria-relevant="additions"
>
<!-- cada mensagem completa entra como filho novo -->
<p class="message-assistant">...</p>
</div>
E tem um detalhe que me pegou de surpresa no artigo: embora seja um detalhe menor, um elemento de cursor piscando conta como conteúdo piscando. Ou seja, a barrinha fofa que marca onde o texto está crescendo bate em prefers-reduced-motion. A conduta correta é desligar a animação de cursor e, idealmente, para streaming, pular a animação e renderizar a resposta completa de uma vez. O conteúdo é o mesmo, só sem o movimento.
@media (prefers-reduced-motion: reduce) {
.streaming-caret { display: none; }
.message-assistant { animation: none; }
}
4. O Botão de Stop e o que Ele Deixa na Tela
Aqui está a tese central que atravessa quase tudo que eu escrevo sobre interface: sistema bom declara onde ele para. Streaming de LLM é o exemplo mais bruto disso. O modelo pode travar, pode alucinar no meio da resposta, pode começar a repetir. O usuário precisa de uma saída que não puna ele.
O padrão certo tem três partes. Primeiro, troque o botão de enviar por Stop. Coloque o Stop exatamente onde a seta de enviar estava, para o usuário não precisar caçar. Segundo, quando ele apertar, mantenha a resposta parcial na tela e ofereça Editar prompt e Retry logo abaixo. Terceiro, o Stop precisa de fato cancelar a chamada upstream, não só parar de renderizar no cliente.
const controller = new AbortController();
const stream = await fetch('/api/chat', {
method: 'POST',
body: JSON.stringify({ prompt }),
signal: controller.signal,
});
// botão Stop
botaoStop.onclick = () => {
controller.abort();
// texto parcial continua no DOM
mostrarAcoes(['editar prompt', 'tentar de novo']);
};
O que Isso Significa na Prática
Eu passei anos publicando design system e style guide de interface e uma coisa que fica óbvia quando você faz isso é que quase nenhum engenheiro de IA tem isso. E por isso que quase toda interface de produto com agente, por dentro, é feia. Não feia de cor, feia de comportamento: a mensagem pula, o scroll trava, o Stop não cancela de verdade, o leitor de tela não anuncia, o bloco de código vira sopa até o fechamento chegar.
Se você está construindo uma UI de chat agora, o checklist mínimo é esse:
- Container da conversa com
role="log",aria-live="polite"earia-atomic="false". - Auto-scroll condicional, com botão de Jump to latest quando o usuário sai do final.
- Buffer de markdown até fim de linha ou fechamento de bloco de código.
min-heightna bolha econtain: layoutno container da mensagem.- Botão de Stop no mesmo lugar do Send, usando
AbortControllerreal. - Texto parcial preservado após o Stop, com Editar e Retry visíveis.
- Respeito a
prefers-reduced-motion, incluindo o cursor piscando.
Onde Isso Quebra
Nenhum dos padrões acima é grátis, e vale ser honesto sobre o trade-off.
Buferizar markdown até fechar linha aumenta o tempo entre tokens perceptível na tela. Em respostas curtas, o usuário vai sentir que o streaming está mais lento do que o concorrente que cospe tudo cru. A compensação é que o layout não treme, mas você precisa medir isso com usuários reais, não com intuição.
Auto-scroll condicional tem casos de borda feios. Em mobile, o teclado virtual mudando de tamanho faz o scrollHeight variar sem o usuário encostar. Você pode acabar interpretando isso como “usuário rolou pra cima” e desligar o follow sem motivo. A solução é um debounce no detector e checar a origem do evento quando o navegador permite.
O aria-live polite em conversas muito longas, com respostas longas, pode criar um backlog de anúncio no leitor de tela. Testei isso apenas em VoiceOver no macOS e NVDA no Windows, com respostas abaixo de 500 tokens. Acima disso, não posso afirmar como se comporta. Se você tem produto grande com uso intenso por pessoas que dependem de leitor de tela, teste com os usuários reais.
Eu rodei teste A/B por anos num fluxo de assinatura e uma coisa que ficou clara: mesmo backend, mesma API, duas interfaces diferentes, receita mensuravelmente diferente. Se o valor estivesse todo atrás da API, os dois lados dariam o mesmo número. Não davam. A mesma lógica vale aqui: o modelo pode ser o mesmo, a qualidade da saída pode ser idêntica, e ainda assim a UI que respeita scroll e tem Stop honesto vai reter o usuário que a UI que trema vai perder.
O que Ainda Não Dá para Afirmar
O artigo do Pambou e as outras fontes convergem no diagnóstico, mas divergem em detalhes de implementação. Não há consenso ainda sobre qual é a cadência ideal de anúncio para leitor de tela num stream (frase inteira? parágrafo? bloco semântico?). Não há dado público forte sobre o impacto de cada um desses padrões em conversão ou retenção. E, especificamente para agentes que executam ferramentas e não só geram texto, a UI de streaming de tool calls ainda está se formando como padrão, não como regra. Quem afirmar que existe um melhor jeito já estabelecido para renderizar execução de ferramenta está vendendo opinião, não mecanismo.
Como Testar Isso Você Mesmo
Pega um projeto Next.js ou Vite com qualquer SDK de streaming de LLM (Vercel AI SDK serve). Monta um chat básico. Depois, em sequência:
- Abre o DevTools, aba Performance. Grava uma resposta longa sendo transmitida. Procura layout shift e conta quantos ocorrem por segundo.
- Enquanto a resposta está chegando, tenta rolar pra cima. Se o scroll pular pra baixo sozinho, você tem o bug.
- Ativa VoiceOver (Cmd+F5 no Mac) ou NVDA. Manda uma pergunta e fecha os olhos. Se você não escuta nada chegando, seu
aria-liveestá errado ou não existe. - Aperta o Stop no meio. Verifica se a request no Network aba de fato foi cancelada (status canceled) e se o texto parcial continua na tela.
- Em DevTools, ativa Emulate CSS prefers-reduced-motion: reduce. Confirma que o cursor piscando sumiu.
Se os cinco testes passarem, a sua UI está no patamar que o Pambou descreve como estável. Se não, você agora sabe exatamente onde atacar.





