Melhores práticas de prompting

Esta é a referência única para engenharia de prompts com os modelos mais recentes do Claude, incluindo Claude Opus 4.6, Claude Sonnet 4.6 e Claude Haiku 4.5. Ela cobre técnicas fundamentais, controle de saída, uso de ferramentas, pensamento e sistemas agentic. Vá para a seção que corresponde à sua situação.

Princípios gerais

Seja claro e direto

Claude responde bem a instruções claras e explícitas. Ser específico sobre a saída desejada pode ajudar a melhorar os resultados. Se você quer comportamento "acima e além", solicite-o explicitamente em vez de contar com o modelo para inferir isso a partir de prompts vagos.

Pense em Claude como um funcionário brilhante mas novo que não tem contexto sobre suas normas e fluxos de trabalho. Quanto mais precisamente você explicar o que quer, melhor será o resultado.

Regra de ouro: Mostre seu prompt a um colega com contexto mínimo sobre a tarefa e peça-lhe para segui-lo. Se ele ficaria confuso, Claude também ficará.

• Seja específico sobre o formato de saída desejado e as restrições.
• Forneça instruções como etapas sequenciais usando listas numeradas ou pontos de bala quando a ordem ou completude das etapas importa.

Adicione contexto para melhorar o desempenho

Fornecer contexto ou motivação por trás de suas instruções, como explicar ao Claude por que tal comportamento é importante, pode ajudar Claude a entender melhor seus objetivos e entregar respostas mais direcionadas.

Claude é inteligente o suficiente para generalizar a partir da explicação.

Use exemplos efetivamente

Exemplos são uma das formas mais confiáveis de orientar o formato, tom e estrutura da saída do Claude. Alguns exemplos bem elaborados (conhecidos como prompting few-shot ou multishot) podem melhorar dramaticamente a precisão e consistência.

Ao adicionar exemplos, faça-os:

• Relevantes: Espelhem seu caso de uso real de perto.
• Diversos: Cubram casos extremos e variem o suficiente para que Claude não capte padrões não intencionais.
• Estruturados: Envolva exemplos em tags <example> (múltiplos exemplos em tags <examples>) para que Claude possa distingui-los das instruções.

Estruture prompts com tags XML

Tags XML ajudam Claude a analisar prompts complexos de forma inequívoca, especialmente quando seu prompt mistura instruções, contexto, exemplos e entradas variáveis. Envolver cada tipo de conteúdo em sua própria tag (por exemplo, <instructions>, <context>, <input>) reduz a má interpretação.

Melhores práticas:

• Use nomes de tags consistentes e descritivos em seus prompts.
• Aninhe tags quando o conteúdo tem uma hierarquia natural (documentos dentro de <documents>, cada um dentro de <document index="n">).

Dê um papel ao Claude

Definir um papel no prompt do sistema foca o comportamento e tom do Claude para seu caso de uso. Até uma única frase faz diferença:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    system="You are a helpful coding assistant specializing in Python.",
    messages=[
        {"role": "user", "content": "How do I sort a list of dictionaries by key?"}
    ],
)
print(message.content)

Prompting de contexto longo

Ao trabalhar com documentos grandes ou entradas ricas em dados (20k+ tokens), estruture seu prompt cuidadosamente para obter os melhores resultados:

• Coloque dados longos no topo: Coloque seus documentos longos e entradas perto do topo do seu prompt, acima de sua consulta, instruções e exemplos. Isso pode melhorar significativamente o desempenho em todos os modelos.

  Consultas no final podem melhorar a qualidade da resposta em até 30% em testes, especialmente com entradas complexas e multi-documentos.

• Estruture conteúdo e metadados de documentos com tags XML: Ao usar múltiplos documentos, envolva cada documento em tags <document> com subtags <document_content> e <source> (e outros metadados) para clareza.

  Exemplo de estrutura multi-documento

• Fundamente respostas em citações: Para tarefas de documentos longos, peça ao Claude para citar partes relevantes dos documentos primeiro antes de realizar sua tarefa. Isso ajuda Claude a cortar o ruído do resto do conteúdo do documento.

  Exemplo de extração de citações

Autoconhecimento do modelo

Se você gostaria que Claude se identificasse corretamente em sua aplicação ou usasse strings de API específicas:

The assistant is Claude, created by Anthropic. The current model is Claude Opus 4.6.

Para aplicativos alimentados por LLM que precisam especificar strings de modelo:

When an LLM is needed, please default to Claude Opus 4.6 unless the user requests otherwise. The exact model string for Claude Opus 4.6 is claude-opus-4-6.

Saída e formatação

Estilo de comunicação e verbosidade

Os modelos mais recentes do Claude têm um estilo de comunicação mais conciso e natural em comparação com modelos anteriores:

• Mais direto e fundamentado: Fornece relatórios de progresso baseados em fatos em vez de atualizações auto-celebratórias
• Mais conversacional: Ligeiramente mais fluente e coloquial, menos parecido com máquina
• Menos verboso: Pode pular resumos detalhados por eficiência, a menos que solicitado de outra forma

Isso significa que Claude pode pular resumos verbais após chamadas de ferramentas, pulando diretamente para a próxima ação. Se você preferir mais visibilidade em seu raciocínio:

After completing a task that involves tool use, provide a quick summary of the work you've done.

Controle o formato das respostas

Existem algumas maneiras particularmente eficazes de orientar a formatação da saída:

1. Diga ao Claude o que fazer em vez do que não fazer

   • Em vez de: "Não use markdown em sua resposta"
   • Tente: "Sua resposta deve ser composta de parágrafos de prosa fluida."

2. Use indicadores de formato XML

   • Tente: "Escreva as seções de prosa de sua resposta em tags <smoothly_flowing_prose_paragraphs>."

3. Corresponda o estilo do seu prompt à saída desejada

   O estilo de formatação usado em seu prompt pode influenciar o estilo de resposta do Claude. Se você ainda está tendo problemas de direcionabilidade com formatação de saída, tente corresponder o estilo do seu prompt ao estilo de saída desejado o máximo possível. Por exemplo, remover markdown do seu prompt pode reduzir o volume de markdown na saída.

4. Use prompts detalhados para preferências de formatação específicas

   Para mais controle sobre o uso de markdown e formatação, forneça orientação explícita:

<avoid_excessive_markdown_and_bullet_points>
When writing reports, documents, technical explanations, analyses, or any long-form content, write in clear, flowing prose using complete paragraphs and sentences. Use standard paragraph breaks for organization and reserve markdown primarily for `inline code`, code blocks (```...```), and simple headings (###, and ###). Avoid using **bold** and *italics*.

DO NOT use ordered lists (1. ...) or unordered lists (*) unless : a) you're presenting truly discrete items where a list format is the best option, or b) the user explicitly requests a list or ranking

Instead of listing items with bullets or numbers, incorporate them naturally into sentences. This guidance applies especially to technical writing. Using prose instead of excessive formatting will improve user satisfaction. NEVER output a series of overly short bullet points.

Your goal is readable, flowing text that guides the reader naturally through ideas rather than fragmenting information into isolated points.
</avoid_excessive_markdown_and_bullet_points>

Saída LaTeX

Claude Opus 4.6 usa LaTeX por padrão para expressões matemáticas, equações e explicações técnicas. Se você preferir texto simples, adicione as seguintes instruções ao seu prompt:

Format your response in plain text only. Do not use LaTeX, MathJax, or any markup notation such as \( \), $, or \frac{}{}. Write all math expressions using standard text characters (e.g., "/" for division, "*" for multiplication, and "^" for exponents).

Criação de documentos

Os modelos mais recentes do Claude se destacam na criação de apresentações, animações e documentos visuais com criatividade impressionante e forte seguimento de instruções. Os modelos produzem saída polida e utilizável na primeira tentativa na maioria dos casos.

Para melhores resultados com criação de documentos:

Create a professional presentation on [topic]. Include thoughtful design elements, visual hierarchy, and engaging animations where appropriate.

Migrando de respostas pré-preenchidas

A partir dos modelos Claude 4.6 e Claude Mythos Preview, respostas pré-preenchidas na última volta do assistente não são mais suportadas. No Mythos Preview, solicitações com mensagens de assistente pré-preenchidas retornam um erro 400. A inteligência do modelo e o seguimento de instruções avançaram de modo que a maioria dos casos de uso de pré-preenchimento não requer mais isso. Os modelos existentes continuarão a suportar pré-preenchimentos, e adicionar mensagens de assistente em outro lugar na conversa não é afetado.

Aqui estão cenários comuns de pré-preenchimento e como migrar para longe deles:

Uso de ferramentas

Uso de ferramentas

Os modelos mais recentes do Claude são treinados para seguimento preciso de instruções e se beneficiam de direção explícita para usar ferramentas específicas. Se você disser "você pode sugerir algumas mudanças", Claude às vezes fornecerá sugestões em vez de implementá-las, mesmo que fazer mudanças pudesse ser o que você pretendia.

Para que Claude tome ação, seja mais explícito:

Para tornar Claude mais proativo em tomar ação por padrão, você pode adicionar isso ao seu prompt do sistema:

<default_to_action>
By default, implement changes rather than only suggesting them. If the user's intent is unclear, infer the most useful likely action and proceed, using tools to discover any missing details instead of guessing. Try to infer the user's intent about whether a tool call (e.g., file edit or read) is intended or not, and act accordingly.
</default_to_action>

Por outro lado, se você quer que o modelo seja mais hesitante por padrão, menos propenso a pular direto para implementações e apenas tomar ação se solicitado, você pode orientar esse comportamento com um prompt como o abaixo:

<do_not_act_before_instructions>
Do not jump into implementatation or changes files unless clearly instructed to make changes. When the user's intent is ambiguous, default to providing information, doing research, and providing recommendations rather than taking action. Only proceed with edits, modifications, or implementations when the user explicitly requests them.
</do_not_act_before_instructions>

Claude Opus 4.5 e Claude Opus 4.6 também são mais responsivos ao prompt do sistema do que modelos anteriores. Se seus prompts foram projetados para reduzir o subtriggering em ferramentas ou habilidades, esses modelos podem agora overtrigger. A correção é reduzir qualquer linguagem agressiva. Onde você poderia ter dito "CRÍTICO: Você DEVE usar essa ferramenta quando...", você pode usar prompting mais normal como "Use essa ferramenta quando...".

Otimize chamadas de ferramentas paralelas

Os modelos mais recentes do Claude se destacam na execução paralela de ferramentas. Esses modelos irão:

• Executar múltiplas buscas especulativas durante pesquisa
• Ler vários arquivos de uma vez para construir contexto mais rápido
• Executar comandos bash em paralelo (o que pode até criar gargalo no desempenho do sistema)

Esse comportamento é facilmente direcionável. Embora o modelo tenha uma alta taxa de sucesso em chamadas de ferramentas paralelas sem prompting, você pode aumentar isso para ~100% ou ajustar o nível de agressão:

<use_parallel_tool_calls>
If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentially. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible to increase speed and efficiency. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
</use_parallel_tool_calls>

Execute operations sequentially with brief pauses between each step to ensure stability.

Pensamento e raciocínio

Excesso de pensamento e minuciosidade excessiva

Claude Opus 4.6 faz significativamente mais exploração inicial do que modelos anteriores, especialmente em configurações de effort mais altas. Esse trabalho inicial frequentemente ajuda a otimizar os resultados finais, mas o modelo pode reunir contexto extenso ou perseguir múltiplas linhas de pesquisa sem ser solicitado. Se seus prompts anteriormente encorajavam o modelo a ser mais minucioso, você deve ajustar essa orientação para Claude Opus 4.6:

• Substitua padrões genéricos por instruções mais direcionadas. Em vez de "Padrão para usar [ferramenta]," adicione orientação como "Use [ferramenta] quando isso melhoraria sua compreensão do problema."
• Remova over-prompting. Ferramentas que undertriggered em modelos anteriores provavelmente triggering apropriadamente agora. Instruções como "Se em dúvida, use [ferramenta]" causarão overtriggering.
• Use effort como fallback. Se Claude continuar sendo excessivamente agressivo, use uma configuração mais baixa para effort.

Em alguns casos, Claude Opus 4.6 pode pensar extensivamente, o que pode inflar tokens de pensamento e desacelerar respostas. Se esse comportamento for indesejável, você pode adicionar instruções explícitas para restringir seu raciocínio, ou você pode baixar a configuração de effort para reduzir o pensamento geral e o uso de tokens.

When you're deciding how to approach a problem, choose an approach and commit to it. Avoid revisiting decisions unless you encounter new information that directly contradicts your reasoning. If you're weighing two approaches, pick one and see it through. You can always course-correct later if the chosen approach fails.

Se você precisar de um teto rígido em custos de pensamento, pensamento estendido com um limite de budget_tokens ainda é funcional em Opus 4.6 e Sonnet 4.6 mas está deprecado. Prefira baixar a configuração de effort ou usar max_tokens como um limite rígido com pensamento adaptativo.

Aproveite as capacidades de pensamento e pensamento intercalado

Os modelos mais recentes do Claude oferecem capacidades de pensamento que podem ser especialmente úteis para tarefas envolvendo reflexão após uso de ferramentas ou raciocínio complexo multi-etapa. Você pode guiar seu pensamento inicial ou intercalado para melhores resultados.

Claude Opus 4.6 e Claude Sonnet 4.6 usam pensamento adaptativo (thinking: {type: "adaptive"}), onde Claude decide dinamicamente quando e quanto pensar. Claude calibra seu pensamento com base em dois fatores: o parâmetro effort e a complexidade da consulta. Effort mais alto elicia mais pensamento, e consultas mais complexas fazem o mesmo. Em consultas mais fáceis que não requerem pensamento, o modelo responde diretamente. Em avaliações internas, pensamento adaptativo impulsiona de forma confiável melhor desempenho do que pensamento estendido. Considere mudar para pensamento adaptativo para obter as respostas mais inteligentes.

Use pensamento adaptativo para cargas de trabalho que requerem comportamento agentic como uso de ferramentas multi-etapa, tarefas de codificação complexas e loops de agente de longo horizonte. Modelos mais antigos usam modo de pensamento manual com budget_tokens.

Você pode guiar o comportamento de pensamento do Claude:

After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.

O comportamento de triggering para pensamento adaptativo é promptável. Se você achar que o modelo está pensando mais frequentemente do que gostaria, o que pode acontecer com prompts de sistema grandes ou complexos, adicione orientação para dirigi-lo:

Extended thinking adds latency and should only be used when it will meaningfully improve answer quality - typically for problems that require multi-step reasoning. When in doubt, respond directly.

Se você está migrando de pensamento estendido com budget_tokens, substitua sua configuração de pensamento e mova o controle de orçamento para effort:

Antes (pensamento estendido, modelos mais antigos):

client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=64000,
    thinking={"type": "enabled", "budget_tokens": 32000},
    messages=[{"role": "user", "content": "..."}],
)

Depois (pensamento adaptativo):

client.messages.create(
    model="claude-opus-4-6",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # or max, medium, low
    messages=[{"role": "user", "content": "..."}],
)

Se você não está usando pensamento estendido, nenhuma mudança é necessária. Pensamento está desligado por padrão quando você omite o parâmetro thinking.

• Prefira instruções gerais sobre passos prescritivos. Um prompt como "pense minuciosamente" frequentemente produz melhor raciocínio do que um plano passo-a-passo escrito à mão. O raciocínio do Claude frequentemente excede o que um humano prescreveria.
• Exemplos multishot funcionam com pensamento. Use tags <thinking> dentro de seus exemplos few-shot para mostrar ao Claude o padrão de raciocínio. Ele generalizará esse estilo para seus próprios blocos de pensamento estendido.
• CoT manual como fallback. Quando pensamento está desligado, você ainda pode encorajar raciocínio passo-a-passo pedindo ao Claude para pensar sobre o problema. Use tags estruturadas como <thinking> e <answer> para separar claramente raciocínio da saída final.
• Peça ao Claude para auto-verificar. Acrescente algo como "Antes de terminar, verifique sua resposta contra [critérios de teste]." Isso captura erros de forma confiável, especialmente para codificação e matemática.

Sistemas agentic

Raciocínio de longo horizonte e rastreamento de estado

Os modelos mais recentes do Claude se destacam em tarefas de raciocínio de longo horizonte com capacidades de rastreamento de estado excepcionais. Claude mantém orientação em sessões estendidas focando em progresso incremental, fazendo avanços constantes em algumas coisas de cada vez em vez de tentar tudo de uma vez. Essa capacidade emerge especialmente em múltiplas janelas de contexto ou iterações de tarefa, onde Claude pode trabalhar em uma tarefa complexa, salvar o estado e continuar com uma janela de contexto fresca.

Consciência de contexto e fluxos de trabalho multi-janela

Os modelos Claude 4.6 e Claude 4.5 apresentam consciência de contexto, permitindo que o modelo rastreie sua janela de contexto restante (ou seja, "orçamento de tokens") ao longo de uma conversa. Isso permite que Claude execute tarefas e gerencie contexto de forma mais eficaz compreendendo quanto espaço tem para trabalhar.

Gerenciando limites de contexto:

Se você está usando Claude em um harness de agente que compacta contexto ou permite salvar contexto em arquivos externos (como em Claude Code), considere adicionar essa informação ao seu prompt para que Claude possa se comportar de acordo. Caso contrário, Claude pode às vezes tentar naturalmente encerrar o trabalho conforme se aproxima do limite de contexto. Abaixo está um prompt de exemplo:

Your context window will be automatically compacted as it approaches its limit, allowing you to continue working indefinitely from where you left off. Therefore, do not stop tasks early due to token budget concerns. As you approach your token budget limit, save your current progress and state to memory before the context window refreshes. Always be as persistent and autonomous as possible and complete tasks fully, even if the end of your budget is approaching. Never artificially stop any task early regardless of the context remaining.

A ferramenta de memória combina naturalmente com consciência de contexto para transições de contexto perfeitas.

Fluxos de trabalho multi-janela de contexto

Para tarefas que abrangem múltiplas janelas de contexto:

1. Use um prompt diferente para a primeira janela de contexto: Use a primeira janela de contexto para configurar um framework (escrever testes, criar scripts de configuração), depois use futuras janelas de contexto para iterar em uma lista de tarefas.

2. Tenha o modelo escrever testes em um formato estruturado: Peça ao Claude para criar testes antes de começar o trabalho e acompanhá-los em um formato estruturado (por exemplo, tests.json). Isso leva a melhor capacidade de longo prazo para iterar. Lembre Claude da importância dos testes: "É inaceitável remover ou editar testes porque isso pode levar a funcionalidade ausente ou bugada."

3. Configure ferramentas de qualidade de vida: Encoraje Claude a criar scripts de configuração (por exemplo, init.sh) para iniciar graciosamente servidores, executar suites de teste e linters. Isso evita trabalho repetido ao continuar de uma janela de contexto fresca.

4. Começando do zero vs compactação: Quando uma janela de contexto é limpa, considere começar com uma janela de contexto completamente nova em vez de usar compactação. Os modelos mais recentes do Claude são extremamente eficazes em descobrir estado do sistema de arquivos local. Em alguns casos, você pode querer aproveitar isso sobre compactação. Seja prescritivo sobre como deve começar:

   • "Call pwd; you can only read and write files in this directory."
   • "Review progress.txt, tests.json, and the git logs."
   • "Manually run through a fundamental integration test before moving on to implementing new features."

5. Forneça ferramentas de verificação: Conforme o comprimento de tarefas autônomas cresce, Claude precisa verificar correção sem feedback humano contínuo. Ferramentas como servidor Playwright MCP ou capacidades de uso de computador para testar UIs são úteis.

6. Encoraje uso completo de contexto: Solicite ao Claude para completar eficientemente componentes antes de passar para o próximo:

This is a very long task, so it may be beneficial to plan out your work clearly. It's encouraged to spend your entire output context working on the task - just make sure you don't run out of context with significant uncommitted work. Continue working systematically until you have completed this task.

Melhores práticas de gerenciamento de estado

• Use formatos estruturados para dados de estado: Ao rastrear informações estruturadas (como resultados de testes ou status de tarefa), use JSON ou outros formatos estruturados para ajudar Claude a entender requisitos de esquema
• Use texto não estruturado para notas de progresso: Notas de progresso em forma livre funcionam bem para rastrear progresso geral e contexto
• Use git para rastreamento de estado: Git fornece um log do que foi feito e checkpoints que podem ser restaurados. Os modelos mais recentes do Claude funcionam especialmente bem em usar git para rastrear estado em múltiplas sessões.
• Enfatize progresso incremental: Peça explicitamente ao Claude para acompanhar seu progresso e focar em trabalho incremental

Equilibrando autonomia e segurança

Sem orientação, Claude Opus 4.6 pode tomar ações que são difíceis de reverter ou afetam sistemas compartilhados, como deletar arquivos, force-push ou postar em serviços externos. Se você quer que Claude Opus 4.6 confirme antes de tomar ações potencialmente arriscadas, adicione orientação ao seu prompt:

Consider the reversibility and potential impact of your actions. You are encouraged to take local, reversible actions like editing files or running tests, but for actions that are hard to reverse, affect shared systems, or could be destructive, ask the user before proceeding.

Examples of actions that warrant confirmation:
- Destructive operations: deleting files or branches, dropping database tables, rm -rf
- Hard to reverse operations: git push --force, git reset --hard, amending published commits
- Operations visible to others: pushing code, commenting on PRs/issues, sending messages, modifying shared infrastructure

When encountering obstacles, do not use destructive actions as a shortcut. For example, don't bypass safety checks (e.g. --no-verify) or discard unfamiliar files that may be in-progress work.

Pesquisa e coleta de informações

Os modelos mais recentes do Claude demonstram capacidades de busca agentic excepcionais e podem encontrar e sintetizar informações de múltiplas fontes efetivamente. Para resultados de pesquisa ótimos:

1. Forneça critérios de sucesso claros: Defina o que constitui uma resposta bem-sucedida para sua pergunta de pesquisa

2. Encoraje verificação de fonte: Peça ao Claude para verificar informações em múltiplas fontes

3. Para tarefas de pesquisa complexas, use uma abordagem estruturada:

Search for this information in a structured way. As you gather data, develop several competing hypotheses. Track your confidence levels in your progress notes to improve calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or research notes file to persist information and provide transparency. Break down this complex research task systematically.

Essa abordagem estruturada permite que Claude encontre e sintetize praticamente qualquer informação e critique iterativamente suas descobertas, não importa o tamanho do corpus.

Orquestração de subagentes

Os modelos mais recentes do Claude demonstram capacidades significativamente melhoradas de orquestração nativa de subagentes. Esses modelos podem reconhecer quando tarefas se beneficiariam de delegar trabalho a subagentes especializados e fazê-lo proativamente sem exigir instrução explícita.

Para aproveitar esse comportamento:

1. Garanta ferramentas de subagente bem definidas: Tenha ferramentas de subagente disponíveis e descritas em definições de ferramentas
2. Deixe Claude orquestrar naturalmente: Claude delegará apropriadamente sem instrução explícita
3. Observe o uso excessivo: Claude Opus 4.6 tem uma forte predileção por subagentes e pode gerá-los em situações onde uma abordagem mais simples e direta seria suficiente. Por exemplo, o modelo pode gerar subagentes para exploração de código quando uma chamada grep direta é mais rápida e suficiente.

Se você está vendo uso excessivo de subagentes, adicione orientação explícita sobre quando subagentes são e não são justificados:

Use subagents when tasks can run in parallel, require isolated context, or involve independent workstreams that don't need to share state. For simple tasks, sequential operations, single-file edits, or tasks where you need to maintain context across steps, work directly rather than delegating.

Encadear prompts complexos

Com pensamento adaptativo e orquestração de subagentos, Claude lida com a maioria do raciocínio multi-etapas internamente. O encadeamento explícito de prompts (dividir uma tarefa em chamadas sequenciais de API) ainda é útil quando você precisa inspecionar saídas intermediárias ou impor uma estrutura de pipeline específica.

O padrão de encadeamento mais comum é autocorreção: gerar um rascunho → fazer Claude revisar contra critérios → fazer Claude refinar com base na revisão. Cada etapa é uma chamada de API separada para que você possa registrar, avaliar ou ramificar em qualquer ponto.

Reduzir criação de arquivos em codificação com agentes

Os modelos mais recentes do Claude podem às vezes criar novos arquivos para fins de teste e iteração, particularmente ao trabalhar com código. Essa abordagem permite que Claude use arquivos, especialmente scripts Python, como um 'bloco de rascunho temporário' antes de salvar sua saída final. O uso de arquivos temporários pode melhorar os resultados, particularmente para casos de uso de codificação com agentes.

Se você preferir minimizar a criação de novos arquivos, pode instruir Claude a limpar após si mesmo:

If you create any temporary new files, scripts, or helper files for iteration, clean up these files by removing them at the end of the task.

Excesso de entusiasmo

Claude Opus 4.5 e Claude Opus 4.6 têm uma tendência a superengenharia criando arquivos extras, adicionando abstrações desnecessárias ou construindo flexibilidade que não foi solicitada. Se você está vendo esse comportamento indesejado, adicione orientação específica para manter as soluções mínimas.

Por exemplo:

Avoid over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused:

- Scope: Don't add features, refactor code, or make "improvements" beyond what was asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need extra configurability.

- Documentation: Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.

- Defensive coding: Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).

- Abstractions: Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. The right amount of complexity is the minimum needed for the current task.

Evitar focar em passar em testes e hard-coding

Claude às vezes pode focar muito em fazer testes passarem em detrimento de soluções mais gerais, ou pode usar workarounds como scripts auxiliares para refatoração complexa em vez de usar ferramentas padrão diretamente. Para evitar esse comportamento e garantir soluções robustas e generalizáveis:

Please write a high-quality, general-purpose solution using the standard tools available. Do not create helper scripts or workarounds to accomplish the task more efficiently. Implement a solution that works correctly for all valid inputs, not just the test cases. Do not hard-code values or create solutions that only work for specific test inputs. Instead, implement the actual logic that solves the problem generally.

Focus on understanding the problem requirements and implementing the correct algorithm. Tests are there to verify correctness, not to define the solution. Provide a principled implementation that follows best practices and software design principles.

If the task is unreasonable or infeasible, or if any of the tests are incorrect, please inform me rather than working around them. The solution should be robust, maintainable, and extendable.

Minimizar alucinações em codificação com agentes

Os modelos mais recentes do Claude são menos propensos a alucinações e fornecem respostas mais precisas, fundamentadas e inteligentes baseadas no código. Para encorajar ainda mais esse comportamento e minimizar alucinações:

<investigate_before_answering>
Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering. Make sure to investigate and read relevant files BEFORE answering questions about the codebase. Never make any claims about code before investigating unless you are certain of the correct answer - give grounded and hallucination-free answers.
</investigate_before_answering>

Dicas específicas de capacidade

Capacidades de visão melhoradas

Claude Opus 4.5 e Claude Opus 4.6 têm capacidades de visão melhoradas em comparação com modelos Claude anteriores. Eles têm melhor desempenho em tarefas de processamento de imagem e extração de dados, particularmente quando há múltiplas imagens presentes no contexto. Essas melhorias se estendem ao uso de computador, onde os modelos podem interpretar de forma mais confiável capturas de tela e elementos de UI. Você também pode usar esses modelos para analisar vídeos dividindo-os em quadros.

Uma técnica que se mostrou eficaz para impulsionar ainda mais o desempenho é dar ao Claude uma ferramenta de corte ou skill. Testes mostraram melhoria consistente em avaliações de imagem quando Claude é capaz de "ampliar" regiões relevantes de uma imagem. Anthropic criou um cookbook para a ferramenta de corte.

Design de frontend

Claude Opus 4.5 e Claude Opus 4.6 se destacam na construção de aplicações web complexas e do mundo real com design de frontend forte. No entanto, sem orientação, os modelos podem usar padrões genéricos que criam o que os usuários chamam de estética "AI slop". Para criar frontends distintivos e criativos que surpreendem e encantam:

Aqui está um trecho de prompt de sistema que você pode usar para encorajar um melhor design de frontend:

<frontend_aesthetics>
You tend to converge toward generic, "on distribution" outputs. In frontend design, this creates what users call the "AI slop" aesthetic. Avoid this: make creative, distinctive frontends that surprise and delight.

Focus on:
- Typography: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics.
- Color & Theme: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Draw from IDE themes and cultural aesthetics for inspiration.
- Motion: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions.
- Backgrounds: Create atmosphere and depth rather than defaulting to solid colors. Layer CSS gradients, use geometric patterns, or add contextual effects that match the overall aesthetic.

Avoid generic AI-generated aesthetics:
- Overused font families (Inter, Roboto, Arial, system fonts)
- Clichéd color schemes (particularly purple gradients on white backgrounds)
- Predictable layouts and component patterns
- Cookie-cutter design that lacks context-specific character

Interpret creatively and make unexpected choices that feel genuinely designed for the context. Vary between light and dark themes, different fonts, different aesthetics. You still tend to converge on common choices (Space Grotesk, for example) across generations. Avoid this: it is critical that you think outside the box!
</frontend_aesthetics>

Você também pode consultar a definição completa de skill.

Considerações de migração

Ao migrar para modelos Claude 4.6 de gerações anteriores:

1. Seja específico sobre o comportamento desejado: Considere descrever exatamente o que você gostaria de ver na saída.

2. Estruture suas instruções com modificadores: Adicionar modificadores que encorajam Claude a aumentar a qualidade e o detalhe de sua saída pode ajudar a moldar melhor o desempenho do Claude. Por exemplo, em vez de "Criar um painel de análise", use "Criar um painel de análise. Inclua o máximo de recursos e interações relevantes possível. Vá além do básico para criar uma implementação completa."

3. Solicite recursos específicos explicitamente: Animações e elementos interativos devem ser solicitados explicitamente quando desejados.

4. Atualize a configuração de pensamento: Os modelos Claude 4.6 usam pensamento adaptativo (thinking: {type: "adaptive"}) em vez de pensamento manual com budget_tokens. Use o parâmetro de esforço para controlar a profundidade do pensamento.

5. Migre para longe de respostas pré-preenchidas: Respostas pré-preenchidas no último turno do assistente estão descontinuadas a partir dos modelos Claude 4.6. Consulte Migrando para longe de respostas pré-preenchidas para orientação detalhada sobre alternativas.

6. Ajuste o prompt anti-preguiça: Se seus prompts anteriormente encorajavam o modelo a ser mais minucioso ou usar ferramentas mais agressivamente, reduza essa orientação. Os modelos Claude 4.6 são significativamente mais proativos e podem sobreativar em instruções que eram necessárias para modelos anteriores.

Para etapas de migração detalhadas, consulte o Guia de migração.

Migrando de Claude Sonnet 4.5 para Claude Sonnet 4.6

Claude Sonnet 4.6 usa como padrão um nível de esforço de high, em contraste com Claude Sonnet 4.5 que não tinha parâmetro de esforço. Considere ajustar o parâmetro de esforço conforme você migra de Claude Sonnet 4.5 para Claude Sonnet 4.6. Se não for explicitamente definido, você pode experimentar latência mais alta com o nível de esforço padrão.

Configurações de esforço recomendadas:

• Medium para a maioria das aplicações
• Low para cargas de trabalho de alto volume ou sensíveis à latência
• Defina um orçamento de token de saída máximo grande (64k tokens recomendados) em esforço médio ou alto para dar ao modelo espaço para pensar e agir

Quando usar Opus 4.6 em vez disso: Para os problemas mais difíceis e de horizonte mais longo (migrações de código em larga escala, pesquisa profunda, trabalho autônomo estendido), Opus 4.6 permanece a escolha certa. Sonnet 4.6 é otimizado para cargas de trabalho onde o retorno rápido e a eficiência de custo são mais importantes.

Se você não estiver usando pensamento estendido

Se você não estiver usando pensamento estendido em Claude Sonnet 4.5, você pode continuar sem ele em Claude Sonnet 4.6. Você deve definir explicitamente o esforço para o nível apropriado para seu caso de uso. Com esforço low e pensamento desabilitado, você pode esperar desempenho similar ou melhor em relação a Claude Sonnet 4.5 sem pensamento estendido.

client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    thinking={"type": "disabled"},
    output_config={"effort": "low"},
    messages=[{"role": "user", "content": "..."}],
)

Se você estiver usando pensamento estendido

Se você estiver usando pensamento estendido com budget_tokens em Claude Sonnet 4.5, ainda é funcional em Claude Sonnet 4.6 mas está descontinuado. Migre para pensamento adaptativo com o parâmetro de esforço.

Migrando para pensamento adaptativo

O pensamento adaptativo é particularmente bem adequado para os seguintes padrões de carga de trabalho:

• Agentes autônomos multi-etapas: agentes de codificação que transformam requisitos em software funcionando, pipelines de análise de dados e busca de bugs onde o modelo funciona independentemente em muitas etapas. O pensamento adaptativo permite que o modelo calibre seu raciocínio por etapa, mantendo-se no caminho em trajetórias mais longas. Para essas cargas de trabalho, comece com esforço high. Se latência ou uso de token for uma preocupação, reduza para medium.
• Agentes de uso de computador: Claude Sonnet 4.6 alcançou precisão de melhor classe em avaliações de uso de computador usando modo adaptativo.
• Cargas de trabalho bimodais: uma mistura de tarefas fáceis e difíceis onde adaptativo pula pensamento em consultas simples e raciocina profundamente em complexas.

Ao usar pensamento adaptativo, avalie esforço medium e high em suas tarefas. O nível certo depende da compensação de sua carga de trabalho entre qualidade, latência e uso de token.

client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)

Mantendo budget_tokens durante a migração

Se você precisar manter budget_tokens temporariamente durante a migração, um orçamento em torno de 16k tokens fornece espaço para problemas mais difíceis sem risco de uso de token descontrolado. Essa configuração está descontinuada e será removida em uma versão futura do modelo.

Para casos de uso de codificação (codificação com agentes, fluxos de trabalho pesados em ferramentas, geração de código), comece com esforço medium:

client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16384,
    thinking={"type": "enabled", "budget_tokens": 16384},
    output_config={"effort": "medium"},
    messages=[{"role": "user", "content": "..."}],
)

Para chat e casos de uso não-codificação (chat, geração de conteúdo, busca, classificação), comece com esforço low:

client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    thinking={"type": "enabled", "budget_tokens": 16384},
    output_config={"effort": "low"},
    messages=[{"role": "user", "content": "..."}],
)