IA em produção: 5 lições práticas que devs tiram das notícias

OpenAI em marcha lenta: o que isso significa de verdade para quem codifica com IA

Segundo o Olhar Digital, Sam Altman comunicou a funcionários que a OpenAI considera reduzir o ritmo de lançamento de modelos avançados para acompanhar concorrentes. Na minha experiência, isso não é má notícia — é um sinal de maturidade do setor. Quando trabalhei com GPT-3.5 e migrei para o 4, vi o salto de capacidade ser compensado por um salto proporcional em custo, latência e complexidade de prompt. Quem programa em produção sabe: nem sempre o modelo mais novo é o mais útil.

Para nós, devs, a desaceleração tem três efeitos práticos:

Estabilidade de API: menos quebras de contrato quando o time opta por congelar versões. Já passei por projetos que precisaram reescrever parsers porque um endpoint mudou de schema sem aviso.
Custo previsível: dá pra orçar fine-tuning e embeddings com horizonte de 12 meses.
Janela para consolidar pipelines RAG: em vez de correr atrás do próximo modelo, dá pra investir em retrieval, cache semântico e avaliação.

ChatGPT inventando testemunhas: o problema de alucinação é seu também

Esse caso me chamou atenção porque é exatamente o tipo de erro que vejo acontecer em código de produção. A Suprema Corte do Novo México multou um advogado que usou o ChatGPT para redigir um recurso criminal. A IA inventou depoimentos de policiais e criou testemunhas fictícias. Jurisprudência clara: alucinação judicial tem consequência judicial.

Para um dev, isso traduz em algo direto: se o seu sistema de IA pode "inventar" dados, ele pode quebrar um contrato, vazar informação falsa num relatório ou reprovar um cliente legítimo. Já vi sistema de análise de currículos rejeitando candidatos reais porque o modelo "alucinou" requisitos que não existiam na vaga.

Por que modelos alucinam?

Não é bug, é feature mal calibrada. Um LLM gera o próximo token estatisticamente provável, não o token verdadeiro. Quando a pergunta sai do domínio de treino ou exige precisão factual, o modelo prefere "chutar bem" a dizer "não sei". E o problema piora quando você fornece contexto pobre.

Como mitigar na prática

Existem três camadas que aplico em todo projeto sério:

Retrieval-Augmented Generation (RAG): o modelo só responde com base em documentos indexados que você controla.
Validação cruzada com citação de fonte: peça para o LLM devolver o trecho exato que usou como base.
Abstenção programada: quando a confiança fica abaixo de um threshold, o sistema retorna "não encontrado" em vez de inventar.

IA descobrindo alimentos: o que devs podem aprender com um pipeline de P&D

O terceiro destaque do Olhar Digital News fala de sistemas de IA que aceleram o desenvolvimento de novos produtos alimentícios. A tecnologia não inventa do nada — ela identifica relações entre ingredientes, propriedades nutricionais e objetivos sensoriais. Isso é literalmente o mesmo problema que enfrentamos ao recomendar produtos, classificar tickets ou sugerir tags em CMS.

Na minha vivência com sistemas de recomendação, o padrão que funciona é sempre o mesmo:

Vetorização de itens com embeddings treinados no domínio
Função de scoring que mistura relevância, restrições e novidade
Loop de feedback com usuários reais para re-treino

O detalhe que pouca gente comenta: o sucesso do caso dos alimentos veio de dados bem estruturados sobre combinações que já existem. Sem dataset de qualidade, a IA "descobre" besteiras — é o velho princípio garbage-in, garbage-out.

Fábrica de eVTOL da Embraer: o software industrial que ninguém vê

O destaque sobre a Eve Air Mobility investir na fábrica do eVTOL pode parecer distante do dia a dia de quem programa web. Mas eu vejo diferente: fábrica moderna é software. SCADA, MES, visão computacional para inspeção, AGVs (veículos autônomos guiados) e gêmeos digitais são todos problemas de programação. Se você quer diversificar carreira saindo de CRUD, esse é um oceano azul com salários altos e pouca concorrência de devs juniors.

Na Prática: detector simples de alucinações em respostas de LLM

Vou mostrar um exemplo real de como adiciono uma camada de abstenção num pipeline Python. É o tipo de guardrail que teria salvo o advogado do Novo México.

import re
from typing import Optional

class RespostaVerificada:
    """Wrapper que exige citação literal da fonte antes de aceitar a resposta."""

    PADRAO_CITACAO = re.compile(r"\[FONTE:\s*(.+?)\s*\|\s*página\s*(\d+)\]", re.IGNORECASE)

    def __init__(self, base_conhecimento: list[str], limite_confianca: float = 0.6):
        self.base = base_conhecimento
        self.limite = limite_confianca

    def verificar(self, resposta_llm: str) -> Optional[str]:
        # 1. Procura citação explícita no texto gerado
        match = self.PADRAO_CITACAO.search(resposta_llm)
        if not match:
            return None  # Sem citação = resposta descartada

        trecho_fonte, _ = match.groups()
        trecho_fonte = trecho_fonte.strip().lower()

        # 2. Verifica se o trecho citado existe literalmente na base
        base_lower = " ".join(self.base).lower()
        if trecho_fonte not in base_lower:
            return None  # Citação fabricada = alucinação detectada

        # 3. Calcula cobertura: quanto da resposta é suportada pela fonte
        palavras_resposta = set(re.findall(r"\w+", resposta_llm.lower()))
        palavras_fonte = set(re.findall(r"\w+", trecho_fonte))
        cobertura = len(palavras_resposta & palavras_fonte) / max(len(palavras_resposta), 1)

        if cobertura < self.limite:
            return None  # Cobertura baixa = provavelmente inventado

        return resposta_llm

# Exemplo de uso
base = [
    "O prazo de entrega padrão é de 5 dias úteis para a região Sudeste.",
    "Devoluções são aceitas em até 7 dias após o recebimento.",
]

validador = RespostaVerificada(base)

# Resposta bem comportada: cita a fonte
r1 = "O prazo de entrega é de 5 dias úteis [FONTE: prazo de entrega padrão é de 5 dias úteis | página 1]."
print(validador.verificar(r1))  # aceita

# Resposta alucinada: não cita
r2 = "O prazo de entrega é de 3 dias úteis para todo o Brasil."
print(validador.verificar(r2))  # None

# Resposta com citação fabricada
r3 = "Entregamos em 24h [FONTE: entrega expressa em 24 horas | página 5]."
print(validador.verificar(r3))  # None - citação não existe na base

O código é simplificado de propósito. Em produção, eu substituo regex por embeddings (similaridade de cosseno entre a resposta e os chunks do RAG) e uso um threshold calibrado com dados reais. Mas o princípio é o mesmo: sem fonte verificável, não há resposta.

Erros Comuns que vejo em projetos com IA

Depois de revisar código de dezenas de times, esses são os erros que mais custam caro:

Confiar em logprobs para fatos críticos: o modelo pode estar 95% confiante numa informação errada. Confiança estatística ≠ verdade.
Não versionar prompts como código: prompt em string solta no controller é receita para desastre. Use arquivo .yaml ou .json versionado no Git.
Pular a camada de abstração: chamar a API da OpenAI direto do frontend expõe chave e quebra quando você quiser trocar de provedor. Sempre uma interface.
Ignorar custo por feature: embedding de documento inteiro em vez de chunking explode a fatura. Sempre chunk + rerank.
Não tratar prompt injection: se o input do usuário vai direto pro prompt do sistema, ele pode sobrescrever suas instruções. Sempre sanitize e iste.
Achar que LLM substitui banco de dados: LLM não é fonte da verdade. Use LLM para raciocinar sobre dados que vivem em banco, não para "lembrar" deles.

Checklist rápido antes de colocar LLM em produção

Existe validação determinística da saída? (regex, schema, chamada a função)
O prompt está versionado e revisado por código?
Há testes automatizados com casos adversariais?
O custo por request está calculado e tem alerta de orçamento?
O sistema se recusa a responder quando não sabe, em vez de alucinar?
Existe fallback para indisponibilidade da API?

Se a resposta for "não" em três ou mais itens, não coloque em produção ainda. Eu sei que a pressão de prazo é real, mas recall em escala é mais caro que refatorar.

FAQ — Perguntas que devs realmente fazem sobre essas notícias

1. A desaceleração da OpenAI vai trair meu roadmap que dependia do GPT-5?

Não. Quando uma big tech anuncia mudança de ritmo, raramente significa "vamos parar". Significa que o intervalo entre saltos de geração vai aumentar. A recomendação pragmática: projete seu sistema para funcionar com pelo menos duas versões atrás do modelo top. Assim você nunca fica refém de um lançamento.

2. Como saber se meu sistema está alucinando sem ter um caso jurídico para me avisar?

Monte um conjunto de perguntas-respostas canônicas com seu time de domínio. Rode semanalmente no modelo em produção. Se a acurácia cair abaixo do baseline, algo mudou. É o mesmo princípio de regression test em software tradicional, só que aplicado a saída não-determinística.

3. Vale a pena migrar para modelo open-source (Llama, Mistral, Qwen) em vez de esperar a OpenAI?

Depende do caso. Para dados sensíveis (saúde, jurídico, financeiro), open-source self-hosted é quase obrigatório por questão de compliance. Para tarefas genéricas com custo baixo, API gerenciada ainda ganha em TCO. Não existe resposta única — existe trade-off entre controle, custo e velocidade de entrega.

4. RAG resolve o problema de alucinação de vez?

Não. RAG reduz drasticamente, mas não elimina. O modelo ainda pode interpretar mal o chunk recuperado ou misturar informações de chunks diferentes. A camada de citação e validação que mostrei no código continua sendo necessária mesmo com RAG.

5. Vale a pena entrar na área de software industrial (fábrica da Eve, etc.)?

Vale se você curte sistemas embarcados, visão computacional e tolerância zero a bug. Os salários são altos, a concorrência é menor que web e o trabalho é estável. A curva de aprendizado é íngreme no início (OPC UA, PLCs, protocolos industriais), mas devs que conseguem entram num nicho bem pago.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto. Se quiser que eu monte um projeto completo de RAG com abstração de provedor e validação automática, fala nos comentários que eu transformo em artigo.