Em 10 de novembro de 2026, Jens Oliver Meiert publicou no CSS-Tricks um artigo revisitando uma técnica de otimização de CSS com pelo menos dezoito anos de idade: UDJO, usando declarações apenas uma vez. A pergunta do texto é direta: isso ainda funciona hoje? Para responder, ele construiu uma ferramenta, o CSS Dedup, e rodou medições em trinta sites. Este artigo pega essa medição, explica o mecanismo por trás dela e mostra onde a técnica compensa e onde ela custa mais bytes do que economiza.
O que é UDJO, em uma frase que importa
UDJO significa usar cada declaração CSS uma única vez. Declaração aqui é o par propriedade mais valor, tipo display: flex. Se esse par aparece em duas regras diferentes, UDJO manda juntar os seletores dessas regras e deixar a declaração em um lugar só.
Antes:
.example { display: flex; }
.sample { display: flex; }
Depois:
.example, .sample { display: flex; }
A técnica é uma aplicação do princípio DRY ao CSS que funciona porque evitar repetição de declaração costuma ser mais efetivo do que evitar repetição de seletor, já que declarações são frequentemente mais longas. Esse é o ponto de mecânica que decide tudo: toda vez que você junta duas regras, você paga o preço de repetir o seletor na lista. Se os seletores somados são menores que a declaração que você economizou, você ganha bytes. Se são maiores, você perde.
Como o CSS Dedup decide o que deduplicar
O CSS Dedup é a ferramenta que Meiert publicou junto com o artigo. Ela encontra declarações duplicadas e, quando solicitado e onde é seguro, consolida: o mesmo par normalizado propriedade e valor não deveria aparecer em mais de uma regra dentro do mesmo escopo.
A parte interessante é por que ela não sai consolidando tudo. Juntar duas regras muda a posição delas no documento, e posição no CSS importa por causa da cascata. Se .a está no topo do arquivo e .b está no fim, e no meio tem outra regra que redefine a mesma propriedade em um desses seletores, mover .a para junto de .b pode mudar o que acaba aplicado na tela. Por isso o texto no CSS-Tricks diz que deduplicação afeta localização de seletores, o que, pela cascata, influencia que regras são aplicadas.
Pense no CSS como uma fila de atendimento onde quem chega por último fala mais alto, mas só se estiver falando da mesma coisa. Trocar a ordem da fila só importa quando duas pessoas estão discutindo o mesmo ponto. A ferramenta precisa olhar para toda a fila antes de decidir se pode trocar alguém de lugar. A analogia quebra num detalhe: na cascata, especificidade do seletor também entra, não é só ordem. Mas para entender por que a ferramenta precisa ser conservadora, serve.
Os dois modos do CSS Dedup
A ferramenta trabalha em dois modos principais. O modo padrão de inspeção roda com npx css-dedup e só reporta. O interessante é o modo que corrige apenas quando reduz o tamanho do arquivo:
npx css-dedup --fix --savings-only .
Esse comando é documentado pelo próprio autor como a opção para corrigir duplicação onde é seguro e apenas quando há economia de bytes. A ferramenta também pode ser usada programaticamente e como plugin do PostCSS, o que significa que dá para plugar ela no build sem reescrever pipeline.
O trade-off que a própria documentação do CSS Dedup declara é importante: dobrar uma declaração em uma lista de seletores compartilhada adiciona os bytes dessa lista de volta, então consolidar uma declaração que só tem em comum alguns seletores longos e sem outra relação pode acabar custando mais do que remove; os dois modos do CSS Dedup chamam isso à atenção para que seja uma decisão consciente, que vale a pena se você valoriza usar declaração uma vez por manutenibilidade, mas não se está otimizando puramente para tamanho de transferência.
Isso é um sistema que declara onde para e não te pune por isso. Ele mostra os dois cenários e deixa você escolher.
O que a medição em 30 sites mostrou
O artigo rodou a ferramenta em 20 sites de organizações e 10 sites de desenvolvedores web conhecidos. A pergunta era: dá para deduplicar? E dá para deduplicar economizando bytes?
Nos 20 sites de organizações, aplicar UDJO de forma natural (todos os pares seguros) aumentou o arquivo em 18 dos 20 casos. Em eff.org, por exemplo, o CSS cresceu 120,8 KB, ou 27,7%. Em die-linke.de, cresceu 104 KB (20,5%). Isso acontece porque, como explicamos acima, o custo dos seletores repetidos superou o ganho das declarações consolidadas.
Mas o segundo modo, o --savings-only, reduziu o tamanho do arquivo em todos os 20 sites. Modesto em muitos (0,2% no 12371.cn), relevante em outros (7,2% no globalsumudflotilla.org, 5,9% no nam.go.ug, 5,1% no commission.europa.eu).
Nos 10 sites de desenvolvedores, o padrão foi parecido mas atenuado. Em todo site há alguma repetição de declaração segura de remover, mas só em 5 dos 10 o modo natural aumentou o arquivo (contra 90% no grupo anterior). Em todos os 10, o modo com economia conseguiu reduzir bytes. sarasoueidan.com teve o maior corte, 11,1%, 4,5 KB.
O que isso diz na prática: UDJO ainda funciona como vetor de otimização, mas só se você usa a opção que mede ganho antes de aplicar. Sem isso, a chance de o arquivo ficar maior é alta em bases grandes.
O que isso significa quando você tem um design system
Aqui vale um aviso de contexto, já que estou publicando design system e style guide de interface. A escolha entre deduplicar por manutenção ou deduplicar por bytes depende de quem lê o CSS depois.
Se o arquivo é gerado por build a partir de tokens e componentes, o CSS final não é lido por humano nenhum e você deveria estar otimizando para transferência: rode --savings-only depois da minificação. A deduplicação nesse ponto é só mais uma passada de compressão semântica em cima do que o Brotli vai comprimir de novo.
Se o arquivo é escrito à mão e lido para manutenção, o cálculo inverte. Consolidar seletores em uma única regra significa que quando você mudar display: flex para display: grid, você vai mexer num lugar só. Mas isso é verdade só se a mudança de uma declaração puder de fato ser aplicada a todos os seletores agrupados, e é isso que determina se UDJO leva a uma vantagem real de manutenibilidade. Se amanhã metade daqueles seletores precisa de display: grid e metade continua em display: flex, você desagrupa de novo e volta ao início.
Onde a técnica quebra
Quatro limites concretos.
Um. Bases grandes com seletores longos (BEM profundo, classes utilitárias longas, prefixos de componente) tendem a perder bytes quando deduplicadas sem o filtro de economia. Isso está nos dados: 90% dos sites de organização ficaram maiores no modo natural.
Dois. A ferramenta não distingue intenção. Ferramentas como o CSS Dedup não fazem diferença entre casos de uso de declaração e são portanto grosseiras, mas é possível configurá-las para colher os benefícios de performance. Se duas regras compartilham color: #333 por coincidência, a ferramenta vai juntar as duas, e você vai ter que lembrar de desagrupar quando o design mudar uma das duas.
Três. O ganho precisa ser medido contra compressão. O texto mesmo reconhece que esses valores não foram testados com compressão adicional e seria justo testá-los também. Gzip e Brotli já são muito bons em comprimir repetição textual. É bem possível que ganhos de 5% antes da compressão virem 1% depois. O artigo não cobre isso, e eu também não testei.
Quatro. UDJO não substitui custom properties, variáveis ou qualquer camada de abstração semântica. Juntar color: #333 de dois seletores é diferente de ter --text-primary. A segunda carrega intenção, a primeira carrega valor.
O que ainda não dá para afirmar
A amostra do artigo tem 30 sites, escolhidos arbitrariamente, e valeria expandir essa análise com mais amostras e investigar diferenças entre elas. Também não sabemos o efeito depois de Brotli, como mencionei. E não sabemos quanto da economia sobrevive quando o pipeline já tem PostCSS, Lightning CSS, cssnano ou similares rodando. Pode ser que boa parte da duplicação encontrada já seja consolidada por essas ferramentas em outro passo, ou pode ser que elas não toquem nisso. O artigo não compara.
Como testar isso você mesmo
Pegue o CSS de um site seu, idealmente o arquivo já minificado de produção. Rode em dois passos.
Primeiro, só o relatório:
npx css-dedup caminho/para/styles.css
Veja quantas declarações estão repetidas. Depois, o modo que só corrige quando economiza:
npx css-dedup --fix --savings-only caminho/para/styles.css
Compare o tamanho antes e depois. Depois comprima os dois arquivos com Brotli ou gzip e compare de novo. É o número que importa de verdade, porque é o que vai pela rede. Se a diferença comprimida for menor que 1% e você tem design system com time consumindo, provavelmente o ganho não paga o ruído no diff do PR. Se é um site estático, HTML gerado, CSS escrito à mão, qualquer economia antes de compressão tende a virar alguma economia depois.
Para fechar: UDJO não é truque novo, é técnica velha com ferramenta nova. O que o artigo do Meiert adiciona é a medida. A medida diz que a técnica funciona, mas só se você aceita que ela também pode piorar o arquivo quando aplicada sem cuidado. Essa honestidade sobre quando o próprio método quebra é a parte que vale copiar, independentemente de você usar CSS Dedup ou não.





