{"meta":{"title":"Otimizar o uso de IA para maximizar a eficiência e reduzir o custo","intro":"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.","product":"GitHub Copilot","breadcrumbs":[{"href":"/pt/copilot","title":"GitHub Copilot"},{"href":"/pt/copilot/tutorials","title":"Tutoriais"},{"href":"/pt/copilot/tutorials/optimize-ai-usage","title":"Otimizar o uso de IA"}],"documentType":"article"},"body":"# Otimizar o uso de IA para maximizar a eficiência e reduzir o custo\n\nSaiba 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.\n\n## Introduction\n\nAs estratégias descritas neste artigo mostram como melhorar Copilot a eficiência e, como resultado, usar menos AI credits.\n\n## 1. Escolha o modelo certo para a tarefa certa\n\nSelecionando 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.\n\n### Selecione o modelo certo\n\nA 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.\n\nEscolha o modelo com base no trabalho envolvido:\n\n* **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.\n* **Modelos intermediários**: ideais quando o plano já está claro e o agente precisa executar com eficiência.\n* **Modelos mais leves**: melhores para refatoração, formatação, atualizações de documentação e outras alterações rotineiras e bem delimitadas.\n\nUse 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.\n\nPara obter uma divisão por modelo e tipo de tarefa, consulte [Comparação de modelos de IA usando tarefas diferentes](/pt/copilot/tutorials/compare-ai-models).\n\n### Configurar o nível de raciocínio do modelo\n\nAlguns 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.\n\nConsulte [Modelos de IA com suporte no GitHub Copilot](/pt/copilot/reference/ai-models/supported-models#models-with-extended-capabilities).\n\n### Usar Copilot seleção automática de modelo como padrão\n\nSeleção de modelo automática escolhe um modelo capaz para você, com base na intenção de sua tarefa.\n\nUm 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.\n\nSeleçã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](#4-preserve-the-cache).\n\nSeleçã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.\n\nIf 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.\n\nPara obter informações sobre o recurso e sua disponibilidade, consulte [Sobre CopilotSeleção de modelo automática](/pt/copilot/concepts/models/auto-model-selection#copilot-chat-in-ides).\n\n### Usar modelos mais baratos para subagentes\n\nExecute subagentes em modelos mais baratos.\nSubagentes 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.\n\n## 2. Forneça diretrizes claras em seus prompts\n\nSeu 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.\n\nOs prompts bem estruturados têm três qualidades:\n\n* **Uma definição de tarefa clara.** Em vez de \"corrigir esse problema\", explique qual é o problema, onde ele ocorre e como é o resultado esperado.\n* **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.\n* **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.\n\nEssa 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.\n\nPara obter as melhores práticas de engenharia de prompt, consulte [Engenharia de prompts para o GitHub Copilot Chat](/pt/copilot/concepts/prompting/prompt-engineering).\n\n## 3. Mantenha o contexto enxuto\n\nCopilot 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.\n\nPara manter o contexto sob controle, considere fazer o seguinte:\n\n### Inicie uma nova conversa ao mudar de problema\n\nUm 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:\n\n* Em CLI do Copilot uso `/new` (ou `/clear`)\n* In Bate-papo do Copilot, inicie uma nova sessão de chat.\n\n### Compactar sessões CLI do Copilot longas que você deseja retomar\n\nQuando 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`).\n\nAlém disso, você pode usar `/context` para verificar o uso atual a qualquer momento.\n\nConsulte [Gerenciando o contexto em CLI do GitHub Copilot](/pt/copilot/concepts/agents/copilot-cli/context-management).\n\n### Fornecer Copilot um mapa do seu projeto\n\nUm 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](/pt/copilot/reference/custom-instructions-support).\n\n### Traga apenas as ferramentas necessárias\n\nConjuntos 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.\n\nConsulte [Configurando conjuntos de ferramentas para o servidor MCP GitHub](/pt/copilot/how-tos/provide-context/use-mcp-in-your-ide/configure-toolsets).\n\n## 4. Preservar o cache\n\nO 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](/pt/copilot/reference/copilot-billing/models-and-pricing).\n\nNo entanto, as seguintes ações invalidam o cache, fazendo com que o contexto completo seja reenviado e cobrado como tokens de entrada novos:\n\n* **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.\n* **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.\n* **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.\n\n## 5. Definir AI credit limites de sessão\n\nUm AI credit limite de sessão limita a quantidade de trabalho Copilot executada em uma única sessão.\n\nDentro CLI do Copilot e SDK do Copilot, você pode definir um limite de sessão antes de iniciar uma tarefa e, quando o limite é atingido, o agente para de forma limpa, notifica você e permite que você escolha se deseja continuar ou aumentar o limite.\n\nAI credit os limites de sessão são mais úteis quando:\n\n* Você deseja limitar AI credits o uso em uma única sessão para evitar custos inesperados.\n* Você está ajustando a eficiência do agente e quer encontrar o mínimo AI credits que ainda produza um bom resultado.\n\nOs limites de sessão são limites suaves que ajudam a controlar quantas AI credits tarefas individuais consomem, mas não substituem os orçamentos no nível do usuário ou os limites de gastos, que regem o consumo mensal geral. Para esses controles, consulte [Orçamentos para cobrança baseada em uso](/pt/copilot/concepts/billing/budgets-for-usage-based-billing).\n\nPara obter informações sobre como definir um limite de sessão, CLI do Copilotconsulte [Definindo um AI credit limite de sessão em CLI do GitHub Copilot](/pt/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit).\n\n## 6. Pesquisar, planejar e implementar\n\nUma 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.\n\nDividir o trabalho em fases claras:\n\n* **Pesquisa:** Use o agente para explorar a base de código, identificar arquivos relevantes e entender as dependências.\n* **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.\n  * Em CLI do Copilot, use `/plan`.\n  * Em Bate-papo do Copilot em Visual Studio Code, selecione \"Planejar\" na lista suspensa do agente ou digite `plan` na janela de contexto.\n* **Implementar:** Execute de acordo com o plano usando um contexto focado e um modelo adequado para execução.\n\nIniciar 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](/pt/copilot/tutorials/cloud-agent/get-the-best-results).\n\n## 7. Utilizar aprendizados para ser mais eficiente a cada turno\n\n### Use `/chronicle` para gerar análises\n\nEm CLI do Copilot, `/chronicle` pode gerar insights úteis com base no histórico da sua sessão.\n\n* Use `/chronicle tips` para analisar o histórico da sua sessão recente e identificar oportunidades de usar Copilot com mais eficiência.\n* Use `/chronicle cost-tips` para entender os padrões de uso do token e obter insights sobre como reduzir o custo.\n\nConsulte [Sobre os dados de sessão CLI do GitHub Copilot](/pt/copilot/concepts/agents/copilot-cli/chronicle#the-chronicle-slash-command).\n\n### Inserir insights em um arquivo `copilot-instructions.md`\n\nUm `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.\n\nQuando `/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.\n\nPara obter mais informações, consulte [Adicionando instruções personalizadas do repositório para GitHub Copilot](/pt/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions).\n\n### Mantenha o arquivo `copilot-instructions.md` específico e baseado em fatos concretos\n\nInstruçõ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.\n\n**O que incluir:**\n\n* Estruturas, bibliotecas ou padrões de design necessários\n* Armadilhas conhecidas que o agente tende a repetir\n* Expectativas de saída, como \"ser conciso\" ou \"retorne apenas código\"\n* Convenções específicas da equipe que o agente deve seguir\n* Comandos de compilação, teste e lint\n\n**O que evitar:**\n\n* Documentação longa e genérica\n* Diretrizes geradas por IA que não refletem seu sistema real\n* Preferências pontuais ou detalhes raramente usados\n* Instruções sobrecarregadas que tornam o contexto barulhento\n\nMantenha 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.\n\n## 8. Adicionar proteções determinísticas\n\nOs 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.\n\nOs controles determinísticos introduzem sinais de passagem/falha claros:\n\n* **Os testes de unidade** verificam se as alterações do agente produziram o comportamento esperado.\n* **Linters** garantem estrutura e consistência, evitando problemas de formatação, inconsistências de estilo e retrabalho de limpeza desnecessário.\n* **As verificações de segurança** identificam padrões de risco cedo, antes que se tornem mais difíceis de corrigir.\n\nJuntos, 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.\n\nAs 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.\n\n## Próximas Etapas \n\nAcompanhe e gerencie seus gastos para aproveitar ao máximo seu AI credits:\n\n* **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. Consulte [Monitorar o uso de GitHub AI Credits](/pt/copilot/how-tos/manage-and-track-spending/monitor-ai-usage).\n* **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](/pt/copilot/concepts/billing/individual-plans#github-ai-credits-allowance-by-plan) e [Exibindo e alterando seu plano do GitHub Copilot](/pt/copilot/how-tos/manage-your-account/view-and-change-your-copilot-plan)."}