Programação Assistida por IA: O Que Eu Delego e O Que Não Delego

Há um ano comecei a manter um registro de cada tarefa em que usei assistência de IA para programar e a qualidade do resultado. Não foi um estudo formal. Uma anotação pessoal no meu gerenciador de tarefas com uma avaliação de uma linha: o que pedi, o que recebi, se era utilizável e se eu delegaria aquela categoria novamente. Após 12 meses de anotações, o padrão está claro o suficiente para escrever sobre.

A versão resumida: IA é um engenheiro júnior altamente capaz que leu todos os tutoriais e páginas de documentação já publicados, mas nunca trabalhou em um codebase de produção sob pressão de prazo. Ela conhece padrões extremamente bem. Ela não conhece o seu sistema, suas restrições, o histórico da sua equipe, nem por que aquele serviço específico foi projetado daquela forma. Delegue de acordo.

O Que Eu Delego Sem Hesitar

Boilerplate e Scaffolding

Gerar um novo componente Angular standalone com change detection OnPush, um arquivo de spec correspondente, uma interface para seus inputs e a estrutura básica de SCSS leva bem menos de um minuto com um assistente de IA. Na mão leva vários minutos. Ao longo de um dia com múltiplos componentes, isso se acumula. O resultado é confiável, consistente com os padrões que configurei no arquivo de instruções personalizadas do projeto, e requer revisão mínima.

// Prompt I use for scaffolding:
// "Create a standalone Angular component called UserProfileCard.
// It should accept a User input (use the existing User interface from core/models).
// OnPush change detection. Include a loading skeleton state.
// SCSS using design tokens. Spec file with a basic render test."

// Output quality: usable on the first pass, small adjustments for project-specific patterns
// Time saved: most of the typing per component
// Review required: light scan for any deviances from the project rules

Testes Unitários para Funções Puras

É aqui que vejo a maior qualidade de resultado de forma consistente. Dada uma função pura com entradas e saídas claras, a IA gera testes unitários abrangentes incluindo casos extremos que eu poderia ter deixado passar. Eu forneço a assinatura da função e uma descrição do comportamento esperado, e a suíte de testes volta com caminho feliz, condições de contorno, tratamento de null/undefined e testes de validação de tipo.

// Function I provide:
export function formatCurrency(
  amount: number,
  currency: string,
  locale: string
): string {
  if (amount < 0) throw new Error('Amount must be non-negative');
  return new Intl.NumberFormat(locale, {
    style: 'currency',
    currency,
    minimumFractionDigits: 2
  }).format(amount);
}

// AI-generated tests cover:
// - Standard formatting for CAD/USD/EUR
// - Zero amount
// - Large amounts with thousands separators
// - Locale differences (en-CA vs fr-CA)
// - Negative amount throws error
// - Invalid currency code behavior
// Output quality: the most reliable category in my log, week after week
// Time saved: most of the test-writing time per function

Regex e Manipulação de Strings

Eu não escrevo mais expressões regulares do zero. Descrevo o padrão que preciso em linguagem simples, peço o regex, peço casos de teste e verifico contra eles. O resultado de regex da IA é mais legível do que o que eu costumava produzir sob pressão de tempo, e os casos de teste que ela gera frequentemente revelam casos extremos que eu não tinha considerado. Regex de validação para códigos postais canadenses, checagens de formato de SIN, normalização de números de telefone. Tudo delegado. Repare na separação: a regra de formato é genérica e segura de entregar, enquanto o que o código faz depois com o valor, mascarar, logar, armazenar, não é, e essa parte eu escrevo eu mesmo.

Refatoração de Padrões Conhecidos

Converter um componente declarado em NgModule para um componente standalone, migrar formulários reativos sem tipagem para a API de forms tipados, atualizar código RxJS antigo para padrões RxJS mais novos, extrair um bloco repetido em um componente compartilhado. Essas são transformações mecânicas onde as regras são conhecidas e a IA as executa com precisão. Eu ainda reviso o resultado, mas a revisão é confirmação, não reconstrução.

Mecânica de CSS e SCSS

Layouts CSS complexos, keyframes de animação, stylesheets específicas para impressão, áreas de template CSS grid. Essas são áreas onde a IA produz resultados corretos que levariam significativamente mais tempo para eu escrever manualmente. Descrevo o comportamento de layout que preciso e reviso o resultado para conformidade com tokens e compatibilidade com navegadores.

Documentação e JSDoc

Eu dou a IA uma função ou serviço e peço para gerar comentários JSDoc. Ela produz documentação precisa e bem estruturada que eu então reviso e ajusto para nuances. Essa costumava ser a tarefa mais procrastinada em qualquer projeto. Agora é um prompt de 30 segundos.

Onde a IA Falha: O Que Eu Nunca Delego

Decisões de Arquitetura

Essa funcionalidade deveria ficar em uma biblioteca compartilhada ou na aplicação host? Deveríamos usar um padrão facade ou expor a store diretamente? Esses dados deveriam ser buscados de forma eager ou lazy? Essas decisões exigem entender o histórico do codebase, as capacidades da equipe, o modelo de deploy, o budget de performance e o roadmap de longo prazo. A IA vai te dar uma resposta. A resposta será plausível e bem fundamentada. Será baseada nas informações que você forneceu no prompt, que nunca é o quadro completo.

A IA vai recomendar dividir um serviço em três microsserviços sem saber se seu pipeline de deploy consegue entregar serviços de forma independente. Vai recomendar uma implementação NgRx para um estado que seu time já planeja mover para outro padrão. Decisões de arquitetura exigem contexto que vive fora do codebase.

Lógica de Negócio Específica do Domínio

Lógica de negócio regulada é específica e moldada por décadas de evolução de produto. Pegue sinistros de seguro como exemplo neutro: quais termos da apólice valem na data do sinistro, o que a franquia faz com o valor pago, quando um caso precisa ser escalado para um regulador de sinistros. A IA não tem conhecimento das regras de uma seguradora específica e vai gerar com confiança código que parece plausível mas está errado para o domínio, e errado de um jeito que passa por correto na revisão. Eu não faço prompts para a IA com essas tarefas de jeito nenhum. Eu mesmo as escrevo com a especificação do product owner aberta ao lado do editor.

Código Sensível a Segurança

Fluxos de autenticação, verificações de autorização, utilitários de criptografia, validação de tokens, verificação de consentimento. Eu escrevo manualmente, exijo uma revisão antes do merge e não itero sobre eles com IA. O risco de uma sugestão sutilmente errada nessa categoria é alto demais, e o esforço de revisão necessário para confiar no resultado torna o processo não mais rápido do que escrever eu mesmo.

Caminhos Críticos de Performance

Quando estou otimizando um componente crítico para renderização, um pipeline RxJS complexo que lida com eventos de alta frequência, ou uma implementação de virtual scrolling. Eu escrevo e profilo manualmente. O código gerado por IA está correto em termos de comportamento, mas raramente é ótimo em termos de performance. Ela não conhece sua estratégia de change detection, seu budget de bundle size, nem quais chamadas estão acontecendo no caminho crítico de renderização.

Como Minha Delegação Evoluiu

Quando comecei o registro, a IA já fazia parte do meu trabalho diário. O que eu não tinha era um mapa. Eu delegava amplamente e julgava cada resultado isoladamente, então continuava entregando categorias que voltavam precisando de reescrita, e continuava fazendo na mão trabalho que a ferramenta resolve bem. Os primeiros três meses de anotações serviram principalmente para separar essas duas listas.

Por volta do sexto mês, o registro tinha me dado um conjunto de padrões de prompting específicos para meu fluxo de trabalho: assinaturas de função antes de implementações, testes antes de código, e restrições declaradas explicitamente ('isso roda em contexto OnPush', 'isso não pode acionar change detection do zone.js'). Os padrões em si são simples. Aplicá-los em todo prompt, e não só quando eu lembrava, foi o que mexeu na qualidade do resultado.

No décimo segundo mês, meu fluxo de trabalho havia se estabilizado. A IA lida com uma parcela grande das minhas teclas digitadas em qualquer dia, principalmente em arquivos de teste, SCSS e boilerplate. O resto é arquitetura, lógica de negócio, revisão e qualquer coisa que exija conhecimento de como nosso sistema específico funciona. Essa parcela é genuinamente valiosa porque é a que eu achava menos interessante e mais demorada.

• Delegação de alta confiança: testes unitários, boilerplate, regex, SCSS, refatoração, JSDoc
• Delegação de média confiança: scaffolding de testes de integração, pipelines RxJS complexos (com revisão), utilitários de transformação de dados
• Delegação de baixa confiança: effects NgRx com efeitos colaterais, estratégias de tratamento de erros, qualquer coisa que toque autenticação
• Nunca delegar: decisões de arquitetura, lógica de negócio do domínio, código sensível a segurança, caminhos críticos de performance

A Avaliação Honesta

Ferramentas de IA para programação me tornaram significativamente mais rápido nas tarefas que elas fazem bem. Elas não me tornaram um arquiteto melhor, um especialista de domínio melhor ou um revisor melhor. Os engenheiros que conheço que estão tirando mais valor dessas ferramentas são aqueles que têm clareza sobre a distinção. Eles usam IA para acelerar a execução e reservam seu próprio julgamento para as decisões que exigem isso.

O melhor uso da IA no desenvolvimento não é substituir o pensamento. É eliminar o trabalho que não exige pensamento, para que você tenha mais tempo e energia para o trabalho que exige.

Acompanhe suas delegações por um mês. Não formalmente. Apenas uma nota mental do que você pediu à IA para fazer e se o resultado foi utilizável sem revisão significativa. Você vai rapidamente construir um mapa pessoal de onde a ferramenta ganha sua confiança e onde desperdiça seu tempo. Esse mapa é mais valioso do que qualquer guia genérico de prompting de IA, porque está calibrado para seu domínio específico, codebase e estilo de trabalho.

Referências

• GitHub Copilot repository custom instructions. https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions
• GitHub Copilot. https://github.com/features/copilot