Otimizar o uso de IA para maximizar a eficiência e reduzir o custo

Saiba como escolher os modelos certos, estruturar seus prompts e adicionar salvaguardas para que Copilot conclua tarefas com mais eficiência e use menos AI credits.

Neste artigo

Introduction

As estratégias descritas neste artigo mostram como melhorar Copilot a eficiência e, como resultado, usar menos AI credits.

1. Escolha o modelo certo para a tarefa certa

Selecionando o nível de capacidade certo para sua tarefa, configurando o raciocínio adequadamente e aproveitando Seleção de modelo automática modelos mais baratos para cargas de trabalho específicas, você pode manter a qualidade, reduzindo significativamente o consumo de token.

Selecione o modelo certo

A escolha do modelo é uma das maneiras mais rápidas de melhorar a eficiência do custo, mas muitas vezes é 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.

Usar Copilot seleção automática de modelo como padrão

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

Um roteador pequeno examina seu prompt e o envia para o modelo que pode lidar com ele com mais eficiência, reservando modelos de raciocínio caros para problemas complexos. Ele também evita modelos que consomem rapidamente um orçamento de tokens.

Seleção de modelo automática também protege seu cache. Ele só altera modelos em limites de cache naturais, quando uma nova sessão é iniciada ou após a execução /compact, nunca no meio da tarefa. Para entender mais sobre por que isso importa, consulte 4. Preservar o cache.

Seleção de modelo automática também redireciona o tráfego para evitar modelos com desempenho degradado ou sobrecarregados, para que você enfrente menos limitações de taxa e erros.

If you are on a paid Copilot plan, you qualify for a 10% discount on model costs while using Seleção de modelo automática in Bate-papo do Copilot, CLI do Copilot, or agente de nuvem Copilot.

Para obter informações sobre o recurso e sua disponibilidade, consulte Sobre CopilotSeleção de modelo automática.

Usar modelos mais baratos para subagentes

Execute subagentes em modelos mais baratos. Subagentes executam em sua própria sessão e não herdam o histórico de conversas do agente principal. Como seu contexto se restringe a uma única tarefa específica, um modelo mais leve geralmente é suficiente — e atribuir um desses modelos não afeta o cache do agente principal como afetaria uma troca de modelo no meio da sessão.

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.

4. Preservar o cache

O cache permite que um modelo de IA armazene partes do contexto de uma conversa para que elas não precisem ser reprocessadas em cada solicitação. Na programação agêntica, em que o mesmo contexto extenso — prompt do sistema, conteúdo de arquivos e definições de ferramentas — é enviado repetidamente ao longo de muitas interações, o cache faz diferença: a parte armazenada em cache da resposta anterior é reutilizada em vez de ser reprocessada, e os tokens em cache normalmente são tarifados em 10% do preço normal dos tokens de entrada. Consulte Modelos e preços para GitHub Copilot.

No entanto, as seguintes ações invalidam o cache, fazendo com que o contexto completo seja reenviado e cobrado como tokens de entrada novos:

  • Alternar modelos no meio da sessão. Um modelo diferente não pode reutilizar o cache de outro modelo, portanto, a próxima solicitação o recompila do zero. Escolha um modelo (ou use Copilot seleção automática de modelo) e continue com ele durante a sessão.
  • Voltando a uma sessão antiga. Os caches expiram após um período de inatividade (24 horas para modelos OpenAI e 1 hora para a maioria dos outros). Se você esteve ausente por algum tempo, inicie uma nova sessão ou execute /compact (em CLI do Copilot) para que seja recriado um breve resumo, em vez do histórico completo.
  • Alterando o raciocínio no meio da sessão. Alterar o nível de esforço de raciocínio, o tamanho do contexto ou o conjunto de ferramentas e servidores MCP habilitados durante uma sessão invalida o cache. Defina essas configurações antes de começar e deixe-as inalteradas para a sessão.

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 e as informações irrelevantes se acumulam.

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 , sempre planeje com um modelo de raciocínio forte e implemente o trabalho com um modelo mais barato.
    • 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 que você carregue adiante contexto desnecessário, o que pode aumentar o uso de tokens 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. Utilize aprendizados para ser mais eficiente a cada turno

Use /chronicle para gerar análises

Em CLI do Copilot, /chronicle pode gerar insights úteis com base no histórico da sua sessão.

  • Use /chronicle tips para analisar o histórico da sua sessão recente e identificar oportunidades de usar Copilot com mais eficiência.
  • Use /chronicle cost-tips para entender os padrões de uso do token e obter insights sobre como reduzir o custo.

Consulte Sobre os dados de sessão CLI do GitHub Copilot.

Inserir insights em um arquivo copilot-instructions.md

Um copilot-instructions.md arquivo no nível do repositório é a maneira mais direta de codificar diretrizes específicas para o repositório. Instruções pessoais e no nível da organização podem ser adicionadas em camadas para garantir uma consistência mais ampla.

Quando /chronicle aparece um padrão recorrente — uma ferramenta sendo usada demais, um prompt que continua sendo mal lido — codifica essa observação diretamente em seu copilot-instructions.md arquivo. Isso transforma um insight pontual em uma orientação permanente que se aplica a todas as sessões futuras, sem que você precise repetir isso.

Para obter mais informações, consulte Adicionando instruções personalizadas do repositório para GitHub Copilot.

Mantenha o arquivo copilot-instructions.md específico e baseado em fatos concretos

Instruções persistentes melhoram a consistência entre as interações do agente, mas seu valor depende inteiramente de como elas são escritas. 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.

7. Adicione restrições 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 

Acompanhe e gerencie seus gastos para aproveitar ao máximo seu AI credits: