Um agente de I.A. gera em minutos um código que compila e parece certo. Isso ainda não é software pronto. Software pronto faz o que o negócio pediu, é seguro e pode ser mantido daqui a um ano, e nada disso vem do agente: vem da engenharia em volta dele. No desenvolvimento com agentes de I.A., quem digita mudou. Quem responde pelo resultado, não. Este guia mostra os quatro controles que separam código gerado de software entregue, com exemplos reais de cada um.
O gargalo saiu da escrita e foi para a revisão
A Gartner colocou o tema entre as dez tendências estratégicas de tecnologia para 2027. O diagnóstico da consultoria é que os sistemas de I.A. já geram software mais rápido do que as pessoas conseguem revisar. A previsão dela é que, até o fim de 2026, agentes autônomos de código respondam por 20% de todos os commits públicos.
Para a empresa, o efeito é direto. Sem um sistema de controle, o desenvolvedor passa o tempo conferindo à mão o que a máquina produziu, e o ganho de produtividade desaparece. A empresa paga pela ferramenta, o código sai mais rápido e a entrega continua no mesmo prazo, porque a fila só mudou de lugar.
O nome que o mercado deu à solução é harness. A Gartner o define como um sistema de circuito fechado que governa o comportamento do agente em todo o ciclo de desenvolvimento, integrando o contexto da empresa, os portões de verificação e os ciclos de feedback. Em termos de negócio, o harness são os trilhos: o agente continua rápido, mas só anda por onde a empresa definiu.
Uma ferramenta não resolve isso sozinha. O que resolve são quatro controles de engenharia, que exigem método e disciplina para funcionar.
Controle 1: especificação antes do código
O agente executa exatamente o que foi pedido. Se o pedido é vago, ele preenche as lacunas com suposições e entrega um código plausível e errado. Por isso a especificação vem antes, no modelo conhecido como SDD, o desenvolvimento dirigido por especificação.
Uma spec útil para um agente cabe em uma página e tem quatro blocos:
## História
Como analista financeiro, quero exportar as faturas do mês em CSV,
para conciliar os valores com o extrato do banco.
## Regras de negócio
- Só entram faturas com status "Emitida" ou "Paga".
- Valores em reais, com duas casas decimais e vírgula como separador.
## Critérios de aceite
- Dado um mês sem faturas, o arquivo sai apenas com o cabeçalho.
- Dado um usuário sem o perfil "financeiro", a rota responde 403.
- Dado um mês com 10 mil faturas, a exportação termina em até 5 segundos.
## Fora do escopo
- Exportação em PDF.
- Filtro por cliente.Cada critério de aceite vira um teste automatizado. O bloco "Fora do escopo" impede que o agente invente funcionalidade que ninguém pediu. Para o negócio, a spec tem um segundo efeito: a discussão sobre o que construir acontece antes do código, quando mudar de ideia ainda é barato.
Controle 2: contexto do projeto, escrito e versionado
Um desenvolvedor novo leva semanas para aprender os padrões da casa. O agente começa cada tarefa do zero. Sem contexto, ele resolve o mesmo problema de um jeito diferente a cada vez, e a base de código vira uma colcha de retalhos.
A solução é um arquivo de regras na raiz do repositório, lido pelo agente no início de toda tarefa:
# Regras do projeto
## Arquitetura
- Camadas: Domain, Application, Infrastructure, Api.
- Regra de negócio fica em Domain. Controller não tem lógica.
## Linguagem do domínio
- "Fatura" é o documento de cobrança. "Nota" é o documento fiscal.
- Use os termos do glossário em nomes de classe, método e tabela.
## Antes de concluir uma tarefa
- Rode `dotnet build` e `dotnet test`. Os dois precisam passar.
- Copie o padrão de um módulo existente antes de criar um novo.
## Proibido
- Alterar migration já aplicada.
- Adicionar dependência sem aprovação.
- Ler ou gravar arquivos de segredo.A linguagem do domínio vem do DDD e é o ponto mais subestimado. Quando o código usa as mesmas palavras do negócio, a revisão fica mais rápida e o erro de interpretação aparece cedo. O arquivo é versionado junto com o código: toda decisão nova de arquitetura entra nele, e o próximo agente já nasce sabendo.
Controle 3: portões de verificação no pipeline
O agente não decide sozinho que terminou. Quem decide é o pipeline. Todo pull request passa pelos mesmos portões automáticos, e nada chega à branch principal sem passar por eles.
Um ponto de partida em GitHub Actions, para um back-end em .NET:
name: portoes
on: pull_request
jobs:
verificar:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-dotnet@v4
with:
dotnet-version: '10.0.x'
- name: Build sem avisos
run: dotnet build --warnaserror
- name: Testes
run: dotnet test --no-build
- name: Formato
run: dotnet format --verify-no-changesTrês configurações do repositório completam o portão:
- A branch principal só aceita merge com todos os checks verdes.
- Todo merge exige a aprovação de pelo menos uma pessoa.
- A credencial do agente não tem permissão de aprovar nem de fazer merge.
Some a isso uma etapa de análise de segurança e de varredura de segredos, com a ferramenta que a empresa já usa. O ganho para o negócio é previsibilidade: a qualidade mínima deixa de depender de quem revisou naquele dia.
Controle 4: revisão independente e rastreio
Quem valida não é quem escreveu. Essa regra vale para pessoas e vale ainda mais para agentes. O agente que implementou tende a confirmar o próprio raciocínio, inclusive nos testes que ele mesmo escreveu.
Na prática, a revisão tem duas camadas:
- Um segundo agente, com contexto novo. Ele recebe a spec e a entrega, sem o histórico da implementação. A tarefa dele é tentar quebrar: casos de borda, entradas inválidas, regressão.
- Uma pessoa responsável. Ela lê o parecer, confere os critérios de aceite e aprova o merge. A responsabilidade pelo que entra em produção continua humana.
O rastreio fecha o conjunto. Cada entrega é pequena, ligada a uma spec, com commits que contam o que mudou. Se algo escapar, a empresa sabe onde olhar e faz o rollback em minutos, em vez de investigar por dias.
Onde o desenvolvimento com agentes de I.A. costuma falhar
Os erros se repetem de empresa para empresa:
- O mesmo agente escreve o código e os testes, e os testes apenas confirmam o que ele escreveu.
- A entrega chega em um bloco de milhares de linhas, que ninguém revisa de verdade.
- O agente recebe acesso amplo a produção e a segredos, sem necessidade.
- O arquivo de contexto existe, mas ninguém o atualiza.
Nenhum desses erros aparece na semana da entrega. Eles aparecem meses depois, como custo de manutenção, incidente ou retrabalho.
Como medir se o controle funciona
Linhas de código geradas não medem nada. Os indicadores que importam são de negócio:
Meça antes de adotar os controles e de novo depois de dois ou três ciclos de entrega. Se a I.A. acelerou a escrita e esses números não melhoraram, o processo ainda não tem controle.
Como a Alcance Tech aplica esse modelo
Na Alcance Tech, cada tarefa nasce de uma spec com critérios de aceite. Um agente implementa seguindo os padrões do projeto. Outro, com contexto independente, testa. Um terceiro valida a regra de negócio. A decisão final é de uma pessoa. O cliente não contrata digitação: contrata o resultado e a responsabilidade por ele, com a velocidade da I.A. e a rastreabilidade de um processo de engenharia.
O agente gera código. Quem entrega software é a engenharia que decide o que entra em produção.
