Introduction
Quando os agentes são bem delimitados, bem instruídos e operam dentro de limites claros, a eficiência no uso de tokens melhora naturalmente. Agentes de alta qualidade completam tarefas em menos tentativas, seguem fluxos de trabalho mais claros com menos retrabalho e evitam ciclos de depuração e correção caros.
Este artigo descreve cinco estratégias para melhorar tanto a qualidade dos agentes quanto AI credits a eficiência:
- Escolha o modelo certo para a tarefa certa
- Forneça diretrizes claras em seus prompts
- Pesquisar, planejar e implementar
- Adicionar proteções determinísticas
- Seja conciso
copilot-instructions.md
1. Escolha o modelo certo para a tarefa certa
A escolha do modelo é uma das maneiras mais rápidas de melhorar a qualidade do agente e a eficiência de custo, mas geralmente é ignorada. Um padrão comum é adotar por padrão o modelo mais capaz para каждой tarefa, mas isso geralmente aumenta o uso de tokens sem melhorar o resultado. Em alguns cenários de execução pesada, o uso excessivo de modelos de raciocínio pode reduzir a qualidade porque o modelo pode pensar demais na tarefa ou introduzir alterações desnecessárias.
Escolha o modelo com base no trabalho em questão. Copilot seleção automática de modelo também pode lidar com isso automaticamente com base na integridade do sistema em tempo real e no desempenho do modelo.
- Modelos de raciocínio: melhor para decisões de arquitetura, depuração complexa, design do sistema e tarefas que exigem uma análise mais profunda.
- Modelos intermediários: ideais quando o plano já está claro e o agente precisa executar com eficiência.
- Modelos mais leves: melhores para refatoração, formatação, atualizações de documentação e outras alterações rotineiras e bem delimitadas.
Use o máximo de capacidade necessário para a tarefa e o mínimo necessário. Adequar a capacidade à tarefa melhora os resultados e controla diretamente os custos em larga escala.
Para obter uma divisão por modelo e tipo de tarefa, consulte Comparação de modelos de IA usando tarefas diferentes.
2. Forneça diretrizes claras em seus prompts
Seu prompt define a direção de tudo o que o agente faz. Quando um prompt é vago, o agente precisa inferir a intenção, buscar mais contexto e tomar decisões com base no próprio julgamento. Isso geralmente leva a novas tentativas, expansão do escopo e uso desnecessário de tokens.
Os prompts bem estruturados têm três qualidades:
- Uma definição de tarefa clara. Em vez de "corrigir esse problema", explique qual é o problema, onde ele ocorre e como é o resultado esperado.
- Contexto relevante fornecido antecipadamente. Se você já souber quais arquivos, serviços, logs, erros ou entradas importam, inclua-os. Isso ajuda o agente a evitar a exploração desnecessária.
- Uma condição de parada clara. Diga ao agente o que significa "concluído". Sem um ponto de interrupção, os agentes podem continuar além da meta adicionando confirmações extras, refatorando código não relacionado ou expandindo o escopo.
Essa orientação adicionada não aumenta significativamente o uso do token, mas pode reduzir significativamente o número de execuções de agente necessárias para alcançar o resultado certo.
Para obter as melhores práticas de engenharia de prompt, consulte Engenharia de prompts para o GitHub Copilot Chat.
3. Pesquisar, planejar e implementar
Uma das maiores mudanças no trabalho efetivamente com agentes é deixar de fazer tudo em uma única sessão. Quando a pesquisa, o planejamento e a implementação ocorrem juntos, o contexto cresce rapidamente, as informações irrelevantes se acumulam e a qualidade do agente se degrada ao longo do tempo.
Dividir o trabalho em fases claras:
- Pesquisa: Use o agente para explorar a base de código, identificar arquivos relevantes e entender as dependências.
- Plano: Crie um plano ou especificação detalhada e estruturada antes de fazer alterações. É aí que os modelos de raciocínio são mais valiosos.
- Implementar: Execute de acordo com o plano usando um contexto focado e um modelo adequado para execução.
Iniciar uma nova sessão entre as fases evita levar adiante contexto desnecessário. Uma única sessão concluída dentro de um escopo razoável se beneficia do cache. Levar o contexto de fases anteriores pode aumentar o uso de token, introduzir viés e reduzir a clareza para o agente. Cada fase deve operar somente com o que precisa. Para orientações sobre como definir o escopo das sessões de forma eficaz, consulte Práticas recomendadas para usar GitHub Copilot para trabalhar em tarefas.
4. Adicione barreiras de proteção determinísticas
Os agentes são não determinísticos e nem sempre acertam, especialmente em fluxos de trabalho com várias etapas. Sem salvaguardas, pequenos erros podem se acumular rapidamente: os agentes se baseiam em saídas incorretas, se afastam ainda mais do objetivo e tornam a depuração mais cara e demorada.
Os controles determinísticos introduzem sinais de passagem/falha claros:
- Os testes de unidade verificam se as alterações do agente produziram o comportamento esperado.
- Linters garantem estrutura e consistência, evitando problemas de formatação, inconsistências de estilo e retrabalho de limpeza desnecessário.
- As verificações de segurança identificam padrões de risco cedo, antes que se tornem mais difíceis de corrigir.
Juntos, esses controles criam um ciclo de feedback estreito: o agente faz uma alteração, um teste, uma regra ou uma varredura a avalia, e o agente faz ajustes antes de seguir em frente. Isso impede cadeias longas de alterações incorretas, que são um dos maiores fatores de desperdício de token.
As equipes que investem nessas proteções observam menos novas tentativas, uma conclusão mais rápida das tarefas e um comportamento mais previsível dos agentes. Eles geralmente reduzem o consumo total de tokens mesmo que as etapas individuais usem um pouco mais de tokens antecipadamente.
5. Manter uma concisa copilot-instructions.md
Instruções persistentes melhoram a consistência entre as interações do agente, mas seu valor depende inteiramente de como elas são escritas. Um copilot-instructions.md arquivo no nível do repositório é a maneira mais direta de codificar essas diretrizes. Instruções pessoais e no nível da organização podem ser adicionadas em camadas para garantir uma consistência mais ampla.
As melhores instruções são curtas, específicas e fundamentadas no comportamento real do agente observado , não práticas recomendadas genéricas que soam bem, mas não se aplicam ao seu sistema.
O que incluir:
- Estruturas, bibliotecas ou padrões de design necessários
- Armadilhas conhecidas que o agente tende a repetir
- Expectativas de saída, como "ser conciso" ou "retorne apenas código"
- Convenções específicas da equipe que o agente deve seguir
- Comandos de compilação, teste e lint
O que evitar:
- Documentação longa e genérica
- Diretrizes geradas por IA que não refletem seu sistema real
- Preferências pontuais ou detalhes raramente usados
- Instruções sobrecarregadas que tornam o contexto barulhento
Mantenha as instruções atualizadas à medida que sua base de código, arquitetura, padrões e fluxos de trabalho evoluem. Como essas instruções são incluídas no contexto do agente em cada execução, até mesmo pequenas melhorias podem reduzir erros repetidos e reduzir o uso de token desperdiçado ao longo do tempo.
Para obter mais informações, consulte Adicionando instruções personalizadas do repositório para GitHub Copilot.