Imagine uma empresa que consegue desenvolver, em poucos dias, um sistema que antes exigiria meses de trabalho.
A interface funciona. Os relatórios aparecem. A integração responde. Na demonstração, tudo segue o caminho esperado e a primeira impressão é excelente.
Então chegam as perguntas que a tela não responde.
O que acontece quando dois usuários alteram o mesmo registro? Quem pode acessar os dados financeiros? Como o sistema reage quando uma integração fica indisponível? Onde está documentada a regra usada para aprovar uma solicitação? Quanto custará mudar essa regra daqui a dois anos?
Talvez ninguém saiba responder com segurança.
A inteligência artificial reduziu muito o esforço necessário para transformar uma instrução em código. Ela também tornou possível gerar aplicações completas, com interface, banco de dados, autenticação, testes e infraestrutura. Mas uma aplicação que abre e executa alguns fluxos ainda não provou que pode sustentar uma operação real.
Essa diferença está se tornando o centro da engenharia de software.
A capacidade de produzir cresceu mais rápido que a capacidade de verificar
Na Developer Survey 2026 do Stack Overflow, 65,9% dos 17.464 respondentes disseram usar assistentes ou agentes de IA para programação no trabalho. A mesma pesquisa encontrou uma condição importante: 48% confiam na resposta da IA quando conseguem verificá-la com facilidade.
Os dois dados ajudam a entender o momento atual. O uso avançou, mas a confiança continua ligada à capacidade de conferir o resultado.
Essa verificação já enfrenta um limite operacional. Um estudo da Linux Foundation com profissionais de cibersegurança identificou que 58% das equipes entregam código mais rápido do que a revisão de segurança consegue acompanhar. O relatório apresenta o resultado como “3 em 5 equipes”.
As pesquisas medem populações e perguntas diferentes. O Stack Overflow ouviu profissionais de tecnologia sobre uso e confiança. A Linux Foundation pesquisou 308 profissionais qualificados de cibersegurança, e a pergunta sobre ritmo de entrega e revisão teve 173 respostas. Os percentuais não devem ser somados. Juntos, porém, eles revelam uma tensão: a produção está acelerando, enquanto a capacidade humana de compreender e validar cada mudança continua limitada.
Quando o volume de código cresce mais rápido que a revisão, o risco não aparece apenas como vulnerabilidade. Ele surge como regra de negócio mal interpretada, dependência desnecessária, teste superficial, decisão sem registro e comportamento que ninguém consegue explicar.
Uma demonstração percorre o caminho feliz
Quase toda demonstração segue uma sequência preparada. O usuário preenche os campos corretos, a conexão está disponível, os dados estão completos e nenhuma ação acontece ao mesmo tempo que outra.
A operação real não oferece esse conforto.
Há cadastros duplicados, aprovações atrasadas, documentos incompletos, mudanças de responsável, integrações fora do ar, permissões diferentes e exceções que só aparecem depois de meses de uso. Um sistema confiável precisa tratar esses casos sem perder dados, expor informações ou interromper o trabalho de quem depende dele.
Por isso, “funciona” precisa deixar de ser uma impressão e virar uma definição verificável.
Para uma clínica, funcionar pode significar impedir dois agendamentos para o mesmo horário, preservar o histórico do paciente e manter o atendimento mesmo quando o serviço de mensagens falha. Para uma operação de engenharia, pode significar registrar quem aprovou uma alteração, impedir que uma medição seja paga duas vezes e mostrar qual versão de um documento estava válida em determinada data.
Essas regras não nascem do código. Nascem do conhecimento da operação.
Se a equipe não consegue descrevê-las, a IA também não consegue implementá-las com consistência. Ela preencherá as lacunas com uma solução provável. Em software empresarial, uma solução provável pode parecer correta durante semanas antes de produzir um erro caro.
Quem decide o que conta como pronto?
Quanto mais autonomia as ferramentas recebem para executar, mais importante fica a qualidade das decisões anteriores à execução.
Uma análise da Anthropic sobre cerca de 400 mil sessões do Claude Code encontrou uma divisão clara: as pessoas tomaram, em média, cerca de 70% das decisões de planejamento, enquanto a ferramenta tomou aproximadamente 80% das decisões de execução. O estudo também observou maior frequência de sucesso nas sessões em que o usuário demonstrava mais conhecimento do domínio.
O dado não mostra que toda ferramenta ou equipe trabalha da mesma forma. Ele oferece um sinal útil: agentes conseguem assumir grande parte do “como fazer”, mas alguém ainda precisa decidir o que fazer, quais limites respeitar e o que será aceito como evidência de sucesso.
Esse trabalho inclui perguntas que não cabem em um prompt genérico:
- Qual problema da operação o sistema precisa resolver?
- Que regra nunca pode ser violada?
- Que erro causaria dano financeiro, operacional ou reputacional?
- Quem pode tomar cada decisão dentro do fluxo?
- Que evidência mostrará que o resultado está correto?
Sem essas respostas, a velocidade da IA apenas antecipa o momento em que a empresa descobre que construiu a coisa errada.
Verificar um sistema exige mais que revisar código
Revisão humana continua importante, mas ler cada linha gerada não resolve o problema inteiro. Em sistemas maiores, ninguém mantém todos os detalhes na cabeça. A confiança precisa vir de várias formas de evidência.
Os testes automatizados confirmam que regras conhecidas continuam funcionando depois de uma mudança. Testes de integração mostram se banco, APIs e serviços externos se comportam como esperado. Testes de segurança procuram acessos indevidos, exposição de dados e dependências vulneráveis. Monitoramento revela o que acontece depois que usuários reais começam a trabalhar. Logs e trilhas de auditoria permitem reconstruir decisões quando algo dá errado.
A arquitetura também funciona como uma forma de controle. Ela define limites entre componentes, reduz o impacto de uma falha e impede que qualquer parte do sistema tenha acesso a tudo. A documentação registra decisões que o código sozinho não explica: por que uma regra existe, qual risco foi aceito, quem responde por um serviço e como recuperar a operação.
Cada camada responde a uma pergunta diferente. O sistema faz o que deveria? Continua fazendo depois de uma alteração? Resiste a uso indevido? A equipe percebe quando ele falha? Alguém consegue corrigir sem depender da memória de quem o criou?
Um sistema confiável não precisa ser perfeito. Precisa tornar seus riscos visíveis e oferecer meios concretos de detectar, conter e corrigir problemas.
A manutenção começa antes do primeiro deploy
Parte do custo de um sistema aparece muito depois da primeira entrega.
Uma biblioteca deixa de receber atualizações. Uma API externa muda. Uma regra fiscal ganha uma exceção. A empresa reorganiza responsabilidades. O volume de dados cresce. A pessoa que conhecia uma decisão importante sai da equipe.
Se o sistema foi construído apenas para passar pela demonstração, cada mudança vira investigação. A equipe precisa descobrir o que o código faz, por que faz e o que pode quebrar. A velocidade conquistada no início reaparece como lentidão acumulada na manutenção.
IA também pode ajudar nessa fase. Pode explicar partes do código, sugerir testes, localizar dependências, apoiar migrações e investigar incidentes. Mas ela trabalha melhor quando encontra um sistema organizado: regras explícitas, histórico de decisões, testes relevantes, componentes com limites claros e dados observáveis.
Código gerado rapidamente não é necessariamente descartável. Ele se torna difícil de manter quando entra em produção sem contexto, sem critérios e sem dono.
A nova medida de competência
Durante muito tempo, a capacidade de uma empresa de tecnologia era percebida pelo tamanho da equipe ou pela quantidade de código que conseguia produzir. Essa medida perde força quando uma equipe pequena, bem orientada, consegue executar muito mais com agentes de IA.
Outras capacidades passam a diferenciar o trabalho: compreender a operação, formular o problema, escolher uma arquitetura, definir critérios de aceitação, automatizar verificações, proteger dados, observar o sistema e assumir responsabilidade pela evolução.
A IA pode escrever uma grande parte do código. Pode ajudar a testar, documentar, revisar e operar. O que ela não resolve sozinha é a responsabilidade por uma decisão que afeta clientes, funcionários e processos reais.
Quando escrever código deixa de ser a principal dificuldade, uma boa empresa de tecnologia passa a ser reconhecida pela qualidade das perguntas que faz, pelas evidências que produz e pelo sistema que continua funcionando depois que a demonstração termina.





Comentários
Nenhum comentário ainda. Comece a conversa.