<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ricardo Augusto Franco on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Augusto Franco on Medium]]></description>
        <link>https://medium.com/@francocontigo?source=rss-fc6c37201ecd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*aj2yNyUtAabAZHEcyY_PKQ.jpeg</url>
            <title>Stories by Ricardo Augusto Franco on Medium</title>
            <link>https://medium.com/@francocontigo?source=rss-fc6c37201ecd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 21:29:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@francocontigo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Sua empresa não sabe usar IA]]></title>
            <link>https://medium.com/@francocontigo/sua-empresa-n%C3%A3o-sabe-usar-ia-368ba7a3005f?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/368ba7a3005f</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 12:55:29 GMT</pubDate>
            <atom:updated>2026-10-14T12:55:29.455Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zcAa_VeBFiGhm1rH" /><figcaption>Photo by <a href="https://unsplash.com/@joshua_hoehne?utm_source=medium&amp;utm_medium=referral">Joshua Hoehne</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Em abril de 2026 uma startup chamada <a href="https://zenity.io/blog/ai-agent-database-deletion-pocketos">PocketOS</a> perdeu o banco de dados de produção inteiro em nove segundos. Não foi hacker. Foi o agente de IA da própria empresa, com permissão pra mexer no código, que achou num arquivo qualquer uma credencial com muito mais poder do que deveria e usou, numa única chamada, pra apagar o banco e os backups que estavam no mesmo lugar. O backup mais recente que dava pra recuperar tinha três meses. O system prompt, o texto de instruções que a empresa dá ao agente, dizia com todas as letras pra nunca rodar comando destrutivo sem pedir. A instrução dizia não, a credencial dizia pode, e ganhou a credencial.</p><p>Esse artigo nasceu de uma irritação nossa com o jeito que essa história, e as dezenas parecidas dos últimos cinco anos, são contadas. Companhia aérea condenada pelo que o chatbot prometeu, consultoria devolvendo dinheiro por referência inventada, fintech recontratando o atendimento que tinha demitido, agente apagando banco de cliente durante code freeze. Cada uma sai no noticiário como se fosse um problema diferente, “a IA alucinou”, “o agente saiu do controle”, “o modelo não estava pronto”. Não é. É o mesmo erro com roupa diferente. Alguém colocou o modelo num lugar onde ele ia errar, e ninguém sabia responder o que aconteceria quando ele errasse.</p><p>A gente opera sistema desse tipo todo dia, e é daí que vem o direito de escrever o título aí em cima. O CreatorAds é uma plataforma brasileira de marketing com criadores em que IA não é feature, é o produto. São os nossos sistemas que decidem se um vídeo de criador cumpriu o que a marca contratou, e que acham, numa base grande de criadores, os certos pra cada campanha. Cada decisão dessas mexe com o dinheiro de uma pessoa e com a marca de outra. A gente não tem o luxo de tratar IA como experimento, e aprendeu, medindo, que a pergunta certa nunca foi “qual modelo usar”. A pergunta certa é onde ele erra, quanto custa quando erra e como a gente vai ficar sabendo.</p><p>A tese é simples e incômoda. A maioria das empresas não sabe usar IA porque não sabe onde a própria IA erra. Não é problema de modelo, porque os modelos de 2026 são muito melhores que os de 2023 e os casos continuam acontecendo, agora com agentes mais capazes fazendo estrago maior. Não é problema de ferramenta, e não é falta de gente boa, várias dessas empresas tinham time excelente que sabia disso tudo em tese. É falta de critério, no sentido mais bobo da palavra. Uma loja que aceita troca sem nota sabe quanto vai perder com golpe e decidiu que compensa. Ela tem critério sobre o erro. A maioria das empresas que colocou IA em produção não fez essa conta. Muitas nem sabem que a conta existe. E isso é uma boa notícia, porque critério é muito mais barato que GPU.</p><h3>O que os números já dizem</h3><p>Se você acha que o título exagera, começa por quem mede isso por ofício. Em agosto de 2025 o <a href="https://virtualizationreview.com/articles/2025/08/19/mit-report-finds-most-ai-business-investments-fail-reveals-genai-divide.aspx">MIT NANDA</a> publicou que 95% dos pilotos corporativos de IA generativa não geram retorno mensurável, com US$ 30 a 40 bilhões investidos, e que só 5% das ferramentas customizadas chegam a produção. A manchete parou nos 95%, mas o que interessa é o motivo. Os sistemas <a href="https://www.forbes.com/sites/jasonsnyder/2025/08/26/mit-finds-95-of-genai-pilots-fail-because-companies-avoid-friction/">não retêm feedback, não se adaptam ao contexto e não melhoram com o tempo</a>. Traduzindo, ninguém construiu o caminho pelo qual um erro volta pra dentro do sistema e o corrige. E tem o dado mais revelador do relatório, que quase ninguém citou. Só 40% das empresas compraram assinatura oficial de IA, mas em mais de 90% os funcionários usam ferramenta pessoal por conta própria. A empresa não sabe usar IA. Os funcionários dela já estão usando.</p><p>A <a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">Gartner</a> previu em junho de 2025 que mais de 40% dos projetos de IA agêntica, o nome que se dá a sistemas em que o modelo não só responde mas executa ações, vão ser cancelados até o fim de 2027, por custo, valor de negócio pouco claro ou controle de risco inadequado. A mesma Gartner cunhou “agent washing” pra fornecedor que rebatiza automação velha como agente, e estimou que dos milhares que se dizem agênticos uns 130 eram de verdade. A conta do outro lado já chegou. Em maio de 2025 a Orgvue achou 55% dos líderes arrependidos das demissões feitas por automação, e a <a href="https://www.inc.com/bruce-crumley/55-percent-of-leaders-regret-ai-layoffs-and-a-major-hiring-reversal-has-begun/91380901">Forrester</a> prevê que metade das demissões atribuídas à IA vai ser revertida em silêncio. A Robert Half achou <a href="https://www.cnbc.com/2026/07/01/employers-who-laid-off-workers-for-ai-are-reversing-their-decisions.html">um terço dos executivos</a> que cortaram vaga por IA já recontratando, e Ford, IBM, Booz Allen Hamilton e CSX estão entre as que <a href="https://qz.com/companies-rehiring-workers-ai-layoffs-automation-070126">trouxeram gente de volta</a>.</p><p>E isso não começou com o ChatGPT. Em novembro de 2021 a Zillow fechou o <a href="https://insideainews.com/2021/12/13/the-500mm-debacle-at-zillow-offers-what-went-wrong-with-the-ai-models/">Zillow Offers</a>, o braço que comprava imóvel com base num modelo de precificação, com mais de US$ 500 milhões de baixa contábil e 25% de demissões, porque o modelo não acompanhou a virada do mercado. Sem modelo de linguagem, sem alucinação, sem agente. Só um modelo competente numa posição em que cada erro custava uma casa, e ninguém encarregado de perguntar o que aconteceria quando o mercado virasse. Cinco anos e uma geração de tecnologia depois, a pergunta continua sem dono. Isso deveria incomodar mais do que incomoda.</p><h3>Sete jeitos de errar</h3><p>O que vem abaixo não é lista de vexame. É um mapa, e você vai se achar nele.</p><h3>Erro 1: substituir antes de medir</h3><p>A Klarna anunciou em fevereiro de 2024 que o assistente de IA fazia o trabalho de 700 atendentes e tinha respondido 2,3 milhões de conversas no primeiro mês. Segurou contratação por mais de um ano e o quadro caiu 22%. Em maio de 2025 o CEO, Sebastian Siemiatkowski, <a href="https://www.entrepreneur.com/business-news/klarna-ceo-reverses-course-by-hiring-more-humans-not-ai/491396">admitiu</a> que o resultado era mais barato, porém de qualidade inferior, e voltou a contratar gente. O <a href="https://www.abc.net.au/news/2025-08-21/cba-backtracks-on-ai-job-cuts-as-chatbot-lifts-call-volumes/105679492">Commonwealth Bank</a>, na Austrália, demitiu 45 pessoas de call center porque um bot de voz ia reduzir as chamadas. As chamadas subiram e o banco desfez tudo. O Duolingo publicou um memorando <a href="https://www.customerexperiencedive.com/news/duolingo-ai-first-consumer-backlash-lessons/757133/">“AI-first”</a> e um ano depois o CEO <a href="https://fortune.com/2026/04/13/duolingo-ceo-luis-von-ahn-ai-usage-requirement-employee-performance-evaluations/">recuou</a> até da ideia de avaliar funcionário pelo uso de IA. O contraexemplo é o Ingka Group, dono da IKEA, onde o bot absorveu 47% das chamadas e, em vez de demitir 8.500 pessoas, a empresa retreinou essas pessoas como consultoras de design de interiores desde 2021, e o canal de design remoto já <a href="https://www.fastcompany.com/91571824/the-great-ai-layoff-is-turning-into-the-great-ai-rehire">faturava €1,3 bilhão no ano fiscal de 2022</a>. A <a href="https://fortune.com/2025/09/02/salesforce-ceo-billionaire-marc-benioff-ai-agents-jobs-layoffs-customer-service-sales/">Salesforce</a>, que cortou 4.000 vagas de suporte dizendo que agentes fazem metade do trabalho, é o teste em aberto, e seria desonesto chamar de fracasso o que ainda está rodando.</p><p>Em todos esses casos a métrica de sucesso foi headcount, não qualidade. Nenhuma dessas empresas tinha um número dizendo quão bom era o atendimento humano antes de trocar, e sem esse número “mais barato” é a única coisa que dá pra medir. No CreatorAds o Guardian, o sistema que verifica os vídeos, só aprova um veredito sozinho depois que a confiança dele foi calibrada contra veredito humano, e só nas faixas em que a gente sabe a acurácia. O humano não saiu do processo, virou a referência. E bot no atendimento não é o problema, a gente mesmo roda um, o Whisper, que atende centenas de conversas de criadores por dia, resolve uma parte sozinho e passa o resto pra uma pessoa, e a gente sabe exatamente qual parte. O problema é trocar gente por bot antes de saber esse número. Substituir e medir não cabem na mesma sprint, porque a medida é feita justamente contra a pessoa que você estaria mandando embora.</p><h3>Erro 2: deixar o modelo falar em nome da empresa sem contrato</h3><p>O chatbot da <a href="https://www.cbc.ca/news/canada/british-columbia/air-canada-chatbot-lawsuit-1.7116416">Air Canada</a> inventou uma política de tarifa de luto, o cliente acreditou, e em fevereiro de 2024 um tribunal canadense rejeitou o argumento de que o bot era “uma entidade legal separada, responsável pelas próprias ações” e condenou a companhia. Lê isso de novo, porque a defesa da empresa foi que o bot era outra pessoa. O bot da DPD xingou um cliente e escreveu um poema sobre como a empresa era ruim. O bot de suporte da <a href="https://fortune.com/article/customer-support-ai-cursor-went-rogue">Cursor</a> inventou uma política de um dispositivo por assinatura e usuário cancelou em público.</p><p>Em todos, o modelo estava na interface com o cliente sem escopo, sem a política real mandando na resposta e às vezes sem se apresentar como IA. O que o bot diz é o que a empresa diz. O erro individual é barato, o precedente não. A distinção que a gente usa é entre IA que sugere e IA que decide. No SmartMatch, nosso sistema de busca de criadores, o modelo sugere e não promete nada, e se a sugestão for ruim, uma pessoa ignora e o custo foi um clique. No Guardian um veredito tem consequência pro criador, então exige confiança medida, trilha de decisão e canal de contestação. A pergunta que resolve quase tudo é se essa saída é uma opinião ou um compromisso.</p><h3>Erro 3: confundir demo com produção</h3><p>O <a href="https://www.fastcompany.com/91142882/mcdonalds-ai-drive-thru-ordering-glitches">McDonald’s</a> encerrou em 2024 o drive-thru por voz com a IBM, em mais de cem lojas, depois de vídeo viral com bacon no sorvete. No <a href="https://techcrunch.com/2025/08/30/taco-bell-is-having-second-thoughts-about-relying-on-ai-at-the-drive-through/">Taco Bell</a> um cliente pediu 18.000 copos de água e o sistema aceitou. A distância entre o que a empresa acha e o que o cliente sente está medida. Numa pesquisa da <a href="https://teletime.com.br/27/01/2026/brasil-adota-ia-no-atendimento-mas-consumidores-nao-estao-tao-satisfeitos/">Twilio</a> de janeiro de 2026, 96% das empresas acreditam que o cliente está satisfeito com a IA conversacional e só 66% dos consumidores confirmam. No Brasil, 44% das empresas já concluíram ou estão concluindo a implementação. Em maio de 2026 a <a href="https://finance.yahoo.com/news/ai-backlash-grows-across-us-141500259.html">AnswerConnect</a> ouviu 6.000 consumidores e 85% preferem falar com uma pessoa, enquanto 57% dizem que a confiança na empresa cai se o atendimento for majoritariamente automatizado.</p><p>Demo roda em ambiente controlado, com usuário cooperativo. Produção tem ruído, sotaque, motor de caminhão e gente tentando quebrar o sistema porque isso dá view. Foi assim que o chatbot de uma concessionária <a href="https://gizmodo.com/ai-chevy-dealership-chatgpt-bot-customer-service-fail-1851111825">Chevrolet</a> aceitou vender um Tahoe de US$ 76 mil por um dólar e ainda avisou que a oferta era juridicamente vinculante. Ninguém enganou o bot sem querer, o usuário instruiu ele a concordar com qualquer coisa, e o sistema obedeceu, porque ninguém tinha previsto que alguém faria isso de propósito. Teste sem adversário não é teste, é demonstração. Vídeo de criador é exatamente esse tipo de entrada, às vezes feito por quem quer passar na verificação sem cumprir o combinado, e por isso a nossa eval, o conjunto de casos contra o qual a gente mede o Guardian, inclui os casos que vieram de contestação. É ali que o sistema já errou uma vez.</p><h3>Erro 4: entregar sem revisar</h3><p>Em outubro de 2025 a <a href="https://fortune.com/2025/10/07/deloitte-ai-australia-government-report-hallucinations-technology-290000-refund">Deloitte Austrália</a> entregou ao governo um relatório de 237 páginas, contrato de AU$ 440 mil, com referência acadêmica fabricada e citação inventada de um juiz. Devolveu a última parcela e declarou que as correções “de forma alguma” afetavam as conclusões. Em abril de 2026 a <a href="https://www.cnn.com/2026/04/23/business/ai-hallucination-sullivan-cromwell-nightcap">Sullivan &amp; Cromwell</a>, uma das firmas mais prestigiadas de Wall Street, protocolou uma moção com cerca de 42 imprecisões, incluindo casos que não existem, e quem achou foi a parte contrária. Nem quem faz os modelos escapa, em 2025 o advogado externo da Anthropic <a href="https://techcrunch.com/2025/05/15/anthropics-lawyer-was-forced-to-apologize-after-claude-hallucinated-a-legal-citation">pediu desculpas</a> por uma citação inventada pelo Claude.</p><p>O modelo foi usado onde a verificação era o produto. Se a fundamentação é inventada, o entregável vale zero, não “quase certo”, e a revisão não aconteceu porque ninguém decidiu que ela era obrigatória. O que a gente aprendeu operando é que a confiança verbalizada pelo modelo, o “tenho 95% de certeza” que ele escreve na resposta, não é calibração. Calibração é saber se os 90% de confiança do sistema acertam 90% das vezes, e isso só se descobre medindo contra a realidade. No Guardian a gente comparou as frases do modelo com os vereditos humanos que já tinha guardado e a relação era fraca demais pra sustentar qualquer decisão automática. O número era enfeite. O que funcionou foi usar as probabilidades internas do modelo, os logprobs, e corrigir com um ajuste estatístico chamado regressão isotônica, que aprende com os vereditos humanos quanto cada faixa de confiança acerta de verdade. Isso dá a acurácia real de cada faixa, e só nas faixas em que ela sustenta a decisão o sistema decide sozinho. O modelo não sabe quando não sabe. Isso a empresa constrói por fora.</p><h3>Erro 5: dar poder de ação sem guardrail</h3><p>Em julho de 2025 o agente de código da <a href="https://www.eweek.com/news/replit-ai-coding-assistant-failure/">Replit</a> apagou o banco de produção de um cliente durante um code freeze explícito, depois disse que o rollback era impossível (não era) e gerou dado falso pra esconder o que tinha feito. O caso da PocketOS, lá do começo, é a versão 2026 do mesmo erro, e o padrão já está medido. A <a href="https://www.cyera.com/research/agent-inflicted-damage-inside-the-real-world-failures-of-enterprise-ai-systems">Cyera</a> analisou 344 incidentes verificados entre setembro de 2023 e maio de 2026, e 188 foram sistemas autônomos causando dano sem atacante nenhum, 65 deles com deleção de dado ou código. O volume disparou a partir de dezembro de 2025, junto com a adoção de agente de código autônomo.</p><p>O agente tinha permissão de escrita irreversível e nenhuma barreira entre planejar e executar, e quando a instrução diz uma coisa e a credencial permite outra, vale a credencial. E o pior do caso Replit não é a deleção, é a confabulação depois, o sistema não tinha noção de que tinha errado. Por isso a direção do Guardian é arquitetura mais enxuta e menos agêntica, com menos passos em que o modelo decide sozinho o que fazer em seguida, e o ganho de eficiência de tirar autonomia é maior do que a indústria admite. A pergunta que a gente faz pra cada ação é uma só, se ela é reversível. Se não é, passa por gente, e o sistema continua rápido em tudo que dá pra desfazer.</p><h3>Erro 6: comprar a narrativa em vez do sistema</h3><p>A <a href="https://www.techspot.com/news/108173-builderai-collapses-after-revelation-ai-hundreds-engineers.html">Builder.ai</a>, avaliada em US$ 1,5 bilhão e com apoio da Microsoft, entrou em insolvência em maio de 2025 depois de revelações de receita inflada, com transações de ida e volta entre a empresa e um parceiro pra engordar o faturamento mostrado a investidor. A história de que a “IA” era na verdade centenas de engenheiros nunca foi confirmada, e nem precisava ser, porque o que quebrou a empresa foi o número, não o modelo. O agent washing da Gartner é a versão difusa da mesma coisa, dos milhares de fornecedores que se dizem agênticos, uns 130 eram. A compra foi feita no pitch, sem critério pra separar o que era modelo, o que era regra e o que era gente. Quem veio de plataforma de automação sabe montar a demo, mas não sabe avaliar o sistema, e empresa sem alguém que saiba avaliar compra pelo brilho. Na nossa decisão de construir ou comprar, a pergunta que mais pesa não é quanto custa. É se a gente vai conseguir medir a coisa depois que ela estiver rodando.</p><h3>Erro 7: medir sensação em vez de resultado</h3><p>Em julho de 2025 o <a href="https://www.theregister.com/2025/07/11/ai_code_tools_slow_down/">METR</a> mediu desenvolvedores experientes usando ferramenta de IA e achou que eles ficaram cerca de 19% mais lentos, achando que estavam 20% mais rápidos. A <a href="https://metr.org/blog/2026-02-24-uplift-update/">atualização de fevereiro de 2026</a> enfraqueceu o número, com ferramentas mais novas o resultado ficou misto, e o próprio METR admitiu que o desenho do estudo ficou inviável, porque desenvolvedor se recusa a trabalhar sem IA mesmo a US$ 50 por hora. O achado que sobreviveu é que produtividade percebida e produtividade medida divergem, e a percebida é a que aparece na pesquisa interna de satisfação. A gente também se sente mais rápido. Todo mundo se sente. O ponto é que sentir não é medir, e por isso o que a gente conta mais pra frente é entrega, não sensação. Esse é o erro mais comum de todos, porque a maioria das empresas está exatamente aqui, convencida de que ganhou, sem ter medido. Não tem manchete, não tem tribunal, não tem banco apagado. Tem uma sensação de velocidade e um resultado que não mudou.</p><h3>Não é alucinação, é contexto</h3><p>Tem uma palavra que atravessa quase todos os casos acima e está sendo usada errado. “Alucinação” virou o termo que a empresa usa quando quer culpar o modelo pelo que ela mesma não forneceu. Relê os casos com essa lente. O bot da Air Canada inventou a política de tarifa de luto e, na mesma resposta, mandou o link da página onde estava a política certa. A informação existia e estava a um clique. O que não existia era uma regra dizendo que, quando a resposta e a fonte não batem, a fonte ganha, e uma saída pra parar e encaminhar quando o caso não estivesse coberto. O Sam da Cursor não tinha acesso à política real de dispositivos. A Deloitte pediu referência acadêmica a um modelo sem fonte pra consultar e depois chamou de alucinação o que era um pedido impossível. Contexto, nessa conversa, não é só documento. É o que o modelo recebe junto com a pergunta, o que ele tem permissão de fazer com isso e o que ele pode responder quando não encontra.</p><p>O mecanismo é fácil de explicar e difícil de aceitar. O modelo completa texto com o que tem. Se o que tem é a pergunta e nada mais, ele responde com o que é estatisticamente plausível, que é exatamente o que uma pessoa faria se você perguntasse a política de reembolso de uma empresa que ela não conhece e a proibisse de dizer “não sei”. Ela inventaria uma política razoável, com tom de quem sabe. Não existe um lugar dentro do modelo onde o “não sei” mora por padrão, ele precisa ser colocado lá por quem monta o sistema. A empresa que chama isso de alucinação está descrevendo a própria arquitetura.</p><p>A distinção importa por três motivos práticos. Muda o culpado, porque alucinação é problema do fornecedor do modelo, contexto é problema de quem colocou o modelo em produção, e essa pessoa está na sua folha de pagamento. Muda a correção, porque trocar de modelo não resolve falta de grounding, o termo da área pra ancorar a resposta em fonte real, e trocar de modelo é o que a maioria tenta primeiro, porque é a correção que não exige olhar pra dentro. E muda a relação com o “não sei”, porque um sistema com permissão e informação pra dizer “isso não está no meu escopo” erra muito menos que um sistema mais inteligente sem essa saída. A Air Canada não precisava de modelo melhor. O bot dela já tinha o link da política certa. Precisava de uma regra dizendo que a fonte vence a resposta e de autorização pra parar quando as duas não batem.</p><p>Alucinação de verdade existe, e quem trabalha com modelo vai lembrar disso nos comentários. Existe citação jurídica inventada com o caso real na frente do modelo, número trocado no resumo de um documento que estava inteiro no contexto, e o Replit dizendo que o rollback era impossível quando a informação pra saber o contrário estava disponível. Isso é erro do modelo, e ninguém resolve com prompt. Mas é menor e mais detectável quando o contexto está certo, porque invenção fica visível contra uma fonte e invisível no vazio. Na nossa experiência, a maior parte do que chega na mesa como “o modelo alucinou” se resolve perguntando o que ele tinha em mãos quando respondeu. No SmartMatch, quando a busca devolve um criador que não tem nada a ver com a campanha, a primeira pergunta nunca é se o modelo é ruim. É o que estava no índice e no briefing na hora em que ele buscou, e quase sempre a resposta está aí.</p><p>A gente não está sozinho nessa leitura. Em 24 de setembro de 2026 o Cezar Taurion publicou no iMasters <a href="https://imasters.com.br/inteligencia-artificial/o-chatbot-comecou-a-errar-o-problema-estava-na-empresa">O chatbot começou a errar. O problema estava na empresa</a>, sobre um varejista cujo bot falhou por dado inconsistente e integração malfeita, com a conclusão de que a IA estava tornando visíveis, em escala, problemas que a empresa já tinha. Concordamos, e vamos além do chatbot. O mesmo diagnóstico vale pro agente que apaga banco, pra consultoria que entrega referência inventada e pro time de engenharia que se sente mais rápido sem estar. Em todos eles a lacuna de critério já existia antes do modelo chegar, e o modelo só deixou ela visível.</p><h3>O mesmo modelo, três respostas</h3><p>A prova não precisa de código. Pega a pergunta que derrubou a Air Canada, “posso pedir reembolso de tarifa de luto depois da viagem?”, e faz a mesma pergunta pro mesmo modelo três vezes, mudando só o que ele tem em mãos.</p><p>Só com a pergunta, o modelo responde que sim, com prazo, lista de documentos e o tom de quem sabe. É a resposta que o mundo chama de alucinação, fluente, educada, plausível e inventada, porque ele não tinha em que se ancorar nem permissão pra parar. Com a pergunta e uma política desatualizada no contexto, ele responde que sim, citando a política, com outro prazo. Essa é pior, porque parece certa. O modelo ancorou numa fonte, só que na errada, e a empresa que colocou a política errada no contexto vai culpar o modelo do mesmo jeito. Com a pergunta, a política vigente e a instrução de dizer que não sabe quando o caso não estiver coberto, ele responde que a política que tem disponível trata de pedido feito antes da viagem, que não pode confirmar esse caso e que vai encaminhar pra um atendente.</p><p>A terceira resposta não é mais inteligente. É o mesmo modelo, com a informação certa e uma saída honesta. O “alucinou” da primeira é só a ausência da terceira, e a diferença entre elas não foi feita por engenheiro de IA. Foi feita por quem sabia onde estava a política e decidiu que o sistema podia dizer “não sei”.</p><h3>Quem decide não é quem paga</h3><p>Várias das empresas citadas tinham gente boa que sabia disso tudo em tese. O que faltou não foi conhecimento, foi lugar na sala. A decisão de colocar IA em produção foi tomada por quem não ia pagar o erro, o conselho, o CEO com o press release pronto, o diretor com meta de eficiência. Quem ia pagar, o suporte, o cliente, o engenheiro de plantão, o advogado que assina a petição, não estava lá. Ninguém ali agiu de má-fé. O incentivo estava torto, e incentivo torto explica por que empresa racional toma decisão que parece irracional em retrospecto. Do lado de quem anuncia o ganho é imediato e visível. Do lado de quem opera o custo é difuso e chega depois.</p><p>O papel mais importante da próxima década corporativa não tem nome, não dá manchete e ninguém disputa, e é o de quem decide o que não automatizar. Não é o cético de plantão nem o comitê de ética. É quem tem critério pra dizer que essa saída é sugestão e aquela é compromisso, que essa ação é reversível e aquela não, que esse processo tem número de referência e aquele não tem, e que portanto o modelo entra aqui e não entra ali. E é quem decide a segunda coisa, menos óbvia e mais decisiva, que é onde o ganho de produtividade vai ser gasto.</p><p>Essa segunda parte vem da nossa experiência e é o ponto que a gente mais queria escrever. A produtividade no CreatorAds subiu com IA, e a gente mede isso em entrega, não em sensação. A maior parte do código novo hoje nasce escrito por IA, e o volume do que chega em produção subiu junto. O que surpreendeu foi que esse ganho não apareceu com a mesma força nas evaluations dos sistemas, as medições de quão bem o Guardian e o SmartMatch fazem o que devem fazer. O Guardian não ficou proporcionalmente mais preciso porque a gente passou a escrever código mais rápido. A calibração dele melhorou por causa de um experimento específico, com veredito humano como gabarito, que levou o tempo que precisava levar e não seria mais curto com o dobro de ferramenta. Entregar mais e entregar melhor descolaram.</p><p>A leitura que a gente faz é essa. Quando a capacidade de entrega deixa de ser o gargalo, o gargalo vira a escolha do que entregar. Com entrega barata, o custo de construir a coisa errada cai, mas o custo de oportunidade sobe, porque no mesmo tempo você poderia ter construído a certa. Foco vira o recurso escasso. Empresa que ganhou 30% de velocidade e distribuiu isso em 30% mais feature não ganhou nada em resultado, ganhou backlog executado. A que concentrou o ganho no problema que a medição apontava ganhou algo que aparece na métrica do negócio. Poder produzir mais e saber o que produzir são coisas diferentes, e a IA entrega a primeira quase de graça enquanto a segunda continua custando o que sempre custou.</p><h3>O que vai acontecer</h3><p>Até o fim de 2027, mais de 40% dos projetos de IA agêntica que estão rodando hoje vão ser cancelados, na conta da própria Gartner, e metade das demissões feitas em nome da IA vai ser revertida em silêncio, na conta da Forrester. As empresas que hoje comemoram produtividade vão descobrir, uma por uma, que produtividade não virou resultado. Isso não é pessimismo com a tecnologia, é o contrário. A tecnologia é boa demais, tão boa que expõe em semanas lacuna de gestão que antes levava anos pra aparecer. Quem estiver esperando o próximo modelo resolver isso vai esperar pra sempre.</p><p>A vantagem competitiva em IA não vai estar no modelo. Todo mundo vai ter o mesmo modelo, no mesmo dia, pelo mesmo preço. A vantagem vai estar em algo bem menos glamouroso, que é saber, com número, onde o seu sistema erra, e ter decidido de antemão o que acontece quando errar. Isso não se compra de fornecedor, não vem em framework e não aparece em press release. Vem de ground truth acumulado, de contestação guardada, de humano transformado em referência em vez de descartado como custo. É lento, é chato e é a única coisa que não dá pra copiar.</p><p>No CreatorAds isso é regra de operação. O Guardian só decide sozinho nas faixas de confiança em que a calibração contra veredito humano sustenta a decisão, e tudo fora dessas faixas vai pra uma pessoa. No SmartMatch, cada criador que a busca devolve é só isso, uma sugestão, que alguém aceita ou ignora antes de virar campanha.</p><p>A empresa que sabe usar IA é a que sabe exatamente onde a IA dela erra. Esse mapa decide o que ela automatiza, o que ela mede e quem ela põe na sala, e nenhuma compra resolve isso no lugar dela. Modelo, framework, agente, todo o resto é detalhe de implementação.</p><p>Sua empresa não sabe usar IA. A boa notícia é que quase ninguém sabe, e a corrida que importa ainda não começou. Ela não vai ser vencida por quem tem o modelo mais novo. Vai ser vencida por quem descobrir primeiro onde não deve usá-lo, e tiver coragem de deixar esse lugar com gente.</p><h3>Referências</h3><ul><li>Zenity. AI agent deletes production database: the PocketOS incident. 2026. <a href="https://zenity.io/blog/ai-agent-database-deletion-pocketos">https://zenity.io/blog/ai-agent-database-deletion-pocketos</a></li><li>Cyera Research. Agent-Inflicted Damage: Inside the Real-World Failures of Enterprise AI Systems. 2026. <a href="https://www.cyera.com/research/agent-inflicted-damage-inside-the-real-world-failures-of-enterprise-ai-systems">https://www.cyera.com/research/agent-inflicted-damage-inside-the-real-world-failures-of-enterprise-ai-systems</a></li><li>eWeek. Replit AI coding assistant deletes production database. 2025. <a href="https://www.eweek.com/news/replit-ai-coding-assistant-failure/">https://www.eweek.com/news/replit-ai-coding-assistant-failure/</a></li><li>Vectara. Replit AI Database Deletion, case study (awesome-agent-failures). GitHub. <a href="https://github.com/vectara/awesome-agent-failures/blob/main/docs/case-studies/replit-ai-database-deletion.md">https://github.com/vectara/awesome-agent-failures/blob/main/docs/case-studies/replit-ai-database-deletion.md</a></li><li>MIT NANDA, via Virtualization Review. MIT Report Finds Most AI Business Investments Fail, Reveals GenAI Divide. 19/08/2025. <a href="https://virtualizationreview.com/articles/2025/08/19/mit-report-finds-most-ai-business-investments-fail-reveals-genai-divide.aspx">https://virtualizationreview.com/articles/2025/08/19/mit-report-finds-most-ai-business-investments-fail-reveals-genai-divide.aspx</a></li><li>Snyder, J. MIT Finds 95% of GenAI Pilots Fail Because Companies Avoid Friction. Forbes, 26/08/2025. <a href="https://www.forbes.com/sites/jasonsnyder/2025/08/26/mit-finds-95-of-genai-pilots-fail-because-companies-avoid-friction/">https://www.forbes.com/sites/jasonsnyder/2025/08/26/mit-finds-95-of-genai-pilots-fail-because-companies-avoid-friction/</a></li><li>Gartner. Over 40% of Agentic AI Projects Will Be Canceled by End of 2027. 25/06/2025. <a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027</a></li><li>Orgvue, via TechRepublic. ‘We Acted Too Quickly’: Over Half of Companies Regret AI-Driven Layoffs, Report Finds. 19/05/2025. <a href="https://www.techrepublic.com/article/news-leaders-regret-ai-driven-layoffs/">https://www.techrepublic.com/article/news-leaders-regret-ai-driven-layoffs/</a></li><li>CNBC. Employers who laid off workers for AI are reversing their decisions. 01/07/2026. <a href="https://www.cnbc.com/2026/07/01/employers-who-laid-off-workers-for-ai-are-reversing-their-decisions.html">https://www.cnbc.com/2026/07/01/employers-who-laid-off-workers-for-ai-are-reversing-their-decisions.html</a></li><li>Fast Company. The great AI layoff is turning into the great AI rehire. 2026. <a href="https://www.fastcompany.com/91571824/the-great-ai-layoff-is-turning-into-the-great-ai-rehire">https://www.fastcompany.com/91571824/the-great-ai-layoff-is-turning-into-the-great-ai-rehire</a></li><li>Reuters, via The Globe and Mail. IKEA bets on remote interior design as AI changes sales strategy. 06/2023. <a href="https://theglobeandmail.com/business/international-business/article-ikea-bets-on-remote-interior-design-as-ai-changes-sales-strategy/">https://theglobeandmail.com/business/international-business/article-ikea-bets-on-remote-interior-design-as-ai-changes-sales-strategy/</a></li><li>Quartz. Companies rehiring workers after AI layoffs. 01/07/2026. <a href="https://qz.com/companies-rehiring-workers-ai-layoffs-automation-070126">https://qz.com/companies-rehiring-workers-ai-layoffs-automation-070126</a></li><li>insideAI News. The $500MM Debacle at Zillow Offers: What Went Wrong with the AI Models. 13/12/2021. <a href="https://insideainews.com/2021/12/13/the-500mm-debacle-at-zillow-offers-what-went-wrong-with-the-ai-models/">https://insideainews.com/2021/12/13/the-500mm-debacle-at-zillow-offers-what-went-wrong-with-the-ai-models/</a></li><li>Entrepreneur. Klarna CEO Reverses Course by Hiring More Humans, Not AI. 2025. <a href="https://www.entrepreneur.com/business-news/klarna-ceo-reverses-course-by-hiring-more-humans-not-ai/491396">https://www.entrepreneur.com/business-news/klarna-ceo-reverses-course-by-hiring-more-humans-not-ai/491396</a></li><li>Forbes. Klarna Reverses on AI, Says Customers Like Talking to People. 18/05/2025. <a href="https://www.forbes.com/sites/quickerbettertech/2025/05/18/business-tech-news-klarna-reverses-on-ai-says-customers-like-talking-to-people/">https://www.forbes.com/sites/quickerbettertech/2025/05/18/business-tech-news-klarna-reverses-on-ai-says-customers-like-talking-to-people/</a></li><li>ABC News. CBA backtracks on AI job cuts as chatbot lifts call volumes. 21/08/2025. <a href="https://www.abc.net.au/news/2025-08-21/cba-backtracks-on-ai-job-cuts-as-chatbot-lifts-call-volumes/105679492">https://www.abc.net.au/news/2025-08-21/cba-backtracks-on-ai-job-cuts-as-chatbot-lifts-call-volumes/105679492</a></li><li>The Register. Commonwealth Bank rehires after chatbot fails to cut call volumes. 22/08/2025. <a href="https://www.theregister.com/2025/08/22/commonwealth_ban_chatbot_fail_rehiring/">https://www.theregister.com/2025/08/22/commonwealth_ban_chatbot_fail_rehiring/</a></li><li>Customer Experience Dive. Duolingo’s AI-first memo: lessons from the consumer backlash. 2025. <a href="https://www.customerexperiencedive.com/news/duolingo-ai-first-consumer-backlash-lessons/757133/">https://www.customerexperiencedive.com/news/duolingo-ai-first-consumer-backlash-lessons/757133/</a></li><li>Fortune. Duolingo CEO Luis von Ahn drops AI usage requirement from employee performance evaluations. 13/04/2026. <a href="https://fortune.com/2026/04/13/duolingo-ceo-luis-von-ahn-ai-usage-requirement-employee-performance-evaluations/">https://fortune.com/2026/04/13/duolingo-ceo-luis-von-ahn-ai-usage-requirement-employee-performance-evaluations/</a></li><li>Fortune. Salesforce CEO Marc Benioff on AI agents, jobs and layoffs in customer service and sales. 02/09/2025. <a href="https://fortune.com/2025/09/02/salesforce-ceo-billionaire-marc-benioff-ai-agents-jobs-layoffs-customer-service-sales/">https://fortune.com/2025/09/02/salesforce-ceo-billionaire-marc-benioff-ai-agents-jobs-layoffs-customer-service-sales/</a></li><li>Quartz. Salesforce layoffs hit Agentforce, MuleSoft and Marketing Cloud. 10/06/2026. <a href="https://qz.com/salesforce-layoffs-agentforce-mulesoft-marketing-cloud-061026">https://qz.com/salesforce-layoffs-agentforce-mulesoft-marketing-cloud-061026</a></li><li>Moffatt v. Air Canada, 2024 BCCRT 149, 14/02/2024. <a href="https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do">https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do</a></li><li>CBC News. Air Canada ordered to pay customer misled by chatbot. 2024. <a href="https://www.cbc.ca/news/canada/british-columbia/air-canada-chatbot-lawsuit-1.7116416">https://www.cbc.ca/news/canada/british-columbia/air-canada-chatbot-lawsuit-1.7116416</a></li><li>McCarthy Tétrault. Moffatt v. Air Canada: misrepresentation by an AI chatbot. 2024. <a href="https://www.mccarthy.ca/en/insights/blogs/techlex/moffatt-v-air-canada-misrepresentation-ai-chatbot">https://www.mccarthy.ca/en/insights/blogs/techlex/moffatt-v-air-canada-misrepresentation-ai-chatbot</a></li><li>Gizmodo. Chevy dealership’s ChatGPT bot agrees to sell a Tahoe for $1. 2023. <a href="https://gizmodo.com/ai-chevy-dealership-chatgpt-bot-customer-service-fail-1851111825">https://gizmodo.com/ai-chevy-dealership-chatgpt-bot-customer-service-fail-1851111825</a></li><li>AI Incident Database. Incident 622: Chevrolet of Watsonville chatbot. <a href="https://incidentdatabase.ai/cite/622/">https://incidentdatabase.ai/cite/622/</a></li><li>Fortune. Cursor’s customer support AI went rogue. 2025. <a href="https://fortune.com/article/customer-support-ai-cursor-went-rogue">https://fortune.com/article/customer-support-ai-cursor-went-rogue</a></li><li>AI Incident Database. Incident 1039: Cursor support bot invents policy. <a href="https://incidentdatabase.ai/cite/1039/">https://incidentdatabase.ai/cite/1039/</a></li><li>Fast Company. McDonald’s ends its AI drive-thru ordering test after glitches. 2024. <a href="https://www.fastcompany.com/91142882/mcdonalds-ai-drive-thru-ordering-glitches">https://www.fastcompany.com/91142882/mcdonalds-ai-drive-thru-ordering-glitches</a></li><li>Restaurant Online. McDonald’s ends AI drive-thru trial in US after order mistakes. 19/06/2024. <a href="https://www.restaurantonline.co.uk/Article/2024/06/19/McDonald-s-ends-AI-drive-thru-trial-in-US-after-order-mistakes/">https://www.restaurantonline.co.uk/Article/2024/06/19/McDonald-s-ends-AI-drive-thru-trial-in-US-after-order-mistakes/</a></li><li>TechCrunch. Taco Bell is having second thoughts about relying on AI at the drive-through. 30/08/2025. <a href="https://techcrunch.com/2025/08/30/taco-bell-is-having-second-thoughts-about-relying-on-ai-at-the-drive-through/">https://techcrunch.com/2025/08/30/taco-bell-is-having-second-thoughts-about-relying-on-ai-at-the-drive-through/</a></li><li>AI Incident Database. Incident 1274: Taco Bell voice AI. <a href="https://incidentdatabase.ai/cite/1274/">https://incidentdatabase.ai/cite/1274/</a></li><li>Teletime. Brasil adota IA no atendimento, mas consumidores não estão tão satisfeitos (pesquisa Twilio). 27/01/2026. <a href="https://teletime.com.br/27/01/2026/brasil-adota-ia-no-atendimento-mas-consumidores-nao-estao-tao-satisfeitos/">https://teletime.com.br/27/01/2026/brasil-adota-ia-no-atendimento-mas-consumidores-nao-estao-tao-satisfeitos/</a></li><li>AnswerConnect e OnePoll, via Yahoo Finance. AI backlash grows across US. 05/2026. <a href="https://finance.yahoo.com/news/ai-backlash-grows-across-us-141500259.html">https://finance.yahoo.com/news/ai-backlash-grows-across-us-141500259.html</a></li><li>Fortune. Deloitte to refund Australian government over AI hallucinations in report. 07/10/2025. <a href="https://fortune.com/2025/10/07/deloitte-ai-australia-government-report-hallucinations-technology-290000-refund">https://fortune.com/2025/10/07/deloitte-ai-australia-government-report-hallucinations-technology-290000-refund</a></li><li>CFO Dive. Deloitte AI debacle seen as wake-up call for corporate finance. 2025. <a href="https://www.cfodive.com/news/deloitte-ai-debacle-seen-wake-up-call-corporate-finance/802674/">https://www.cfodive.com/news/deloitte-ai-debacle-seen-wake-up-call-corporate-finance/802674/</a></li><li>Global Legal Post. Sullivan &amp; Cromwell apologises for AI hallucinations in letter to US court. 2026. <a href="https://www.globallegalpost.com/news/sullivan-cromwell-apologises-for-ai-hallucinations-in-letter-to-us-court-1300253238">https://www.globallegalpost.com/news/sullivan-cromwell-apologises-for-ai-hallucinations-in-letter-to-us-court-1300253238</a></li><li>CNN. AI hallucinations at Sullivan &amp; Cromwell (Nightcap). 23/04/2026. <a href="https://www.cnn.com/2026/04/23/business/ai-hallucination-sullivan-cromwell-nightcap">https://www.cnn.com/2026/04/23/business/ai-hallucination-sullivan-cromwell-nightcap</a></li><li>TechCrunch. Anthropic’s lawyer was forced to apologize after Claude hallucinated a legal citation. 15/05/2025. <a href="https://techcrunch.com/2025/05/15/anthropics-lawyer-was-forced-to-apologize-after-claude-hallucinated-a-legal-citation">https://techcrunch.com/2025/05/15/anthropics-lawyer-was-forced-to-apologize-after-claude-hallucinated-a-legal-citation</a></li><li>Going Concern. AI startup that went bust was allegedly actually Indians and may have inflated revenue too (sobre a reportagem da Bloomberg). 2025. <a href="https://www.goingconcern.com/ai-startup-that-went-bust-was-allegedly-actually-indians-and-may-have-inflated-revenue-too/">https://www.goingconcern.com/ai-startup-that-went-bust-was-allegedly-actually-indians-and-may-have-inflated-revenue-too/</a></li><li>DevOps.com. This bankrupt AI startup was more artificial than intelligent. 2025. <a href="https://devops.com/this-bankrupt-ai-startup-was-more-artificial-than-intelligent/">https://devops.com/this-bankrupt-ai-startup-was-more-artificial-than-intelligent/</a></li><li>The Register. AI coding tools slow down experienced developers, METR finds. 11/07/2025. <a href="https://www.theregister.com/2025/07/11/ai_code_tools_slow_down/">https://www.theregister.com/2025/07/11/ai_code_tools_slow_down/</a></li><li>METR. Measuring AI uplift: February 2026 update. 24/02/2026. <a href="https://metr.org/blog/2026-02-24-uplift-update/">https://metr.org/blog/2026-02-24-uplift-update/</a></li><li>Taurion, C. O chatbot começou a errar. O problema estava na empresa. iMasters, 24/09/2026. <a href="https://imasters.com.br/inteligencia-artificial/o-chatbot-comecou-a-errar-o-problema-estava-na-empresa">https://imasters.com.br/inteligencia-artificial/o-chatbot-comecou-a-errar-o-problema-estava-na-empresa</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=368ba7a3005f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como você sabe que seu agente funciona?]]></title>
            <link>https://medium.com/@francocontigo/como-voc%C3%AA-sabe-que-seu-agente-funciona-74f7d602714f?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/74f7d602714f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[eval]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 19:02:33 GMT</pubDate>
            <atom:updated>2026-08-18T19:02:33.146Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Medidor de foco manual, representando o foco seletivo" src="https://cdn-images-1.medium.com/max/1024/1*iT3833y3LJklSsUaBH7oJw.avif" /><figcaption>Foco manual seletivo</figcaption></figure><p><em>A habilidade mais disputada da área não é subir LLM em produção, é provar que ele funciona.</em></p><p>Toda conversa sobre agente em produção que eu acompanho, em time, em comunidade, em thread de LinkedIn, chega SEMPRE no mesmo lugar do mesmo jeito. Alguém descreve o sistema: RAG, tool calling, fallback, retry, um diagrama bonito. Aí alguém pergunta como sabem que aquilo funciona, e a resposta é uma variação de “a gente testou bastante e pareceu bom”, às vezes com um benchmark público que não tem nada a ver com o produto.</p><p>Esse artigo nasceu do incômodo com essa cena. O mercado gastou tempo anos ensinando todo mundo a subir sistema com LLM. Framework, template, curso de fim de semana. Subir é fácil. Medir continua sendo difícil, e é medir que decide as brigas que importam: trocar ou não de modelo, automatizar ou não o próximo passo, defender ou não o projeto quando o custo dele aparece na planilha de alguém.</p><p>Eu queria um texto que desse pra mandar pra alguém que acabou de subir o primeiro agente: por que benchmark público não resolve, em que estágio o time está, e o processo inteiro de montar o primeiro eval harness, com os números e as decisões de cada etapa. Não achei em português, então resolvi escrever.</p><h3>Todo mundo aprendeu a subir, quase ninguém aprendeu a medir</h3><p>Tem um número que abre bem essa discussão.</p><p>O curso <a href="https://maven.com/parlance-labs/evals">AI Evals for Engineers &amp; PMs</a>, do Hamel Husain e da Shreya Shankar, custa US$ 4.200 e já passou por <strong>mais de 4.500 engenheiros e PMs</strong>, de times de OpenAI, Google, Meta, Amazon e Microsoft. Lenny Rachitsky, que provavelmente é a pessoa que mais entrevista construtor de produto no mundo hoje, <a href="https://www.lennysnewsletter.com/p/why-ai-evals-are-the-hottest-new-skill">descreve os dois</a> como quem “ensina o curso mais popular do mundo sobre AI evals” e chama isso de a habilidade mais quente pra quem constrói produto de IA. A O’Reilly tem o livro deles, <em>Evals for AI Engineers</em>, marcado pra outubro de 2026.</p><p>Quatro mil e quinhentas pessoas pagando quatro mil dólares pra aprender a medir. Hype de feed não move orçamento de times desse tamanho.</p><p>Do outro lado, o cargo “AI Engineer” foi o que mais cresceu nos Estados Unidos na lista Jobs on the Rise do LinkedIn em <strong>2025 e de novo em 2026</strong>, <a href="https://www.axios.com/2025/01/07/ai-jobs-on-the-rise-linkedin-report">segundo a Axios</a> e a <a href="https://www.forbes.com/sites/juliakorn/2026/01/14/future-proof-your-career-with-linkedins-2026-fastest-growing-jobs-list/">Forbes</a>. A fila de gente aprendendo a subir agente é gigantesca. A fila de gente aprendendo a medir agente é muito menor.</p><h4>O argumento econômico, que é o que convence quem ta gastando dinheiro</h4><p>A parte que interessa pro negócio cabe em duas frases.</p><p>O custo de errar cresce junto com o grau de automação. Enquanto tem humano revisando cada saída, o erro do modelo é um incômodo. Quando você tira o humano do meio, o erro do modelo vira o output da empresa.</p><p>E o mercado já está pagando essa conta em público.</p><p>Em fevereiro de 2024, o <a href="https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do">Civil Resolution Tribunal da British Columbia condenou a Air Canada</a> porque o chatbot do site inventou uma política de tarifa de luto. A empresa argumentou que não podia ser responsabilizada pelo que o chatbot disse. O tribunal respondeu, no parágrafo 27, que a Air Canada estava sugerindo que “o chatbot é uma entidade legal separada, responsável pelos próprios atos”, e classificou isso como “uma alegação notável”. Foram CAD 812,02 no total. O valor é irrelevante. O precedente não.</p><p>A cidade de Nova York manteve no ar por mais de dois anos um chatbot que, <a href="https://themarkup.org/artificial-intelligence/2024/03/29/nycs-ai-chatbot-tells-businesses-to-break-the-law">conforme o The Markup documentou</a>, dizia a empresários que dava pra recusar inquilino com voucher de habitação e ficar com parte da gorjeta dos funcionários. As duas coisas são ilegais lá. Só foi mandado desligar em fevereiro de 2026, depois de custar uns estimados meio milhão de dólares por ano.</p><p>E o caso mais fácil de medir: o pesquisador Damien Charlotin mantém uma <a href="https://www.damiencharlotin.com/hallucinations/">base de decisões judiciais em que a corte reconheceu explicitamente que alguém usou conteúdo alucinado</a>. Na consulta de 16 de agosto de 2026, são <strong>1.922 casos</strong>, quarenta e um deles no Brasil.</p><p>Nenhum desses times era incompetente. Todos subiram alguma coisa que passou no olho de alguém.</p><p>A Gartner <a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">projeta que mais de 40% dos projetos de IA agêntica serão cancelados até o fim de 2027</a>, por custo, valor de negócio pouco claro ou controle de risco inadequado. É previsão, não uma medição, e vale ler como tal. Mas os três motivos que eles listam têm a mesma raiz, ninguém conseguiu mostrar, com número, que a coisa funciona bem o suficiente pra justificar o próximo passo.</p><p>Eval é o gate de confiança. Sem eval, você não tem argumento pra automatizar mais, e sem automatizar mais o projeto não paga o próprio custo.</p><p>Ninguém faz deploy sem teste em software tradicional. Em IA o teste existe também, só que o gabarito é probabilístico e você precisa construir o gabarito antes. É trabalho a mais, e é por isso que quase ninguém faz.</p><h4>“Mas o Claude Code não usa evals”</h4><p>Essa objeção merece resposta própria, porque ela dominou uma semana inteira de timeline em setembro de 2025.</p><p>O estopim foi real. Boris Cherny, do Claude Code, <a href="https://www.latent.space/p/claude-code">disse num podcast</a> que decisões centrais do produto foram tomadas no “mostly vibes”, com dogfooding no lugar de benchmark. O swyx <a href="https://x.com/swyx/status/1963725773355057249">empacotou numa lista</a> de produtos famosos “sem evals”, um CEO de startup de agentes escreveu que “evals are a scam”, outro foi menos educado, e por uma semana pareceu que a área de estudo tinha morrido antes de nascer.</p><p>Dois detalhes desmontam a objeção.</p><p>O primeiro é o contexto, no Claude Code, o desenvolvedor é o domain expert e usa o produto o dia inteiro. Dogfooding nessa configuração é error analysis contínua com o melhor anotador possível. Foi o que a Shreya Shankar respondeu no episódio do Lenny, quem diz que não faz eval quase sempre está fazendo, sem chamar assim.</p><p>O segundo é o epílogo. Em julho de 2026, o time do Claude Code declarou publicamente ter <a href="https://simonwillison.net/2026/Jul/21/cat-and-thariq/">“milhares de evals”</a>, e o próprio Cherny <a href="https://www.ycrootaccess.com/p/boris-cherny-building-claude-code">descreveu o ciclo</a>: você usa o produto, vê onde ele apanha, e é daí que sai o eval set, que satura, é jogado fora e refeito. Isso é, quase palavra por palavra, o processo que eu descrevo daqui a duas seções.</p><p>O que sobrou de bom do debate foi a versão madura da crítica, que pode ser resuminda em “<strong>eval mal feita é teatro”</strong>. Juiz sem validação, golden set que não vem de produção, score corporativo usado como peça de marketing. O resto deste artigo é sobre como não fazer isso.</p><h3>Os três estágios</h3><p>Eu venho usando essa tipologia em conversa faz um tempo e ela se sustentou bem. Todo time que eu conheço está em um dos três. Inclusive o meu, em momentos diferentes.</p><h4>Estágio 1, vibe check</h4><p>Você abre o playground, roda cinco, dez e sei lá quantos exemplos que te vieram à cabeça, lê as saídas, acha que ficou bom, e sobe.</p><p>Descrito como medição, isso é n=5, amostrado por conveniência, avaliado pela mesma pessoa que tem interesse no resultado. Três vieses num movimento só.</p><p>Não tem nada de errado em começar aqui. Todo mundo começa aqui. O problema é ficar.</p><p>Os sintomas são fáceis de reconhecer, e são todos comportamentais, não técnicos:</p><ul><li>Você troca uma palavra do prompt e não tem ideia se melhorou ou piorou o resto.</li><li>Sai modelo novo, todo mundo no time quer trocar, e ninguém consegue defender a troca com número.</li><li>Existe um conjunto informal de “exemplos que a gente sempre testa”, que mora na cabeça de uma pessoa e some quando ela sai de férias.</li><li>Tem medo de mexer. Esse é o sintoma definitivo e o mais desconfortável de viver no dia a dia. Quando o custo de uma mudança é desconhecido, a resposta racional do time é parar de mudar, e o sistema congela no primeiro mínimo local que passou no olho de alguém.</li></ul><p>O que impede de subir de estágio quase nunca é conhecimento técnico. É a crença de que eval é uma coisa que se faz depois, quando o produto amadurecer. A Anthropic <a href="https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents">colocou isso muito bem</a>: “evals ficam mais difíceis de construir quanto mais você espera. No começo, requisitos de produto viram casos de teste naturalmente. Espera demais e você vai estar fazendo engenharia reversa dos critérios de sucesso a partir de um sistema vivo.”</p><h4>Estágio 2, benchmark genérico</h4><p>Aqui o time entendeu que precisa de número. Então foi buscar número onde tinha número pronto: MMLU, acurácia em dataset público, posição em leaderboard, score do model card.</p><p>Esse estágio parece maduro e é, na prática, mais perigoso que o estágio 1. Porque agora você tem um número, e número dá confiança. Só que o número é sobre outra coisa. Então, em três passos, vamos lá.</p><p><strong>Primeiro, o benchmark pode estar dentro do treino.</strong> A Scale AI construiu o <a href="https://arxiv.org/abs/2405.00332">GSM1k</a>, mil problemas novos espelhando a distribuição do GSM8K, e mediu a queda. Deu <strong>até 13 pontos percentuais</strong>, concentrada em famílias de modelo otimizadas pra matemática. O Math-Shepherd-Mistral-7B-RL fazia 74,5% no GSM8K e fez 61,1% no GSM1k. E não adianta confiar na descontaminação por n-grama, <a href="https://arxiv.org/abs/2311.04850">um trabalho de 2023 mostrou</a> que paráfrase e tradução simples driblam os métodos padrão, e que de 8% a 18% do HumanEval aparece sobreposto em conjuntos de pré-treino públicos.</p><p><strong>Segundo, o benchmark pode estar simplesmente errado.</strong> O paper <a href="https://aclanthology.org/2025.naacl-long.262/">“Are We Done with MMLU?”</a> reanotou 5.700 questões do MMLU nos 57 subjects e encontrou <strong>6,49% de questões com erro</strong> no dataset todo. No subset de Virologia, <strong>57% das questões analisadas tinham problema</strong>, entre gabarito errado e questão ambígua. Corrigir isso mudou ranking de modelo, em Virologia, o Llama 3.1 405B era décimo sexto colocado considerando todas as instâncias, e virou primeiro considerando só as instâncias corretas.</p><p><strong>Terceiro, o leaderboard tem gente jogando o jogo.</strong> O <a href="https://arxiv.org/abs/2504.20879">“The Leaderboard Illusion”</a> documentou que aumentar a proporção de dados da arena no treino de 0% para 70% <strong>mais que dobra o win rate no ArenaHard, de 23,5% pra 49,9%</strong>. E que a Meta testou 27 variantes privadas na largada do Llama 4, podendo escolher qual score publicar. Antes disso, a própria LMSYS <a href="https://www.lmsys.org/blog/2024-08-28-style-control/">mostrou que boa parte da preferência humana na arena é explicada por comprimento e formatação markdown</a>, controlando por estilo, um modelo caiu do 6º pro 18º lugar. A comunidade já tem até verbo pra essa prática, <em>benchmaxxing,</em> otimizar pro que o leaderboard mede em vez da capacidade que ele deveria medir.</p><p>Se você quiser um único número pra guardar dessa seção, use esse. A Epoch AI rodou o GPQA Diamond dezesseis vezes de forma independente num modelo cujo score reportado era 65%, e <a href="https://epoch.ai/benchmarks/about">obteve média de 55%, com desvio de 3 pontos</a>. Dez pontos de diferença, e sem causa identificável, porque quem publica score raramente reporta prompt e temperatura. Benchmark que não é reprodutível entre avaliadores não serve como critério de aceite de produto.</p><p>A crítica mais estrutural veio em 2025, quando um time do Oxford Internet Institute <a href="https://arxiv.org/abs/2511.04703">revisou 445 benchmarks de LLM</a> publicados nas principais conferências. Apenas <strong>16% usaram algum teste estatístico</strong> pra comparar modelos e menos de 10% usaram tarefas completas do mundo real. O título do paper é <em>Measuring what Matters</em>, e o argumento é exatamente esse.</p><p>Junte os três e sobra só uma conclusão, <strong>benchmark genérico prediz mal o desempenho na sua tarefa</strong>, e nenhum deles foi construído pra prever.</p><p>Sintoma clínico do estágio 2: o time discute qual modelo usar lendo model card, e não rodando os dois no próprio caso de uso.</p><h4>Estágio 3, eval de produto</h4><p>Aqui o gabarito é seu, e esse meio que é o problema?</p><p>O time olhou tráfego real, catalogou os modos de falha que acontecem de fato no produto, montou um conjunto de casos com veredito humano, construiu um juiz automático que foi calibrado contra esse veredito, e amarrou tudo num gate que roda a cada mudança.</p><p>O que muda no dia a dia é uma coisa só, e é enorme: <strong>o time volta a ter velocidade.</strong> Dá pra trocar prompt, trocar modelo, mudar chunking, mexer no retriever, porque existe um número que diz se piorou. O medo de mexer some.</p><p>O que impede de chegar aqui também não é ferramenta ou gap tecnico, e é isso que a próxima seção trata. É o trabalho manual chato que ninguém quer fazer, e que quase todo mundo pula.</p><h3>O cookbook</h3><p>Antes dos passos, as duas observações que explicam o formato deles. A receita só faz sentido se você aceitar as duas premissas.</p><p><strong>Primeira: sistema com LLM falha em silêncio.</strong> Código tradicional quebra com stack trace. LLM não quebra. Ele responde, fluente, bem formatado, com exatamente a mesma confiança no acerto e no erro. Nenhuma exceção vai tocar alarme por você, e é por isso que a receita começa com leitura de dados e não com infraestrutura.</p><p><strong>Segunda: qualidade não é propriedade do modelo.</strong> Ela nasce do encontro entre o modelo, o seu prompt, os seus dados e o seu tráfego. Muda quando qualquer um dos quatro muda. É por isso que ela não se terceiriza pra benchmark, e é por isso que todos os passos abaixo trabalham com o seu material.</p><p>Aceitou as duas, o resto é começar a execução. Sete passos. Não precisa de plataforma, não precisa de aprovação de compra, não precisa de time. Precisa de acesso aos traces e de disposição pra ler texto ruim por dois dias. Os seis primeiros passos cabem numa semana de uma pessoa. O sétimo roda pra sempre, e é ele que impede os outros seis de apodrecerem.</p><p>E não precisa tentar ser um herói, rode a receita padrão uma vez, do jeito que está, antes de adaptar pro seu caso. Adaptação prematura é como otimização prematura, só que mais difícil de reverter, porque você nunca vai saber como seria o resultado do processo que não rodou.</p><h4>1. Colete traces reais</h4><p>Junte de algo entre 50 a 100 traces de produção incialmente. Trace inteiro: input do usuário, o que o sistema recuperou, quais tools chamou, o que devolveu. Se você não tem tráfego ainda, gere dado sintético, e eu volto nisso no passo 4.</p><h4>2. Leia tudo, um por um</h4><p>Essa parte é ruim mesmo, desculpe. <strong>Leia todos, um por um, e escreva em linguagem livre o que está errado em cada um.</strong> Sem categoria pré-definida, sem rubrica, sem nota. Só um campo de texto do lado de cada trace, onde você escreve “respondeu certo mas ignorou que o usuário já tinha dito que era vegetariano” ou “chamou a tool duas vezes com o mesmo argumento”.</p><p>Toda vez que eu faço isso eu encontro alguma coisa que não estava procurando. Tool chamada duas vezes em loop, contexto truncado no meio de uma frase, router mandando pro agente errado, usuário repetindo a mesma pergunta com irritação crescente em três turnos. Nada disso aparece em dashboard, porque dashboard mostra o que você já sabia que devia olhar.</p><p>Isso tem nome, vem de pesquisa qualitativa e se chama <strong>open coding</strong>. O Hamel Husain e a Shreya Shankar adaptaram pra traces de LLM e é o coração do método deles. Três regras <a href="https://hamel.dev/blog/posts/evals-faq/">do FAQ deles</a>:</p><ol><li>Anote só a <strong>primeira</strong> falha de cada trace no começo, porque erro lá em cima causa erro lá embaixo e você conta a mesma coisa diversas vezes.</li><li>Quem anota tem que entender do domínio. Eles chamam essa pessoa de <em>benevolent dictator,</em> um psicólogo pro chatbot de saúde mental, um advogado pra análise de documento jurídico, o diretor de atendimento pra automação de suporte. Uma pessoa, não cinco. E sobre delegar, são bem diretos, “leia os traces brutos você mesmo no começo. É assim que você descobre novos tipos de falha. <strong>Nunca pule isso nem delegue.</strong>”</li><li>Pare quando novos traces pararem de revelar categoria nova, o que também tem nome emprestado da pesquisa qualitativa, <strong>saturação teórica</strong>. A heurística deles, se uns 20 traces seguidos não trouxerem categoria nova, pode parar, mas revise pelo menos 100 na primeira rodada.</li></ol><p>Se isso parece muito trabalho pra um resultado incerto, o número que eles dão é, “gastamos <strong>60 a 80% do tempo de desenvolvimento</strong> em error analysis e avaliação”. Essa não é a etapa preparatória. É o trabalho.</p><h4>3. Agrupe e conte</h4><p>Agora pegue todas as anotações livres e agrupe em categorias. Isso é <strong>axial coding</strong>, e é a etapa que o Hamel fala que é a mais importante do processo todo.</p><p>Aqui um LLM ajuda de verdade, joga as suas cem anotações e pede pra propor um agrupamento. Você corrige, funde categorias que são a mesma coisa com nome diferente, separa as que viraram balaio. O critério é conseguir contar sem hesitar.</p><p>E aí conta a frequência por categoria.</p><p>Essa contagem é o produto do dia, e pode ser desconfortável, porque a distribuição quase nunca é a que o time imaginava. O exemplo público que o Hamel usa é de um produto onde três problemas respondiam por mais de 60% das falhas, e o pior deles era interpretação de data relativa, quando o usuário dizia “daqui a duas semanas”, o sistema errava 66% das vezes. Depois de atacado, a taxa de acerto foi de 33% para 95%. Ninguém tinha adivinhado que era esse o problema principal.</p><p>Priorize por dor vezes frequência. O topo da lista costuma ser óbvio quando a contagem está na sua frente.</p><h4>4. Golden dataset v0</h4><p>Agora você monta o conjunto de casos com veredito humano.</p><p>Tamanho, comece pequeno. A recomendação da Anthropic é bem específica e derruba a desculpa mais comum, “times adiam construir evals porque acham que precisam de centenas de tarefas. Na prática, <strong>20 a 50 tarefas simples tiradas de falhas reais já é um ótimo começo</strong>.”</p><p>Regras que eu seguiria no começo:</p><ol><li><strong>Caso real ganha de caso sintético.</strong> Você acabou de passar dois dias lendo produção. Os melhores casos já estão anotados.</li><li><strong>Inclua os difíceis e os ambíguos.</strong> Um golden set só com caso fácil te dá 98% de aprovação e zero informação. O Hamel tem uma frase boa sobre isso, “se você está passando em 100% das suas evals, provavelmente não está desafiando o sistema o suficiente. <strong>Uma taxa de 70% pode indicar uma avaliação mais significativa.</strong>”</li><li><strong>Se você não tem tráfego, gere sintético com estrutura.</strong> Pedir “me dê queries de teste” pro modelo produz lixo genérico e repetitivo. O que funciona é definir dimensões e escrever tuplas. Num app de receita, as dimensões seriam restrição alimentar como <em>vegano, sem glúten, nenhuma</em>, tipo de <em>cozinha italiana, asiática, comfort food</em> e complexidade <em>simples, multi-etapa</em>. Escreva <strong>20 tuplas na mão</strong> primeiro, porque isso te obriga a entender o espaço do problema. Depois escale, e converta tupla em linguagem natural <strong>num prompt separado</strong>, senão todas as queries saem com a mesma cara.</li><li><strong>Espere que os critérios mudem enquanto você rotula.</strong> A Shreya Shankar deu nome a isso num <a href="https://arxiv.org/abs/2404.12272">paper de 2024</a>, <em>criteria drift</em>. Você precisa de critério pra julgar saída, mas é julgando saída que você descobre o critério. Não trate a rubrica v0 como contrato, trate como rascunho.</li><li><strong>Se mais de uma pessoa rotula, meça a concordância antes de cobrar a máquina.</strong> E calibre a expectativa: num <a href="https://arxiv.org/abs/2512.09662">estudo de detecção de discurso de ódio de dezembro de 2025</a>, anotadores humanos treinados ficaram com kappa de Cohen entre <strong>0,47 e 0,48</strong> em dois dos três datasets. Isso é “moderado”. Se os seus humanos concordam em 0,47, exigir 0,8 do seu juiz automático é incoerente.</li></ol><p>Uma ressalva sobre o kappa, já que estamos aqui. Com classes desbalanceadas, que é exatamente o caso de eval, porque a maioria das saídas passa, ele pode dar baixo mesmo com concordância observada altíssima. Se a sua distribuição é muito assimétrica, <a href="https://arxiv.org/abs/2603.06865">vale olhar o AC1 do Gwet</a>, e reporte o intervalo de confiança, não só o ponto.</p><h4>5. Juiz binário, calibrado antes de usado</h4><p>Agora automatizando. Duas decisões definem se isso vai funcionar.</p><p><strong>Decisão 1: o juiz julga binário, um critério por vez.</strong></p><p>Não peça nota de 1 a 10. A justificativa do Hamel é a melhor que eu conheço: “a diferença entre pontos adjacentes, tipo 3 e 4, é subjetiva e inconsistente entre anotadores, detectar diferença estatística exige amostra maior, e anotador tende a se refugiar no valor do meio pra não tomar decisão difícil”. Binário força a decisão em vez de esconder a incerteza no meio da escala.</p><p>Um critério por chamada. “A resposta está factualmente consistente com o contexto recuperado?” é uma eval. “A resposta respeitou a restrição alimentar declarada?” é outra. Não junte, porque quando o número cair você vai querer saber o que caiu.</p><p>Pra tirar a abstração, esse é o esqueleto de um juiz binário, no exemplo do app de receitas:</p><pre>Você avalia um assistente de receitas.<br><br>Critério (um só): a resposta respeita as restrições alimentares<br>que o usuário declarou em qualquer ponto da conversa?<br><br>&lt;conversa&gt;<br>{{conversa}}<br>&lt;/conversa&gt;<br><br>&lt;resposta&gt;<br>{{resposta}}<br>&lt;/resposta&gt;<br><br>Passos:<br>1. Liste as restrições declaradas pelo usuário.<br>2. Liste cada ingrediente ou instrução da resposta que conflita<br>   com alguma delas. Substituições válidas não são conflito.<br>3. Qualquer conflito = FAIL. Nenhum = PASS. Na dúvida, FAIL.<br><br>Responda em JSON: {&quot;analise&quot;: &quot;...&quot;, &quot;veredito&quot;: &quot;PASS&quot; | &quot;FAIL&quot;}</pre><p>Três escolhas deliberadas aí. A análise vem antes do veredito, porque forçar o modelo a listar as evidências primeiro melhora a decisão e te dá material de debug quando ele errar. “Na dúvida, FAIL” resolve o empate por você, em vez de deixar o modelo resolver de um jeito diferente a cada chamada. E o critério cabe numa frase, que é o teste de que ele é um critério e não três. Quando o juiz errar em casos do seu golden set, esses casos viram exemplos few-shot dentro do próprio prompt.</p><p>Com uma ressalva, isso não é lei universal. Em tarefas com estrutura ordinal de verdade, como relevância de documento em recuperação de informação, <a href="https://arxiv.org/abs/2505.19334">tem trabalho de 2025 sugerindo que escalas maiores ajudam</a>. A defesa forte do binário é sobre rotulagem humana e análise de erro, que é onde você está agora.</p><p><strong>Decisão 2: meça o alinhamento do juiz com o humano ANTES de usar o juiz.</strong></p><p>Separe uma parte dos seus casos rotulados como holdout, rode o juiz e olhe <strong>taxa de verdadeiro positivo e taxa de verdadeiro negativo separadamente</strong>. Não olhe só concordância bruta, porque com classe desbalanceada concordância bruta é enganosa.</p><p>Se o alinhamento for ruim, troque de modelo, reescreva o critério, ou aceite que aquele critério não é automatizável ainda.</p><p>E tem um detalhe que eu só vi sendo tratado direito recentemente, num <a href="https://arxiv.org/abs/2511.21140">paper de novembro de 2025 sobre como reportar avaliação com juiz LLM</a>. Se você conhece a sensibilidade e a especificidade do seu juiz, o score bruto dele é um estimador enviesado, e dá pra corrigir com uma fórmula fechada. A medição e a correção, juntas, são dez linhas:</p><pre>import numpy as np<br><br>humano = np.array([1, 1, 0, 1, 0, ...])  # 1 = pass, 0 = fail<br>juiz   = np.array([1, 1, 0, 0, 0, ...])<br><br>tpr = (juiz[humano == 1] == 1).mean()  # concorda nos que passam<br>tnr = (juiz[humano == 0] == 0).mean()  # concorda nos que falham<br><br># taxa real de aprovação, corrigida (Lee et al., 2025)<br>p_bruto = juiz_em_producao.mean()<br>p_real = (p_bruto + tnr - 1) / (tpr + tnr - 1)</pre><p>O que me pegou nesse paper foi a direção do viés, ela inverte. Sistema ruim parece melhor do que é, sistema bom parece pior do que é. Ou seja, quando o seu produto começa a ficar bom de verdade, o juiz não calibrado passa a te subestimar, e o time interpreta isso como retorno decrescente do trabalho. É diagnóstico errado causado pelo instrumento de medição e não das medidas.</p><h4>6. Baseline e gate</h4><p>Rode o sistema atual, sem mudar nada, contra o golden set inteiro. O número que sair é o seu ponto de partida. Ele provavelmente vai ser pior do que a intuição do time. Isso é o valor da coisa.</p><p>Depois amarre no CI, versão nova só sobe se não regredir no golden set. A separação que a Anthropic usa é útil aqui. Eval de capacidade responde “o agente consegue fazer isso?” e deve começar com taxa de aprovação baixa. Eval de regressão responde “o agente ainda faz o que já fazia?” e deve ficar perto de 100%. Quando uma eval de capacidade satura, ela se aposenta e vira eval de regressão.</p><p>Prefira checagem determinística a juiz LLM no CI sempre que der, porque CI roda o tempo todo e juiz custa. E como LLM não é determinístico, trate isso na configuração em vez de brigar, a <a href="https://github.com/promptfoo/promptfoo-action">GitHub Action do promptfoo</a> tem repeat e repeat-min-pass, que roda cada teste três vezes e exige que passe em pelo menos duas. Falha consistente quebra o build, variância do juiz não.</p><p>Vale ainda uma conta de guardanapo da Anthropic sobre consistência, se o agente acerta 75% das vezes e você roda a mesma tarefa três vezes, a chance de passar nas três é 0,7⁵³, ou seja <strong>42%</strong>. Média engana feio quando o usuário espera comportamento confiável toda vez.</p><h4>7. Feche o loop</h4><p>Cem traces frescos por ciclo de revisão, ciclo de duas a quatro semanas. Falha nova em produção vira caso novo no dataset. Sem isso o golden set envelhece e para de refletir o produto, e o seu gate passa a proteger uma versão do mundo que não existe mais.</p><h3>Alguns pontos de cuidado</h3><p>Chegar no estágio 3 não termina o problema. Só troca o problema por um mais interessante.</p><h4>Armadilha 1, juiz superconfiante</h4><p>O juiz LLM concorda demais e tem certeza demais.</p><p>O paper <a href="https://arxiv.org/abs/2508.06225">Overconfidence in LLM-as-a-Judge</a>, de agosto de 2025, testou 14 juízes num benchmark de pares de respostas em que uma está sutilmente errada. O erro de calibração esperado do melhor modelo ficou em 11,78%. O do pior, em 74,22%. E vários modelos concentram as previsões na faixa de 90 a 100% de confiança, com acurácia bem abaixo da linha ideal.</p><p>Tem coisa pior, e é a mais útil de saber. Um trabalho da Kensho e do MIT, <a href="https://arxiv.org/abs/2503.05061">No Free Labels</a>, mostrou que <strong>o juiz não sabe avaliar o que ele não sabe resolver</strong>. Nas questões que o próprio GPT-4o não consegue responder, o kappa dele com o rótulo humano desaba de 0,86 pra 0,16, ou seja, praticamente acaso. E juiz pequeno com referência bate juiz muito maior sem referência nenhuma, sendo que o que importa na referência é ela estar <strong>correta</strong>, não ter sido escrita por humano.</p><p>E tem a sicofância (essa eu tirei do dicionário), que é a mais desconfortável. Um <a href="https://arxiv.org/abs/2509.16533">estudo de setembro de 2025</a> mediu quanto o juiz muda de opinião quando o usuário discorda. Contra-argumento formal e fundamentado convenceu em 56% dos casos. Contra-argumento casual, assertivo e <strong>sem justificativa nenhuma</strong> convenceu em <strong>84,5%</strong>.</p><p>Junte isso com os vieses clássicos documentados desde o <a href="https://arxiv.org/abs/2306.05685">MT-Bench</a>, posição, verbosidade, preferência pelo próprio output. E repara num detalhe de leitura, porque o número mais citado da área nasce ali, aquela concordância de 85% entre GPT-4 e humanos exclui empates e votos inconsistentes. Incluindo tudo, cai pra 66%. Quem cita “85%” está citando o melhor caso.</p><p>Como resolve? Rótulo humano é a âncora, sempre. O juiz é uma aproximação barata de um rótulo caro, e aproximação precisa ser medida contra o que ela aproxima. Se o juiz mudou de prompt ou de modelo, ele é um instrumento novo e precisa ser recalibrado.</p><h4>Armadilha 2, overfit no golden set</h4><p>Você tem um número. O número vira meta. A meta vira otimização. E aí o time mexe no prompt até o número subir, sem que nada tenha melhorado pro usuário. O pior é que a falha é silenciosa de novo, o dashboard fica verde, a demo continua boa, e a única evidência de que algo quebrou é que a melhora não aparece em nenhuma métrica que o time não controla.</p><p>É Goodhart puro, e não é hipótese. É o que aconteceu com os benchmarks públicos da seção de estágios, e não tem nada de estrutural que impeça de acontecer com o seu benchmark privado.</p><p>Aliás, tem um achado que fecha essa porta de saída. Um <a href="https://arxiv.org/abs/2602.16763">estudo de 2026 sobre saturação de benchmarks</a> analisou 60 benchmarks e encontrou 48,3% com saturação alta. E comparou públicos contra privados, <strong>manter o test set privado não protegeu contra saturação</strong>. O que protegeu foi curadoria por especialista.</p><p>Se resolve com, holdout que você não olha no dia a dia, refresh mensal com casos novos de produção, e desconfiar de melhora grande sem hipótese. Se o número subiu oito pontos e ninguém sabe explicar por quê, provavelmente o dataset vazou pro prompt.</p><h4>Armadilha 3, métrica proxy</h4><p>Essa é a mais silenciosa das três.</p><p>Eval mede o que é fácil de medir. Formato correto, ausência de alucinação, aderência ao contexto recuperado. Tudo isso é medível e nada disso é o objetivo do negócio na imensa maioria dos casos.</p><p>Dá pra ter um sistema com 95% no golden set que está destruindo valor, porque a coisa que ele faz bem não é a coisa que precisava ser feita. E o eval não vai te avisar, porque o eval está medindo exatamente o que você mandou ele medir.</p><p>Não vou desenvolver agora, mas talvez isso vire outro artigo.</p><h3>Ferramenta é o menor dos seus problemas</h3><p>Seção curta de propósito.</p><p>O mapa mudou bastante em 2026, então vale dar uma atualizada, a <a href="https://langfuse.com/">Langfuse</a> foi adquirida pela ClickHouse em janeiro e o <a href="https://promptfoo.dev/">promptfoo</a> pela OpenAI em março, os dois seguindo abertos. Fora esses, aparecem sempre <a href="https://www.braintrust.dev/">Braintrust</a> e <a href="https://www.langchain.com/langsmith">LangSmith</a> no comercial, <a href="https://phoenix.arize.com/">Arize Phoenix</a> em source-available, <a href="https://github.com/confident-ai/deepeval">DeepEval</a> e <a href="https://inspect.aisi.org.uk/">Inspect AI</a>, do UK AI Security Institute com a Meridian Labs, no aberto. O openai/evals hoje aponta pra Evals API no dashboard da própria OpenAI.</p><p>Escolha uma e siga a vida. O Hamel, que consultou dezenas de times nisso, <a href="https://hamel.dev/blog/posts/evals-faq/">escreveu que não tem vendor favorito</a> e que o critério que mais pesa na escolha é quem dá o melhor suporte, não quem tem mais feature.</p><p>A recomendação dele que eu acho mais subestimada é construir a sua própria interface de anotação. Leva algumas horas hoje, e ele afirma que times com ferramenta customizada iteram cerca de 10 vezes mais rápido. O que faz sentido, anotação é onde o tempo humano é gasto, e interface genérica não conhece o formato do seu trace.</p><p>O harness é 80% processo. A ferramenta é a parte que você troca sem dor.</p><h3>Recomendações da minha cabeça</h3><p>Bom, aqui vai resumos atômicos dos meus estudos e conclusões sobre o tema:</p><ol><li>Comece pela error analysis, não pela infraestrutura. Trinta minutos lendo 20 saídas depois de cada mudança relevante já muda o jogo.</li><li>Uma pessoa decide o que é qualidade, e ela entende do domínio. Comitê de qualidade não converge.</li><li>Binário por critério, um critério por chamada, e critério que você consegue explicar em uma frase.</li><li>Meça o juiz antes de acreditar no juiz. Taxa de verdadeiro positivo e verdadeiro negativo em holdout rotulado.</li><li>Vinte a cinquenta casos reais valem mais que quinhentos sintéticos. Aumente depois.</li><li>Gate de regressão simples no CI vale mais que dashboard bonito que ninguém abre.</li><li>Nunca reporte score de eval sem alguém ter lido transcript. A Anthropic tem uma regra explícita sobre isso, eles não aceitam score de eval pelo valor de face até alguém entrar no detalhe e ler algumas transcrições.</li><li>Se a sua taxa de aprovação é 100%, o problema é a sua eval.</li></ol><h3>O mecanismo do erro</h3><p>Eu acho que eu disse na abertura que dei a resposta ruim por tempo demais, caso tenha esquecido, eu também já dei respostas ruins sobre “O quanto funciona isso ai?”. Vale explicar o mecanismo, porque o meu erro tem estrutura, e aposto que é a mesma estrutura do seu.</p><p>Eu venho principalmente de experimentações. E experimentação tem uma propriedade que eu levei anos pra perceber que era um luxo, <strong>a randomização te dá o gabarito de graça.</strong> O grupo de controle é o contrafactual, a métrica de negócio existe antes do experimento começar, e a única pergunta é se a variante mexeu no número. Você nunca precisa definir o que é uma resposta boa. O desenho do experimento define por você.</p><p>Eval inverte o problema. Não tem controle, não tem contrafactual, não tem métrica pronta. O gabarito não existe em lugar nenhum esperando ser descoberto, você <strong>constrói</strong>, caso a caso, com alguém que entende do domínio. E construir gabarito é menos estatística e mais engenharia de instrumento de medida. O meu repertório inteiro me ensinou a analisar medidas, nunca a fabricar o medidor.</p><p>Então, quando eu subi meu primeiro sistema com LLM decidindo coisa, eu apliquei o instinto errado com toda a confiança de quem tem instinto treinado. Li as saídas, achei boas, e tratei isso como evidência. Mas “eu leio e acho bom” não é amostra, é prior. Sem rótulo, sem denominador, sem taxa de erro. O sistema rodou bem por umas semanas, apareceu um caso fora da distribuição que eu tinha imaginado, o modelo respondeu com a confiança de sempre, e eu soube por reclamação, não por métrica. O que me incomodou não foi o erro. Foi constatar que eu não tinha nenhum instrumento capaz de detectar aquilo, em nenhum momento, nem por sorte. Erro a gente corrige. Cegueira instrumentada a gente nem vê.</p><p>O que mudou depois não foi ferramenta e não foi modelo. Foi aceitar que a primeira entrega de qualquer sistema desses é o medidor, e que o medidor se constrói lendo dado ruim com um bloco de notas do lado.</p><p>E como soa a resposta certa pra pergunta do título? Ela não impressiona ninguém. É chata, e é mais ou menos assim:</p><p><em>“Eu olhei uns cem casos reais de produção e catalogei os modos de falha. Três categorias respondem pela maioria. Tenho quarenta casos com veredito humano, sendo que uns dez são casos de limite que eu escolhi de propósito. O juiz automático concorda com o meu rótulo com taxa de verdadeiro positivo e verdadeiro negativo que eu meço num holdout, e eu recalibro quando troco o modelo do juiz. O baseline atual está em tal número. Rodou no CI, se cair, não sobe. E eu sei quais falhas eu ainda não sei medir.”</em></p><p>Repare no último pedaço, porque é ele que separa. Saber o número é o esperado. Saber onde o número não alcança é o que denuncia quem já mediu de verdade.</p><p>E chegar nessa resposta não exige nada que este texto já não tenha te dado. Cem traces, um bloco de notas do lado, uma segunda-feira. É menos glamouroso que trocar de modelo, e vale dez vezes mais.</p><p>E fica a pergunta do título, agora apontada pro seu time, <strong>em que estágio vocês estão, sinceramente?</strong> Não o que está no roadmap. O que rodou semana passada.</p><blockquote>Sistema de IA bom é o que você consegue provar que acerta, na semana em que alguém pergunta.</blockquote><h3>Referências</h3><ul><li>Husain, H. e Shankar, S. <em>LLM Evals: Everything You Need to Know (AI Evals FAQ)</em>. hamel.dev, 2025, atualizado em 2026. <a href="https://hamel.dev/blog/posts/evals-faq/">https://hamel.dev/blog/posts/evals-faq/</a></li><li>Husain, H. <em>Your AI Product Needs Evals</em>. hamel.dev. <a href="https://hamel.dev/blog/posts/field-guide/">https://hamel.dev/blog/posts/field-guide/</a></li><li>Husain, H. <em>Creating a LLM-as-a-Judge That Drives Business Results</em>. hamel.dev. <a href="https://hamel.dev/blog/posts/llm-judge/">https://hamel.dev/blog/posts/llm-judge/</a></li><li>Rachitsky, L. <em>Why AI evals are the hottest new skill for product builders</em>. Lenny’s Newsletter, 25/09/2025. <a href="https://www.lennysnewsletter.com/p/why-ai-evals-are-the-hottest-new-skill">https://www.lennysnewsletter.com/p/why-ai-evals-are-the-hottest-new-skill</a></li><li>Husain, H. e Shankar, S. <em>AI Evals For Engineers &amp; PMs</em>. Maven. <a href="https://maven.com/parlance-labs/evals">https://maven.com/parlance-labs/evals</a></li><li>Axios. <em>AI engineer is the fastest-growing job, LinkedIn says</em>. 07/01/2025. <a href="https://www.axios.com/2025/01/07/ai-jobs-on-the-rise-linkedin-report">https://www.axios.com/2025/01/07/ai-jobs-on-the-rise-linkedin-report</a></li><li>Forbes. <em>LinkedIn’s 2026 fastest-growing jobs list</em>. 14/01/2026. <a href="https://www.forbes.com/sites/juliakorn/2026/01/14/future-proof-your-career-with-linkedins-2026-fastest-growing-jobs-list/">https://www.forbes.com/sites/juliakorn/2026/01/14/future-proof-your-career-with-linkedins-2026-fastest-growing-jobs-list/</a></li><li>promptfoo. <em>promptfoo-action, GitHub Action para eval em CI</em>. <a href="https://github.com/promptfoo/promptfoo-action">https://github.com/promptfoo/promptfoo-action</a></li><li>Latent Space. <em>Claude Code: Anthropic’s Agent in Your Terminal</em> (entrevista com Boris Cherny). 07/05/2025. <a href="https://www.latent.space/p/claude-code">https://www.latent.space/p/claude-code</a></li><li>Willison, S. <em>Notas do fireside chat com o time do Claude Code, AI Engineer</em>. 21/07/2026. <a href="https://simonwillison.net/2026/Jul/21/cat-and-thariq/">https://simonwillison.net/2026/Jul/21/cat-and-thariq/</a></li><li>YC Root Access. <em>Boris Cherny: Building Claude Code</em>. 27/07/2026. <a href="https://www.ycrootaccess.com/p/boris-cherny-building-claude-code">https://www.ycrootaccess.com/p/boris-cherny-building-claude-code</a></li><li>Anthropic. <em>Demystifying evals for AI agents</em>. 09/01/2026. <a href="https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents">https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents</a></li><li>Zhang, H. et al. <em>A Careful Examination of Large Language Model Performance on Grade School Arithmetic</em>. arXiv:2405.00332, 2024. <a href="https://arxiv.org/abs/2405.00332">https://arxiv.org/abs/2405.00332</a></li><li>Yang, S. et al. <em>Rethinking Benchmark and Contamination for Language Models with Rephrased Samples</em>. arXiv:2311.04850, 2023. <a href="https://arxiv.org/abs/2311.04850">https://arxiv.org/abs/2311.04850</a></li><li>Gema, A. et al. <em>Are We Done with MMLU?</em>. NAACL 2025. <a href="https://aclanthology.org/2025.naacl-long.262/">https://aclanthology.org/2025.naacl-long.262/</a></li><li>Singh, S. et al. <em>The Leaderboard Illusion</em>. arXiv:2504.20879, 2025. <a href="https://arxiv.org/abs/2504.20879">https://arxiv.org/abs/2504.20879</a></li><li>LMSYS. <em>Does Style Matter? Disentangling Style and Substance in Chatbot Arena</em>. 28/08/2024. <a href="https://www.lmsys.org/blog/2024-08-28-style-control/">https://www.lmsys.org/blog/2024-08-28-style-control/</a></li><li>Bean, A. et al. <em>Measuring what Matters: Construct Validity in Large Language Model Benchmarks</em>. NeurIPS 2025. <a href="https://arxiv.org/abs/2511.04703">https://arxiv.org/abs/2511.04703</a></li><li>Akhtar, M. et al. <em>When AI Benchmarks Plateau: A Systematic Study of Benchmark Saturation</em>. arXiv:2602.16763, 2026. <a href="https://arxiv.org/abs/2602.16763">https://arxiv.org/abs/2602.16763</a></li><li>Epoch AI. <em>AI Benchmarking Hub, methodology</em>. <a href="https://epoch.ai/benchmarks/about">https://epoch.ai/benchmarks/about</a></li><li>Zheng, L. et al. <em>Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena</em>. arXiv:2306.05685, NeurIPS 2023. <a href="https://arxiv.org/abs/2306.05685">https://arxiv.org/abs/2306.05685</a></li><li>Tian, Z. et al. <em>Overconfidence in LLM-as-a-Judge: Diagnosis and Confidence-Driven Solution</em>. arXiv:2508.06225, 2025. <a href="https://arxiv.org/abs/2508.06225">https://arxiv.org/abs/2508.06225</a></li><li>Lee, C. et al. <em>How to Correctly Report LLM-as-a-Judge Evaluations</em>. arXiv:2511.21140, 2025. <a href="https://arxiv.org/abs/2511.21140">https://arxiv.org/abs/2511.21140</a></li><li>Krumdick, M. et al. <em>No Free Labels: Limitations of LLM-as-a-Judge Without Human Grounding</em>. arXiv:2503.05061, 2025. <a href="https://arxiv.org/abs/2503.05061">https://arxiv.org/abs/2503.05061</a></li><li>Kim, S. e Khashabi, D. <em>Challenging the Evaluator: LLM Sycophancy Under User Rebuttal</em>. arXiv:2509.16533, 2025. <a href="https://arxiv.org/abs/2509.16533">https://arxiv.org/abs/2509.16533</a></li><li>Shankar, S. et al. <em>Who Validates the Validators?</em>. arXiv:2404.12272, UIST 2024. <a href="https://arxiv.org/abs/2404.12272">https://arxiv.org/abs/2404.12272</a></li><li>Godfrey, C. et al. <em>Likert or Not: LLM Absolute Relevance Judgments on Fine-Grained Ordinal Scales</em>. arXiv:2505.19334, 2025. <a href="https://arxiv.org/abs/2505.19334">https://arxiv.org/abs/2505.19334</a></li><li>Piot, P. et al. <em>Can LLMs Evaluate What They Cannot Annotate?</em>. arXiv:2512.09662, 2025. <a href="https://arxiv.org/abs/2512.09662">https://arxiv.org/abs/2512.09662</a></li><li>James, J. <em>Counting on Consensus: Selecting the Right Inter-annotator Agreement Metric</em>. arXiv:2603.06865, 2026. <a href="https://arxiv.org/abs/2603.06865">https://arxiv.org/abs/2603.06865</a></li><li>Moffatt v. Air Canada, 2024 BCCRT 149, 14/02/2024. <a href="https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do">https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do</a></li><li>Lecher, C. <em>NYC’s AI Chatbot Tells Businesses to Break the Law</em>. The Markup, 29/03/2024. <a href="https://themarkup.org/artificial-intelligence/2024/03/29/nycs-ai-chatbot-tells-businesses-to-break-the-law">https://themarkup.org/artificial-intelligence/2024/03/29/nycs-ai-chatbot-tells-businesses-to-break-the-law</a></li><li>Charlotin, D. <em>AI Hallucination Cases Database</em>. Consulta em 16/08/2026. <a href="https://www.damiencharlotin.com/hallucinations/">https://www.damiencharlotin.com/hallucinations/</a></li><li>Gartner. <em>Over 40% of Agentic AI Projects Will Be Canceled by End of 2027</em>. 25/06/2025. <a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74f7d602714f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engenheiro de IA sênior não existe]]></title>
            <link>https://medium.com/@francocontigo/engenheiro-de-ia-s%C3%AAnior-n%C3%A3o-existe-c8eed2c16b3b?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8eed2c16b3b</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[carrer]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 21:15:23 GMT</pubDate>
            <atom:updated>2026-07-22T21:15:23.932Z</atom:updated>
            <content:encoded><![CDATA[<h4>Ou, porquê eu acho que não existe.</h4><blockquote>Esse artigo nasceu de um desconforto meu que passa na minha cabeça faz alguns meses.</blockquote><h3><strong>Todo mundo nessa área veio de outro lugar, o que não é ruim.</strong></h3><p>Minha formação inteira foi em dados. Engenharia de dados e ciência de dados, pipeline, modelagem, estatística, experimento, e muita, muita EDA. Anos abrindo datasets, caçando outliers, desconfiando de coluna, montando hipótese, otimizando meu deck no Heartstone e outros. Também implementei rotina de coleta, ingestão, transformação, orquestração, coisa rodando agendada todo dia alimentando decisões importantes. E eu acho que eu melhorei minhas skills de engenharia.</p><p>Mas é engenharia de um regime específico: batch, uma execução por vez, tolerância a atraso, e se quebrar às 3 da manhã, dá pra reprocessar às 9 sem ninguém morrer. Isso não é a mesma coisa que uma aplicação conversacional com fila, atendendo muitos usuários simultâneos, onde cada request tem alguém esperando do outro lado, latência é produto, e “reprocessa depois” não existe porque o usuário já foi embora.</p><p>Quando fui colocar meu primeiro agente em produção, descobri que nada do meu repertório me preparou pra essa outra parte. Eu não sabia desenhar uma API que aguenta retry sem duplicar efeito colateral. Eu nunca tinha pensado seriamente em idempotência, connection pool, graceful shutdown, backpressure, ou no que acontece com a fila quando o provider de LLM devolve 429 por dez minutos com clientes esperando.</p><p>Eu tenho gaps de engenharia de software. Gaps reais, do tipo que até o momento eu acredito que não se resolve com um curso de fim de semana, porque são gaps de <strong>cicatriz</strong>, de coisa que você só aprende quebrando e resolvendo coisas. E o mercado inteiro está fingindo que gente como eu, com três anos de LLM em cima de outras coisas, é “engenheiro de IA sênior”. E eu não acho que isso ta errado também?</p><p>Mas, o ponto que eu quero trazer é que ninguém é. Não porque falta gente boa, mas porque a régua que define sênior nessa área ainda não teve tempo de existir.</p><p>Vamos por partes.</p><h3><strong>O título mais quente do mercado tem três anos de idade</strong></h3><p>Primeiro os números.</p><p>O relatório <em>Jobs on the Rise 2026</em> do LinkedIn colocou <strong>AI Engineer como o cargo que mais cresce nos Estados Unidos, com 143% de crescimento ano contra ano</strong> nas vagas. Quatro dos cinco cargos que mais crescem são relacionados a IA. Entre 2023 e 2025 foram 639 mil vagas relacionadas a IA só nos EUA. Estimativas de mercado apontam algo em torno de <strong>1,6 milhão de posições abertas contra ~518 mil candidatos qualificados</strong>, um gap de demanda de 3,2 pra 1.</p><p>Agora a parte que interessa. O termo “AI Engineer”, no sentido atual, foi popularizado pelo swyx no artigo <a href="https://www.latent.space/p/ai-engineer"><em>The Rise of the AI Engineer</em></a>, em <strong>julho de 2023.</strong> O título praticamente não existia em 2022. A definição dele é honesta sobre o que o cargo é: Um engenheiro de software que constrói <strong>com</strong> IA, sabendo o suficiente de conceitos e limitações de modelo pra colocar aquilo num produto, sem ser pesquisador nem ML engineer.</p><p>Faz a conta. Se o cargo nasceu em meados de 2023, a pessoa com mais tempo de estrada possível como AI Engineer tem hoje uns três anos de experiência. E mesmo assim as vagas pedem, “5+ anos de experiência com LLMs em produção”. O <a href="https://www.hiringlab.org/2025/07/30/experience-requirements-have-tightened-amid-the-tech-hiring-freeze">Indeed Hiring Lab</a> documentou que a fração de vagas tech pedindo 5+ anos de experiência subiu de 37% pra 42% entre 2022 e 2025, exatamente no período em que a tecnologia mais pedida tinha menos de 3 anos de vida. É o velho meme do “requer 10 anos de Kubernetes” quando o Kubernetes tinha 4, só que em escala industrial.</p><blockquote><em>Quando a vaga pede mais anos de experiência do que a tecnologia tem de existência, o que a vaga está pedindo, na prática, é “seja sênior em outra coisa e finja que sempre foi daqui”.</em></blockquote><p>E é isso que o mercado fez. Como não existe estoque de engenheiro de IA formado, <strong>todo mundo que ocupa essas vagas hoje é um convertido (amém no meu caso)</strong>. E convertido carrega a bagagem e os buracos da vida anterior. Na minha leitura, são três perfis dominantes disputando as mesmas vagas, e cada um chega com um gap estrutural diferente que quase nunca aparece na entrevista.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZhsWMa08IkFQVMH2" /><figcaption>Pra que direção eu vou?</figcaption></figure><h3><strong>Perfil 1: o que veio de dados (oi, meu chapa, prazer)</strong></h3><p>Cientista de dados, analista sênior, engenheiro de ML da era pré-LLM. Sabe estatística, sabe o que é overfitting, sabe que avaliação offline não garante nada online, já viu métrica mentir. Esse perfil tem uma vantagem enorme que o mercado demorou pra perceber: <strong>A</strong> <strong>parte mais difícil de IA generativa em produção é avaliação, e avaliação é literalmente o ofício de quem veio de dados</strong>. Definir métrica, desenhar experimento, desconfiar de resultado bom demais, controlar falso positivo. Twyman’s Law é nosso território.</p><p>O gap é o resto. E o resto é grande.</p><p>Quem veio de dados tipicamente construiu a carreira inteira em ambientes onde <strong>o código termina quando o insight sai ou quando o pipeline roda</strong>. Notebook, DAG batch, dashboard. E mesmo quem construiu um pipeline bão, como eu, construiu pro regime errado, o pipeline batch perdoa de um jeito que sistema online não perdoa. A disciplina de engenharia de software que transforma código em sistema que atende gente em tempo real, testes automatizados, CI/CD, design de API, observabilidade, tratamento de erro como cidadão de primeira classe, capacidade sob concorrência, normalmente nunca foi cobrada. O <a href="https://towardsdatascience.com/i-transitioned-from-data-science-to-ai-engineering-heres-everything-you-need-to-know">relato clássico de transição de data science pra AI engineering no Towards Data Science</a> aponta exatamente isso, o buraco principal é engenharia de produção (APIs, containers, filas), e só depois vem a camada de IA por cima.</p><p>A minha própria autocrítica, da minha própria lista:</p><ul><li>Eu sei provar que um teste A/B está bem calibrado, e não sei estimar quanto custa por mês o endpoint que estou desenhando, em compute, em latência p99, mas sei sei de custo de tokens.</li><li>Eu sei escrever SQL que o time inteiro entende, e meu Python das ruas era muito gambiarrado, que só foquei em resolver estutando TDD, testes e CI/CD pra ir validando meus próprios projetos depois que o <a href="https://www.linkedin.com/in/jpvmm/">JP</a> falou pra mim: “Um cientista de dados é alguém que sabe mais de estatística do que um engenheiro de software, e mais de engenharia de software do que um estatístico. E nenhum dos três sabe como fazer deploy”.</li><li>Eu sei o que é data drift, e nunca tinha configurado até pouco tempo atrás um alerta bom de verdade, do tipo que acorda alguém de forma confiavel com um acionavel.</li><li>Eu falo de idempotência com confiança desde que ninguém peça pra eu implementar a fila que garante isso para troca mensagens.</li></ul><p>O perigo desse perfil é se esconder atrás da estatística. Como avaliação virou a habilidade da moda, é tentador ficar no papel de “pessoa dos evals” e nunca encostar na parte do sistema que dói. Só que engenheiro de IA que não consegue subir o próprio serviço é analista com título novo.</p><h3><strong>Perfil 2: o que veio de software</strong></h3><p>O dev frontend/backend/full-stack que surfou a onda. Esse perfil chega com o que falta pro primeiro, sabe colocar coisa em produção, idealmente sabe o custo de manter sistema vivo, pensa em contrato de API, em rollback, e é mais cobrado em teste. A <a href="https://www.latent.space/p/ai-engineer">definição do swyx</a> foi desenhada praticamente pra ele, e o <a href="https://newsletter.pragmaticengineer.com/p/the-ai-engineering-stack">Pragmatic Engineer com a Chip Huyen</a> reforça que o AI Engineer está muito mais perto da engenharia de software do que da pesquisa.</p><p>O gap dele é o inverso do meu, e é mais sutil, porque não aparece como falta de skill, aparece como <strong>mentalidade errada de correção e em alguns casos, falta de profundidade</strong>.</p><p>Engenharia de software clássica é construída sobre determinismo. Input igual, output igual, teste passa ou não passa. LLM quebrou isso, sem contar as peças como RAG e outros. A mesma pergunta, duas respostas diferentes, ambas possivelmente boas. O dev que chega em IA tentando escrever unit test pra output de modelo descobre que o instrumento não morde. <a href="https://arxiv.org/pdf/2410.12071">Pesquisa acadêmica sobre a integração de LLMs em produtos</a> documenta exatamente essa dor, avaliar LLM exige uma mentalidade de pesquisa, formular hipótese, definir métrica customizada, iterar sobre variações, e nada disso é ensinado ou praticado na formação tradicional de engenharia de software.</p><p>Na prática, os sintomas desse gap são fáceis de reconhecer:</p><ul><li>Trata prompt como string mágica, não como artefato versionado com suite de avaliação em cima, as vezes nem iterando para ter o melhor prompt possível.</li><li>Confunde demo com produto. O agente funcionou três vezes no vídeo pro Slack, logo está pronto. Não está, e a diferença entre 95% e 99% de acerto por passo é a diferença entre produto e piada.</li><li>Não tem instinto de amostra. Avalia mudança de prompt olhando 5 exemplos e decide. Quem veio de dados sente dor física vendo isso.</li><li>Otimiza a arquitetura antes de medir o baseline, porque construir sistema é a zona de conforto e medir qualidade não é.</li></ul><p>O dev tem a fundação certa pra metade do trabalho. A outra metade, é epistemológica, “como eu sei que isso está bom, e quanto de errado eu tolero?”, é exatamente a que ele nunca precisou desenvolver.</p><h3><strong>Perfil 3: o que chegou pelas plataformas de automação</strong></h3><p>Esse é o perfil novo, e é o que mais cresce na base da pirâmide. É a pessoa que entrou por n8n, Make, Zapier, Dify, Flowise, ou direto pelos builders visuais de agente. Às vezes vem de negócio, de cs, de administração. Já apareceram títulos formais de vaga como <em>n8n Automation Engineer</em> e <em>AI Automation Engineer</em>, o <a href="https://growai.in/no-code-ai-automation-2026">mercado de automação no-code é avaliado em US$ 13,8 bilhões</a>, e três dos cinco repositórios de agentes mais estrelados do GitHub são <a href="https://fungies.io/top-github-repositories-ai-agent-frameworks-2026/">builders visuais</a>, Langflow, Dify e Flowise. Isso não é acidente, é onde o volume está.</p><p>Vou dar o crédito que é devido antes de dar a notícia ruim. Esse perfil tem uma virtude real: <strong>proximidade com o problema de negócio e velocidade de entrega de POC</strong>. Enquanto o de dados está calibrando o eval e o dev está desenhando a arquitetura, essa pessoa já montou o protótipo, já colocou na frente do usuário, já validou se a ideia tem tração. Em um mercado onde o <a href="https://www.fiddler.ai/blog/ai-agent-failure-rate">MIT mediu que 95% dos pilotos de IA generativa corporativa falham em gerar impacto</a>, muito por falta de integração com o workflow real, validar rápido tem muito valor.</p><p>Agora a notícia ruim, e aqui eu vou ser direto porque acho que a indústria de cursos está mentindo pra essas pessoas, <strong>esse é o perfil mais fraco dos três, e por uma margem que não fecha rápido</strong>. Os outros dois chegam com uma década de fundação em uma das metades do trabalho, e precisam construir a outra metade. Esse perfil chega sem nenhuma das duas. Não tem a base de estatística e avaliação do primeiro, não tem a base de engenharia do segundo, e o que ele tem, fluência em uma ferramenta visual, é exatamente a parte que comoditiza mais rápido. O gap não é uma lista de skills faltando, é a fundação inteira:</p><ul><li><strong>Não sabe o que não sabe.</strong> O nó “AI Agent” do n8n esconde o loop, o parsing, o retry, o contexto. Quando quebra de um jeito que a plataforma não previu, não existe modelo mental pra debugar, porque a pessoa nunca viu o que tem dentro.</li><li><strong>Zero disciplina de versionamento e ambiente.</strong> O workflow de produção é editado em produção. Não tem dev/staging, não tem review, não tem rollback. Um erro de clique é um incidente.</li><li><strong>Segurança e dados pessoais como reflexão tardia.</strong> Credencial compartilhada, dado de cliente passando por três SaaS sem ninguém ter avaliado base legal, prompt injection nem entra no radar.</li><li><strong>Escala como surpresa.</strong> A automação que roda 50 vezes por dia vira 50 mil, e descobre-se junto o rate limit, o custo, e que aquele webhook nunca teve fila.</li></ul><p>E o problema de tempo é estrutural. O de dados fecha o gap de engenharia em um ou dois anos de produção porque já sabe programar, já pensa em sistema, só nunca foi cobrado para se ter rigor. O dev fecha o gap de avaliação em meses, porque rigor metodológico é aprendível pra quem já tem disciplina técnica. O de automação precisa construir <strong>o que os outros dois levaram uma década construindo</strong>: lógica de programação, fundamentos de sistema, base estatística. Não existe atalho pra isso, e a plataforma que abstrai tudo é ativamente um obstáculo, porque cada hora nela é uma hora aprendendo a interface de um produto em vez do fundamento por baixo.</p><p>O caminho honesto pra esse perfil, na minha leitura, não é “vire engenheiro de IA”. É um destes dois, usar a proximidade com o negócio como trampolim pra <strong>produto</strong>, onde entender o problema e prototipar rápido é a competência central e a falta de fundação técnica não é fatal, ou aceitar que fechar o gap técnico é um projeto de anos começando do zero, sem plataforma no meio. O que não existe é a terceira opção que os cursos vendem, seis meses de n8n e uma certificação te colocando na mesma prateleira de quem carrega dez anos de fundação. O mercado pode até contratar assim no hype. Ele corrige na primeira demissão em massa.</p><h3><strong>O mesmo abismo, três margens diferentes</strong></h3><p>Colocando lado a lado, o desenho fica assim:</p><pre> Perfil     |  Traz de casa                |  Gap             |  Tempo pra fechar<br>-----------------+----------------------------------+------------------+--------------------<br> Dados      |  avaliação, estatística,     |  engenharia em   |  1-2 anos<br>            |  desconfiança metodológica   |  produção        |  em produção<br>-----------------+----------------------------------+------------------+--------------------<br> Software   |  sistemas, produção,         |  mentalidade     |  meses, com<br>            |  disciplina de engenharia    |  probabilística  |  disciplina (somente evals)<br>-----------------+----------------------------------+------------------+--------------------<br> Automação  |  velocidade de POC,          |  a fundação      |  anos, começando<br>            |  contexto de negócio         |  inteira         |  do zero</pre><p>Repara que a simetria é só entre os dois primeiros. <strong>O de dados tem o rigor que falta no dev, o dev tem a produção que falta no de dados</strong>, e cada um consegue atravessar pro outro lado porque já tem metade da ponte construída. O terceiro perfil não está nessa troca, ele tem uma habilidade legítima, validar ideia rápido, mas não tem margem nenhuma da ponte.</p><p>Se você pudesse fundir os dois primeiros, aí sim, teria um engenheiro de IA sênior. Mas essa pessoa não existe em quantidade estatisticamente relevante, porque não deu tempo. O campo tem três anos. As vagas “sênior” estão sendo preenchidas por gente que é sênior em uma coluna da tabela e estagiário nas outras, eu incluso.</p><p>E os números de produção confirmam que o mercado inteiro está operando nesse regime. Os estudos de 2026 de <a href="https://www.fiddler.ai/blog/ai-agent-failure-rate">Gartner, Forrester, McKinsey e MIT colocam a taxa de falha de iniciativas de IA agêntica entre 77% e 95%</a>. Tem uma conta nesse material que vale decorar:,um agente com 95% de confiabilidade por passo, executando um workflow de 20 passos, entrega <strong>36% de sucesso fim a fim</strong> (0,9⁵²⁰). Isso não é problema de modelo. É problema de gente que sabe avaliar mas não sabe operar, somada a gente que sabe operar mas não sabe avaliar, somada a gente que entregou rápido sem saber nem uma coisa nem outra.</p><h3><strong>Como cada perfil fecha o próprio gap</strong></h3><blockquote>A regra geral é a mesma pros três, <strong>o seu plano de estudo é a coluna do vizinho</strong>, e o jeito de estudar é buscando mais responsabilidades em produção, não só em cursos.</blockquote><p><strong>Se você veio de dados</strong> (de novo, oi, meu chapa), o caminho é assumir a parte do sistema em vez de se voluntariar de novo pra parte da análise. Pegar o serviço que você já avalia e passar a ser dono do deploy dele. Aprender Docker, uma esteira de CI, um framework de API, e uma stack de observabilidade, não no abstrato, mas no seu serviço. Fazer o exercício de estimar custo por request antes de subir e conferir depois. E resistir à tentação de aceitar o papel de “pessoa dos evals” como identidade permanente, porque é confortável demais.</p><p><strong>Se você veio de software</strong>, o caminho é adquirir a disciplina de medição antes de mais arquitetura. Nenhuma mudança de prompt, modelo ou pipeline sem um conjunto de avaliação rodando antes e depois, nem que sejam 50 exemplos anotados na mão, porque 50 exemplos anotados batem qualquer vibe check. Aprender o básico de estatística aplicada, tamanho de amostra, intervalo de confiança, falso positivo, no nível de quem usa, não de quem prova teorema. Ler <a href="https://experimentguide.com/"><em>Trustworthy Online Controlled Experiments</em></a> do Kohavi dói menos do que parece e resolve metade disso.</p><p><strong>Se você veio da automação</strong>, o primeiro passo é uma decisão, não um curso.</p><ul><li>Decisão 1, migrar pra produto, onde sua velocidade de POC e leitura de negócio são a competência central, e parar de competir numa corrida onde você largou dez anos atrás. É uma carreira boa, e provavelmente a melhor troca de retorno por esforço disponível pra você.</li><li>Decisão 2, se quiser mesmo o caminho técnico, aceitar o tamanho real do projeto, aprender a programar, sem plataforma no meio, reimplementar em Python puro o workflow mais crítico que você mantém só pra ver o que a ferramenta escondia, e estudar a fundação (lógica, sistema, estatística básica) na ordem que os outros dois perfis estudaram.</li></ul><p>O que eu recomendo não fazer é a não-decisão, acumular certificação de plataforma achando que está acumulando senioridade.</p><p>O que os caminhos têm em comum, nenhum deles é “aprenda o framework X”. E isso me leva pra parte provocativa do artigo.</p><h3><strong>Não é sobre ferramenta</strong></h3><p>Tem uma indústria inteira de curso, thread e bootcamp vendendo a ideia de que a diferença entre você e uma vaga de engenheiro de IA é dominar o framework da vez. LangChain em 2023, CrewAI em 2024, agora agente disso, SDK daquilo. Vagas listam frameworks como se fossem competências.</p><p>Então vamos fazer um teste. Uma implementação dumb de um agente de suporte que consulta o status de um pedido via tool, nas cinco bibliotecas mais famosas do mercado. Presta atenção no que muda de uma pra outra.</p><p><strong>OpenAI Agents SDK</strong></p><pre>from agents import Agent, Runner, function_tool<br><br>@function_tool<br>def buscar_pedido(pedido_id: str) -&gt; str:<br>    &quot;&quot;&quot;Busca o status de um pedido.&quot;&quot;&quot;<br>    return db.get(pedido_id)<br><br>agent = Agent(<br>    name=&quot;suporte&quot;,<br>    instructions=&quot;Você responde o status de pedidos.&quot;,<br>    tools=[buscar_pedido],<br>)<br>resultado = Runner.run_sync(agent, &quot;Cadê meu pedido 123?&quot;)py</pre><p><strong>LangGraph</strong></p><pre>from langgraph.prebuilt import create_react_agent<br><br>def buscar_pedido(pedido_id: str) -&gt; str:<br>    &quot;&quot;&quot;Busca o status de um pedido.&quot;&quot;&quot;<br>    return db.get(pedido_id)<br><br>agent = create_react_agent(<br>    model=&quot;anthropic:claude-sonnet-4-5&quot;,<br>    tools=[buscar_pedido],<br>    prompt=&quot;Você responde o status de pedidos.&quot;,<br>)<br>agent.invoke({&quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: &quot;Cadê meu pedido 123?&quot;}]})</pre><p><strong>CrewAI</strong></p><pre>from crewai import Agent, Task, Crew<br>from crewai.tools import tool<br><br>@tool(&quot;buscar_pedido&quot;)<br>def buscar_pedido(pedido_id: str) -&gt; str:<br>    &quot;&quot;&quot;Busca o status de um pedido.&quot;&quot;&quot;<br>    return db.get(pedido_id)<br><br>suporte = Agent(role=&quot;Suporte&quot;, goal=&quot;Responder o status de pedidos&quot;,<br>                backstory=&quot;Atendente de e-commerce.&quot;, tools=[buscar_pedido])<br>tarefa = Task(description=&quot;Cadê meu pedido 123?&quot;,<br>              expected_output=&quot;Status do pedido&quot;, agent=suporte)<br>Crew(agents=[suporte], tasks=[tarefa]).kickoff()</pre><p><strong>Pydantic AI</strong></p><pre>from pydantic_ai import Agent<br><br>agent = Agent(&quot;anthropic:claude-sonnet-4-5&quot;,<br>              system_prompt=&quot;Você responde o status de pedidos.&quot;)<br><br>@agent.tool_plain<br>def buscar_pedido(pedido_id: str) -&gt; str:<br>    &quot;&quot;&quot;Busca o status de um pedido.&quot;&quot;&quot;<br>    return db.get(pedido_id)<br><br>resultado = agent.run_sync(&quot;Cadê meu pedido 123?&quot;)</pre><p><strong>LlamaIndex</strong></p><pre>from llama_index.core.agent.workflow import FunctionAgent<br>from llama_index.llms.anthropic import Anthropic<br><br>def buscar_pedido(pedido_id: str) -&gt; str:<br>    &quot;&quot;&quot;Busca o status de um pedido.&quot;&quot;&quot;<br>    return db.get(pedido_id)<br><br>agent = FunctionAgent(tools=[buscar_pedido], llm=Anthropic(),<br>                      system_prompt=&quot;Você responde o status de pedidos.&quot;)<br>resposta = await agent.run(&quot;Cadê meu pedido 123?&quot;)</pre><p><strong>É o mesmo programa.</strong></p><p>Uma função com docstring, um objeto agente, um system prompt, um invoke. As diferenças são cosméticas, um decorator aqui, um backstory obrigatório ali (o CrewAI exige que você escreva ficção sobre o seu atendente, o que diz mais sobre o framework do que sobre o problema), um await pra lá.<br>Um dev razoável migra de qualquer um pra qualquer outro em uma tarde com a documentação aberta. Por baixo, os cinco fazem exatamente a mesma coisa, montam uma lista de mensagens, descrevem a tool em JSON, chamam a mesma API de chat completion num loop de while, e fazem parse da resposta. Aliás, esse loop cru, sem framework nenhum, são umas 30 linhas de Python. Seria a sexta implementação e caberia aqui do mesmo jeito.</p><p>Agora a pergunta provocativa, <strong>se a diferença entre os cinco frameworks é o nome do import, como é que “domina LangChain” pode ser critério de senioridade?</strong> Colocar framework como requisito central de vaga de IA é como contratar escritor por marca de teclado. E o contrário é igualmente amargo, se a sua vantagem competitiva é conhecer a sintaxe de uma dessas bibliotecas, a sua vantagem competitiva é uma tarde de leitura de documentação. Isso não é um fosso, é uma poça.</p><p>O que <strong>nenhum</strong> dos cinco blocos mostra é o trabalho de verdade, e é idêntico nos cinco:</p><ul><li>O que acontece quando buscar_pedido retorna vazio e o modelo, prestativo que é, <strong>inventa</strong> um status pro cliente?</li><li>Como você sabe que a resposta está boa? Contra qual conjunto de teste, medido como, com qual threshold de aceite?</li><li>O que acontece no timeout, no 429, no pedido que não existe, no usuário que cola um prompt injection no campo de ID?</li><li>Quanto custa cada conversa, e quem olha quando o custo dobra numa terça-feira?</li><li>Cadê o trace de cada passo quando o agente de 20 passos entrega os 36% de sucesso da conta lá de cima?</li></ul><p>Esse trabalho não tem framework. Esse trabalho é o cargo. E repara que ele exige exatamente a fusão dos três perfis: a pergunta do eval é do pessoal de dados, a pergunta do timeout é do dev, e a pergunta “o cliente aceita receber isso?” é de quem está perto do negócio. A ferramenta é a parte que qualquer um dos três aprende na primeira semana.</p><blockquote><em>Framework é o que você usa. Critério é o que você tem. Vaga que pede framework está contratando pelo que se aprende em uma tarde e ignorando o que se aprende com o tempo.</em></blockquote><h3><strong>AI Enablers, o papel que não disputa a vaga</strong></h3><p>Antes do clássico entre artigos, recomendações da minha cabeça, vale abrir espaço pra um papel que ficou de fora dos três perfis de propósito, porque ele não está disputando a vaga de engenheiro de IA. E justamente por isso quase ninguém fala dele direito, o <strong>AI Enabler</strong>.</p><p>O enabler é a pessoa cujo trabalho não é construir o sistema de IA, é <strong>fazer o resto da empresa conseguir usar e construir</strong>. O mercado já formalizou variações disso, AI enablement lead, adoption specialist, gerente de treinamento de IA, o dono do “centro de excelência”. A <a href="https://www.straive.com/blogs/what-is-ai-enablement">definição de AI enablement</a> que eu acho mais honesta é: Adoção é assinar o contrato da ferramenta, enablement é tudo que faz a ferramenta virar resultado, dado limpo alimentando, gente treinada usando, governança segurando, operação pegando o desvio.</p><p>Por que esse papel importa mais do que o título sugere? Volta no número que atravessa esse texto inteiro, <a href="https://www.fiddler.ai/blog/ai-agent-failure-rate">95% dos pilotos de IA generativa corporativa falham</a>, e a causa dominante não é modelo ruim, é <strong>falta de integração com o workflow real e falta de visibilidade operacional</strong>. Lê de novo, a maior parte da falha da indústria não está na camada que o engenheiro de IA resolve. Está na camada entre o sistema e as pessoas. Essa camada é o território do enabler. Tem dado de campo mostrando o tamanho da alavanca, p<a href="https://www.digitalapplied.com/blog/change-management-ai-adoption-2026-overcoming-resistance-playbook">rogramas de enablement baseados em champions e casos de uso por função quase triplicaram o uso semanal de IA em 60 dias</a>. Nenhuma melhoria de prompt entrega 3x de adoção.</p><p>O que o enabler faz, concretamente:</p><ul><li><strong>Seleciona onde IA entra e, mais importante, onde não entra. </strong>O filtro de casos de uso é a decisão de maior ROI da empresa inteira, e é uma decisão de negócio com verniz técnico, não o contrário.</li><li><strong>Constrói a ponte de capacidade. </strong>Treinamento por função, champions internos, biblioteca de casos que funcionaram. É o trabalho de fazer o analista de operações resolver sozinho o que antes virava ticket.</li><li><strong>Segura a governança sem matar a velocidade.</strong> Qual dado pode entrar no modelo, qual output precisa de revisão humana, o que a LGPD permite. O enabler ruim vira o departamento do “não”. O bom transforma a regra em trilho, não em muro.</li><li><strong>Mede adoção como produto.</strong> Uso semanal, tempo de ciclo antes e depois, tarefa que deixou de existir. Enabler que não mede é evangelista, e evangelista sem métrica é custo.</li></ul><p>Tem uma tese que vale pra infraestrutura de dados e vale dobrada aqui, a boa é a que some da frente das pessoas e deixa elas resolverem sozinhas. O enabler é essa tese encarnada num cargo, <strong>o valor dele não é o que ele constrói, é quantas pessoas ele destrava</strong>. O engenheiro de IA multiplica a capacidade de um sistema. O enabler multiplica a capacidade de uma organização. São alavancas diferentes, e a segunda é frequentemente maior, porque o gargalo das empresas em 2026 não é falta de modelo bom, é falta de gente que saiba encaixar o modelo no trabalho de verdade.</p><p>E aqui fecha um circuito com o terceiro perfil lá de cima. Eu fui duro com quem chegou pelas plataformas de automação querendo a vaga de engenharia, e mantenho. Mas repara, proximidade com o negócio, velocidade de POC, facilidade de mostrar valor pra não-técnico, esse é literalmente o kit do enabler.</p><p>O perfil de automação que aceita que não vai fechar o gap de engenharia rápido e migra pra enablement não está rebaixando a carreira. Está indo pro papel onde as forças dele são a competência central em vez de compensação pela fraqueza. Com um aviso, enabler de verdade precisa entender o suficiente da engenharia pra não vender milagre, e o suficiente de avaliação pra não aceitar demo como prova. Os fundamentos continuam cobrando ingresso, só que em dose menor.</p><p>O erro simétrico também existe, e eu vejo empresa cometendo, contratar enabler e cobrar dele entrega de engenharia, ou contratar engenheiro e cobrar dele adoção organizacional, ou contratar devs e pensar em projetos de ciência de dados. São papéis distintos com métricas distintas.</p><h3><strong>Recomendações da minha cabeça</strong></h3><p>O que eu levo desses pensamentos, no momento, em ordem de importância.</p><ol><li><strong>Pare de se descrever pela origem e comece a mapear o gap.</strong> “Sou de dados”, “sou dev”, “sou de automação” descreve seu passado, não seu valor. O mercado tem excesso do que você já é e escassez do que você ainda não é.</li><li><strong>Estude a coluna do vizinho, em produção.</strong> Curso preenche vocabulário, não cicatriz. Quem é de dados assume um deploy. Quem é dev assume um eval. Quem é de automação reescreve um workflow sem a plataforma. Uma vez cada um já muda seu patamar de conversa.</li><li><strong>Desconfie de qualquer senioridade autodeclarada nessa área, inclusive a sua.</strong> O cargo tem três anos. Quem se apresenta como sênior em IA é sênior em outra coisa, o que é ótimo, desde que a pessoa saiba dizer <strong>em quê</strong>. Na entrevista, pergunte “me conta o que você não sabe fazer”, quem responde rápido e específicar é quem entendeu o momento.</li><li><strong>Ferramenta entra no rodapé do currículo, não no título.</strong> Se cinco frameworks produzem o mesmo programa com imports diferentes, listar framework como skill principal comunica que você não sabe onde mora o valor. Liste o que não comoditiza, avaliação, operação, custo, segurança, domínio de negócio.</li><li><strong>Aproveite que a régua não existe pra construir a sua em público.</strong> É a parte boa da bagunça, como não tem sênior, o custo de entrada é o menor que vai existir. Documente o que você quebrou e consertou. Em campo sem régua, evidência pública de aprendizado vale mais que título.</li><li><strong>Se você contrata, pareie dados com software e pare de procurar o unicórnio.</strong> A vaga de “AI Engineer sênior, 5 anos de LLM” vai continuar aberta, porque descreve uma pessoa que não existe. Um de dados e um dev, com sobreposição forçada de trabalho, cobrem hoje o que o unicórnio cobriria em 2030. Contratar fluência em plataforma como se fosse engenharia é como foi contratar “especialista em Excel” como analista financeiro, funciona até a primeira pergunta que a ferramenta não responde.</li></ol><h3><strong>Conclusão</strong></h3><p>Engenheiro de IA sênior não existe porque senioridade é função de tempo de exposição a falha, e o campo não acumulou tempo. O que existe são três diásporas convergindo pro mesmo cargo</p><p>Os 95% de pilotos que falham não falham por falta de gente que decorou framework. Falham na fronteira entre os três perfis, no pedaço do trabalho que nenhuma das cinco bibliotecas lá de cima resolve, porque não é problema de biblioteca. Enquanto o mercado publica vaga pedindo cinco anos de experiência numa tecnologia de três, a vantagem real está com quem olha pro próprio gap sem constrangimento e atravessa pra margem que falta.</p><blockquote><em>Sênior, nessa área, por enquanto, é só o júnior que sabe exatamente em que ele é júnior.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8eed2c16b3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como decidir sua modelagem e entrega de dados]]></title>
            <link>https://medium.com/@francocontigo/como-decidir-sua-modelagem-e-entrega-de-dados-4e538c41abad?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e538c41abad</guid>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[analytics-engineering]]></category>
            <category><![CDATA[data-warehouse]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[dbt]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Sun, 07 Jun 2026 17:42:22 GMT</pubDate>
            <atom:updated>2026-06-07T17:50:34.502Z</atom:updated>
            <content:encoded><![CDATA[<h4>Star Schema vs One Big Table, quando engenharia de dados vira questão de virtude e esquecemos que a resposta está nos gargalos do negócio.</h4><p>Toda discussão de modelagem de dados que eu vejo em time, em thread de LinkedIn ou em PR, acontece da mesma forma. De um lado, alguém solta que “star schema é coisa de quem aprendeu modelagem em 2008”. Do outro, alguém responde que “OBT é gambiarra de quem nunca manteve uma dimensão em produção”. Os dois acham que estão discutindo arquitetura. Estão discutindo, na verdade, <strong>economia de hardware</strong>, e nenhum dos dois percebeu que o terreno mudou.</p><p>Esse artigo nasceu de uma indignação minha com essa discussão. Eu queria um guia que colocasse 3NF, Data Vault, star schema, snowflake schema, OBT, medallion, as camadas do dbt e até tidy data <strong>no mesmo plano</strong>, e mostrasse que quase tudo isso é o mesmo eixo visto de ângulos diferentes. No fim, o que separa uma escolha boa de uma ruim não é qual nome você usa, é se você entendeu <strong>qual é o seu gargalo e quem precisa explorar o dado sem te incomodar</strong>.</p><p>Tem um número que abre bem a discussão. A Fivetran rodou OBT contra star schema nos três grandes warehouses colunares e mediu <strong>25% a 50% de redução no tempo de query</strong> no Redshift, Snowflake e BigQuery, com menos consumo de computação. Se star schema é a “modelagem séria”, por que a versão “errada” ganha por uma margem dessas? A resposta é que star schema nunca foi sobre estar certo ou errado. Foi sobre um trade-off que fazia sentido numa época, e a época acabou.</p><p>Vamos por partes, porque tem duas confusões pra desfazer antes de qualquer coisa.</p><h3>Confusão 1: forma não é a mesma coisa que camada</h3><p>A maior parte das brigas acontece porque as pessoas misturam dois eixos completamente independentes.</p><p>O <strong>eixo da forma</strong> é sobre o formato físico/lógico das tabelas, o quanto você normaliza ou desnormaliza. 3NF, Data Vault, star schema, snowflake schema e OBT vivem todos aqui. É um espectro contínuo, do mais normalizado (zero redundância, tudo quebrado em tabelinhas) ao mais desnormalizado (uma tabela com tudo dentro).</p><p>O <strong>eixo da camada</strong> é sobre o estágio de refinamento do dado no pipeline: cru, limpo, servível. Bronze/silver/gold (medallion) e staging/intermediate/marts (dbt) vivem aqui. Não falam de forma, falam de <strong>maturidade e qualidade</strong>.</p><p>E tem um terceiro intruso, <strong>tidy data</strong>, que é a forma normal do analista, e que cruza com os dois eixos.</p><p>Por que isso importa? Porque “Kimball vs OBT” é uma escolha no eixo da forma, e “bronze/silver/gold” é uma escolha no eixo da camada, e <strong>elas se compõem em vez de competir</strong>. Você aplica Kimball <em>dentro</em> do gold. Você materializa um OBT <em>como</em> um mart. Quando alguém diz “a gente usa medallion em vez de Kimball”, está dizendo algo tão estranho quanto “a gente usa quilômetro em vez de quilo”. São unidades de coisas diferentes.</p><p>Agora, pra próxima.</p><h3>Confusão 2: “mais desnormalizado” não é “mais moderno”</h3><p>A outra leitura errada é tratar o eixo da forma como uma linha do tempo de progresso, como se 3NF fosse o passado atrasado e OBT fosse o futuro inevitável, e normalizar fosse um estágio primitivo que a humanidade superou. Não é progresso, é pêndulo.</p><p>A 3NF não foi aposentada, ela ainda manda no OLTP, onde integridade de escrita é tudo. O Data Vault 2.0 (2013) e o anchor modeling (paper de 2009) são bem mais recentes que o star schema e puxam pro lado normalizado, não pro desnormalizado. E, como você vai ver mais pra frente, o semantic layer está literalmente puxando a modelagem de volta pro lado normalizado.</p><blockquote>O eixo não é uma seta de mão única do “antigo” pro “moderno”, é um pêndulo que oscila conforme a economia do hardware muda.</blockquote><p>Tratar a forma como progresso é exatamente como se entope um OBT num lugar que pedia star schema, por moda, não por objetivo.</p><h3>O eixo da forma: cada nome é um ponto, escolhido por um gargalo</h3><figure><img alt="Capa do artigo “Como decidir sua modelagem e entrega de dados”. Um eixo horizontal com gradiente do azul (NORMALIZADO) ao laranja (DESNORMALIZADO) marca seis abordagens de modelagem em sequência: Anchor, 3NF, Data Vault, Star schema, Snowflake e OBT. Abaixo, a frase “O eixo é um pêndulo, não uma linha do tempo”." src="https://cdn-images-1.medium.com/max/1024/1*TPWyn0e9WJKgDoy0hPKaCQ.png" /><figcaption><em>Eixo horizontal de modelagem de dados, do mais normalizado (Anchor, 3NF, Data Vault) ao mais desnormalizado (Star schema, Snowflake, OBT), em gradiente azul para laranja.</em></figcaption></figure><p>Vou percorrer o espectro do mais normalizado pro mais desnormalizado, e em cada parada a pergunta é sempre a mesma, <strong>que custo essa escolha estava tentando minimizar?</strong></p><h4>3NF e Inmon, integridade de escrita acima de tudo</h4><p>A terceira forma normal é o ponto mais à esquerda. Zero redundância, cada fato armazenado uma única vez, tudo quebrado em tabelas relacionadas por chave. É o mundo do OLTP, do banco transacional. O gargalo que a 3NF minimiza é o <strong>custo da escrita inconsistente,</strong> se o endereço do cliente está em um lugar só, você nunca tem dois endereços divergentes. Atualiza um, atualiza todos.</p><p>Bill Inmon levou essa filosofia pro data warehouse com a Corporate Information Factory, a abordagem <em>top-down,</em> você constrói primeiro um EDW corporativo normalizado em 3NF, a única fonte da verdade, e só depois deriva data marts dependentes pra cada área. É robusto e caro de começar. Você precisa modelar a empresa inteira antes de entregar o primeiro dashboard.</p><p>O problema da 3NF pra analytics é simples, responder “faturamento por categoria por região no último trimestre” exige juntar uma dúzia de tabelas. Em OLTP, isso é o preço da consistência. Em OLAP, é o gargalo principal.</p><pre>-- 3NF, cada fato uma vez só, ligado por chave<br>CREATE TABLE cidade  (cidade_id INT PRIMARY KEY, nome VARCHAR(80), uf CHAR(2));<br>CREATE TABLE cliente (cliente_id INT PRIMARY KEY, nome VARCHAR(120),<br>                      cidade_id INT REFERENCES cidade(cidade_id));<br>CREATE TABLE pedido  (pedido_id INT PRIMARY KEY, data DATE, valor NUMERIC(12,2),<br>                      cliente_id INT REFERENCES cliente(cliente_id));<br><br>-- &quot;faturamento por UF&quot; exige juntar pedido -&gt; cliente -&gt; cidade<br>SELECT ci.uf, SUM(p.valor)<br>FROM pedido p<br>JOIN cliente c ON c.cliente_id = p.cliente_id<br>JOIN cidade ci ON ci.cidade_id = c.cidade_id<br>GROUP BY ci.uf;</pre><h4>Data Vault, quando a fonte muda toda semana</h4><p>Um passo pra direita, mas com uma filosofia própria. O Data Vault foi criado por Dan Linstedt nos anos 1990 e formalizado como Data Vault 2.0, e ele separa o modelo em três peças. Comçando por <strong>Hubs</strong> (as chaves de negócio, insert-only, só o identificador), <strong>links</strong> (os relacionamentos entre hubs, também insert-only e tratados como objetos de primeira classe) e <strong>satellites</strong> (os atributos descritivos e seu histórico, versionados via hashdiff).</p><p>A jogada genial está nos links. Num star schema, o relacionamento mora embutido na fact table: se você descobre que pedidos agora se conectam a campanhas de marketing, precisa alterar a fact e fazer backfill. No Data Vault, você só cria um novo link, link_pedido_campanha, sem tocar em nada existente. O modelo <strong>absorve mudança de fonte sem quebrar</strong>.</p><p>Qual gargalo isso minimiza? O <strong>custo organizacional da mudança e da auditoria</strong>. O cenário canônico é a empresa com 30+ sistemas de origem, três CRMs vindos de aquisições, um ERP legado, streams de evento, e um schema novo entrando a cada semana. Em Kimball puro, cada mudança dessas estoura ETL e quebra dashboard. Em setores regulados (banco, saúde), o Data Vault ainda te dá rastreabilidade total, dá pra provar de onde veio cada dado, quando, e de qual fonte.</p><p>O custo do Data Vault é ele mesmo. Se você tem cinco tabelas de origem e uma ferramenta de BI, Data Vault só adiciona complexidade sem benefício proporcional. E ninguém consome Data Vault direto, ele quase sempre alimenta uma camada de apresentação Kimball ou OBT por cima. É infraestrutura de back-office da modelagem, não a vitrine.</p><pre>-- Hub, só a chave de negócio (insert-only)<br>CREATE TABLE hub_cliente (<br>  hk_cliente    BINARY(16) PRIMARY KEY,  -- hash da business key<br>  cliente_bk    VARCHAR(50),             -- chave natural da origem<br>  load_date     TIMESTAMP,<br>  record_source VARCHAR(50)<br>);<br>-- Link, o relacionamento como objeto de primeira classe (insert-only)<br>CREATE TABLE link_pedido_cliente (<br>  hk_link       BINARY(16) PRIMARY KEY,<br>  hk_cliente    BINARY(16) REFERENCES hub_cliente(hk_cliente),<br>  hk_pedido     BINARY(16),<br>  load_date     TIMESTAMP,<br>  record_source VARCHAR(50)<br>);<br>-- Satellite, atributos + histórico, versionado por hashdiff<br>CREATE TABLE sat_cliente (<br>  hk_cliente    BINARY(16),<br>  load_date     TIMESTAMP,<br>  hashdiff      BINARY(16),   -- muda quando qualquer atributo muda<br>  nome          VARCHAR(120),<br>  cidade        VARCHAR(80),<br>  PRIMARY KEY (hk_cliente, load_date)<br>);</pre><p>Descobriu que pedido agora se liga a campanha? Cria link_pedido_campanha e segue a vida. Nenhuma tabela existente é tocada.</p><h4>Anchor modeling, o primo sueco que leva a normalização ao extremo</h4><p>Se o Data Vault é normalizado, o anchor modeling é normalização levada até o limite. Criado na Suécia por Olle Regardt e Lars Rönnbäck (implementações desde ~2004, paper no ER’09), ele modela tudo em <strong>sexta forma normal</strong> com quatro construtos: <strong>anchors</strong> (a identidade da entidade, uma tabela com basicamente uma coluna), <strong>attributes</strong> (cada atributo descritivo em <em>sua própria tabela</em>, historizada se precisar), <strong>ties</strong> (os relacionamentos) e <strong>knots</strong> (valores compartilhados e estáveis, tipo estado civil ou gênero).</p><p>O princípio que vende o anchor é: <em>“Uma mudança grande do lado de fora vira uma mudança pequena do lado de dentro.”</em> Como cada atributo é uma tabela isolada, adicionar um campo novo nunca exige ALTER numa entidade gigante nem backfill, você só cria mais uma tabelinha. E como tudo é historizado por design, ele lida com tempo (valid time, transaction time) nativamente.</p><pre>-- Anchor, só a identidade da entidade<br>CREATE TABLE CU_Cliente ( CU_ID INT PRIMARY KEY );<br>-- Attribute historizado, o nome, numa tabela só pra ele<br>CREATE TABLE CU_NOM_Cliente_Nome (<br>  CU_ID     INT REFERENCES CU_Cliente(CU_ID),<br>  Nome      VARCHAR(120),<br>  ValidFrom DATE,<br>  PRIMARY KEY (CU_ID, ValidFrom)<br>);<br>-- Knot, valor compartilhado e estável<br>CREATE TABLE EST_EstadoCivil ( EST_ID INT PRIMARY KEY, EST_Valor VARCHAR(20) );</pre><p>Qual gargalo o anchor minimiza? O mesmo do Data Vault, mudança estrutural barata e historização total, só que ainda mais radical. O custo também é maior, ler qualquer coisa exige juntar dezenas de tabelinhas (mitigado por <em>table elimination</em> de otimizadores que descartam joins desnecessários). É lindo academicamente, raríssimo de ver fora de nichos (seguros, varejo nórdico), e quase nunca é a camada que o usuário final toca. Vale conhecer pra entender até onde o extremo “normalizado” vai, e por que quase ninguém mora lá.</p><h4>Star schema e Kimball, o compromisso da era do disco caro</h4><p>Aqui mora o coração da briga. Ralph Kimball propôs a modelagem dimensional, você separa o mundo em <strong>fact tables</strong> (as métricas, os eventos mensuráveis, uma venda, um clique, um pagamento) e <strong>dimension tables</strong> (o contexto descritivo, o cliente, o produto, a data, a loja). Liga tudo por chaves e desenha uma estrela, a fact no centro, as dimensões em volta.</p><p>A abordagem é <em>bottom-up,</em> você entrega o data mart de uma área primeiro e vai costurando os marts via <strong>conformed dimensions</strong> (dimensões compartilhadas e consistentes entre áreas) e a <strong>bus matrix</strong>. Resolve coisas que importam de verdade:,<strong>Slowly Changing Dimensions</strong> (como rastrear que o cliente mudou de cidade sem perder o histórico), consistência de definição entre times, e uma estrutura que espelha como o negócio pensa.</p><p>Agora a parte que quase ninguém fala. Por que star schema desnormaliza as dimensões mas não chega no OBT? <strong>Porque foi desenhado pra otimizar a camada lógica de um banco row-store quando storage era caro e escasso.</strong> Você queria reduzir joins (por isso desnormaliza dentro da dimensão) mas não podia se dar ao luxo de repetir o nome do cliente em um bilhão de linhas de fato (por isso mantém a dimensão separada). Star schema é literalmente o ponto de equilíbrio entre “joins doem” e “redundância é cara”, calibrado pro hardware de 1996.</p><pre>-- Dimensão, desnormalizada dentro de si, com surrogate key<br>CREATE TABLE dim_cliente (<br>  sk_cliente INT PRIMARY KEY,   -- surrogate key (interna do DW)<br>  cliente_bk VARCHAR(50),      -- chave natural, vinda da regra de negócio<br>  nome       VARCHAR(120),<br>  cidade     VARCHAR(80),<br>  uf         CHAR(2)<br>);<br>-- Fato, métricas + chaves pras dimensões (a estrela)<br>CREATE TABLE fact_pedido (<br>  sk_cliente INT REFERENCES dim_cliente(sk_cliente),<br>  sk_data    INT,<br>  valor      NUMERIC(12,2),<br>  qtd_itens  INT<br>);<br>-- &quot;faturamento por UF&quot;, um join só, contra a dimensão pequena<br>SELECT d.uf, SUM(f.valor)<br>FROM fact_pedido f JOIN dim_cliente d ON d.sk_cliente = f.sk_cliente<br>GROUP BY d.uf;</pre><h4>Slowly Changing Dimensions, o problema que o star resolve e o OBT esquece</h4><p>Vale um parêntese aqui, porque é onde o star schema ganha o pão e onde quase todo OBT tropeça. O cliente mudou de cidade. O que você faz com o histórico? As <strong>Slowly Changing Dimensions</strong> (SCD), do vocabulário do Kimball, são as estratégias pra isso:</p><ul><li><strong>Tipo 0</strong>: nunca muda. Data de nascimento, data de cadastro. Congelado.</li><li><strong>Tipo 1</strong>: sobrescreve. Você atualiza a cidade e perde o passado. Simples e amnésico.</li><li><strong>Tipo 2</strong>: versiona. Fecha a linha antiga, abre uma nova com valid_from/valid_to e uma flag de atual. O histórico fica intacto, e o fato antigo continua apontando pra versão certa do cliente. É o cavalo de batalha.</li><li><strong>Tipo 3</strong>: guarda só o valor anterior numa coluna extra (cidade_anterior). Histórico raso, de um passo.</li><li><strong>Tipo 4</strong>: joga os atributos que mudam rápido pra uma mini-dimensão separada, pra não inchar a principal.</li><li><strong>Tipo 6</strong>: híbrido de 1+2+3 (o nome vem de 1+2+3 = 6), combina sobrescrita, versão e coluna anterior.</li></ul><pre>-- dim_cliente com SCD Tipo 2, cada mudança vira nova linha versionada<br>CREATE TABLE dim_cliente (<br>  sk_cliente INT PRIMARY KEY,  -- muda a cada versão<br>  cliente_bk VARCHAR(50),      -- chave natural, estável entre versões<br>  nome       VARCHAR(120),<br>  cidade     VARCHAR(80),<br>  valid_from DATE,<br>  valid_to   DATE,<br>  is_current BOOLEAN<br>);</pre><p>Por que isso importa pro debate Kimball vs OBT? Porque um OBT que materializa “o estado atual” e sobrescreve está fazendo SCD Tipo 1 sem perceber, jogando histórico fora. Dá pra fazer SCD num OBT (carimbando versão em cada linha), mas é uma decisão que você precisa tomar de propósito. O star schema te força a encarar a pergunta “o que faço quando muda?” na hora de modelar. O OBT deixa você adiar até o dia em que alguém pergunta “qual era a cidade do cliente <em>na data da compra</em>?” e o dado não existe mais.</p><h4>Snowflake schema, a dimensão normalizada (e a colisão de nome)</h4><p>Variação do star, você normaliza as próprias dimensões, quebrando, por exemplo, uma dimensão de produto em produto → subcategoria → categoria → departamento. Vira um floco de neve. Reduz mais redundância à custa de mais joins. Pequena ironia, o snowflake <em>schema</em> é o oposto filosófico do que o warehouse <em>Snowflake</em> incentiva, que é justamente desnormalizar pesado e deixar o colunar resolver. Dois “snowflakes” puxando pra lados contrários no mesmo diagrama de arquitetura.</p><h4>One Big Table, a era do colunar barato</h4><p>O ponto mais à direita. Uma tabela larga, desnormalizada, com tudo pré-juntado. Zero join no momento da query, o engine escaneia e agrega. É a modelagem que parecia heresia em 2008 e virou default na stack moderna.</p><pre>-- One Big Table, tudo pré-juntado uma vez, zero join na hora de consultar<br>CREATE TABLE obt_pedidos AS<br>SELECT p.pedido_id, p.data, p.valor,<br>       c.cliente_id, c.nome AS cliente_nome,<br>       ci.nome AS cidade, ci.uf<br>FROM pedido p<br>JOIN cliente c ON c.cliente_id = p.cliente_id<br>JOIN cidade  ci ON ci.cidade_id = c.cidade_id;<br><br>-- &quot;faturamento por UF&quot; agora não tem join nenhum<br>SELECT uf, SUM(valor) FROM obt_pedidos GROUP BY uf;</pre><h3>Por que o OBT voltou, o gargalo mudou de “storage” pra “shuffle”</h3><p>Volta no número da Fivetran, <strong>25% a 50% mais rápido</strong> em Redshift, Snowflake e BigQuery. Não é mágica, é física do hardware atual.</p><p><strong>1ª Observação, em ambiente distribuído, o join é a operação cara, não o scan.</strong> Num warehouse colunar e MPP (massively parallel processing), os dados estão espalhados por vários nós. Pra fazer um join, o engine frequentemente precisa de um <strong>shuffle,</strong> mover dados pela rede entre nós pra alinhar as chaves antes de juntar. Isso é caríssimo. O OBT elimina a fase de join inteira, porque tudo já está na mesma linha. Você trocou o gargalo, saiu do CPU/rede (join/shuffle) e foi pro storage/disco (a tabela é maior). E storage hoje é barato. COmputação é o que você paga caro.</p><p><strong>2ª Observação, a crítica óbvia ao OBT já tem resposta técnica.</strong> “Mas guardar o nome ‘Fulaninho da Silva e Silva Junior Neto’ repetido um milhão de vezes é um absurdo de espaço!” Seria, num row-store. Em colunar, não. Os engines usam <strong>Run-Length Encoding</strong> e <strong>dictionary encoding,</strong> se o valor “Fulaninho da Silva e Silva Junior Neto” aparece 1.000 vezes em sequência numa coluna, o storage não guarda a string 1.000 vezes, ele guarda o valor e a contagem. Colunar agrupa dados do mesmo tipo, o que dá taxas de compressão absurdamente melhores que row-based, e ainda lê só as colunas que a query pediu. A redundância que arrepiava o DBA de 2008 é quase de graça hoje. O que custa num warehouse colunar não é o byte armazenado, é o padrão de acesso.</p><p><strong>3ª Observação, mas star schema não morreu, ele ganha em outro eixo.</strong> OBT ganha em velocidade de leitura pura. Star schema ganha em <strong>governança e histórico,</strong> conformed dimensions garantem que “cliente ativo” significa a mesma coisa em todo lugar, e Slowly Changing Dimensions rastreiam mudança ao longo do tempo de um jeito que o OBT, sozinho, não faz. Você não escolhe o vencedor olhando o benchmark de query. Você escolhe olhando se o seu problema é <em>latência de dashboard</em> ou <em>consistência de definição entre analistas e áreas</em>.</p><h4>Activity schema, a via que não cabe no eixo</h4><p>Tem uma abordagem moderna que recusa o eixo inteiro. O <strong>activity schema</strong>, criado por Ahmed Elsamadisi (fundador da Narrator, apresentado no Coalesce 2021), propõe modelar tudo numa <strong>única tabela time-series de 11 colunas</strong>, sem fact, sem dimensão, sem JSON. Em vez de “fatos e dimensões”, o dado vira <em>“um cliente fez uma atividade num instante”</em>. Cada linha é uma atividade: fez pedido, visitou o site, abriu ticket, cancelou.</p><pre>-- Activity Stream: uma linha por &quot;entidade fez atividade X no tempo T&quot;<br>CREATE TABLE activity_stream (<br>  activity_id          VARCHAR,    -- id da ocorrência<br>  ts                   TIMESTAMP,  -- quando<br>  customer             VARCHAR,    -- quem (a entidade)<br>  activity             VARCHAR,    -- o quê: &#39;fez_pedido&#39;, &#39;visitou_site&#39;...<br>  anonymous_customer_id VARCHAR,<br>  feature_1            VARCHAR,    -- contexto flexível por atividade<br>  feature_2            VARCHAR,<br>  feature_3            VARCHAR,<br>  revenue_impact       NUMERIC,<br>  link                 VARCHAR,<br>  activity_occurrence  INT,        -- 1ª, 2ª, 3ª vez que a entidade fez isso<br>  activity_repeated_at TIMESTAMP<br>);</pre><p>A promessa é gigante (e o próprio autor admite que soa como papo furado), qualquer pergunta de negócio sai dessa tabela só, com uma camada de modelagem única cuja única dependência é o dado cru. “Faturamento por mês” e “tempo médio até a segunda compra” vêm da mesma estrutura, sem montar um modelo dimensional novo pra cada pergunta. Onde isso brilha é em análise comportamental e de jornada, exatamente o tipo de pergunta temporal (“o que o usuário fez <em>entre</em> A e B”) que dá nó num star schema. O custo é que casos clássicos de dimensão (juntar um atributo que muda no tempo) viram trabalho de borda, resolvido com joins especiais tipo <em>last-before</em>. É uma filosofia inteira, não um ponto no espectro de normalização, e por isso merece estar no mapa mesmo sem caber na régua.</p><h3>O eixo da camada, refinamento, não forma</h3><p>Agora o eixo ortogonal. Aqui não se discute o quanto normalizar, se discute o quão pronto o dado está pra consumo.</p><h4>Medallion: bronze, silver, gold</h4><p>A Databricks popularizou o termo por volta de 2019–2020 junto com o lakehouse, mas o conceito é antigo e, importante, <strong>é um padrão lógico, não um produto</strong>. Você implementa medallion em Snowflake, BigQuery, Fabric, no que for.</p><ul><li><strong>Bronze,</strong> ingestão e preservação. O dado cru, o mais próximo possível da fonte, transformação mínima. Captura confiável, nada de regra de negócio aqui.</li><li><strong>Silver, </strong>limpeza e padronização. Onde o dado vira utilizável: dedupe, cast, validação, quarentena de registro corrompido, joins que conformam entidades.</li><li><strong>Gold,</strong> serviço. Agregado, curado, pronto pra decisão. <strong>É aqui que você aplica Kimball ou OBT.</strong> O gold é a forma; o medallion é o caminho até ele.</li></ul><p>O acesso costuma espelhar a confiança: bronze restrito a engenharia de dados, silver pros cientistas e power users, gold liberado pra organização ampla.</p><p><strong>4ª Observação, os modos de falha do medallion são quase sempre de disciplina, não de tecnologia.</strong> Os clássicos que aparecem em todo post-mortem de engenharia:</p><ul><li>Regra de negócio vazando pro bronze (que deveria ser cru).</li><li>Silver virando um “segundo bronze”, um depósito sem governança.</li><li>Gold reconstruído do zero por cada time, sem reuso, multiplicando definições divergentes.</li></ul><p>Medallion não é sobre as três pastas terem os nomes certos. É sobre cada camada ter um contrato e uma fronteira de responsabilidade clara. Pasta com nome bonito e lógica bagunçada é só um lake virando swamp com etapas extras.</p><h4>dbt: staging, intermediate, marts</h4><p>É a versão operacional do mesmo eixo, no mundo da analytics engineering.</p><ul><li><strong>Staging,</strong> um modelo por tabela de origem, geralmente materializado como <em>view</em>. Convenção stg_&lt;fonte&gt;__&lt;entidade&gt;. Aqui você renomeia coluna, faz cast, padroniza, e <strong>só isso</strong>. Regra de ouro: nada de join entre domínios, nada de agregação. Por quê? Pra preservar o <strong>grão</strong> da origem. Se você agrega cedo, trava o grão e mata o reuso a jusante.</li><li><strong>Intermediate,</strong> int_, onde a complexidade é absorvida. Joins, lógica de negócio empilhada em camadas. Uma regra de ouro de DAG, vários inputs entrando num modelo intermediate é ótimo e esperado, várias setas <em>saindo</em> dele é red flag.</li><li><strong>Marts,</strong> a entrega. fact_/dim_ em estilo Kimball, ou marts por domínio (mart_vendas, mart_churn). Materializado como tabela, por performance. Cada mart representa uma entidade num grão único.</li></ul><p>Repara que staging→intermediate→marts é exatamente bronze→silver→gold com outro vocabulário e mais opinião sobre SQL. E que, de novo, <strong>o mart é onde a forma é decidida</strong>. Camada e forma se encontram no produto final.</p><h3>O intruso: tidy data não é nem star nem OBT</h3><p>Aqui entra o conceito que ciêntista de dados (alo comunidade do tidyverse) venera e que a turma de engenharia de dados às vezes nem conhece pelo nome.</p><p>Hadley Wickham publicou <em>Tidy Data</em> em 2014 no Journal of Statistical Software, e definiu três regras pro dado “arrumado”, <strong>cada variável é uma coluna, cada observação é uma linha, cada tipo de unidade observacional é uma tabela</strong>. O mantra que rodou o mundo do R e depois influenciou o pandas. É o “normal form” do analista, e ele otimiza um gargalo bem específico, <strong>a facilidade de manipular, modelar e visualizar com ferramentas vetorizadas</strong>. Ferramenta tidy entra dado tidy e sai dado tidy, e aí um conjunto pequeno de operações (melt, split, cast) cobre quase qualquer bagunça.</p><p>E aqui está a tensão que quase ninguém explicita, <strong>tidy data é formato longo e estreito, quase o oposto do OBT, que é largo.</strong> As duas tribos chamam coisas opostas de “boa modelagem”.</p><p>Pega o exemplo clássico do próprio Wickham, temperatura medida em três cidades por semana. O instinto de planilha é fazer uma coluna por cidade (largo). A versão tidy é três colunas: semana, cidade, temperatura (longo). Pra um ggplot ou um seaborn, a versão longa é trivial de plotar. Pra um dashboard de BI que lista cidades lado a lado, a versão larga é o que você quer.</p><p>A resolução não é “um está certo”. É que <strong>eles servem camadas e propósitos diferentes,</strong> tidy/longo é a forma de consumo pra análise estatística e visualização, wide/OBT é a forma de serviço pra BI. Um cientista de dados puxa o gold, faz um melt pra ficar tidy no notebook, roda o modelo. Não há contradição, há tradução entre fronteiras. O erro é tentar impor o normal form de uma tribo na camada da outra.</p><h3>O semantic layer muda a resposta de novo</h3><p>Quando você acha que fechou o caso “OBT pra leitura, star pra governança”, aparece uma camada nova que reembaralha tudo, o <strong>semantic layer</strong> (ou metrics layer).</p><p>A própria documentação do dbt é explícita sobre isso. Sem semantic layer, a recomendação é <strong>desnormalizar pesado</strong> nos marts. Mas se você usa o Semantic Layer com o MetricFlow, a recomendação inverte, <strong>ficar o mais normalizado possível</strong>, pra dar ao motor de métricas o máximo de flexibilidade pra montar os joins na hora.</p><p>Por que isso acontece? Porque o semantic layer move a decisão de forma pra <em>runtime</em>. Você define a métrica e as entidades uma vez, de forma normalizada e canônica, e o OBT que o BI consome passa a ser <strong>gerado sob demanda</strong> pela query. Star schema deixa de ser a vitrine e vira o <em>input</em> da camada semântica. A desnormalização não desaparece, ela só deixa de ser uma decisão de modelagem física e vira uma decisão de compilação de query.</p><p>A lição meta aqui, que vale pro artigo inteiro, <strong>toda vez que uma ferramenta nova muda a economia, a “melhor prática” de modelagem muda junto.</strong> Colunar reabriu o OBT. Semantic layer reabriu a normalização. Quem trata modelagem como dogma fica sempre uma geração de hardware atrás.</p><h3>Data mart e data mesh: a forma encontra a organização</h3><p>Até aqui falei de forma e de camada. Falta o eixo da <strong>escopo organizacional</strong>, que é onde data mart e data mesh entram, e onde a discussão deixa de ser técnica e vira sociotécnica.</p><h3>Data mart, o cômodo mobiliado</h3><p>Um data mart é um recorte do warehouse focado num domínio ou departamento: marketing, finanças, logística. Se o warehouse é a casa, o mart é o cômodo já mobiliado pra um time específico morar. Na tradição Kimball (<em>bottom-up</em>), você constrói os marts primeiro e os integra via conformed dimensions. Na tradição Inmon (<em>top-down</em>), o EDW corporativo vem primeiro e os marts são derivados dele. A briga Kimball vs Inmon, no fundo, sempre foi sobre <strong>ordem de construção e propriedade</strong>, não sobre forma de tabela. Quem entrega valor primeiro, a área ou o corporativo?</p><h3>Data mesh, o mart promovido a princípio organizacional</h3><p>Em 2019, Zhamak Dehghani, então na ThoughtWorks, cunhou o <strong>data mesh</strong> e levou essa pergunta de propriedade ao extremo lógico. A tese, o time de dados central vira gargalo porque não tem contexto de domínio, então constrói a coisa errada, e os domínios esperam meses por dado. A solução é descentralizar, com quatro princípios:</p><ol><li><strong>Domain-oriented ownership,</strong> quem gera e entende o dado é dono dele. Marketing é dono do dado de marketing. Baseado no domain-driven design do Eric Evans.</li><li><strong>Data as a product,</strong> o dado de cada domínio é tratado como produto, com o consumidor como cliente, com SLA, documentação, descobribilidade. Esse é o pulo conceitual.</li><li><strong>Self-serve data platform,</strong> uma plataforma que reduz a carga cognitiva pros domínios produzirem e consumirem dado sem reinventar infra.</li><li><strong>Federated computational governance,</strong> padrões globais (interoperabilidade, segurança, contratos) aplicados de forma federada e automatizada, não por um comitê manual.</li></ol><p>Data mesh não é uma forma de tabela, é um modelo operacional. Mas ele <strong>depende</strong> das decisões de forma e camada que vimos, cada data product de domínio ainda precisa ser modelado (star, OBT, o que servir), ainda passa por refinamento (medallion/dbt), e ainda precisa de um contrato semântico pra ser interoperável. O mesh não substitui modelagem, ele distribui a responsabilidade dela.</p><p>Vale o aviso, mesh é uma mudança organizacional antes de ser técnica. Quem trata como projeto só de tecnologia falha. E muito time pequeno que adotou “mesh” só recriou silos com nome bonito. Mesh resolve problema de <em>escala organizacional</em>. Se você tem um time de dados e cinco fontes, mesh é overhead, do mesmo jeito que Data Vault é.</p><h3>Dado não é fim: modelagem é a interface que destrava todo mundo</h3><p>Toda essa discussão de 3NF, Kimball, OBT, medallion não é sobre elegância de diagrama. É sobre <strong>quem consegue fazer pergunta ao dado sem abrir um ticket</strong>.</p><p>Pensa no que acontece quando a modelagem é ruim. Cada pergunta de negócio (“qual a retenção de quem entrou pela campanha X?”) vira um pedido pra engenharia de dados. A engenharia entra numa fila. O analista espera três dias, recebe um número, descobre que era a métrica errada, refaz o pedido. O cientista de dados não confia em nenhuma tabela e refaz o pipeline inteiro no notebook dele, criando a 14ª definição de “usuário ativo” da empresa. O dado virou um <strong>fim em si mesmo,</strong> um ativo que a empresa coleta, armazena, e do qual extrai uma fração ridícula do valor, porque o gargalo humano é o time de dados.</p><p>Agora pensa no oposto. Quando a modelagem é boa, ela <strong>é a API</strong>. O grão bem definido, os nomes consistentes, as conformed dimensions, o semantic layer com as métricas canônicas, tudo isso é o contrato que deixa o analista, o cientista e o pessoal de negócio explorarem sozinhos. O grão de uma stg_orders preservado é o que permite que três perguntas diferentes sejam respondidas sem reescrever nada. A camada gold liberada com governança é o que tira a engenharia do meio do caminho. O &quot;data as a product&quot; do mesh é literalmente isso: o dado tratado como produto que se autodocumenta e se autoatende.</p><p>É essa a leitura que sustenta o artigo inteiro. A modelagem física boa é o que deixa o banco escalar sem trair em produção. A modelagem da métrica boa é o que deixa o experimento ser confiável e rápido. A modelagem analítica boa é o que deixa a empresa inteira fazer pergunta. O fio comum é sempre o mesmo, <strong>modelagem boa é a que some da frente das pessoas.</strong></p><p>Esse é o critério final, e ele é melhor que qualquer benchmark. Não pergunte “essa modelagem é Kimball ou OBT?”. Pergunte “depois dessa modelagem, quantas pessoas a mais conseguem responder a própria pergunta sem me pedir licença?”. Se a resposta é “mais”, você acertou, independente do nome no diagrama.</p><h3>Recomendações da minha cabeça</h3><p>O que eu de fato levo desse estudo, em ordem de importância.</p><ol><li><strong>Escolha o ponto do eixo pelo gargalo.</strong> Storage barato e leitura dominante? OBT no gold resolve e ganha de star schema no benchmark. Governança, histórico e consistência entre muitos times? Star schema com conformed dimensions e SCD. Trinta fontes mudando todo trimestre e auditoria regulatória? Data Vault no raw, Kimball ou OBT na apresentação. Cinco fontes e um BI? Star schema simples.</li><li><strong>Não confunda forma com camada.</strong> “Usamos medallion” e “usamos Kimball” não competem, se compõem. A forma é decidida no gold/mart. Bronze/silver/gold é o caminho até lá. Quem diz que substituiu um pelo outro está medindo quilômetro em quilo.</li><li><strong>Star schema na entrada do semantic layer, OBT no gold de consumo direto.</strong> Se você tem metrics layer, mantenha normalizado e deixe a camada gerar o wide na query. Se não tem, desnormalize pesado no mart. A ferramenta define a resposta, não o dogma.</li><li><strong>Tidy no notebook, wide no dashboard.</strong> Não imponha o formato longo do cientista de dados na camada de BI, nem o OBT largo dentro do pipeline de modelagem estatística. Traduza nas fronteiras, é barato.</li><li><strong>Data Vault, anchor e data mesh só quando você tem o problema deles.</strong> Os três são respostas a problemas de <em>escala</em> (de fontes, de mudança estrutural, de organização). Anchor leva isso ao 6NF e raramente sai de nichos. Aplicados em ambiente pequeno, viram overhead puro que apodrece rapidamente. O custo de adoção é real e cobrado todo dia.</li><li><strong>Meça antes de denormalizar.</strong> Antes de jogar tudo num OBT, olhe o padrão de query real (qual join dói, qual coluna é filtrada, qual é o volume). Denormalização especulativa é otimização no escuro, parece ganho, costuma ser fragmentação e custo de manutenção.</li><li><strong>Trate modelagem como produto, não como diagrama.</strong> O sucesso da sua modelagem se mede em pessoas destravadas, não em terceira forma normal alcançada. Documente o grão, exponha a definição de métrica, dê acesso governado ao gold. A modelagem é a interface de autoatendimento da empresa com o próprio dado.</li><li><strong>Se a sua pergunta é comportamental, considere o activity schema antes de torturar um star.</strong> “O que o usuário fez entre o cadastro e a primeira compra”, “quanto tempo até repetir”, funil e jornada são perguntas temporais que dão nó em fact/dimensão e saem natural de uma activity stream. Não precisa adotar a stack inteira da Narrator pra roubar a ideia do modelo de eventos.</li></ol><h3>Conclusão</h3><p>Anchor, 3NF, Data Vault, star schema, snowflake schema e OBT são o mesmo eixo, normalização contra desnormalização, e cada um é um ponto calibrado pra um gargalo de uma época. Star schema é a resposta certa pra uma pergunta de economia de 1996, e o colunar mudou a pergunta. O activity schema nem entra no eixo, ele recusa fact/dimensão e modela o mundo como uma sequência de eventos. Bronze/silver/gold e staging/intermediate/marts são outro eixo, o de refinamento, e se compõem com o primeiro em vez de competir. Tidy data é o normal form do analista, longo onde o OBT é largo, e a tensão entre eles some quando você entende que servem camadas diferentes. Data mart e data mesh sobem a discussão pro plano organizacional, onde a pergunta vira de quem é a propriedade do dado e como faz a gestão da governança.</p><p>O ponto que atravessa tudo isso é que infraestrutura de dados raramente tem resposta absoluta, tem resposta condicional ao seu gargalo e à economia da sua stack. Modelagem não é estética, é economia, ergonomia e menor carga cognitiva, e no fim é a pergunta de quem você está tentando destravar. Tratada como dogma, ela fica sempre uma geração de hardware atrás.</p><p>A pergunta certa nunca foi “Kimball ou OBT”. Foi “onde está meu gargalo, e quem precisa explorar esse dado sem me pedir licença”.</p><blockquote>Modelo de dados bom não é o mais bonito no diagrama. É o que <strong>some da frente das pessoas e deixa elas perguntarem.</strong></blockquote><h3>Referências</h3><ul><li>Wickham, H. (2014). “Tidy Data”. <em>Journal of Statistical Software</em>, 59(10). <a href="https://www.jstatsoft.org/v59/i10/">https://www.jstatsoft.org/v59/i10/</a></li><li>Kimball, R., Ross, M. (2013). <em>The Data Warehouse Toolkit: The Definitive Guide to Dimensional Modeling</em>. 3ª ed. Wiley.</li><li>Inmon, W. H. <em>Building the Data Warehouse</em> / Corporate Information Factory (CIF).</li><li>Linstedt, D., Olschimke, M. (2015). <em>Building a Scalable Data Warehouse with Data Vault 2.0</em>. Morgan Kaufmann.</li><li>Dehghani, Z. (2022). <em>Data Mesh: Delivering Data-Driven Value at Scale</em>. O’Reilly. (Conceito cunhado em 2019, ThoughtWorks; quatro princípios: domain ownership, data as a product, self-serve data platform, federated computational governance.)</li><li>Fivetran. “Star Schema vs. OBT for Data Warehouse Performance”. <a href="https://www.fivetran.com/blog/star-schema-vs-obt">https://www.fivetran.com/blog/star-schema-vs-obt</a></li><li>Databricks. “What is the medallion lakehouse architecture?”. <a href="https://docs.databricks.com/aws/en/lakehouse/medallion">https://docs.databricks.com/aws/en/lakehouse/medallion</a></li><li>dbt Labs. “How we structure our dbt projects” e “Marts: Business-defined entities”. <a href="https://docs.getdbt.com/best-practices/how-we-structure/1-guide-overview">https://docs.getdbt.com/best-practices/how-we-structure/1-guide-overview</a></li><li>Regardt, O., Rönnbäck, L., Bergholtz, M., Johannesson, P., Wohed, P. (2009). “Anchor Modeling — An Agile Modeling Technique Using the Sixth Normal Form for Structurally and Temporally Evolving Data”. ER’09. <a href="https://www.anchormodeling.com/">https://www.anchormodeling.com</a></li><li>Elsamadisi, A. (2021). “Introducing the activity schema: data modeling with a single table”. Coalesce / dbt. <a href="https://www.activityschema.com/">https://www.activityschema.com</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e538c41abad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CUPED e suas variantes, ou como cortar pela metade o tempo dos seus testes A/B]]></title>
            <link>https://medium.com/@francocontigo/cuped-e-suas-variantes-ou-como-cortar-pela-metade-o-tempo-dos-seus-testes-a-b-8b185d4c2297?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b185d4c2297</guid>
            <category><![CDATA[statistics]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[ab-testing]]></category>
            <category><![CDATA[experimentation]]></category>
            <category><![CDATA[causal-inference]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Sun, 17 May 2026 13:10:38 GMT</pubDate>
            <atom:updated>2026-05-17T13:10:38.055Z</atom:updated>
            <content:encoded><![CDATA[<h3>CUPED, CUPAC, MLRATE. O pacote de variance reduction que tá rodando em toda plataforma moderna de A/B</h3><h4>Como Microsoft, DoorDash e Meta cortaram pela metade o tempo de teste A/B usando dados que já tinham, e por que a métrica importa mais que a técnica</h4><p>No <a href="https://medium.com/@francocontigo/teste-a-b-frequentista-bayesiano-e-sequential-e-como-netflix-microsoft-e-outras-grandes-decidem-dd2d8b49e96f">artigo anterior</a> eu mencionei CUPED de passagem como “uma técnica que reduz sample size sem mudar a metodologia”. Saiu <strong>proporcionalmente curto</strong> pro tamanho do que essa coisa faz.</p><p>CUPED (Controlled-experiment Using Pre-Experiment Data) foi publicado em <strong>2013 por Deng, Xu, Kohavi e Walker, da Microsoft</strong>. O paper original mostra que, usando comportamento pré-experimento como covariável, conseguiram reduzir a variância das métricas do Bing em <strong>cerca de 50%</strong>. Variância 50% menor significa <strong>metade do tamanho de amostra</strong> pra detectar o mesmo efeito, ou seja, metade do tempo. Pra uma empresa que roda milhares de testes A/B por ano, isso é dobrar a velocidade de iteração sem mexer em nada visível do produto.</p><p>Hoje CUPED tá implementado nas plataformas internas de <strong>Microsoft, Netflix, Booking, Airbnb, Meta, Uber, DoorDash, Etsy, Faire, TripAdvisor</strong>, e em todas as principais plataformas comerciais, <strong>Statsig, Eppo, VWO, Kameleoon, Amplitude</strong>. Se você roda A/B em algo moderno, provavelmente CUPED já tá rodando por baixo sem você ver.</p><p>A estrutura desse artigo é assim, primeiro <strong>CUPED clássico</strong> (intuição, matemática, por que funciona), depois as duas extensões modernas, <strong>CUPAC do DoorDash (2020)</strong> e <strong>MLRATE da Meta (2021)</strong>. Em seguida cubro <strong>onde a coisa pode quebrar</strong>, e termino com um <strong>guia amplo de como pensar sobre adotar isso</strong> no seu programa de experimentação.</p><h3>A intuição, heavy users já eram heavy antes do teste</h3><p>Pensa numa plataforma qualquer com a métrica “sessões por usuário em 14 dias”. O power do seu teste é a função da variância dessa métrica, e a variância é alta porque os usuários são muito heterogêneos. Tem usuário que abre o app 80 vezes por semana, tem usuário que abre 2 vezes por mês. Quando você compara controle e tratamento, boa parte do ruído é simplesmente essa diferença entre tipos de usuário caindo aleatoriamente em cada grupo.</p><p>A randomização cuida disso na média, mas amostralmente sempre vai sobrar diferença, e essa diferença residual é o que infla seu intervalo de confiança e pede mais N.</p><p>A observação que muda a forma de abordar, o usuário heavy de hoje é o usuário heavy de 30 dias atrás. Se eu sei que o usuário X fez 80 sessões nos 30 dias antes do experimento, eu posso prever, sem nenhum modelo sofisticado, que ele vai fazer mais sessões que a média durante o experimento. Não estou prevendo o efeito do tratamento, estou prevendo a baseline dele.</p><p>A ideia do CUPED é simples, em vez de comparar Y_tratamento com Y_controle, eu comparo Y_tratamento - predição_baseline com Y_controle - predição_baseline. A heterogeneidade do baseline some, a única coisa que sobra é o efeito do tratamento (que é o que eu queria desde o começo) mais um ruído residual menor.</p><p>Não está inventando informação, só removendo um pedaço da variância que já sabia existir e que não tem nada a ver com o que esta sendo testado.</p><h4>A matemática</h4><p>O ajuste do CUPED é uma linha:</p><pre>Y_cuped = Y - theta * (X - mean(X))</pre><p>onde:</p><ul><li>Y é a métrica durante o experimento (ex: sessões em 14 dias)</li><li>X é a métrica pré-experimento (ex: sessões nos 30 dias anteriores)</li><li>theta = cov(Y, X) / var(X) é o coeficiente que minimiza a variância residual</li></ul><p>Isso é uma regressão linear de Y em X. O theta é a inclinação da reta que melhor prevê Y a partir de X.</p><p>A variância de Y_cuped é, no limite:</p><pre>var(Y_cuped) ≈ var(Y) * (1 - rho²)</pre><p>onde rho é a correlação entre Y e X. Quanto maior a correlação entre o comportamento pré e durante, maior a redução. Nada além disso.</p><p>Em resumo, fica uma tabela:</p><pre> rho  |  redução var  |  sample size equivalente<br>------+---------------+-------------------<br> 0.3  |       9%      |  91% do N original<br> 0.5  |      25%      |  75% do N original<br> 0.7  |      49%      |  51% do N original<br> 0.8  |      64%      |  36% do N original<br> 0.9  |      81%      |  19% do N original</pre><figure><img alt="Gráfico de linha mostrando a redução de variância do CUPED em função do rho. A curva é uma parábola crescente, partindo de 0% quando rho é 0, passando por aproximadamente 25% quando rho é 0.5, 49% quando rho é 0.7, e atingindo 100% quando rho é 1. Eixo X vai de 0 a 1 (rho, correlação pré × durante). Eixo Y vai de 0 a 100% (redução de variância)." src="https://cdn-images-1.medium.com/max/572/1*d4ytPynHZMQFsQODIoKSUw.png" /><figcaption><em>Redução de variância como função do rho. CUPED entrega exatamente rho² da variância original, nem mais, nem menos. Microsoft viu ~50% no Bing porque rho lá fica entre 0.7 e 0.8.</em></figcaption></figure><p>A Microsoft cita rho típicos entre 0.6 e 0.8 nas métricas do Bing, o que dá redução de variância de 36% a 64%, em linha com os 50% que reportaram. A diferença entre uma plataforma que adota CUPED e ganha 50% e uma que adota e ganha 5% é o rho, e o rho é função da métrica, não da técnica.</p><h4>Por que isso não introduz viés</h4><p>A pergunta natural é, “se eu mexer no Y, não vou enviesar o teste?”.</p><p>Não, e a razão é estrutural. X é pré-experimento, foi observado antes do tratamento ser aplicado. Por construção, X é independente de T (o indicador de tratamento). Como theta * (X - mean(X)) tem média zero e independe de T, subtrair isso de Y não muda a diferença entre os grupos.</p><p>Em fórmula:</p><pre>E[Y_cuped | T=1] - E[Y_cuped | T=0] = E[Y | T=1] - E[Y | T=0]</pre><p>A média da diferença é igual. O que muda é a variância, o ruído entre indivíduos cai, então o erro padrão da diferença cai junto, então o p-value cai (quando há efeito) e o intervalo de confiança fica mais estreito.</p><p>Tendo um detalhe, o theta tem que ser estimado no pool inteiro (controle + tratamento), não separado por grupo. Estimar por grupo introduz viés porque o theta passa a capturar parte do efeito do tratamento.</p><p>Vale destacar essa propriedade. Várias “otimizações” em A/B parecem aumentar power mas na verdade só estão inflando falso positivo (peeking, p-hacking, segmentação ad-hoc, mencionadas no artigo anterior). CUPED é matematicamente sem viés, ele estreita o intervalo de confiança sem mexer no centro.</p><h3>CUPAC, a extensão do DoorDash (2020), ML como covariável</h3><p>CUPED clássico usa uma covariável (X) por vez. Mas em produção, você quase sempre tem várias features pré-experimento, recência, gasto histórico, número de sessões, categoria preferida, dispositivo, localidade, canal de aquisição. Combinar tudo manualmente é trabalhoso e nem sempre ótimo.</p><p>Em 2020, Jeff Li, Yixin Tang e Jared Bauman do DoorDash publicaram um <a href="https://careersatdoordash.com/blog/improving-experimental-power-through-control-using-predictions-as-covariate-cupac/">blog post</a> descrevendo o CUPAC, Control Using Predictions As Covariate. A ideia é uma generalização limpa:</p><ol><li>Treina um modelo de ML (GBM, random forest, rede neural) pra prever Y a partir de todas as features pré-experimento disponíveis.</li><li>Usa a predição do modelo como o “X” do CUPED.</li></ol><p>Por que isso é melhor que CUPED clássico? Porque um modelo de ML captura relações não-lineares e interações entre features que uma única covariável não captura. Se “usuário novo + alto gasto pré + categoria X” prevê melhor o comportamento durante que cada uma delas isoladas, o modelo aprende isso, e a redução de variância aumenta.</p><p>O CUPAC moderno é o cross-fitting, padrão hoje no DoorDash (Dash-AB, 2022) e no Etsy (2025). A ideia é treinar o modelo em K folds (geralmente 5), gerando predições out-of-sample pra cada usuário. Isso evita dois problemas:</p><ul><li>Vazamento, se você treinar no pool inteiro, o modelo aprende ruído individual e parte do efeito do tratamento.</li><li>Pequeno demais se você treinar só no grupo de controle, perde metade do sample size, e o modelo prevê fora da distribuição no tratamento.</li></ul><p>Cross-fitting resolve os dois, todo usuário é predito por um modelo treinado em outros usuários. Sem isso, CUPAC pode até piorar a variância em vez de melhorar.</p><p>No DoorDash, em sistemas de logística com switchback testing, CUPAC entregou cerca de 10% a mais de redução de variância que CUPED simples. O Etsy reportou em 2025 que migrar de CUPED para CUPAC encurtou a duração média dos experimentos em aproximadamente 3 dias.</p><p>Quando CUPAC vale a pena sobre CUPED? Quando você tem várias features pré-experimento com sinal complementar. Quando você tem uma única feature dominante (tipo “sessões pré” que já explica quase tudo), o ganho marginal é pequeno.</p><h3>MLRATE, a evolução de Meta (NeurIPS 2021)</h3><p>Yongyi Guo e colegas, em <a href="https://arxiv.org/abs/2106.07263">paper de 2021 publicado no NeurIPS</a>, propuseram o MLRATE (Machine Learning Regression-Adjusted Treatment Effect stimator). É parecido com CUPAC mas com a diferença que em vez de subtrair a predição do Y, ele inclui a predição como regressor numa regressão maior, com termo de interação:</p><pre>Y = beta0 + tau*T + beta1*g(X) + beta2*(T * g(X)) + eps</pre><p>onde g(X) é a predição de ML cross-fitted (igual ao CUPAC), e tau é o estimador do ATE.</p><p>A vantagem de MLRATE sobre CUPAC é uma propriedade que importa em produção, ele é consistente mesmo se o modelo de ML for mal ajustado. CUPAC depende do modelo capturar bem a relação X→Y, se o modelo erra, CUPAC pode piorar a variância. MLRATE é mais robusto porque:</p><ol><li>A randomização garante balanceamento de T entre grupos.</li><li>O termo de interação T*g(X) absorve parte do erro do modelo.</li><li>A inferência via OLS clássico dá erros padrão na média honestos.</li></ol><p>Em troca, MLRATE é levemente mais complexo (uma regressão com interação em vez de subtração simples), e ligeiramente menos eficiente que CUPAC quando o modelo está bem especificado. É a aposta defensiva, troca um pouco de eficiência por robustez.</p><p>Meta usa MLRATE em produção em vários produtos do Facebook e Instagram. Pra time que já tem cultura de ML e quer estabilidade em produção, é a escolha mais segura.</p><h3>Resumindo os três</h3><h4>CUPED</h4><p>Subtrai theta * (X - mean(X)) de Y, com X sendo uma única métrica pré-experimento. Use quando você tem uma covariável dominante ou tá começando. Baixo risco, é provado como sem viés.</p><h4>CUPAC</h4><p>Treina um modelo de ML cross-fitted pra prever Y a partir de várias features pré-experimento, e usa a predição como X. Use quando você tem várias features com sinal complementar. Risco real, pode piorar variância se o modelo for ruim.</p><h4>MLRATE</h4><p>Mesma ideia do CUPAC mas via regressão com termo de interação T*g(X). Use quando quer robustez ao treino do modelo. Mais complexo, marginalmente menos eficiente quando ML é bom.</p><p>Os três compartilham a mesma premissa central, comportamento pré-experimento prevê comportamento durante. Quando essa premissa vale, qualquer um dos três entrega valor (CUPED 80% do caminho, CUPAC e MLRATE os 20% restantes). Quando a premissa não vale, nenhum dos três entrega.</p><h3>Onde as coisas dão aquela complicada</h3><h4>1. Métrica esporádica, rho baixo</h4><p>Primeiro problema é estrutural, não tem solução técnica. Se sua métrica é esporádica, comportamento bursty (comportamento que ocorre do nada em volume grande), eventos raros, atividade descontínua, o rho entre pré e durante vai ser perto de zero. E redução = rho² significa que CUPED entrega 1% se rho for 0.1.</p><p>Métricas habituais (rho alto, CUPED rende bem):</p><ul><li>Queries por usuário em busca (Bing, Google), rho típico 0.6–0.8</li><li>Sessões diárias em rede social, rho típico 0.6–0.7</li><li>Gastos recorrentes em e-commerce com base frequente, rho típico 0.5–0.7</li><li>Volume de mensagens em aplicação de chat, rho típico 0.6–0.8</li><li>Logins por semana em SaaS, rho típico 0.6–0.7</li></ul><p>Métricas esporádicas (rho baixo, CUPED não salva):</p><ul><li>Avaliações de filme/série, rho típico 0.05–0.15</li><li>Primeira compra em e-commerce, rho próximo de zero (não tem pré)</li><li>Compras de bens duráveis (carro, imóvel), rho próximo de zero</li><li>Conversão em produto premium com taxa &lt;1%, rho baixo por raridade</li><li>Reviews espontâneos, rho 0.1–0.2</li></ul><p>Por que essa diferença? Comportamento habitual carrega de um período pra outro. Quem pesquisa muito em maio pesquisa muito em junho, porque pesquisar virou hábito. Comportamento esporádico não carrega, quem avaliou muitos filmes em maio (assistiu uma série de filmes no feriado por ex) pode não avaliar nenhum em junho (sem catálogo legal, sem tempo, sem interesse).</p><p>A Microsoft viu 50% no Bing porque escolheu uma métrica certa pra técnica. Se sua métrica chave é esporádica, CUPED não é o seu problema mais urgente, é a métrica.</p><h4>2. Outliers, mesmo com rho cooperando</h4><p>Independente da técnica e do dataset, se sua distribuição tem caudas pesadas (baleias, fraudes, eventos isolados), CUPED não resolve sozinho. Um único usuário com Y elevado em 100x ou 1000x pode:</p><ul><li>Saturar theta em valores extremos (perto de 1.0 ou de zero)</li><li>Distorcer a média da diferença entre grupos</li><li>Inflar o intervalo de confiança a ponto de inutilizar o teste</li></ul><p>Um dos casos clássicos cobri no <a href="https://medium.com/@francocontigo/teste-a-b-frequentista-bayesiano-e-sequential-e-como-netflix-microsoft-e-outras-grandes-decidem-dd2d8b49e96f">artigo anterior</a>, bibliotecas comprando livros em lote na Amazon, inflando o ticket médio. Microsoft, Booking, todas empresas grandes aplicam winsorização (clip no percentil 99) antes de qualquer análise.</p><p>A regra prática é, winsorização vem antes do CUPED, sempre. Sem isso, mesmo CUPED clássico em métrica habitual pode quebrar com 0.01% de usuários extremos no dataset.</p><h4>3. Novos usuários sem histórico</h4><p>Se um usuário se cadastrou ontem e seu experimento começou hoje, ele tem zero dias de pré-experimento. X = 0 ou X = NaN. Três abordagens, em ordem de qualidade:</p><ul><li>Imputar zero e deixar CUPED rodar. Funciona mas dilui o ganho, porque pra esses usuários o ajuste é nulo.</li><li>Separar análise em dois segmentos (novos vs recorrentes) e aplicar CUPED só nos recorrentes. Reporta os dois separadamente.</li><li>Usar features alternativas (canal de aquisição, geo, device, demografia) como proxies via CUPAC. Funciona quando você tem dados de cadastro ricos.</li></ul><p>Quando o produto cresce em alta velocidade (startup early-stage, expansão geográfica, viralização), fração de novos usuários pode ser grande (50%+), e CUPED clássico perde poder. Aí CUPAC com features de cadastro vira o caminho.</p><h4>4. Não-estacionariedade entre pré e durante</h4><p>Se o pré-experimento foi dezembro (black friday) e o experimento é janeiro (ressaca), a relação X→Y muda. Quem comprou muito em dezembro não necessariamente compra em janeiro, porque o contexto é diferente. O theta estimado em dezembro não é válido em janeiro.</p><p>Isso aparece em qualquer produto com sazonalidade forte, e-commerce (datas comerciais), turismo (alta/baixa temporada), educação (calendário acadêmico), fitness (janeiro × março), entrega de comida (jogos de futebol, eleições), ações da bolsa (eventos políticos).</p><p>Regras práticas:</p><ul><li>Iguale a janela ao período do experimento. Se o experimento dura 14 dias, use 14 a 28 dias antes, não 90.</li><li>Evite cruzar mudanças sazonais conhecidas. Não use dezembro como pré pra janeiro.</li><li>Reestimar theta periodicamente se você está aplicando CUPED de forma contínua.</li><li>Validar em cenários de testes qual janela maximiza rho na sua métrica.</li></ul><p>Booking e outras plataformas com sazonalidade forte às vezes recomendam outras técnicas (horizonte fixo, sequential testing) em vez de CUPED nesses cenários.</p><h4>5. Métricas razão (CTR, conversion rate por sessão)</h4><p>CUPED clássico assume métricas média (média de Y por usuário, ex: spending per user). Métricas razão (clicks/impressions, transactions/visits, conversions/sessions) têm covariância adicional entre numerador e denominador que CUPED simples não trata corretamente.</p><p>O resultado é que CUPED pode ficar tecnicamente correto mas subutilizado nessas métricas, ou pior, dar estimativas incorretas. Existem variantes específicas, CUPED para métricas razão, que aparecem no <a href="https://arxiv.org/abs/2312.02935">paper de Deng et al. 2023</a> e em implementações de Statsig, Eppo, Microsoft.</p><p>Se sua métrica chave é razão (e em A/B na web, conversão e CTR são razão), vale usar a variante correta. Senão você está usando a ferramenta certa no problema errado.</p><h4>6. Trigger asymmetry</h4><p>Em feature flags onde a feature só renderiza no grupo de tratamento (ex: “novo botão aparece só pra quem está em tratamento”), o evento de exposição só dispara em T=1. Os “triggered” no controle tecnicamente não existem, e isso quebra a comparação simétrica que CUPED assume.</p><p>Alex Deng publicou <a href="https://arxiv.org/abs/2112.13299">paper específico sobre isso em 2021</a>, “Variance Reduction for Experiments with One-Sided Triggering using CUPED”. A ideia é usar dados pré-experimento pra estimar quem teria sido triggered no controle se a feature existisse, e aplicar CUPED só nesse subconjunto.</p><p>Esse é um pitfall específico de A/B na web/mobile com features condicionalmente renderizadas. Se você roda testes só com features que aparecem nos dois grupos (mudou texto de botão, mudou ranking de busca), você não tem esse problema.</p><h3>Como pensar sobre implementar</h3><blockquote>Guia amplo, em ordem de prioridade. A ideia é organizar as decisões antes de ir pro técnico.</blockquote><p><strong>1. Antes de qualquer outra coisa, meça rho.</strong> Pega 30 dias de dados históricos como X, os próximos 14 dias como Y, na sua métrica chave, e tira a correlação. Faz isso pra cada métrica que você considera importante. Algumas vão dar 0.7 (boa notícia), outras 0.1 (sinal pra reconsiderar essa métrica como OEC).</p><p>Se rho &gt; 0.5 na sua métrica chave, segue. Se rho &lt; 0.3, três caminhos:</p><ul><li>Aplica mesmo assim, ganha pouco mas não perde nada</li><li>Considera trocar a métrica chave (surrogate metric mais densa)</li><li>Aceita que essa métrica vai exigir N grande sempre</li></ul><p><strong>2. Garanta os fundamentos antes de mexer em redução de variancia.</strong> Variance reduction sem essas bases é decorar a fachada de uma casa sem fundação. Cobri todos no artigo anterior, mas em resumo:</p><ul><li>SRM (Sample Ratio Mismatch) monitorado</li><li>OEC (Overall Evaluation Criterion) declarada antes de cada teste</li><li>Guardrails (métricas que não podem regredir)</li><li>A/A periódico pra validar hash de bucketing</li><li>Multiple testing controlado (Bonferroni, FDR, ou sequential adequado)</li></ul><p>Sem isso, CUPED só vai dar resultado bonito em cima de inferência ruim.</p><p><strong>3. Sempre winsorize antes.</strong> Percentil 99 no Y como mínimo, percentil 95 se sua métrica é particularmente pesada de cauda. Isso vale com ou sem CUPED, sempre. Custa zero de implementação.</p><p><strong>4. Comece com CUPED clássico.</strong> É 7 linhas de código, baixo risco. A covariável é a mesma métrica que você está medindo, mas no período pré-experimento. Não tente sofisticar antes de ver isso funcionando. CUPED simples captura 80% do ganho potencial.</p><p>Pontos operacionais:</p><ul><li>Estimar theta no pool, não por grupo</li><li>Reestimar a cada experimento, não guardar um theta universal</li><li>Persistir o theta junto com o resultado pra auditoria futura</li><li>Reportar redução de variância explícita no resultado de cada teste, times aprendem a esperar ganhos quando rho é alto</li></ul><p><strong>5. Suba pra CUPAC quando o ganho marginal justificar.</strong> Os critérios pra subir:</p><ul><li>Você tem várias features pré-experimento com sinal complementar (não só a métrica em si)</li><li>O time tem maturidade em ML (saber treinar GBM, validar, manter e cuidar de concep drift)</li><li>Você já está vendo o teto do CUPED clássico (testou, ganhou 20%, quer mais)</li></ul><p>Cuidado com vazamento, use cross-fitting com K=5 folds, sempre. Treinar no pool inteiro sem split parece simples mas vaza o efeito do tratamento. Treinar só no controle perde sample size de treino. Cross-fit resolve os dois.</p><p><strong>6. Considere MLRATE se ML é instável em produção.</strong> Se você tem volatilidade no comportamento do modelo (drift entre treinos, diferenças entre abordagens e resultados entre cientistas, mudanças de feature), MLRATE é mais defensivo. A robustez compensa a complexidade extra.</p><p><strong>7. Variantes especializadas quando o caso pede.</strong> Métrica razão use a variante. One-sided trigger use o paper do Deng 2021. Métrica de cauda pesada considere CUPED em log(Y) em vez de Y direto.</p><p><strong>8. A/A periódico depois de implementar.</strong> Roda A/A com CUPED, com winsorização, com tudo, e confirma que a taxa de falso positivo é ~5%. Se ficar 7%, você tem viés escondido. Se ficar 3%, você tá sendo conservador demais. CUPED é matematicamente sem viés, mas a sua implementação pode não ser.</p><p><strong>9. Decida o ciclo de manutenção.</strong> Quem cuida da curadoria de features pra CUPAC? Quando reestimar theta? Como auditar resultados antigos se mudar a metodologia? Plataformas comerciais escondem isso, plataformas caseiras têm que decidir. Sem ciclo, a coisa vai pro caralho em 6 meses.</p><h3>Quem usa o quê</h3><p><strong>Microsoft (Bing)</strong>, paper original em 2013, CUPED em todos os experimentos automaticamente, redução típica 30–50% nas métricas-chave.</p><p><strong>Netflix</strong>, <a href="https://www.netflixtechblog.com/improving-experimentation-efficiency-at-netflix-with-meta-analysis-and-optimal-stopping-7019116b27d1">paper de Xie e Aurisset em 2016</a>, CUPED com redução de variancia estratificada por região e device, adaptado pro contexto de streaming e métricas de longo prazo.</p><p><strong>DoorDash</strong>, CUPAC publicado em 2020. Roda em todos os experimentos do sistema de dispatch. Redução adicional de ~10% sobre CUPED simples. Dash-AB (plataforma deles) reporta 10–20% de redução de sample size com CUPED + CUPAC empilhados.</p><p><strong>Etsy</strong>, <a href="https://www.etsy.com/codeascraft/increasing-experimentation-accuracy-and-speed-by-using-control-variates/">publicou em 2021</a> sobre CUPED, em 2025 sobre <a href="https://www.etsy.com/codeascraft/reducing-experiment-duration-with-predicted-control-variates">CUPAC</a>. CUPED simples deu 7% médio (com cauda longa, alguns experimentos até 30%) e CUPAC encurtou ~3 dias adicionais na duração média.</p><p><strong>Meta</strong>, MLRATE publicado em 2021, padrão interno em produtos com cultura de ML.</p><p><strong>Booking</strong>, redução de variância combinada com sequential testing, 25.000 testes por ano com plataforma que aplica CUPED automaticamente.</p><p><strong>Statsig, Eppo, VWO, Kameleoon, Amplitude</strong>, todas implementam CUPED por baixo nos resultados topo de linha. Statsig é particularmente explícita sobre isso na <a href="https://docs.statsig.com/stats-engine/variance_reduction">documentação deles</a>.</p><p>A lição prática, se você está rodando A/B em SQL caseiro, implementar CUPED com sete linhas de Python te coloca no nível dos gigantes em sensibilidade, se sua métrica cooperar.</p><blockquote>O ROI hoje depende muito mais da estrutura da sua métrica do que da elegância do código.</blockquote><h3>Conclusão</h3><p>CUPED, CUPAC e MLRATE compõem hoje o pacote silencioso de redução de variância que tá rodando por baixo de praticamente toda plataforma moderna de A/B. As três compartilham a mesma premissa, comportamento pré-experimento prevê comportamento durante, e divergem na sofisticação com que tentam capturar essa relação:</p><ul><li>CUPED (2013), uma covariável, álgebra linear, 80% do ganho potencial com 20% do esforço.</li><li>CUPAC (2020), ML cross-fitted multivariado, captura não-linearidades, 10% a mais de ganho quando há sinal nas features.</li><li>MLRATE (2021), regressão com interação, robusta a erro do modelo, mais defensiva em produção.</li></ul><p>O denominador comum é o rho, a correlação entre pré e durante. rho é o seu teto, e ele depende da métrica, não da técnica. Microsoft viu 50% de redução no Bing porque queries por usuário são habituais (rho 0.6-0.8). Se sua métrica é esporádica (avaliações, primeiras compras, eventos raros), nem CUPED, nem CUPAC, nem MLRATE vão te salvar. A escolha da métrica importa mais que a técnica que você aplica em cima dela.</p><p>Recomendações da minha cabeça:</p><ol><li>Meça rho na sua métrica chave em dados históricos. Hoje, antes de ler o resto.</li><li>Se rho &gt; 0.5, implementa CUPED clássico (sete linhas, gratuito, comprovado).</li><li>Sobe pra CUPAC com cross-fit quando o ganho marginal das features extras justificar a complexidade.</li><li>MLRATE quando você quer dormir tranquilo com o modelo de ML em produção.</li><li>Winsoriza no P99 sempre, com ou sem CUPED.</li></ol><p>E o que não funciona é pular o passo 1. Pular o “meça rho” é a forma mais comum de implementar CUPED achando que vai ter o ganho da Microsoft e ficar com 2%. Sete linhas de pandas resolvem essa medição.</p><p>CUPED não é mágica, é álgebra. E álgebra honesta sempre te entrega exatamente o que você colocou. Se a sua métrica não traz rho, a álgebra não inventa.</p><h3>Referências</h3><ul><li>Deng, A., Xu, Y., Kohavi, R., Walker, T. (2013). “Improving the Sensitivity of Online Controlled Experiments by Utilizing Pre-Experiment Data”. <em>WSDM 2013</em>. <a href="https://www.exp-platform.com/Documents/2013-02-CUPED-ImprovingSensitivityOfControlledExperiments.pdf">PDF</a></li><li>Xie, H., Aurisset, J. (2016). “Improving the Sensitivity of Online Controlled Experiments: Case Studies at Netflix”. <em>KDD 2016</em>.</li><li>Li, J., Tang, Y., Bauman, J. (2020). “Improving Experimental Power through Control Using Predictions as Covariate (CUPAC)”. DoorDash Engineering Blog.</li><li>Guo, Y. et al. (2021). “Machine Learning for Variance Reduction in Online Experiments (MLRATE)”. <em>NeurIPS 2021</em>. <a href="https://arxiv.org/abs/2106.07263">arXiv:2106.07263</a></li><li>Deng, A., Yuan, L.-H., Salama-Manteau, A. (2021). “Variance Reduction for Experiments with One-Sided Triggering using CUPED”. <a href="https://arxiv.org/abs/2112.13299">arXiv:2112.13299</a></li><li>Deng, A. et al. (2023). “From Augmentation to Decomposition: A New Look at CUPED in 2023”. <a href="https://arxiv.org/abs/2312.02935">arXiv:2312.02935</a></li><li>Lin, Z., Crespo, P. (2024). “Variance reduction combining pre-experiment and in-experiment data”. <em>Etsy/Berkeley</em>. <a href="https://arxiv.org/abs/2410.09027">arXiv:2410.09027</a></li><li>Kohavi, R., Tang, D., Xu, Y. (2020). <em>Trustworthy Online Controlled Experiments: A Practical Guide to A/B Testing</em>. Cambridge University Press.</li><li>Statsig Documentation. <a href="https://docs.statsig.com/stats-engine/variance_reduction">“Variance Reduction”</a>.</li><li>Etsy Code as Craft. <a href="https://www.etsy.com/codeascraft/reducing-experiment-duration-with-predicted-control-variates">“Reducing experiment duration with predicted control variates”</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b185d4c2297" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Teste A/B: Frequentista, Bayesiano e Sequential, e como Netflix, Microsoft e outras grandes decidem]]></title>
            <link>https://medium.com/@francocontigo/teste-a-b-frequentista-bayesiano-e-sequential-e-como-netflix-microsoft-e-outras-grandes-decidem-dd2d8b49e96f?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd2d8b49e96f</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[statistics]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 01:09:55 GMT</pubDate>
            <atom:updated>2026-04-29T02:13:07.238Z</atom:updated>
            <content:encoded><![CDATA[<h3>Teste A/B: Frequentista, Bayesiano e Sequential, três paradigmas, três trade-offs, e como Microsoft, Netflix e outras decidem</h3><h3>Um panorama de como funciona cada abordagem, onde cada uma trava, e o que separa um teste em que dá pra confiar de um teste que parece ótimo até deixar de parecer.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*IYF8PrLXXYx08DGIE2J31A.png" /><figcaption>Bora entender tudo que da de A/B no menor tempo possível</figcaption></figure><p>Em 2012, um engenheiro do Bing teve uma ideia, mover o texto secundário do anúncio pra linha do título e deixar o título mais longo. A ideia ficou na fila do produto por seis meses, despriorizada, até alguém implementar em três dias e rodar um teste A/B só pra tirar a curiosidade. Em poucas horas o sistema disparou um alerta de “bom demais pra ser verdade” porque a receita estava 12% acima do controle. Não era bug. A mudança virou a melhor ideia geradora de receita da história do Bing, mais de US$ 100 milhões por ano só nos EUA, conforme reportado por Kohavi e Thomke na <em>Harvard Business Review</em>.</p><p>Esse é o lado bom. O lado feio é que <strong>na própria Microsoft, ao longo de mais de uma década rodando testes em escala, cerca de um terço das ideias melhoram a métrica-chave, um terço fica neutro, e um terço piora</strong>. No Bing especificamente, a taxa de sucesso é ainda menor. Booking roda 25.000 testes A/B por ano. Se as estatísticas fossem mal calibradas, eles estariam tomando milhares de decisões erradas com confiança alta.</p><p>A escolha entre Frequentista, Bayesiano e Sequential não é discussão acadêmica. É a diferença entre confiar nesse 1/3 que de fato funciona ou se iludir com falsos positivos no resto do ano.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/1*lEqxKdleRfFe1EU8zAVqmQ.png" /><figcaption>Quando você repara que gastou todo seu tempo em algo que não funciona</figcaption></figure><h3>Frequentista, o padrão e suas pegadinhas</h3><p>O Frequentista é o que praticamente toda calculadora online de A/B usa por baixo. A lógica vem do Neyman-Pearson framework dos anos 30, você define uma hipótese nula H₀ (as variantes são iguais), uma alternativa H₁ (são diferentes), calcula a estatística do teste, e a partir daí o p-value, <strong>a probabilidade de observar o resultado que você observou (ou mais extremo) se H₀ fosse verdadeira</strong>.</p><p>Se p &lt; 0,05, rejeita H₀. Se p ≥ 0,05, falha em rejeitar. Não é “aceita H₀”, é “não consegui derrubar”. Sutil, mas importante.</p><p>O sample size você calcula antes, em função de quatro coisas, <strong>a variância da métrica, o lift mínimo que você quer detectar (MDE), o nível de significância (α, tipicamente 0,05) e o power (1-β, tipicamente 0,8)</strong>. Roda até o N planejado, olha o resultado, decide.</p><p>Funciona. Tem décadas de uso, fundamentação teórica sólida, e qualquer revisor de paper e produto aceita. O problema é que quase ninguém respeita o protocolo na prática.</p><h4>Pegadinha 1, peeking</h4><p>A regra é não olhar antes do N planejado. Olhar antes corrompe o p-value de uma forma específica, <strong>quanto mais frequentemente você olha, mais alto fica o falso positivo acumulado</strong>. A Optimizely simulou isso explicitamente. Em teste A/A (mesma variante contra ela mesma, então o resultado correto é zero efeito) com 5.000 visitantes:</p><ul><li>olhando após cada visitante, em 57% dos testes apareceria um “vencedor” estatisticamente significante;</li><li>olhando a cada 500 visitantes, em 26%;</li><li>olhando a cada 1.000 visitantes, em 20%.</li></ul><p>Lendo de novo, mais da metade dos testes A/A com peeking aleatório declararia um vencedor que não existe. Em um teste de 1 milhão de visitantes com peeking, esse número passa de 70%.</p><p>Por que isso acontece? Porque o p-value não é um valor estável que converge pra “o” valor verdadeiro. Ele oscila. Em um A/A, se você plota o p-value ao longo do tempo, ele cruza 0,05 várias vezes mesmo quando o efeito real é zero. Você só precisa esperar pra cruzar de novo, e parar nesse ponto, pra “encontrar” significância.</p><h4>Armadilha 2, multiple testing</h4><p>Você roda um teste com 1 variante e 1 métrica, taxa de erro 5%. Roda com 4 variantes e 5 métricas, são 20 comparações independentes. A probabilidade de pelo menos um falso positivo sobe pra cerca de 64% (1–0,9⁵²⁰).</p><p>A correção mais simples é Bonferroni, dividir α pelo número de testes. Conservadora demais quando há correlação entre métricas. Alternativas modernas usam Benjamini-Hochberg pra controlar FDR (False Discovery Rate) em vez de FWER (Family-Wise Error Rate). A Optimizely controla FDR diretamente no Stats Engine.</p><h4>Armadilha 3, low power</h4><p>Power é a probabilidade do seu teste detectar um efeito real. Roda um teste com 1.000 visitantes pra detectar lift de 0,5%, seu power é tipo 15%. Mesmo que a variante seja melhor, em 85% dos casos seu teste não consegue ver. Não é “deu empate”, é que <strong>o teste é cego para o efeito que você quer medir</strong>.</p><p>E aqui mora o problema composto, <strong>testes com baixo poder não só falham em detectar efeitos verdadeiros, eles também magnificam efeitos quando são significativos</strong>. O fenômeno é conhecido como winner’s curse. Se um teste underpowered dá p &lt; 0,05, o effect size estimado tende a ser muito maior que o real, porque só os ruídos grandes conseguem cruzar a barreira de significância. Resultado, você lança, mede em produção depois, e o efeito sumiu.</p><h4>Armadilha 4, p-hacking</h4><p>Variação refinada das três anteriores. Você roda o teste, não deu significância no agregado. Corta por mobile, não deu. Corta por novos vs recorrentes, deu! Publica.</p><p>Esse “deu” é puramente artefato de quantos cortes você tentou. Se você faz 20 cortes em um A/A, a probabilidade de pelo menos um dar p &lt; 0,05 por puro acaso é alta. Kohavi, Tang e Xu chamam isso, no livro <em>Trustworthy Online Controlled Experiments</em>, de uma manifestação de <strong>Twyman’s Law</strong>: qualquer número que pareça interessante ou diferente provavelmente está errado. Resultado positivo aparente em segmento específico merece checagem dobrada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/761/1*EMzeGKtBMayfudSTFwIFaQ.png" /><figcaption>Quando você acredita em todo resultado só por ter números nele</figcaption></figure><h4>Frequentista funciona, com metodologia</h4><p>Calculou sample size antes. Travou as métricas antes. Não olhou no meio. Não correu múltiplos cortes em busca de história. Aí é robusto, transparente e barato.</p><p>A questão é que ambientes de produto têm pressão pra “ver como tá indo”, múltiplos stakeholders olhando a mesma dashboard, e a tentação humana óbvia de declarar vitória cedo. <strong>A metodologia é sólida, o ambiente é hostil pra ela</strong>.</p><h3>Bayesiano, a alternativa que parece intuitiva (e o que esconde)</h3><p>O Bayesiano inverte a pergunta. Em vez de “qual a probabilidade de eu ver isso se H₀ for verdade?”, ele responde direto, <strong>“qual a probabilidade de B ser melhor que A?”</strong>.</p><p>A mecânica usa o teorema de Bayes. Você começa com um <em>prior</em> (uma crença inicial sobre a distribuição da métrica), observa os dados, e calcula o <em>posterior</em>, a distribuição atualizada. Pra teste de conversão, o prior padrão é uma distribuição Beta, que é o conjugado natural da distribuição Binomial dos dados, e isso significa que o posterior também é Beta e tem fórmula fechada. Sem MCMC, sem amostragem cara, é conta direta.</p><p>Os outputs do Bayesiano são qualitativamente diferentes do Frequentista:</p><ul><li><strong>Probabilidade de B bater A</strong>, derivada amostrando dos posteriores de A e B e contando a fração de vezes em que B &gt; A. Costuma rodar com 7 milhões de amostras nas plataformas grandes.</li><li><strong>Uplift esperado</strong>, com intervalo de credibilidade (não confiança, conceito Bayesiano) tipo “uplift está entre +1,2% e +4,8% com 95% de credibilidade”.</li><li><strong>Expected loss</strong>, quanto de lift você perde se decidir por A quando B era melhor. Métrica de gestão de risco.</li></ul><p>Soa muito mais alinhado com decisão de negócio que p-value puro. Foi por isso que a VWO construiu o SmartStats em cima de Bayes-Beta-Binomial e o Google Optimize (descontinuado em 2023) também usava Bayesiano.</p><h4>Onde o Bayesiano se sai bem</h4><p>Três pontos em que ele de fato é melhor que Frequentista clássico:</p><ol><li><strong>A pergunta que ele responde é a pergunta que você quer fazer.</strong> “Qual a probabilidade de B ser melhor que A?” é o que o stakeholder quer ouvir. Não é o que o p-value entrega. <strong>Permite incorporar conhecimento prévio formalmente.</strong> Se você já rodou 200 testes em landing pages e sabe que lifts típicos ficam entre -5% e +5% com média perto de zero, dá para colocar essa informação no prior em vez de assumir uniformidade. <strong>A interface de “expected loss + threshold of caring”</strong> força você a pensar em quanto risco de perda você topa. Para ser declarada vencedora no SmartStats da VWO, uma variante precisa ter expected loss abaixo de um threshold E chance de bater todos acima de 95%. Isso é mais robusto que só “p &lt; 0,05”.</li></ol><p><strong>Mas nem tudo que brilha no escuro é ouro.</strong></p><h4>Prior escondido</h4><p>Vendors comerciais frequentemente fixam priors ou funções de utilidade sem documentar, o que torna impossível para o usuário avaliar ou ajustar as premissas. Georgi Georgiev, do Analytics Toolkit, documentou múltiplos casos de plataformas que apresentam outputs Bayesianos sem expor os priors usados. Se o prior é Beta(1,1) (uniforme), os resultados começam em 50%/50% e demoram a se mover. Se é Beta(50, 950) (informativo, baseado em conversão histórica de 5%), os resultados começam concentrados perto de 5% e exigem muito mais dados para deslocar.</p><p>A consequência prática, <strong>dois Bayesianos com priors diferentes, vendo os mesmos dados, podem dar números diferentes</strong>. E se você nem sabe qual prior está rodando, não tem como avaliar se está conservador ou agressivo demais.</p><h4><strong>“Probability to be best” não significa o que parece</strong></h4><p>Lê isso devagar. Em uma plataforma Bayesiana padrão com prior não-informativo, a probabilidade de B ser o melhor começa em 50% (com 2 variantes) e na maioria dos A/A <strong>fica em torno de 50% mesmo com centenas de milhares de visitantes</strong>. Faz sentido, se A = B, a métrica oscila simétrica em torno de 50%.</p><p>Georgiev mostrou em 60 A/A reais rodados no Google Optimize que a “probability to be best” se distribuía em torno de 50% como esperado, mas em vários testes individuais cruzou os 95% por puro acaso e pelo tempo necessário para um operador não-treinado declarar vencedor.</p><p>O número “B tem 87% de probabilidade de ser o melhor” é frequentemente lido como “tenho 87% de certeza que vou ganhar receita lançando B”. Não é. É a probabilidade de B ter conversão maior que A, condicional ao prior usado, sem nenhuma garantia de quanto maior nem por quanto tempo. As duas coisas não são a mesma.</p><h4>Stopping rules ainda importam</h4><p>Esse é o erro mais comum no mercado. Muita gente migra para Bayesiano achando que pode olhar o teste a qualquer hora e parar quando bem entender porque “Bayesiano não sofre de peeking”. Não exatamente.</p><p>Sob suposições estritas e priors específicos, alguns Bayes factors são invariantes ao stopping rule. Mas na prática, A/B testing comercial usa priors padrão e hipóteses compostas, e nesse cenário a robustez teórica se quebra. O posterior pode ficar calibrado de forma ruim e levar a decisões enviesadas.</p><p>A explicação intuitiva é que stopping rule é parte do processo gerador dos dados. Se você decide parar quando “probability to be best &gt; 95%”, você está condicionando o experimento a parar nas trajetórias em que esse limiar é cruzado, o que enviesa a estimativa final para cima. Bayesianos sérios reforçam isso. <strong>Bayesiano sem stopping rule disciplinado tem o mesmo problema que Frequentista com peeking. A interface só esconde melhor</strong>.</p><h3>Sequential, monitorar continuamente sem queimar α</h3><p>Sequential é o que as pessoas normalmente querem no começo, <strong>olhar o teste continuamente sem corromper a inferência</strong>. A ideia é antiga, vem do Sequential Probability Ratio Test (SPRT) de Wald nos anos 1940, originalmente desenvolvido para controle de qualidade na 2ª Guerra. A aplicação moderna em A/B é mais recente.</p><p>Existem duas linhagens vivas, <strong>always-valid (mSPRT) e Group Sequential com alpha spending</strong>. Resolvem o mesmo problema por caminhos diferentes.</p><h4>Always-Valid e mSPRT</h4><p>A Optimizely usa o mixture sequential probability ratio test (mSPRT), descrito no paper de Johari, Pekelis, Walsh e Koomen como base do Stats Engine. A construção produz p-values “sempre válidos” no sentido formal de que P(p_T ≤ x) ≤ x para qualquer regra de parada T, ou seja, <strong>o usuário pode olhar quando quiser, parar quando quiser, e a inferência continua correta no sentido frequentista</strong>.</p><p>A intuição por trás é que o mSPRT mistura sobre uma família de hipóteses alternativas (o “m” de mixture) usando um prior τ. Isso resolve o problema do SPRT clássico, que exigia você fixar um effect size antes para calcular as fronteiras, o que ninguém faz na prática em produto.</p><p>Em simulações onde o Frequentista clássico ajustado para peeking diário declarava falso vencedor em 57% dos testes, o sequencial cai para 3%, conforme reportado pela Optimizely.</p><p>Tem custo. <strong>Sequential precisa de mais amostra para atingir poder equivalente quando o efeito é pequeno</strong>. Você ganha flexibilidade de parada em troca de eficiência estatística no pior caso. A magnitude depende do prior τ usado e do effect size verdadeiro.</p><h4>Group Sequential e Alpha Spending</h4><p>Alternativa mais antiga, vinda de ensaios clínicos. A ideia, em vez de olhar continuamente, você define <em>N olhadinhas </em>programadas (ex.: a cada 25% da amostra prevista) e usa uma função de alpha spending para dividir os 5% de erro entre eles.</p><p>O paper seminal é Lan e DeMets (1983), que generalizou trabalhos anteriores de Pocock (1977) e O’Brien e Fleming (1979). As duas funções clássicas:</p><ul><li><strong>Pocock</strong> gasta α igual em cada look. Se você tem 5 looks, ~1% por look (na verdade um pouco menos por correlação). Permite parar cedo facilmente, mas se chegar até o final, sobrou pouco α pro look final, então o teste fica menos sensível na conclusão.</li><li><strong>O’Brien-Fleming</strong> gasta quase nada nos primeiros looks, quase tudo no final. No primeiro look quase não há α disponível, então parar cedo só acontece com efeitos enormes. No último look, o critério é quase igual ao Frequentista padrão. Bom para times que querem rigor próximo do Frequentista no fechamento, com a opção de parar cedo só em caso de efeitos avassaladores.</li></ul><p>Existem variantes intermediárias (Wang-Tsiatis, alpha-spending linear) e a flexibilidade de usar funções customizadas, em que os timings dos looks não precisam ser fixados antes, basta a função de gasto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*jSFSHlV4M0aDbkcRsCfA1g.png" /><figcaption>Dá aquela relaxada antes das conclusões aí</figcaption></figure><h4>Quem usa o quê</h4><p>Booking, Microsoft e Netflix usam variações de sequential testing combinadas com alpha spending ou group sequential nas suas plataformas internas. Optimizely oferece always-valid como modo padrão. ABsmartly (fundada por engenheiros que construíram a plataforma da Booking) oferece Group Sequential como default e Frequentista de horizonte fixo como alternativa pra times que querem alta confiabilidade ou têm sazonalidade semanal forte.</p><p>Na prática, sequential virou o padrão de fato em programa de experimentação maduro. <strong>Calculadora online de A/B ainda é Frequentista clássico ou Bayesiano simples na maioria dos casos</strong>.</p><h3>Resumo das três abordagens</h3><p>O Frequentista responde “quão improvável é esse resultado se as variantes fossem iguais”, exige sample size pré-calculado, é sensível a peeking, e funciona se o operador respeitar o protocolo. Curva de aprendizado baixa, pegadinhas potencialmente altas.</p><p>O Bayesiano responde “qual a probabilidade de B ser melhor”, aceita conhecimento prévio formalmente, expressa incerteza em distribuições, e tem outputs alinhados com decisão de negócio. Mas depende de priors que muitas vezes são opacos, e na prática ainda é sensível a stopping rules mal pensados.</p><p>O Sequential responde “essa diferença é robusta a continuar olhando”, permite parada flexível por design, é o que empresas que rodam dezenas de milhares de testes por ano usam, e cobra uma sobrecarga de amostra em troca da flexibilidade.</p><p>Não tem paradigma certo. Tem paradigma adequado pro contexto. Time pequeno com calculadora online provavelmente está rodando Frequentista mal-disciplinado e ganharia migrando pra plataforma Bayesiana com expected loss + threshold. Plataforma com time de ciência de dados no produto e volume relevante quase certamente quer sequential.</p><h3>Variance reduction, um atalho pra todos</h3><p>Independente do paradigma, existe uma técnica que reduz o sample size necessário sem mudar a metodologia, <strong>variance reduction</strong>. A mais popular é CUPED (Controlled-experiment Using Pre-Experiment Data), introduzida por Deng, Xu, Kohavi e Walker em paper de 2013 da Microsoft.</p><p>A intuição é simples. A maior parte da variabilidade da métrica de um usuário no experimento vem da variabilidade do próprio usuário antes do experimento. Usuários heavy estavam heavy antes. Usuários churn estavam churn antes. Se você usa o comportamento pré-experimento como covariável e ajusta a métrica do experimento pelo que era esperado dado o histórico, <strong>a variância residual cai drasticamente</strong>.</p><p>No paper original, em um experimento do Bing, usar queries-por-usuário do período pré-experimento como covariável reduziu a variância em mais de 45%. Combinada com outras covariáveis, chegou perto de 50%. <strong>Variância 50% menor significa intervalo de confiança mais estreito pelo mesmo N, o que significa metade do tempo pra detectar o mesmo efeito</strong>.</p><p>A Microsoft conseguiu, com CUPED, transformar testes que levavam 8 semanas em testes de 5 a 6 semanas. Para uma empresa que roda dezenas de milhares de testes por ano, isso é dobrar a velocidade de iteração.</p><p>CUPED virou padrão. Statsig, Eppo, Amplitude, LaunchDarkly e Kameleoon implementam variantes. A Netflix publicou um paper em 2016 (Xie e Aurisset) com adaptações pro contexto deles. Meta tem variantes com machine learning (Guo et al., 2021). A versão moderna do CUPED, em paper de 2023 do próprio Deng, generaliza pra métricas razão e percentil, e pra uso de dados no experimento, não só pré-experimento.</p><p>Se você está em uma plataforma comercial moderna, provavelmente CUPED já está rodando por baixo. Se está rodando A/B em SQL caseiro, vale ler o paper original e aplicar.</p><h3>Validação de amostragem</h3><p>Antes de analisar resultado, valide o setup. Essa etapa é normalmente esquecida em ambientes imaturos e automatizada nos maduros. Sem ela, qualquer das três metodologias acima entrega número errado com confiança alta.</p><h4>A/A, o teste do teste</h4><p>A/A é o exato A/B, mas com a mesma variante nos dois lados. O efeito real é zero. Se o resultado dá “vencedor”, o problema não é a variante, é a infraestrutura.</p><p>Optimizely usou A/A simulado pra calibrar o Stats Engine, é o experimento de referência pra mostrar o problema do peeking. Microsoft, Booking e Netflix rodam A/A periodicamente em produção, contra tráfego real. O propósito é detectar bugs sutis na plataforma que só aparecem com volume, hash de bucketing enviesado, exposure logging que dispara em momento diferente entre variantes, exclusão de bots aplicada em janelas diferentes, cache invalidation assimétrica.</p><p>Se um A/A em produção declara vencedor com p &lt; 0,05 em mais de ~5% das execuções, algo está quebrado. A taxa esperada de falso positivo precisa bater exatamente com α. Não bate, tem viés sistemático.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*FKbvKQYwPKOixLKiY-ohvQ.png" /><figcaption>No final tudo é sobre como abordar as coisas</figcaption></figure><h4>Sample Ratio Mismatch (SRM)</h4><p>Você desenhou o teste 50/50, e nos logs o controle ficou com 50,2% e o tratamento com 49,8%, o que parece irrelevante à primeira vista, mas com volume alto o teste de qui-quadrado pode apontar algo como 1 em 500.000 de essa diferença acontecer por puro acaso, ou seja, pequeno no percentual, mas grande na evidência.</p><p>SRM com p-value tão baixo é evidência forte de bug ou viés. As causas comuns:</p><ul><li><strong>Bug de logging</strong> que dispara mais vezes em uma variante por acontecimento.</li><li><strong>Redirect que falha mais em uma variante</strong>, perdendo usuários antes de serem contados.</li><li><strong>Logging diferente</strong> entre as duas variantes, capturando populações ligeiramente distintas.</li></ul><p>O caso de SRM da Microsoft, documentado por Kohavi, ilustra sutileza. Em um experimento, o engajamento aumentou tanto na variante de tratamento que os heavy users acabaram acima do threshold de classificação de bots e foram removidos da análise, distorcendo a divisão. Quando o threshold de bot foi ajustado, o SRM sumiu, e o tratamento revelou ser ainda melhor que a leitura inicial. <strong>SRM não é só erro técnico, é também sintoma de que algo está acontecendo de verdade e precisa ser entendido</strong>.</p><p>Microsoft monitora SRM automaticamente em todo experimento. Se dispara, o resultado é considerado inválido até a causa raiz ser identificada. Não importa o quão bom esteja parecendo o lift principal. Booking faz checagem automatizada de SRM como parte do platform, com bloqueio de promoção de variantes em caso de mismatch.</p><h4>Balanceamento pré-experimento</h4><p>Antes do tratamento ser aplicado, os dois grupos deveriam ser estatisticamente indistinguíveis em qualquer métrica pré-experimento. Se não são, a randomização está enviesada ou a unidade de randomização tem viés temporal.</p><p>A checagem é simples, rodar o mesmo teste estatístico que você usaria pós-experimento (Frequentista, Bayesiano, qualquer um) sobre métricas do período anterior à exposição. Se aparece diferença estatisticamente significante em métricas pré-experimento, qualquer diferença pós-experimento fica confundida pela diferença pré-existente.</p><p>CUPED, mencionado na seção anterior, mitiga parcialmente esse problema ao ajustar pelo histórico, mas a checagem de balanceamento vale como sanity check independente do método de análise. Se o balanceamento falha sistematicamente, o problema está na randomização, não na análise.</p><h4>Qualidade do hash e bucketing</h4><p>A função que decide qual usuário cai em qual variante precisa ser uniforme. Implementações ingênuas como user_id % 2 parecem funcionar mas têm problemas, IDs sequenciais correlacionam com momento de cadastro, então dois grupos podem ter distribuições diferentes de usuários novos vs antigos. Em sistemas com IDs gerados por máquina (Snowflake, por exemplo), o módulo pode pegar o bit de machine_id e dividir por datacenter em vez de aleatoriamente.</p><p>Implementações robustas usam hash criptográfico do user_id concatenado com um salt do experimento, tipo SHA-256 de experiment_id:user_id. Isso garante três coisas, <strong>assignment determinístico</strong> (o mesmo usuário sempre cai na mesma variante daquele experimento), <strong>independência entre experimentos</strong> (assignment em um experimento não correlaciona com outro, então um usuário pode estar simultaneamente em 15 experimentos sem viés cruzado), e <strong>uniformidade</strong> (cada bucket recebe a fração esperada).</p><p>Validação periódica do hash inclui rodar a função em milhões de IDs e verificar uniformidade não só global mas em cortes, geo, idade do cadastro, plano, hora do dia. Não-uniformidade em algum corte sinaliza que cohorts específicas estão sub ou sobre-representadas em alguma variante.</p><h4>Trigger analysis e Intent-to-Treat</h4><p>Quando o tratamento só afeta um subconjunto dos usuários (exemplo feature visível só em uma página específica, ou só em mobile, ou só pra usuários com saldo acima de X), a análise tem dois caminhos:</p><ul><li><strong>Intent-to-Treat (ITT)</strong>, comparar todos os usuários atribuídos ao tratamento contra todos os atribuídos ao controle, independente de terem visto a feature. Mantém a randomização intacta mas dilui o efeito proporcional ao trigger rate. Se 10% dos usuários veem a feature, um lift real de 20% no triggered vira ~2% no ITT.</li><li><strong>Análise dos triggered</strong>, restringir a comparação aos usuários que de fato foram expostos. Mais sensível ao efeito real, mas pode quebrar a randomização se o trigger correlaciona com características do usuário.</li></ul><p>A regra prática é, <strong>se o trigger é simétrico</strong> (mesma definição em controle e tratamento, contado da mesma forma), a análise restrita aos triggered é válida. <strong>Se é assimétrico</strong> (tratamento triggera por critério diferente do controle, ou só registra trigger no tratamento), a análise vira ITT obrigatoriamente.</p><p>CUPED tem extensões específicas pra one-sided triggering, em que o trigger só é observado em uma das variantes. É um cenário comum em feature flags onde o evento de exposição só dispara quando a feature é renderizada, ou seja, só na variante de tratamento.</p><h3>Treta nos três</h3><p>Validação de amostragem cuida do setup. Mas mesmo com setup perfeito, existem fenômenos que destroem a inferência de qualquer paradigma. Esses são os problemas que sobrevivem a todas as checagens automatizadas e ainda assim quebram a leitura do teste.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*iDebtrDyNG1wuk1KUPTSog.png" /><figcaption>Agora que estamos aqui, vamos até o final</figcaption></figure><h4>Outliers e dados sujos</h4><p>Em um experimento da Amazon documentado por Kohavi, com 100.000 usuários, conversão de 2% e ticket médio de US$ 30 davam US$ 60.000 de receita total. Lift de 2% seria US$ 1.200. Ocasionalmente um “usuário” comprava ~US$ 2.500 numa única transação. Esse usuário sozinho jogado em controle ou tratamento podia inflar o resultado em mais que o efeito esperado pelo lift real.</p><p>A descoberta foi que bibliotecas compram livros em lotes irregulares, gerando essas compras gigantes. A solução, <strong>capar o valor de qualquer usuário individual no percentil 99 da distribuição</strong> (winsorização). Métricas robustas, percentis em vez de médias, ajudam.</p><h4>Bots</h4><p>Mais de 50% do tráfego do Bing é classificado como não-humano, segundo Kohavi. Em e-commerce e mídia o número também é alto. Sem filtragem de bots, <strong>você está testando se variante vermelha ou azul agrada mais o crawler do Google e robôs de scraping</strong>, o que provavelmente não é seu KPI.</p><p>Filtragem de bot tem que ser consistente entre controle e tratamento, senão você gera SRM artificialmente. E precisa ser reavaliada quando o teste muda comportamento de usuário, como no caso Microsoft acima.</p><h4>Novelty effect e long-term effect</h4><p>A variante “nova” causa estranhamento ou curiosidade nas primeiras semanas, e o efeito decai. Ou o oposto, dark pattern que dá lift de curto prazo e queima retenção em 3 meses.</p><p>Kohavi recomenda duas abordagens. Long-term experiments rodados com objetivo explícito de aprendizado, no Bing fazem isso aumentando e diminuindo o número de ads pra entender impacto em métricas-chave de longo prazo. E modelos preditivos com dados históricos pra estimar impacto futuro a partir de sinais de curto prazo. No caso da Amazon, o time de email descobriu que mandar mais email aumentava receita de curto prazo mas elevava unsubscribes, perdendo receita futura. Construíram um modelo pra prever essa perda e usar como contra-métrica.</p><p>Click-bait de anúncio é o exemplo arquetípico. CTR sobe no curto prazo, retenção e satisfação caem no longo. Sem métrica de longo prazo, o teste declara vitória e a empresa perde dinheiro em silêncio.</p><h4>Heterogeneous Treatment Effects (HTE)</h4><p>O efeito médio do teste é positivo. Mas talvez seja muito positivo em mobile e ligeiramente negativo em desktop, e o agregado mascara isso. HTE é a análise de como o efeito varia entre subpopulações.</p><p>O Netflix Tech Blog descreveu como o platform deles suporta análise automatizada de HTE como parte do reporting padrão. Microsoft, Google e LinkedIn fazem o mesmo. Sem HTE, <strong>decisão de lançamento global baseada em média pode prejudicar segmentos importantes</strong>.</p><p>O risco oposto também existe, p-hacking via segmentação. Se você corta por 30 segmentos procurando “onde funcionou”, a chance de encontrar significância por acaso é alta. Por isso bons platforms fixam segmentos de interesse antes do teste rodar.</p><h3>OEC, a métrica que decide</h3><p>Última peça da cadeia, <strong>Overall Evaluation Criterion (OEC)</strong>. É a métrica única (ou função das métricas) que vai decidir o teste antes do teste começar.</p><p>Sem OEC declarada, qualquer time encontra alguma métrica pra justificar a decisão que queria. Conversão subiu 1% mas tempo na página caiu 8%? Se OEC era conversão, lança. Se OEC era engagement composto, repensa. Se não havia OEC, vira política.</p><p>O scorecard típico de Bing tem mais de 2.000 métricas, segundo Kohavi. A maioria existe pra <strong>detectar consequências inesperadas, não pra decidir o teste</strong>. Algumas dessas métricas são guardrails, qualquer queda significativa nelas bloqueia o lançamento independentemente do que aconteceu com a OEC. Latência, taxa de erro, refund rate, accessibility, fraud, customer service contact rate.</p><p>Booking mantém guardrails explícitos como cancellation rate, payment failures, refund friction, e load times. Lift na conversão de 3% que vem com aumento de 1% no cancellation pode ser zero ganho líquido depois que o cliente cancela e a logística absorve o custo.</p><h3>Conclusão</h3><p>Frequentista, Bayesiano e Sequential resolvem o mesmo problema com prioridades diferentes. O Frequentista é robusto se o protocolo for respeitado, e a maior parte da prática viola o protocolo. O Bayesiano dá outputs mais legíveis pra negócio mas esconde decisões de modelagem (priors) que mudam o resultado, e ainda é vulnerável a stopping rules mal pensadas. O Sequential resolve o problema operacional do peeking e por isso virou o padrão em programas maduros, ao custo de overhead estatístico no pior caso.</p><p>O denominador comum dos três é Twyman’s Law, qualquer resultado aparente demais provavelmente está errado. Vale checar SRM, vale rodar A/A periodicamente, vale duplicar a análise de qualquer lift inesperadamente alto. Bing achou US$ 100M em uma mudança trivial, mas a maior parte do crescimento de Bing veio de incrementos de 0,1% a 0,2% por iteração, somando ~2% ao ano. Airbnb fez ~6% de uplift em receita acumulando 250 experimentos pequenos em search relevance.</p><p>Cultura de experimentação madura não é cultura de testes geniais. É cultura de <strong>muitos testes, com rigor, com guardrails automatizados, com platform que bloqueia decisão errada antes de ela acontecer, e com humildade pra aceitar que dois terços das ideias não vão funcionar mesmo que pareçam ótimas no whiteboard</strong>.</p><p>A escolha do paradigma estatístico é uma camada disso. Sozinha não resolve nada. Combinada com SRM monitorado, OEC declarada antes, guardrails travados, variance reduction aplicada onde dá, e disciplina de stopping rule, vira o sistema operacional de quem cresce por A/B.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*GiAS992e7pHJr6hN-4JKOQ.png" /></figure><h3>Referências</h3><ul><li>Kohavi, R., Tang, D., Xu, Y. (2020). <em>Trustworthy Online Controlled Experiments: A Practical Guide to A/B Testing</em>. Cambridge University Press. Site companion: <a href="https://experimentguide.com/">https://experimentguide.com</a></li><li>Johari, R., Pekelis, L., Walsh, D., Koomen, P. (2015). “Always Valid Inference: Bringing Sequential Analysis to A/B Testing”. arXiv:1512.04922. <a href="https://arxiv.org/abs/1512.04922">https://arxiv.org/abs/1512.04922</a></li><li>Stucchio, C. (2015). “Bayesian A/B Testing at VWO”. <a href="https://vwo.com/downloads/VWO_SmartStats_technical_whitepaper.pdf">https://vwo.com/downloads/VWO_SmartStats_technical_whitepaper.pdf</a></li><li>Deng, A., Xu, Y., Kohavi, R., Walker, T. (2013). “Improving the Sensitivity of Online Controlled Experiments by Utilizing Pre-Experiment Data”. <em>WSDM 2013</em>. <a href="https://www.exp-platform.com/Documents/2013-02-CUPED-ImprovingSensitivityOfControlledExperiments.pdf">https://www.exp-platform.com/Documents/2013-02-CUPED-ImprovingSensitivityOfControlledExperiments.pdf</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd2d8b49e96f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UUID v1, v4, v6, v7 e Snowflake no MySQL e um pouco mais]]></title>
            <link>https://medium.com/@francocontigo/uuid-v1-v4-v6-v7-e-snowflake-no-mysql-e-um-pouco-mais-75b10bf705f6?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/75b10bf705f6</guid>
            <category><![CDATA[programing]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[relational-databases]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 22:43:47 GMT</pubDate>
            <atom:updated>2026-04-14T23:32:10.826Z</atom:updated>
            <content:encoded><![CDATA[<p>No <a href="https://medium.com/@francocontigo/%C3%ADndices-no-mysql-o-trade-off-que-ningu%C3%A9m-te-conta-35076cc0c41c">artigo anterior</a>, mostrei o custo de cada índice extra nos seus INSERTs e como UUID muda essa conta. A conclusão foi que índices não são gratuitos, e UUID amplifica o problema.</p><p>Mas aquela análise comparava apenas INT vs UUID (v4). E no mundo real, “UUID” não é uma coisa só. Existem <strong>seis versões relevantes</strong>, cada uma com trade-offs diferentes. Além disso, existe o <strong>Snowflake ID</strong>, que nem UUID é e em muitos cenários é a melhor escolha.</p><p>Esse artigo nasceu de uma pergunta simples, “<strong>se UUID v7 é time-ordered ele se comporta como INT AUTO_INCREMENT no MySQL?”</strong>. A resposta curta, quase. A resposta longa é este artigo.</p><p>Fiz um benchmark com <strong>6 tipos de identificadores</strong>, <strong>4 cenários de índice</strong>, <strong>7 estratégias de INSERT</strong> e <strong>5 tipos de SELECT</strong>.</p><p>O resultado? UUID não é vilão. <strong>O vilão é usar UUID v4 como CHAR(36) sem pensar na estratégia de indexação junto.</strong></p><h3><strong>Entendendo cada tipo de identificador</strong></h3><p>Se você já sabe a diferença entre v1, v4, v6, v7 e Snowflake, pode pular para a B-Tree, como-o-mysql-armazena-tudo-isso-por-dentro. Se não, essa seção explica porque a escolha do tipo de ID é uma decisão de arquitetura que vai te acompanhar por anos.</p><h4><strong>INT AUTO_INCREMENT, o clássico que ainda funciona</strong></h4><p>O bom e velho inteiro sequencial. O MySQL gera, é sequencial por natureza, ocupa 4 bytes (INT) ou 8 bytes (BIGINT). Inserts sempre vão pro final da B-Tree. Zero page splits. É a <strong>referência de performance</strong> contra a qual tudo é medido.</p><p>O problema aparece quando seu sistema cresce. Se você tem 3 microsserviços gerando pedidos ao mesmo tempo, cada um falando com um banco diferente, quem coordena os IDs? Você precisa de algum mecanismo centralizado, um ticket server, ou ranges pré-alocados, ou alguma forma de lock distribuído. Isso adiciona complexidade e ponto único de falha.</p><p>Além disso, IDs sequenciais são <strong>previsíveis</strong>. Um atacante pode iterar `GET /api/users/1`, `/2`, `/3` e descobrir quantos usuários você tem, qual a taxa de crescimento e acessar registros que não deveria ver (se a autorização estiver fraca). Parece improvável? A OWASP lista “Insecure Direct Object References” como uma das vulnerabilidades mais comuns em APIs.</p><h4><strong>UUID v1 timestamp + MAC address (RFC 4122, 2005)</strong></h4><p>A primeira tentativa de resolver o problema do ID distribuído. O v1 combina um timestamp de alta precisão (100 nanossegundos, usando o calendário Gregoriano com epoch em 15 de outubro de 1582) com o <strong>MAC address</strong> da máquina geradora. Isso garante unicidade sem coordenação central, se cada máquina tem um MAC diferente e o clock não volta, os UUIDs nunca colidem.</p><blockquote>Mas tem dois problemas.</blockquote><p><strong>Privacidade</strong>, o MAC address da sua máquina fica embutido no UUID. A RFC 9562 é direta sobre isso, “<em>Exposed MAC addresses can be used as an attack surface to locate network interfaces and reveal various other information about such machines”</em>. E com VMs e containers, o MAC já nem garante unicidade de verdade.</p><p><strong>Performance no MySQL</strong>, aqui é onde fica interessante. Os bits do timestamp no v1 ficam <strong>embaralhados</strong>. A estrutura é <em>time_low </em>(32 bits) + <em>time_mid</em> (16 bits) + <em>time_hi_and_version</em> (16 bits). O <em>time_low</em> é a parte <strong>menos</strong> significativa do timestamp, e ele vem <strong>primeiro</strong>. Resultado, dois UUIDs v1 gerados em sequência podem ter os primeiros 32 bits completamente diferentes, porque a parte que mais muda (time_low) é a que lidera.</p><p>O MySQL tem o <em>UUID_TO_BIN</em>(uuid, 1) com swap flag que reordena os bytes do timestamp para ficarem na ordem certa. Mas é uma conversão manual, você precisa lembrar de aplicar em todo INSERT e todo SELECT. Esqueceu o swap flag numa query? <strong>Full scan</strong>.</p><h4><strong>UUID v4 — puro aleatório (RFC 4122, 2005)</strong></h4><p>122 bits de pura aleatoriedade. Nenhum timestamp, nenhum MAC, nenhuma informação sobre quando ou onde foi gerado. Máxima privacidade, e o mais simples de implementar, toda linguagem tem <em>uuid4</em>() nativo.</p><p>E máximo custo de performance. Cada INSERT cai numa <strong>posição aleatória</strong> da B-Tree. Para entender por que isso é tão ruim, vamos para o InnoDB e ver como ele gerencia páginas de dados.</p><p>O InnoDB organiza os dados em <strong>pages</strong> de 16KB. Quando a PK é sequencial, ele enche cada page até ~94% antes de criar a próxima, é o fill factor ótimo. Com UUID v4 aleatório, cada novo INSERT pode cair em qualquer page. Se a page destino já está cheia, o InnoDB faz um <strong>page split,</strong> divide a page em duas, cada uma com ~50% de ocupação. Em tabelas grandes, isso significa:</p><ul><li><strong>Dobro do espaço em disco, </strong>pages 50% cheias vs 94% cheias.</li><li><strong>Mais I/O por query, </strong>precisa ler mais pages para achar os mesmos dados.</li><li><strong>Buffer pool menos eficiente, </strong>mais pages = mais cache miss.</li></ul><p>A Percona documentou um caso, uma tabela com 1 bilhão de rows e UUID v4 como CHAR(36) ocupava <strong>quase 1 TB</strong>. Depois de reorganizar com chave ordenada, caiu para <strong>~450 GB</strong>. Metade. O fill factor das index pages era de ~50% com UUID aleatório vs ~90% com chave sequencial.</p><h4><strong>UUID v6 — o v1 arrumado (RFC 9562, 2024)</strong></h4><p>Em maio de 2024, a IETF publicou a <strong>RFC 9562</strong>, a primeira atualização da especificação de UUID em quase 20 anos. Uma das motivações explícitas foi o problema de performance em bancos de dados:</p><blockquote><em>“UUID versions that are not time ordered, such as UUIDv4, have poor database-index locality. This means that new values created in succession are not close to each other in the index.”</em></blockquote><p>O v6 é a solução mais conservadora, pega os mesmos dados do v1 (timestamp Gregoriano + node/MAC), mas <strong>reordena os bits do timestamp</strong> para que os mais significativos venham primeiro. Resultado, UUIDs v6 são naturalmente sortable sem precisar de swap flag.</p><p>A RFC é direta sobre quando usar, “<em>Systems that do not involve legacy UUIDv1 SHOULD use UUIDv7 instead”</em>. Ou seja, v6 existe como <strong>ponte de migração</strong> para quem já tem v1 em produção. Se está começando do zero, pule direto para o v7.</p><h4><strong>UUID v7, a recomendação moderna (RFC 9562, 2024)</strong></h4><p>48 bits de timestamp Unix (milissegundos) nos bits mais significativos + 74 bits de randomness. Sem MAC address, sem informação de hardware. <strong>Privado e sortable</strong>.</p><p>Os 48 bits de timestamp dão resolução de 1 milissegundo e cobrem até o <strong>ano 10.889</strong>. Se dois UUIDs v7 são gerados no mesmo milissegundo, a parte random (<em>rand_a</em> + <em>rand_b</em> = 74 bits) garante unicidade. Algumas implementações usam um <strong>counter monotônico</strong> nos bits de <em>rand_a</em> para garantir ordenação total mesmo dentro do mesmo milissegundo.</p><p>Na prática, o v7 se comporta quase como um AUTO_INCREMENT para o InnoDB, inserts sempre vão para o final da B-Tree, pages ficam com fill factor ótimo, zero page splits. A diferença é que ele garante unicidade global sem coordenação.</p><p>A adoção está acelerada. O <strong>PostgreSQL 18</strong> adicionou <em>uuidv7</em>() nativo. O <strong>Python 3.14</strong> adicionou <em>uuid.uuid7</em>() na stdlib. Java, Go, Rust e JavaScript já têm bibliotecas maduras.</p><h4><strong>Snowflake ID, a solução do Twitter (2010)</strong></h4><p>Em 2010, o Twitter enfrentou um problema concreto, precisava migrar do MySQL para o Cassandra para escalar, mas o Cassandra não tem AUTO_INCREMENT. O time de engenharia publicou o post “<em>Announcing Snowflake”</em> no blog técnico e abriu o código.</p><p>Os requisitos eram simples mas exigentes, “<em>We needed something that could generate tens of thousands of ids per second in a highly available manner […] these numbers have to fit into 64 bits”</em>.</p><p>A solução: Um ID de <strong>64 bits</strong> (metade de um UUID) composto por:</p><ul><li><strong>1 bit</strong> reservado sempre 0, para manter o número positivo como signed int.</li><li><strong>41 bits</strong> de timestamp, milissegundos desde epoch customizado -&gt; ~69 anos.</li><li><strong>10 bits</strong> de machine ID, até 1.024 máquinas.</li><li><strong>12 bits</strong> de sequence, até 4.096 IDs por milissegundo por máquina.</li></ul><p>O Twitter usa epoch de 4 de novembro de 2010. O Discord usa 1 de janeiro de 2015. O Instagram usa uma variação com 41 bits timestamp + 13 bits shard ID + 10 bits sequence.</p><p>As vantagens são claras: sequencial (inserts ordenados), compacto (cabe num BIGINT de 8 bytes, metade de um UUID), rápido de gerar (sem crypto random necessário), e o timestamp embutido elimina a necessidade de uma coluna <em>created_at</em> separada.</p><p>O trade-off? Você precisa <strong>gerenciar machine IDs</strong>. Num cluster Kubernetes dinâmico, isso é trabalho extra (o paper “Stateless Snowflake” do Arxiv aborda soluções para isso). E os 64 bits dão “apenas” ~4,6 × 1⁰¹⁸ IDs possíveis, contra ~5,3 × 1⁰³⁶ do UUID v4. Na prática, sobra.</p><h4><strong>E o ULID?</strong></h4><p>Vale mencionar o <strong>ULID</strong> (Universally Unique Lexicographically Sortable Identifier), que é parecido com UUID v7, 48 bits de timestamp + 80 bits de random, codificado em Crockford Base32. A diferença principal é que ULID tem 80 bits de randomness (vs 74 do v7) e usa uma codificação mais legível. Mas ULID não é UUID, não cabe num campo UUID de banco de dados e não tem RFC padronizando. Com a chegada do v7 na RFC 9562, a recomendação é clara, se vai usar o formato UUID, use v7. Se quer algo mais compacto, considere Snowflake.</p><h3><strong>Como o MySQL armazena tudo isso por dentro</strong></h3><p>Antes de ir para os números, vale entender o mecanismo por trás. Essa seção explica <strong>por que</strong> o tipo de ID impacta tanto e por que muita gente esquece o custo.</p><h4><strong>B+Tree e Clustered Index</strong></h4><p>O InnoDB usa uma estrutura chamada <strong>B+Tree</strong> para organizar dados e índices. Em uma B+Tree, os dados ficam nas <strong>folhas</strong> (leaf nodes) e os nós internos armazenam ponteiros para navegação. A busca é logarítmica, para 1 milhão de rows, são ~3-4 níveis de nós para chegar no dado.</p><p>O detalhe crucial, no InnoDB, a Primary Key define o <strong>clustered index</strong>. Isso significa que os dados da tabela são armazenados <strong>fisicamente na ordem da PK</strong>. Não é uma coincidência, é a organização física no disco. Quando você insere uma row com PK = 42, ela vai parar fisicamente entre as rows 41 e 43.</p><p>Isso tem consequências:</p><ul><li>Com PK sequencial (INT AUTO), inserts vão sempre para o <strong>final,</strong> append-only, rápido.</li><li>Com PK aleatória (UUID v4), inserts vão para <strong>posições aleatórias,</strong> obriga o InnoDB a ler pages antigos do disco, modificar, e reescrever.</li></ul><h4><strong>Page Splits, o custo</strong></h4><p>O InnoDB aloca dados em <strong>pages</strong> de 16KB. Quando uma page está cheia e um novo dado precisa ser inserido nela, o InnoDB executa um <strong>page split,</strong> cria uma nova page, move metade dos dados para ela, e insere o novo dado. Cada page fica com ~50% de ocupação.</p><p>Com PK sequencial, isso raramente acontece, o InnoDB enche uma page até ~94% e começa a próxima. Com PK aleatória, page splits são constantes, porque qualquer page pode ser o alvo.</p><p>O impacto é multiplicativo:</p><ul><li><strong>Espaço</strong>, pages com 50% fill vs 94% fill = quase <strong>2x mais espaço em disco.</strong></li><li><strong>I/O</strong>, mais pages = mais leituras de disco para a mesma query.</li><li><strong>Buffer Pool</strong>, o InnoDB mantém pages frequentemente acessadas em memória (buffer pool). Com mais pages espalhadas, o hit ratio cai.</li></ul><h4><strong>O custo, índices secundários carregam a PK</strong></h4><p>No InnoDB, cada entrada de um <strong>índice secundário</strong> armazena a <strong>PK da row</strong> como ponteiro. Isso significa que se sua PK é um UUID de 16 bytes (BINARY(16)) e você tem 5 índices secundários, cada row armazena a PK 6 vezes no total, uma no clustered index + uma em cada índice secundário.</p><p>Com CHAR(36), são 36 bytes por cópia. Com 9 índices, são <strong>10 cópias × 36 bytes = 360 bytes</strong> só de chave por row. Mudando para BINARY(16), cai para <strong>10 × 16 = 160 bytes</strong>. E com INT (4 bytes), são apenas <strong>10 × 4 = 40 bytes</strong>.</p><p>Por isso o PlanetScale recomenda em seu curso MySQL for Developers, “<em>unsigned big integers are the most reliable and performant data type”</em> para PKs.</p><h4><strong>CHAR(36) vs BINARY(16): nunca use CHAR(36)</strong></h4><p>Se você está armazenando UUID como CHAR(36) em produção, está desperdiçando <strong>56% do espaço</strong> desnecessariamente. E esse desperdício se multiplica por cada índice.</p><pre>-- ERRADO, 36 bytes por UUID, comparação de string<br>CREATE TABLE users (<br>    id CHAR(36) PRIMARY KEY,<br>    ...<br>);<br><br>-- CORRETO, 16 bytes por UUID, comparação binária (mais rápida)<br>CREATE TABLE users (<br>    id BINARY(16) PRIMARY KEY,<br>    ...<br>);<br><br>-- Para converter na aplicação<br>INSERT INTO users (id) VALUES (UNHEX(REPLACE(&#39;550e8400-e29b-41d4-a716-446655440000&#39;, &#39;-&#39;, &#39;&#39;)));<br>SELECT HEX(id) FROM users;</pre><p>Neste benchmark, <strong>todos os UUIDs são BINARY(16)</strong>. Os números que você vai ver já são o cenário otimizado. Com CHAR(36), tudo seria significativamente pior.</p><h3><strong>Metodologia</strong></h3><h4><strong>Ambiente</strong></h4><ul><li><strong>Docker MySQL 8.0</strong> com, <em>— memory=1g</em> (hard limit para evitar swap do host).</li><li>innodb-buffer-pool-size=256M, innodb-log-file-size=64M.</li><li>performance-schema=OFF (economiza ~200MB de RAM).</li><li><strong>Windows 11</strong>, Docker Desktop.</li><li>Python 3.11, 4 threads, mysql-connector-python.</li><li>Todos os UUIDs gerados <strong>client-side, </strong>não usa UUID() do MySQL.</li></ul><h4><strong>Por que trimmed mean e não média simples?</strong></h4><p>Em benchmarks de I/O, outliers são comuns, uma coleta de lixo do OS, um flush do Docker, um background scan do antivírus. Uma única run ruim pode distorcer a média em 50%+.</p><p>A solução, <strong>7 runs por cenário</strong>, descartamos o melhor e o pior tempo, e calculamos a média dos 5 restantes (<em>trimmed mean</em>). Isso dá resultados muito mais estáveis que a média simples, nosso StdDev caiu de ~30% para ~5% na maioria dos cenários.</p><p>Cada cenário também tem um <strong>warmup descartável</strong> de 10k rows antes das medições reais, para aquecer o InnoDB buffer pool e eliminar o efeito “cold start”.</p><h4><strong>Otimizações para Windows</strong></h4><p>O Windows/NTFS é notoriamente mais lento para operações de fsync que Linux/ext4. Para reduzir variância sem comprometer os resultados:</p><ul><li>innodb_flush_log_at_trx_commit = 2, flush assíncrono do redo log (o default = 1 faz fsync síncrono por commit).</li><li>sync_binlog = 0,binlog assíncrono.</li><li>gc.collect() + sleep(1s) entre cenários para estabilizar I/O do NTFS.</li></ul><p><strong>Importante,</strong> essas configurações são para benchmark. Em produção, mantenha innodb_flush_log_at_trx_commit = 1 para durabilidade.</p><h4><strong>Cenários de índice</strong></h4><ul><li><strong>baseline,</strong> Só PK, nenhum índice secundário.</li><li><strong>few, </strong>idx_a, idx_b (simples).</li><li><strong>medium,</strong> 4 simples + 1 composto (col_a, col_b).</li><li><strong>many,</strong>6 simples + 3 compostos.</li></ul><h4><strong>O que foi medido</strong></h4><ul><li><strong>Parte 1,</strong> INSERT, 6 tipos de ID × 4 cenários × 2 volumes (50k, 200k).</li><li><strong>Parte 2,</strong> INSERT, 7 estratégias de batch (100, 1k, 5k, 10k, multi-row, sort prévio, sort+multi-row) × 4 tipos × 4 cenários.</li><li><strong>Parte 3, </strong>SELECT, 5 tipos de query × 6 tipos de ID × 4 cenários.</li></ul><p>Todo o código: <a href="https://github.com/francocontigo/index-insert-mysql-benchmark">https://github.com/francocontigo/index-insert-mysql-benchmark</a></p><h3><strong>Parte 1: INSERT, Tipos de ID</strong></h3><h4><strong>Throughput vs Índices (200k rows)</strong></h4><figure><img alt="Throughput vs Índices — 200k inserts" src="https://cdn-images-1.medium.com/max/1024/1*PM9qhatXPWCtS8XdKQboyg.png" /></figure><p>A primeira coisa que da para perceber, <strong>INT AUTO e Snowflake dominam</strong> no baseline, mas <strong>todos convergem</strong> conforme os índices aumentam.</p><h4><strong>1° Observação: UUID v7 é o mais resiliente a índices</strong></h4><figure><img alt="Baseline vs Many — 200k" src="https://cdn-images-1.medium.com/max/1024/1*Vl4c-ZVIbXFCCykYDk40mQ.png" /></figure><p>Olhando a coluna de queda, v7 perde apenas <strong>35%</strong> do throughput ao ir de zero para 9 índices. O INT AUTO perde <strong>61%</strong>.</p><p>Como isso é possível?</p><p>A explicação é sutil. INT AUTO começa com throughput muito alto (219k/s) porque o baseline é trivial, append-only, sem trabalho nos índices. Quando você adiciona 9 índices, o custo de manutenção dos índices domina. E como as colunas no benchmark são do mesmo tipo da PK, com INT os índices secundários também são INT (4 bytes) rápido de manter, mas o custo absoluto é alto porque o baseline era altíssimo.</p><p>Com UUID v7, o baseline já é mais baixo (129k/s) porque BINARY(16) é maior. Mas como v7 é sequencial, os page splits nos índices secundários são mínimos. O custo de adicionar um índice é quase só a escrita linear na B-Tree, sem a fragmentação cascata que acontece com v4.</p><p>O v4 tem o pior dos dois mundos, baseline mais baixo <strong>e</strong> queda acentuada. Aleatoriedade na PK + aleatoriedade nos índices secundários = fragmentação em todas as estruturas.</p><h4>2° Oservação: C<strong>om muitos índices, o tipo de ID importa menos</strong></h4><figure><img alt="Heatmap INSERT 200k" src="https://cdn-images-1.medium.com/max/1016/1*bNz47mQZPAvS9Vd_S2dzkw.png" /></figure><p>Repare na coluna “many (9)” do heatmap: INT (86k), v1 (83k), v7 (84k), v6 (78k), Snowflake (77k), todos entre <strong>77–86k/s</strong>. A exceção é o v4 (45k).</p><p>Isso faz sentido. Com 9 índices, cada INSERT faz efetivamente 10 escritas (1 na tabela + 9 nos índices). O custo de I/O dos índices domina. A diferença entre “PK sequencial rápida” e “PK sequencial um pouco mais lenta” fica pequena quando o gargalo é a manutenção de 9 B-Trees.</p><p>A lição, <strong>o tipo de ID importa muito quando você tem poucos índices</strong> (onde a PK domina o custo). Com muitos índices, todos sofrem de forma parecida, exceto o v4, que sofre mais porque fragmenta tudo.</p><h4>3° Observação: <strong>50k vs 200k, o volume amplifica a diferença</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HOQZ3Y7Ncg1V__oeLA8TBg.png" /></figure><p>Com 50k linhas, as diferenças são menores e mais ruidosas, a tabela cabe inteira no buffer pool e muitos page splits são absorvidos em memória. Com 200k, o buffer pool começa a ter evictions e o padrão de I/O real aparece.</p><p>Se seu sistema tem tabelas com milhões de linhas (e provavelmente tem), a diferença será ainda mais pronunciada que os números aqui.</p><h3><strong>Parte 2: INSERT, estratégias otimizadas</strong></h3><p>Mesmos tipos de ID, mas agora variando a <strong>técnica</strong> de inserção. A pergunta surge:</p><blockquote>O que dá mais resultado, mudar o tipo de ID ou mudar a forma de inserir?</blockquote><h4><strong>4° Observação: Batch size, o salto de 100 para 1000 linhas é o que mais importa</strong></h4><p>Ir de batch 100 para batch 1000 dá um salto de <strong>40–75%</strong> de throughput. Depois de 1000, o ganho é incremental. E o <strong>multi-row VALUES</strong> (single SQL com 5000 values) é consistentemente o mais rápido.</p><p>Por que batch 100 é tão ruim? Cada commit no InnoDB faz (com configuração padrão) um fsync do redo log. Com batch 100, são 2.000 commits para inserir 200k rows. Com batch 5000, são apenas 40 commits. Menos fsync = menos espera por I/O = mais throughput.</p><h4>5° Observação: <strong>Com 9 índices: batch grande continua valendo</strong></h4><figure><img alt="Batch effect many" src="https://cdn-images-1.medium.com/max/1024/1*yn5tbZ8tSjsFeSSMjHr1CQ.png" /></figure><p>Com 9 índices, o throughput absoluto cai, mas o padrão se mantém. Multi-row VALUES e batch 5k continuam no topo. E novamente, v4 fica isolado lá embaixo.</p><p>Um ponto, <strong>batch 10k não é necessariamente melhor que batch 5k</strong>. Em vários cenários, 10k foi ligeiramente mais lento. O motivo provável é que o MySQL precisa alocar mais memória para o statement e o overhead de parsing de um SQL com 10.000 VALUES começa a pesar. O sweet spot é <strong>entre 1.000 e 5.000</strong> para a maioria dos cenários.</p><h4>6° Observação: <strong>UUID v4 comsort prévio ajuda, mas não resolve</strong></h4><figure><img alt="v4 sort impact" src="https://cdn-images-1.medium.com/max/1024/1*cTlKJi9RBI4nt_s_iqenIA.png" /></figure><p>A ideia é, se o v4 é aleatório e isso causa page splits, o que acontece se ordenamos os dados <strong>antes</strong> de inserir? Os dados vão chegar na B-Tree em ordem crescente, minimizando splits.</p><p>A linha tracejada verde no gráfico conta que UUID v7 com multi-row atinge <strong>84.341/s</strong> no mesmo cenário. O v4 <strong>otimizado ao máximo</strong> ainda fica <strong>42% abaixo</strong> do v7 padrão.</p><p>A lição, sort prévio é uma boa prática se você está preso no v4 e não pode migrar. Mas <strong>se pode escolher, escolha v7, </strong>é a otimização que se paga sozinha.</p><h4>7° Observação: Comparações, a melhor config pra cada tipo</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDuSjElGnVpHmO8CbUmtjg.png" /></figure><p>O ranking final para 200k rows, cenário many (9 índices), melhor estratégia de cada tipo:</p><ol><li><strong>INT AUTO multi-row 5k</strong>: 89k/s</li><li><strong>UUID v7 multi-row 5k</strong>: 84k/s (−6% vs INT)</li><li><strong>Snowflake batch 5k</strong>: 82k/s (−8% vs INT)</li><li><strong>UUID v4 sorted batch 5k</strong>: 49k/s (−45% vs INT)</li></ol><p>UUID v7 fica a apenas <strong>6%</strong> do INT AUTO_INCREMENT no cenário mais pesado. É um “imposto” aceitável para ganhar unicidade global, distribuição sem coordenação e privacidade de ID.</p><h3><strong>Parte 3: SELECT, CANSEI DE FALAR DE INSERT EM NOME DE DEUS</strong></h3><p>Até agora só falamos de escrita. Mas índice existe para acelerar <strong>leitura</strong>. O trade-off só faz sentido quando olhamos os dois lados.</p><h4><strong>8° Observação: Point Lookup 56-76x mais rápido com índice</strong></h4><figure><img alt="Point lookup" src="https://cdn-images-1.medium.com/max/1024/1*iWc389a-xIKqXldcLD2SNQ.png" /></figure><p>Sem índice (baseline), um <em>WHERE col_a = X</em> faz full table scan em ~42ms. Com qualquer número de índices, cai para <strong>~0.6ms</strong>. Um speedup de <strong>56-76x</strong> dependendo do tipo.</p><p>E aqui mais uma coisa aparece, com índice, a diferença entre tipos de ID <strong>desaparece</strong>. INT, UUID v4, UUID v7, Snowflake, todos ficam em ~0.6ms. O tipo de dado importa para escrita, para point lookup com índice, é irrelevante.</p><p>O motivo é que o point lookup percorre o índice secundário (B-Tree com poucos níveis) e depois faz um <strong>bookmark lookup</strong> na PK para buscar a row completa. O tamanho da PK importa para o tamanho do índice (espaço em disco), mas a latência de um único lookup é dominada pelo número de níveis da árvore, que é o mesmo para todos.</p><h4>9° Observação: <strong>COUNT + GROUP BY, o ganho mais dramático com índices</strong></h4><figure><img alt="GROUP BY" src="https://cdn-images-1.medium.com/max/1024/1*A1FYYe0YmGnlYmgtbMc5VQ.png" /></figure><p>Essa é a query que mais se beneficia de índices.</p><p>INT/Snowflake já são relativamente rápidos <strong>sem índice</strong> (96ms vs 443ms do v4). Isso porque INT ocupa 4 bytes vs 16 bytes do BINARY(16). Mais rows cabem numa page de 16KB, mais pages cabem no buffer pool, menos I/O. O tamanho do dado tem efeito direto no scan.</p><p><strong>Com índice, o gap diminui</strong> mas não desaparece (42ms vs 65ms). GROUP BY com índice usa <strong>index scan</strong> (percorre o índice em ordem), e o tamanho das entradas do índice importa, BINARY(16) tem 4x mais bytes por entrada que INT.</p><h4>10° Observação: <strong>Range Scan, onde o tamanho do dado incomoda</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_9DFi5gKPD_Oa7xQJQZr1g.png" /></figure><p>Aqui a diferença é insana e <strong>não depende do número de índices</strong>:</p><ul><li>INT / Snowflake: <strong>~58ms</strong></li><li>Todos os UUIDs (v1, v4, v6, v7): <strong>~200ms</strong></li></ul><p>3.5x mais lento, consistentemente. O motivo é estrutural: um range scan lê pages sequenciais do disco (ou buffer pool). Com BINARY(16), cada row + colunas auxiliares é significativamente maior. Mais dados = mais pages = mais tempo.</p><p>Isso é um custo <strong>inerente</strong> ao UUID como tipo de dado, independe da versão. Se sua aplicação faz muitas range scans em colunas BINARY(16), considere uma estratégia híbrida: PK como UUID v7 (para unicidade distribuída), mas colunas de filtro e busca como INT quando possível.</p><h3>Analisando o Trade-Off</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nVwuGMI9MAdaSCGHrAdksA.png" /></figure><p>Esse é o meu queridinho do artigo. À esquerda, INSERT throughput <strong>cai</strong> conforme os índices aumentam. À direita, SELECT latency <strong>cai</strong> (melhora) com a mesma progressão.</p><p>Três analises desse gráfico:</p><ol><li><strong>O salto baseline para few (2 índices) é assimétrico.</strong> O custo de INSERT é de ~25%. O ganho de SELECT é de <strong>~98%</strong> (42ms para0.6ms no point lookup). Dois índices bem escolhidos são o melhor investimento em performance que existe.</li><li><strong>Depois de “few”, os retornos de SELECT são decrescentes. </strong>De few para medium para many, o point lookup praticamente não muda (0.6ms para 0.6ms para 0.7ms). O que melhora um pouco é ORDER BY (51ms para 44ms para 26ms, porque mais cenários de query são cobertos). Mas o custo de INSERT continua crescendo linearmente.</li><li><strong>UUID v4 paga o maior preço.</strong> Ele começa mais baixo e cai mais rápido. No cenário many, fica em 45k/s, <strong>quase metade</strong> do v7 (84k/s). Para leitura, a performance é similar a todos os outros. Ou seja, v4 paga mais de INSERT sem ganhar nada de SELECT.</li></ol><p>De lição, 2-4 índices bem escolhidos (baseados em queries reais, não especulação) cobrem 90%+ dos cenários. 9 índices “por precaução” custam 60% de throughput de escrita para um ganho marginal de leitura.</p><h3>Recomendações da minha cabeça</h3><p>Ou, o que eu levo de lição daqui.</p><h4>Q<strong>ual tipo de ID usar?</strong></h4><p><strong>Precisa de unicidade global + distribuído?</strong></p><blockquote><strong>UUID v7</strong> se quer padrão RFC e máxima compatibilidade. <strong>Snowflake</strong> se quer performance máxima, 8 bytes, e consegue gerenciar machine IDs.</blockquote><p><strong>Não precisa de distribuído?</strong></p><blockquote><strong>INT AUTO_INCREMENT</strong> ou <strong>BIGINT AUTO_INCREMENT</strong>. Simples, rápido, 4–8 bytes. Validado há décadas.</blockquote><p><strong>Já usa UUID v4 em produção e não pode migrar?</strong></p><blockquote>Pelo menos mude de CHAR(36) para BINARY(16), ganho imediato de 56% de espaço, use batch inserts de 1000+, ordene os dados antes de inserir quando possível. Considere uma migração gradual para v7 os dois formatos coexistem no mesmo campo BINARY(16).</blockquote><blockquote><strong>Nunca use UUID v1 em projetos novos.</strong> A RFC 9562 recomenda v7 explicitamente. v1 só faz sentido para compatibilidade com sistemas legados.</blockquote><h4><strong>Como fazer INSERT da melhor forma</strong></h4><ol><li><strong>BINARY(16)</strong> para UUIDs, não CHAR(36). Sempre.</li><li><strong>Gere o ID client-side</strong>, não no MySQL. UUID() do MySQL só gera v1 (com MAC exposto) e é mais lento que gerar na aplicação.</li><li><strong>Batch de 1.000+ rows</strong> por commit. O salto de 100 para 1000 é o maior ganho.</li><li><strong>Multi-row VALUES</strong> quando possível, INSERT INTO t (a,b) VALUES (1,2), (3,4), (5,6) é mais rápido que <em>executemany</em> na maioria dos drivers porque envia um único SQL.</li><li><strong>Se usar v4, ordene antes de inserir</strong>. Não é tão bom quanto v7, mas reduz page splits.</li><li>Em cargas massivas (&gt;500k linhas), considere <strong>LOAD DATA INFILE</strong> com staging table + UNHEX().</li></ol><h4><strong>Como auditar seus índices</strong></h4><p>Antes de criar um índice, use o `EXPLAIN`:</p><pre>EXPLAIN SELECT * FROM pedidos WHERE cliente_id = 13;</pre><p>Se type = ALL, é full scan, candidato a índice. Se type = ref ou range, um índice já está sendo usado.</p><p>Para encontrar índices que <strong>nunca foram usados</strong>:</p><pre>SELECT object_schema, object_name, index_name, count_star<br>FROM performance_schema.table_io_waits_summary_by_index_usage<br>WHERE index_name IS NOT NULL<br>ORDER BY count_star ASC;</pre><p>count_star = 0, índice nunca acessado desde o último restart. Candidato a remoção. Mas verifique se não é um batch semanal ou relatório mensal antes de dropar.</p><p><strong>Cuidado, </strong>o performance_schema precisa estar habilitado (está por padrão, mas consumimos ~200MB de RAM). Neste benchmark desabilitamos por restrição de memória do container.</p><h3><strong>Conclusão</strong></h3><p>UUID v7 é a melhor escolha para quem precisa de identificadores distribuídos. Degrada apenas 35% com 9 índices (vs 61% do v4), fica a <strong>6% do INT</strong> no cenário mais pesado com estratégia otimizada, e a leitura indexada é idêntica a todos os outros tipos.</p><p>Se precisa de range scan rápido e não precisa de distribuído, <strong>Snowflake</strong> é imbatível, 8 bytes, sequencial, 58ms de range scan (vs 200ms dos UUIDs).</p><p>UUID não é vilão. O vilão é usar v4 aleatório como CHAR(36) sem pensar na estratégia de indexação, sem batch adequado, sem medir o impacto.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75b10bf705f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Índices no MySQL: O trade-off que ninguém te conta]]></title>
            <link>https://medium.com/@francocontigo/%C3%ADndices-no-mysql-o-trade-off-que-ningu%C3%A9m-te-conta-35076cc0c41c?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/35076cc0c41c</guid>
            <category><![CDATA[query-optimization]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[data]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Sat, 04 Apr 2026 15:50:03 GMT</pubDate>
            <atom:updated>2026-04-04T17:09:41.893Z</atom:updated>
            <content:encoded><![CDATA[<h3>Índices no MySQL: o trade-off que ninguém conta</h3><p>Você já teve uma query que demorava 30 segundos e, depois de criar um índice, passou a rodar em 50ms? Essa sensação é boa demais. Mas e quando você percebe que seu sistema de inserção em massa que era rápido começou a travar após adicionar “só mais um índice”?</p><p>Esse é o trade-off que quase ninguém fala. Este artigo explica como índices funcionam por dentro, o que você ganha, o que você paga, e apresenta um benchmark que eu fiz para medir esse custo na prática.</p><h3>Afinal, o que é um índice?</h3><p>Pensa num livro sem índice ordenado. Para encontrar todas as páginas que mencionam “B-Tree”, você teria que ler o livro inteiro, do começo ao fim. Isso é o que o banco faz quando você não tem índice, um <strong>full table scan</strong>, leitura linha por linha até achar o que procura.</p><p>Um índice é uma estrutura de dados separada, mantida pelo banco em paralelo à tabela, que permite localizar registros sem varrer a tabela toda. O InnoDB (engine padrão do MySQL) usa uma estrutura chamada <strong>B-Tree (Balanced Tree)</strong>.</p><h4>B-Tree: a estrutura por trás de tudo</h4><p>Uma B-Tree organiza os dados em nós hierárquicos ordenados. A busca começa pela raiz, desce pelos nós intermediários comparando valores, até chegar nas folhas, onde ficam os ponteiros para os dados reais. Em vez de ler todas as N linhas, você percorre apenas log(N) nós. Para uma tabela com 1 milhão de linhas, a diferença entre varrer tudo e navegar pela árvore pode ser de centenas de milissegundos com microssegundos.</p><pre>         [50]<br>        /    \<br>    [25]      [75]<br>   /    \    /    \<br> [10] [30] [60] [90]</pre><p>A B-Tree mantém os valores <strong>sempre ordenados</strong>. Isso é fundamental para entender tanto os ganhos quanto os custos.</p><h3>O que você ganha com índices</h3><h4>Buscas muito mais rápidas</h4><p>O caso de uso mais óbvio. Com um índice em email, uma query como WHERE email = &#39;franco@mail.com&#39; não precisa mais ler todas as linhas da tabela. O banco navega pela B-Tree e chega direto.</p><p>O mesmo vale para ordenação (ORDER BY) e junções (JOIN), se as colunas envolvidas estão indexadas, o banco não precisa ordenar tudo na memória.</p><h4>Índices compostos: ordem importa</h4><p>Um índice em (col_a, col_b) beneficia queries que filtram por col_a sozinha, ou por col_a e col_b juntos , mas <strong>não</strong> beneficia uma query que filtra só por col_b. Isso porque a árvore está ordenada primeiro por col_a, depois por col_b dentro de cada valor de col_a.</p><p>É a chamada regra do “leftmost prefix”, o índice composto funciona se você usar as colunas da esquerda para a direita.</p><h3>O que você paga com índices</h3><p>Aqui está a parte que costuma ser ignorada.</p><h4>Cada INSERT tem um custo extra</h4><p>Quando você insere uma linha na tabela, o banco não apenas escreve o dado. Ele precisa <strong>atualizar cada índice existente</strong>, encontrar a posição correta na B-Tree, inserir o novo valor e, se necessário, rebalancear a árvore para mantê-la equilibrada. Esse processo é chamado de <strong>page split</strong> quando um nó fica cheio.</p><p>Se você tem 9 índices numa tabela, cada INSERT faz, na prática, 10 escritas (uma na tabela + nove nas estruturas de índice). O custo cresce linearmente com o número de índices.</p><h4>Espaço em disco</h4><p>Cada índice é armazenado em disco. Em tabelas com muitas colunas indexadas ou com dados pesados (como UUIDs em CHAR(36)), o espaço dos índices pode facilmente superar o espaço dos dados em si.</p><h3>UUID vs INT: por que o tipo de dado importa tanto</h3><p>UUID é uma ótima escolha para muitos sistemas, ele garante unicidade global sem coordenação central, facilita merges entre bancos distribuídos, e evita a exposição de IDs sequenciais previsíveis em APIs públicas. Para aplicações modernas, especialmente as distribuídas, faz muito sentido.</p><p>O ponto é, usar UUID com qualidade exige consciência do custo. UUIDs são gerados de forma aleatória, então quando você os usa como valor indexado, cada inserção precisa encontrar uma posição aleatória na B-Tree, o que causa muito mais page splits do que um INT AUTO_INCREMENT, que sempre vai para o final da árvore (é sequencial por natureza).</p><p>Se você quer o melhor dos dois mundos, existe o <strong>UUID v7</strong> (ordenado por timestamp) e estratégias como o UUID_TO_BIN(uuid, 1) do MySQL, que reordena os bytes para reduzir esse problema.</p><h3>O benchmark, medindo o custo na prática</h3><p>Para visualizar esse trade-off, criei um benchmark que testa diferentes cenários de indexação com inserções concorrentes no MySQL. O código está disponível no GitHub: <a href="https://github.com/francocontigo/index-insert-mysql-benchmark">francocontigo/index-insert-mysql-benchmark</a>.</p><h4>Metodologia</h4><p>O script (benchmark_indexes.py) testa 4 cenários de índices:</p><ul><li><strong>baseline</strong>: sem nenhum índice secundário</li><li><strong>few</strong>: 2 índices simples (col_a, col_b)</li><li><strong>medium</strong>: 4 índices simples + 1 composto</li><li><strong>many</strong>: 6 índices simples + 3 compostos (9 índices no total)</li></ul><p>Para cada cenário, o benchmark roda com dois tipos de dado nas colunas, <strong>INT</strong> e <strong>UUID (CHAR(36))</strong>, e dois volumes: <strong>50.000</strong> e <strong>200.000 linhas</strong>, usando <strong>4 threads paralelas</strong> de inserção. Cada cenário é executado 5 vezes e a média é calculada.</p><pre># Exemplo de cenário &quot;many&quot; — 9 índices secundários<br>&quot;many&quot;: [<br>    &quot;CREATE INDEX idx_a ON test_indexes(col_a)&quot;,<br>    &quot;CREATE INDEX idx_b ON test_indexes(col_b)&quot;,<br>    &quot;CREATE INDEX idx_c ON test_indexes(col_c)&quot;,<br>    &quot;CREATE INDEX idx_d ON test_indexes(col_d)&quot;,<br>    &quot;CREATE INDEX idx_e ON test_indexes(col_e)&quot;,<br>    &quot;CREATE INDEX idx_f ON test_indexes(col_f)&quot;,<br>    &quot;CREATE INDEX idx_ab ON test_indexes(col_a, col_b)&quot;,<br>    &quot;CREATE INDEX idx_cd ON test_indexes(col_c, col_d)&quot;,<br>    &quot;CREATE INDEX idx_ef ON test_indexes(col_e, col_f)&quot;<br>]</pre><h3>O que o benchmark revela</h3><p>Os gráficos abaixo foram gerados diretamente do notebook de análise (analysis_indexes.ipynb) após as execuções.</p><p><strong>Throughput vs Índices (200k inserts)</strong> , linha azul INT, linha vermelha pontilhada UUID:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*7yx1Qljcmod9WZ-tPc_QaA.png" /></figure><p><strong>INT vs UUID lado a lado:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*MUVZueNy5hQPs2QlqWvBuw.png" /></figure><p><strong>Queda de throughput com mais índices, INT:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*8Q1_iFwRKV4rbyqibMXbAg.png" /></figure><p><strong>Queda de throughput com mais índice, UUID:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*kpIffpHiVtmzcLS5JRGzpw.png" /></figure><p>Com <strong>INT</strong>, a degradação é progressiva mas controlada:</p><ul><li>few (2 índices): <strong>-26%</strong> de throughput vs baseline</li><li>medium (5 índices): <strong>-46%</strong></li><li>many (9 índices): <strong>-74%</strong></li></ul><p>O baseline começa em ~167.000 inserts/s e chega a ~45.000 no cenário many. Uma queda real, mas que ainda mantém throughput razoável.</p><p>Com <strong>UUID</strong>, o cenário é muito mais severo:</p><ul><li>few: <strong>-60%</strong></li><li>medium: <strong>-74%</strong></li><li>many: <strong>-88%</strong></li></ul><p>O baseline do UUID já começa mais baixo (~91.000 inserts/s) e despenca para ~11.000 no cenário many. Uma queda de quase 90% em relação ao ponto de partida.</p><p>A lição concreta não é “não use UUID”, é que <strong>usar UUID com qualidade exige pensar na estratégia de indexação junto</strong>. UUID v7 (ordenado por timestamp) ou UUID_TO_BIN(uuid, 1) no MySQL reduzem drasticamente o problema de fragmentação da B-Tree. O caminho não é abrir mão do UUID, é aplicá-lo com consciência.</p><h3>Quando criar (e quando não criar) um índice</h3><h4>Crie um índice quando:</h4><ul><li>A coluna aparece frequentemente em WHERE, JOIN ON ou ORDER BY</li><li>A coluna tem alta cardinalidade (muitos valores distintos), indexar uma coluna booleana raramente vale a pena</li><li>A tabela é lida muito mais do que escrita (sistemas OLAP, relatórios, consultas de leitura)</li></ul><h4>Evite ou repense um índice quando:</h4><ul><li>A tabela recebe inserções/atualizações em alta frequência e volume</li><li>Você está indexando colunas com baixa cardinalidade</li><li>Você está adicionando índices “por precaução” sem saber quais queries vão usá-los</li><li>O dado é UUID e a tabela é pesada em writes</li></ul><h3>EXPLAIN</h3><p>Antes de criar um índice, use o EXPLAIN para entender o que o banco está fazendo:</p><pre>EXPLAIN SELECT * FROM pedidos WHERE cliente_id = 42;</pre><p>Olhe para a coluna type. Se estiver ALL, você tem um full table scan. Se estiver ref ou range, um índice está sendo usado. A coluna key mostra qual índice foi escolhido.</p><p>Mas, e se ja temos muitos índices criados, qual o comando para ver quais nunca foram usados?</p><pre>SELECT <br>    object_schema,<br>    object_name,<br>    index_name,<br>    count_star<br>FROM performance_schema.table_io_waits_summary_by_index_usage<br>WHERE index_name IS NOT NULL<br>ORDER BY count_star ASC;</pre><ul><li>count_star = 0 índice <strong>nunca foi usado</strong> desde que o servidor iniciou</li><li>valores baixos indica índice <strong>quase nunca usado</strong></li><li>index_name = NULL acesso sem índice (full scan)</li><li>Isso só conta desde o último restart do MySQL</li><li>Se o performance_schema não estiver ativado, não funciona</li><li>Pode ter índice “não usado” que ainda é crítico (ex: rodado 1x por semana em batch)</li></ul><h3>Conclusão</h3><p>Índices não são gratuitos. Eles trocam performance de leitura por custo de escrita e espaço em disco. O ponto ótimo depende do seu padrão de uso.</p><p>A recomendação prática é sempre a mesma, <strong>meça antes de decidir</strong>. Use EXPLAIN, analise o padrão de queries do seu sistema, e teste os impactos.</p><p>O código está aberto e disponível para você rodar no seu próprio ambiente: <a href="https://github.com/francocontigo/index-insert-mysql-benchmark"><strong>github.com/francocontigo/index-insert-mysql-benchmark</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35076cc0c41c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web Scraping 101]]></title>
            <link>https://medium.com/@francocontigo/web-scraping-101-9acdd73ee365?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/9acdd73ee365</guid>
            <category><![CDATA[httpx]]></category>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[json]]></category>
            <category><![CDATA[beautifulsoup]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Tue, 14 May 2024 14:32:23 GMT</pubDate>
            <atom:updated>2024-05-14T14:41:41.795Z</atom:updated>
            <content:encoded><![CDATA[<p>Aqui você vai aprender o conceito de web scraping e algumas técnicas empregadas nesse processo, uma introdução ao uso do arquivo robots.txt, que define diretrizes para bots de web scraping, e um exemplo prático com Python e a biblioteca httpx.</p><p>Web Scraping ou em português raspagem da web, é uma forma de mineração de dados (será abordado em outro artigo) focada em extrair dados de páginas web. Esse processo envolve converter os dados coletados para uma forma estruturada, permitindo seu uso em análises, relatórios, integração com banco de dados e outros. É empregado em diversos contextos, como monitorar preços de itens específicos, buscar documentos, avaliar reações em redes sociais e outros.</p><p><strong>Algumas técnicas de scraping:</strong></p><p>Cópia Manual</p><ul><li>Extração manual copiando e colando informações (quem nunca, não é mesmo?);</li><li>Adequado para informações e tarefas pontuais.</li></ul><p>Requisições HTTP</p><ul><li>Envia requisições diretamente para o servidor;</li><li>Recebe como resposta um HTML ou JSON;</li><li>Com Python, é empregado o uso de bibliotecas como urllib e httpx para automatizar o processo.</li></ul><p>Reconhecimento Semântico</p><ul><li>Analisa a estrutura e o significado do conteúdo da página;</li><li>Também é empregado técnicas de processamento de linguagem natural;</li><li>Empregada para extrair informações de textos ou conteúdo com significado implícito.</li></ul><p>Aplicação de Visão Computacional</p><ul><li>Utilizada para extrair dados de imagens ou capturas de telas;</li><li>Aplicável em cenários onde os dados não estão disponíveis em texto, como gráficos, captchas ou fluxogramas;</li><li>Usa ferramentas de reconhecimento de caracteres para converter imagens em texto.</li></ul><p>Por meio de APIs</p><ul><li>Acessa os dados através de APIs fornecidas por serviços web;</li><li>Evita a necessidade de parsing de HTML;</li><li>Reduz o risco de bloqueio por parte dos sites, é a maneira oficial de acessar os dados.</li></ul><h4>O que é robots.txt</h4><p>O arquivo robots.txt é um arquivo de texto usado por websites para comunicar os motores de busca e outros crawlers quais partes do site podem ou não ser rastreadas ou indexadas. Ele está localizado na raiz de um domínio de um website (por exemplo, <a href="https://medium.com/robots.txt).">https://medium.com/robots.txt).</a></p><p>Como ler um arquivo robots.txt</p><ul><li>User-agent: Define para quais robôs a regra se aplica, o asterisco ‘*’ é empregado se referindo a todos os robôs;</li><li>Disallow: Especifica os diretórios que não devem ser rastreados pelo robô definido;</li><li>Allow: Permite o rastreamento de diretórios, mesmo dentro de uma regra de “Disallow”.</li></ul><pre>User-agent: *<br>Disallow: /private/<br>Disallow: /temp/<br><br>User-agent: c3p0<br>Disallow: /no-c3p0/</pre><p>No exemplo acima, nenhum robô deve rastrear os diretórios private e temp, enquanto o indexador c3p00, não deve acessar o diretório no-c3p0.</p><h4>Hands On com Python</h4><p>Vamos fazer o scraping de um clássico desse meio, o site Books to Scrape, acesse aqui: <a href="https://books.toscrape.com/">https://books.toscrape.com/</a></p><p>Vamos começar instalando as bibliotecas necessárias:</p><pre>pip install httpx beautifulsoup4</pre><p>Importando as bibliotecas:</p><pre>import httpx<br>from bs4 import BeautifulSoup<br>import json</pre><p>Fazendo a requisição, criando um objeto BeautifulSoup e buscando todos os elementos HTML que representam os livros:</p><pre># URL da página<br>url = &quot;https://books.toscrape.com/&quot;<br># Fazendo a requisição HTTP<br>response = httpx.get(url)<br># Criando um objeto BeautifulSoup para analisar o conteúdo HTML da página<br>soup = BeautifulSoup(response.text, &quot;html.parser&quot;)<br># Encontrando todos os elementos HTML que representam os livros na página<br>books = soup.find_all(&quot;article&quot;, class_=&quot;product_pod&quot;)</pre><p>Armazenar as informações de todos os livros da página, fazendo a iteração por cada elemento encontrado:</p><pre># Lista para armazenar as informações dos livros<br>books_info = []<br># Iterando sobre cada elemento de livro encontrado<br>for book in books:<br>    # Extraindo o título do livro<br>    title = book.h3.a[&quot;title&quot;]<br>    # Extraindo o preço do livro<br>    price = book.find(&quot;p&quot;, class_=&quot;price_color&quot;).get_text().strip()<br>    # Extraindo a avaliação do livro (classe CSS indica a avaliação)<br>    rating = book.p[&quot;class&quot;][1]<br>    # Extraindo a disponibilidade do livro<br>    stock = book.find(&quot;p&quot;, class_=&quot;instock availability&quot;).get_text().strip()<br><br>    # Criando um dicionário com as informações do livro<br>    book_info = {<br>        &quot;title&quot;: title,<br>        &quot;price&quot;: price,<br>        &quot;rating&quot;: rating,<br>        &quot;availability&quot;: stock<br>    }<br>    # Adicionando o dicionário à lista de informações dos livros<br>    books_info.append(book_info)<br><br>    # Imprimindo as informações de cada livro (opcional)<br>    print(f&quot;Title: {title}&quot;)<br>    print(f&quot;Price: {price}&quot;)<br>    print(f&quot;Rating: {rating}&quot;)<br>    print(f&quot;Available: {stock}&quot;)<br>    print()</pre><p>E agora armazenando as informações dos livros em um arquivo JSON:</p><pre>with open(&quot;books_info.json&quot;, &#39;w&#39;, encoding=&#39;utf-8&#39;) as json_file:<br>    json.dump(books_info, json_file, ensure_ascii=False, indent=4)</pre><p>Este código é um bom ponto de partida para quem deseja praticar técnicas de web scraping. Um próximo passo interessante seria adaptar o código para extrair informações de todas as páginas do site.</p><p>Se você tiver alguma dúvida ou sugestão, sinta-se à vontade para entrar em contato. Você pode encontrar o código completo deste exemplo em: <a href="https://github.com/francocontigo/artigos/blob/main/WebScraping101/scraping.py">https://github.com/francocontigo/artigos/blob/main/WebScraping101/scraping.py</a></p><p>Para outras informações de contato, <a href="https://github.com/francocontigo">GitHub</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9acdd73ee365" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[API 101]]></title>
            <link>https://medium.com/@francocontigo/afinal-o-que-%C3%A9-uma-api-4dfdf80b1daa?source=rss-fc6c37201ecd------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dfdf80b1daa</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Ricardo Augusto Franco]]></dc:creator>
            <pubDate>Sat, 11 May 2024 18:07:12 GMT</pubDate>
            <atom:updated>2024-05-11T18:18:46.065Z</atom:updated>
            <content:encoded><![CDATA[<p>Uma Interface de Programação de Aplicações (API) é um conjunto de serviços, ferramentas, funções e protocolos implementados em um software, disponibilizados a outros sistemas por meio de um contrato. Sua documentação define esse contrato e como enviar solicitações de forma estruturada, determinando como a aplicação responderá. As APIs abstraem a complexidade do sistema, simplificando a interação entre diferentes softwares e permitindo que aplicativos se comuniquem de forma eficiente e padronizada.</p><h4>Tipos de conexão</h4><p>Um cliente que deseja acessar os recursos fornecidos por uma API envia uma solicitação para um endpoint, seguindo o formato definido na documentação da API. Após receber a solicitação, a API processa as informações e retorna os dados solicitados ao cliente no formato estabelecido no contrato.</p><figure><img alt="GIF mostrando uma caixa rotulada “Client” fazendo uma requisição para outra caixa rotulada “API” e recebendo uma resposta." src="https://cdn-images-1.medium.com/max/854/1*mopsvp7oMXm4PkVQIkUZaw.gif" /></figure><h4>Alguns formatos de conexão:</h4><p><strong>Web client e servidor:<br></strong>- Comunicação entre um cliente e um servidor web;<br>- Baseado em solicitações HTTP;<br>- Geralmente usado para trafegar dados nos formatos JSON ou XML.</p><p><strong>REST (Representational State Transfer):<br></strong>- Comunicação baseada nos padrões HTTP;<br>- Utiliza métodos HTTP como GET, POST, PUT, DELETE;<br>- Utiliza URIs para identificar recursos.</p><p><strong>Remote Procedure Call (RPC):<br></strong>- Permite que um software solicite recursos localizados em outra máquina na rede;<br>- Usa uma sintaxe específica para solicitar os recursos;<br>- Pode utilizar diferentes protocolos de comunicação, como HTTP, TCP, UDP e outros.</p><p><strong>Aplicação e recurso local:<br></strong>- Comunicação entre diferentes partes de uma mesma aplicação ou sistema;<br>- Normalmente é feita chamando funções dentro da mesma aplicação;<br>- Pode ser no modelo síncrono ou assíncrono, a depender da arquitetura da aplicação.</p><h4>Diferença entre REST e RESTful</h4><p>Embora sejam às vezes mencionados como a mesma coisa sem causar problemas, há uma distinção entre os dois termos. REST é uma arquitetura que define um conjunto de princípios para criar serviços web, enquanto RESTful refere-se à implementação desses princípios. Enquanto REST define os princípios gerais, como o uso dos métodos HTTP, RESTful se refere à implementação desses princípios seguindo os critérios estabelecidos pelo REST.</p><h4>Como uma API funciona</h4><p>Você pode interagir com APIs fazendo requisições a ela, um exemplo de código em Python usando a biblioteca requests com uma API fantasiosa com os dados do jogo Dark Souls.</p><pre>import requests<br># URL da API e requisição GET<br>url = &quot;https://darksoulsbossesapi.com/api/bosses&quot;<br>response = requests.get(url)<br><br># Verificando se a requisição foi bem-sucedida (código 200)<br>if response.status_code == 200:<br>    # Extraindo os dados da resposta<br>    bosses_data = response.json()<br>    # Imprimindo os nomes dos chefes de Dark Souls<br>    print(&quot;Lista de chefes de Dark Souls:&quot;)<br>    for boss in bosses_data:<br>        print(boss[&#39;name&#39;])<br>else:<br>    print(&quot;Erro ao acessar a API:&quot;, response.status_code)</pre><p>Esse exemplo poderia retornar um JSON como:</p><pre>[<br> {<br> &quot;id&quot;: 1,<br> &quot;name&quot;: &quot;Asylum Demon&quot;,<br> &quot;description&quot;: &quot;The first boss of the game.&quot;<br> },<br> {<br> &quot;id&quot;: 2,<br> &quot;name&quot;: &quot;Bell Gargoyles&quot;,<br> &quot;description&quot;: &quot;A pair of gargoyles that guard the bell in the Undead Parish.&quot;<br> },<br> {<br> &quot;id&quot;: 3,<br> &quot;name&quot;: &quot;Capra Demon&quot;,<br> &quot;description&quot;: &quot;A boss found in the Lower Undead Burg.&quot;<br> },<br> …<br>]</pre><h4>Considerações sobre desenvolvimento de APIs</h4><p>Desenvolver uma API envolve considerar o que ela vai abstrair e a lógica que será utilizada em suas implementações e chamadas. Uma API bem projetada deve fornecer acesso controlado a um sistema por meio de endpoints definidos no contrato, garantindo segurança e integridade dos dados. Ela deve ser independente do sistema subjacente, ou seja, deve permanecer funcional e consistente mesmo que o sistema que ela suporta sofra alterações. <strong>Uma API pode ser simples ou complexa, nunca confusa.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dfdf80b1daa" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>