Aprimorando a qualidade do agente para otimizar o uso de IA

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.

Siga as estratégias apresentadas neste artigo para melhorar tanto a qualidade do agente quanto AI credits sua eficiência.

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 envolvido:

• 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.

Configurar o nível de raciocínio do modelo

Alguns modelos também oferecem suporte a níveis de raciocínio configuráveis, que controlam o quanto o modelo raciocina antes de gerar uma resposta. Um nível mais alto pode melhorar as respostas para problemas complexos, mas consome mais tokens e, portanto, mais créditos, portanto, você deve usar o nível regular por padrão e elevá-lo apenas para tarefas mais difíceis. O raciocínio configurável está disponível para Visual Studio Code e CLI do Copilot em modelos compatíveis.

Consulte Modelos de IA com suporte no GitHub Copilot.

Utilize Copilot seleção automática de modelo

Copilot seleção automática de modelo escolhe um modelo capaz para você, com base na intenção de sua tarefa.

Consulte Sobre CopilotSeleção de modelo automática.

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. Mantenha o contexto enxuto

Copilot envia, na forma de tokens de entrada, o contexto a que tem acesso, e esse contexto vai se acumulando: abas abertas no editor, arquivos anexados e todo o histórico de uma conversa longa contam como contexto.

Para manter o contexto sob controle, considere fazer o seguinte:

Inicie uma nova conversa ao mudar de problema

Um thread longo carrega todo o seu histórico em cada nova solicitação. Ao passar para uma tarefa não relacionada, inicie uma nova conversa. Por exemplo:

• Em CLI do Copilot uso /new (ou /clear)
• In Bate-papo do Copilot, inicie uma nova sessão de chat.

Compactar sessões longas CLI do Copilot que você deseja retomar

Quando você precisar que a conversa continue, mas ela ficou muito extensa, execute /compact em CLI do Copilot para resumir o histórico e reduzir a janela de contexto, com a opção de direcionar o resumo (por exemplo, /compact focus on the auth module).

Além disso, você pode usar /context para verificar o uso atual a qualquer momento.

Consulte Gerenciando o contexto em CLI do GitHub Copilot.

Fornecer Copilot um mapa do seu projeto

Um arquivo de instruções personalizadas bem mantido, como um arquivo AGENTS.md ou .github/copilot-instructions.md, oferece aos agentes uma visão estrutural geral do seu repositório, para que eles não precisem ler um grande número de arquivos apenas para se situar. Consulte Suporte para diferentes tipos de instruções personalizadas.

Traga apenas as ferramentas necessárias

Conjuntos grandes de ferramentas (por exemplo, uma quantidade de ferramentas equivalente à de um servidor MCP completo) aumentam o contexto a cada solicitação. Quando ele se ajustar ao fluxo de trabalho, habilite apenas os conjuntos de ferramentas relevantes para a tarefa.

Consulte Configurando conjuntos de ferramentas para o servidor MCP GitHub.

Aproveite o cache de contexto

Copilot reaproveita o contexto que você já enviou usando o cache, o que reduz o custo das interações subsequentes. No entanto, o contexto armazenado em cache expira após um período de inatividade e não é reutilizado quando você alterna modelos no meio da sessão. Em ambos os casos, o contexto é reenviado e cobrado novamente como novos tokens de entrada. Para aproveitar ao máximo o cache, mantenha o trabalho relacionado em uma única sessão contínua e evite trocar de modelo no meio do processo.

4. Reduzir erros repetidos com um copilot-instructions.md arquivo

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.

5. 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.
  • In CLI do Copilot, use /plan.
  • Em Bate-papo do Copilot em Visual Studio Code, selecione "Plan" na lista suspensa do agente ou digite plan na janela de contexto.
• 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. 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.

6. 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.

Próximas Etapas 

Além de melhorar a eficiência do agente, você também pode monitorar e gerenciar seus gastos para aproveitar ao máximo seu AI credits:

• Use o painel e os controles de orçamento. A página "Uso de IA", em https://github.com/settings/billing, detalha o consumo por funcionalidade e modelo, para que você possa ver onde seus créditos estão sendo gastos e ajustar seu uso de acordo.
• Identifique padrões dispendiosos antes que os custos se acumulem. Em uma sessão CLI do Copilot, use /usage para ver as métricas da sessão e identificar padrões de alto custo enquanto você trabalha. Além disso, /chronicle tips analisa o histórico de sessão recente e apresenta oportunidades para usar Copilot com mais eficiência.
• Atualize para obter um subsídio maior. Se você se aproximar regularmente do limite mensal, um plano mais alto poderá ser mais econômico do que pagar pelo uso adicional, pois planos mais altos têm mais AI credit subsídios. Confira Sobre planos e benefícios individuais do GitHub Copilot e Exibindo e alterando seu plano do GitHub Copilot.