Cada questão tem uma jogada correta e três armadilhas.

Um agente de análise de documentos descobre que duas fontes confiáveis contêm estatísticas diretamente contraditórias para uma métrica-chave: um relatório governamental indica crescimento de 40%, enquanto uma análise da indústria indica 12%. Ambas as fontes parecem confiáveis e a discrepância pode afetar materialmente as conclusões da pesquisa. Como o agente de análise de documentos deve lidar com essa situação da forma mais efetiva?

Qual abordagem é mais efetiva?

CorretaD) Concluir a análise com ambos os números, anotar explicitamente o conflito com atribuição de fonte e deixar o coordenador decidir como reconciliar os dados antes de passá-los à síntese.

Esta abordagem preserva a separação de responsabilidades: o agente de análise conclui seu trabalho principal sem bloquear, preserva ambos os valores conflitantes com atribuição clara e passa corretamente a reconciliação ao coordenador, que tem contexto mais amplo.

O subagente de busca web retorna resultados para apenas 3 das 5 categorias de fontes solicitadas (sites de concorrentes e relatórios da indústria têm sucesso, mas arquivos de notícias e feeds sociais sofrem timeout). O subagente de análise de documentos processa com sucesso todos os documentos fornecidos. O subagente de síntese precisa produzir um sumário a partir de entradas a montante de qualidade mista. Qual estratégia de propagação de erro é mais efetiva?

Qual estratégia de propagação de erro é mais efetiva?

CorretaD) Estruturar a saída da síntese com anotações de cobertura indicando quais conclusões estão bem suportadas e onde existem lacunas devido a fontes indisponíveis.

Anotações de cobertura implementam degradação graciosa com transparência, preservando valor do trabalho concluído enquanto propagam incerteza para permitir decisões informadas sobre confiança.

Ao pesquisar "adoção de energia renovável", o agente de busca na web retorna estatísticas recentes (2024: 35% de adoção), enquanto o agente de análise de documentos extrai dados de relatórios internos (2022: 18% de adoção). O agente de síntese sinaliza incorretamente essas fontes como contraditórias, em vez de reconhecer que os dados mostram crescimento ao longo do tempo.

Qual mudança permitiria melhor que o agente de síntese interpretasse corretamente essas diferenças temporais?

CorretaA) Exigir que os subagentes incluam as datas de publicação ou de coleta de dados em suas saídas estruturadas.

Correto. O agente de síntese interpreta mal os dados porque nunca vê as datas. Fazer com que cada ponto de dado carregue seu próprio carimbo de data na saída estruturada permite que a síntese raciocine sobre tendências em vez de contradições.

Sua ferramenta `get_customer` retorna todas as correspondências ao buscar por nome. Atualmente, quando há múltiplos resultados, Claude escolhe o cliente com pedido mais recente, mas dados de produção mostram que isso seleciona a conta errada em 15% dos casos para correspondências ambíguas. Como você deveria tratar isso?

Como você deveria tratar isso?

CorretaB) Instruir Claude a pedir um identificador adicional (email, telefone ou número do pedido) quando `get_customer` retornar múltiplas correspondências antes de tomar qualquer ação específica do cliente.

Pedir ao usuário um identificador adicional é a forma mais confiável de resolver ambiguidade porque o usuário tem conhecimento definitivo da própria identidade. Um turno de conversa extra é um preço pequeno a pagar para eliminar uma taxa de erro de 15% causada por escolher a conta errada.

Revisões em produção revelam um tratamento inconsistente da incerteza nos relatórios finais. Às vezes, descobertas conflitantes dos subagentes são sintetizadas em uma única afirmação confiante (perdendo a nuance), enquanto outras vezes os relatórios fazem ressalvas em excesso com qualificações exageradas (tornando-se inúteis). Quando o agente de busca na web retorna "analistas do setor estimam um mercado de US$ 50 bi (a metodologia varia)" e o agente de análise de documentos retorna "estudo revisado por pares estima 35 bi (±7 bi, IC 95%)", o coordenador ou escolhe um arbitrariamente ou produz afirmações vagas como "o mercado pode ser de 35 bi a 50 bi dependendo de fatores".

Qual abordagem sistemática aborda melhor isso?

CorretaC) Instruir o agente de síntese a estruturar os relatórios com seções explícitas que distinguem descobertas bem estabelecidas das contestadas, preservando as caracterizações das fontes originais e o contexto metodológico.

Correto. Uma estrutura de relatório que mantém o contexto metodológico e separa afirmações consolidadas das contestadas é como se obtém nuance sem ressalvas em excesso.

Seu pipeline de extração processa contratos que frequentemente incluem aditivos. Quando um contrato contém tanto os termos originais quanto aditivos posteriores (por exemplo, a cláusula original especifica "30-day payment terms" enquanto o Aditivo 1 altera isso para "45 days"), o modelo extrai de forma inconsistente um valor ou o outro, sem indicar qual se aplica.

Qual é a abordagem mais eficaz para melhorar a precisão da extração em documentos com aditivos?

CorretaA) Redesenhar o esquema para que os campos alterados capturem múltiplos valores, cada um com sua localização na fonte e data de vigência.

Correto. Aditivos são estruturalmente sobre valores versionados. Um esquema com valor + localização na fonte + data de vigência modela o domínio corretamente e deixa de forçar o modelo a escolher um único.

Ao longo de vários turnos discutindo estratégia de investimento, um usuário declarou "tenho tolerância a risco muito baixa" e depois "quero maximizar meus retornos". Agora ele pergunta: "Em que devo investir?"

Qual abordagem melhor garante que a recomendação se alinhe com a prioridade real do usuário?

CorretaA) Trazer à tona a contradição e pedir ao usuário que esclareça o que importa mais.

Quando preferências do usuário se contradizem diretamente, trazer o conflito à tona e pedir esclarecimento é a única forma de garantir que a recomendação se alinhe com a real intenção do usuário. Qualquer outra abordagem envolve assumir algo que pode estar errado — maximizar retornos e baixa tolerância a risco são objetivos fundamentalmente incompatíveis que exigem decisão humana.

Um subagente de análise de documentos falha frequentemente ao processar arquivos PDF: alguns têm seções corrompidas que disparam exceções de parsing, outros são protegidos por senha e às vezes a biblioteca de parsing trava em arquivos grandes. Atualmente, qualquer exceção termina imediatamente o subagente e retorna um erro ao coordenador, que precisa decidir se retenta, pula ou falha a tarefa toda. Isso causa envolvimento excessivo do coordenador no tratamento rotineiro de erros. Qual melhoria arquitetural é mais efetiva?

Qual melhoria é mais efetiva?

CorretaD) Implementar recuperação local no subagente para falhas transitórias e escalar ao coordenador apenas erros que ele não consegue resolver, incluindo passos tentados e resultados parciais.

Trate erros no nível mais baixo capaz de resolvê-los. A recuperação local reduz a carga do coordenador enquanto ainda escala questões verdadeiramente irrecuperáveis com contexto completo e progresso parcial.

O subagente de análise de documentos encontra um arquivo PDF corrompido que ele não consegue parsear. Ao desenhar o tratamento de erros do sistema, qual é a forma mais efetiva de lidar com essa falha?

Qual abordagem é mais efetiva?

CorretaA) Retornar um erro com contexto ao agente coordenador, permitindo que ele decida como prosseguir.

Retornar um erro com contexto ao coordenador é a abordagem mais efetiva porque o deixa tomar uma decisão informada — pular o arquivo, tentar um método alternativo de parsing ou notificar o usuário — mantendo visibilidade da falha.

O subagente de busca web sofre timeout ao pesquisar um tema complexo. Você precisa desenhar como a informação sobre essa falha é retornada ao coordenador. Qual abordagem de propagação de erro melhor habilita recuperação inteligente?

Qual abordagem de propagação de erro melhor habilita recuperação inteligente?

CorretaA) Retornar contexto estruturado de erro ao coordenador, incluindo o tipo de falha, a query executada, quaisquer resultados parciais e abordagens alternativas potenciais.

Retornar contexto estruturado de erro — incluindo tipo de falha, query executada, resultados parciais e abordagens alternativas — dá ao coordenador tudo que precisa para tomar decisões inteligentes de recuperação (ex.: retentar com query modificada ou continuar com resultados parciais). Preserva o máximo de contexto para decisões informadas no nível de coordenação.

Durante a pesquisa, o subagente de busca web consulta três categorias de fontes com resultados diferentes: bases acadêmicas retornam 15 papers relevantes, relatórios da indústria retornam "0 resultados" e bases de patentes retornam "Connection timeout". Ao desenhar a propagação de erro para o coordenador, qual abordagem habilita as melhores decisões de recuperação?

Qual abordagem habilita as melhores decisões de recuperação?

CorretaD) Distinguir falhas de acesso (timeout) que exigem decisão de retry de resultados vazios válidos ("0 resultados") que representam queries bem-sucedidas.

Um timeout (falha de acesso) e "0 resultados" (resultado vazio válido) são desfechos semanticamente diferentes que exigem respostas diferentes. Distingui-los permite ao coordenador retentar a base de patentes enquanto aceita os "0 resultados" dos relatórios da indústria como achado válido e informativo.

Após chamar `get_customer` e `lookup_order`, o agente tem todos os dados disponíveis no sistema mas ainda enfrenta incerteza. Qual situação é o gatilho mais justificado para chamar `escalate_to_human`?

Qual situação é mais justificada para escalonamento?

CorretaC) Um cliente solicita matching de preço de concorrente. Suas políticas permitem ajustes de preço para quedas no próprio site dentro de 14 dias, mas não dizem nada sobre preços de concorrente. O agente deve escalar para interpretação de política.

Esta é uma genuína lacuna de política: regras da empresa cobrem quedas de preço no próprio site mas não tratam matching de concorrente. O agente não deve inventar política e deve escalar para julgamento humano sobre como interpretar ou estender regras existentes.

Você está implementando o loop do agente de suporte. Após cada chamada de API ao Claude, é preciso decidir se continua o loop (executa as ferramentas pedidas e chama Claude novamente) ou para (apresenta a resposta final ao cliente). O que determina essa decisão?

O que determina essa decisão?

CorretaA) Verificar o campo `stop_reason` na resposta do Claude — continuar se for `tool_use` e parar se for `end_turn`.

`stop_reason` é o sinal estruturado explícito do Claude para controle de loop: `tool_use` indica que Claude quer rodar uma ferramenta e receber resultados de volta, enquanto `end_turn` indica que Claude completou sua resposta e o loop deve encerrar.

Sua ferramenta de exploração de base de código armazena IDs de sessão para permitir que os engenheiros continuem investigações entre sessões de trabalho. Um engenheiro passou uma hora ontem analisando um módulo de autenticação legado, acumulando contexto sobre sua arquitetura e dependências. Ele quer continuar hoje. O ID da sessão é válido, mas o controle de versão mostra que 3 dos 12 arquivos que o agente leu anteriormente foram modificados durante a noite pelo merge de um colega.

Qual abordagem melhor equilibra eficiência e precisão?

CorretaC) Retomar a sessão e informar o agente sobre quais arquivos específicos mudaram para uma reanálise direcionada

Correto. Mantém o contexto custoso que você já construiu, ao mesmo tempo em que diz ao agente exatamente quais 3 arquivos reler — desperdício mínimo, precisão máxima.

O subagente de exploração de um engenheiro passou 30 minutos analisando um sistema de pagamentos legado, lendo 47 arquivos e documentando os fluxos de dados. A sessão foi interrompida quando a conexão do engenheiro caiu. Enquanto ele estava ausente, um colega fez o merge de um PR que renomeou duas funções utilitárias. O engenheiro quer continuar a mesma exploração.

Qual é a abordagem mais eficaz?

CorretaD) Retomar o subagente a partir de sua transcrição anterior e informá-lo sobre as funções renomeadas.

Correto. Mantenha o entendimento acumulado e dê a ele um delta direcionado sobre as renomeações para que possa atualizar seu modelo mental — desperdício mínimo, precisão máxima.

Você está implementando a lógica de escalonamento para quando o agente deve chamar `escalate_to_human`. Sua equipe propõe quatro abordagens diferentes para acionar o escalonamento.

Qual abordagem identificará de forma mais confiável os casos que genuinamente exigem intervenção humana?

CorretaA) Instruir o agente a escalonar quando o cliente solicitar um humano, quando o problema exigir exceções de política ou quando o agente não conseguir avançar de forma significativa.

Correto. Decisões de escalonamento são julgamentos sobre intenção e progresso — exatamente aquilo em que os LLMs são bons. Critérios claros em linguagem natural superam regras rígidas para a cauda longa.

Após investigar uma disputa de cobrança ao longo de mais de 25 turnos, você identificou que as cobranças duplicadas ocorreram devido a um timeout do gateway de pagamento que acionou a lógica de nova tentativa. O reembolso necessário (US$ 847) excede seu limite de autorização de US$ 500. Você precisa chamar `escalate_to_human`, e o agente humano não terá acesso à transcrição da sua conversa.

Qual contexto você deve repassar para permitir uma resolução eficaz?

CorretaB) Um resumo estruturado: ID do cliente, causa raiz, valor do reembolso e ação recomendada.

Correto. Um repasse estruturado com identificadores, causa, valor e ação recomendada é o que um agente humano precisa para assumir o caso instantaneamente, sem reinvestigar.

Durante a resolução de uma disputa de cobrança, seu agente recupera com sucesso as informações do cliente via `get_customer` e os detalhes do pedido via `lookup_order`, mas, ao tentar chamar `process_refund`, a ferramenta retorna um erro de timeout. O agente tem informações suficientes para explicar as cobranças e verificar a elegibilidade do reembolso, mas não consegue de fato processar o reembolso devido à falha no backend.

Qual abordagem equilibra melhor a resolução no primeiro contato com o tratamento de erros adequado?

CorretaC) Explicar a cobrança, confirmar a elegibilidade do reembolso, reconhecer o problema do sistema que impede o processamento imediato e oferecer escalonamento ou nova tentativa mais tarde.

Correto. Entregue o valor parcial que você pode (explicação + elegibilidade), seja honesto sobre a falha e deixe o cliente escolher entre escalonamento humano ou uma nova tentativa. Degradação graciosa clássica.

Um cliente escreve: "Já estou indo e voltando com essa devolução há dias. Só quero falar com alguém que possa realmente me ajudar." O agente confirmou via `lookup_order` que a devolução é simples — dentro da política e elegível para processamento imediato.

O que o agente deve fazer?

CorretaA) Reconhecer a frustração, informar que isso pode ser resolvido agora e oferecer-se para concluí-la ou escalonar.

Correto. Acolha o sentimento, ofereça por escrito o caminho de resolução rápida e preserve a escolha do cliente. Essa é a atitude de respeito ao cliente que ainda aproveita a capacidade do agente.

Quando o agente chama `lookup_order` e recebe detalhes do pedido mostrando que o item foi comprado há 45 dias, como o loop agêntico determina se deve chamar `process_refund` ou `escalate_to_human` em seguida?

CorretaC) Os detalhes do pedido são adicionados à conversa e o modelo raciocina sobre qual ação tomar.

Correto. O loop agêntico funciona acrescentando mensagens `tool_result` à conversa e deixando o modelo decidir o próximo passo a cada turno. É assim que 45 dias → reembolso vs. escalonamento é resolvido.

Um cliente envia: "Isso é frustrante. Já expliquei meu problema duas vezes e nada está sendo resolvido. Quero falar com uma pessoa de verdade AGORA." O agente ainda não chamou nenhuma ferramenta para investigar a conta dele.

O que o agente deve fazer?

CorretaA) Reconhecer a frustração e fazer uma pergunta direcionada para entender o problema específico antes de escalonar.

Correto. O cliente disse "duas vezes", mas você ainda não tem contexto. Uma pergunta focada e acolhedora lhe dá uma chance de resolução no primeiro contato, sem desconsiderar a frustração nem atrasar um possível repasse.

Seu agente está tratando uma disputa de cobrança. Depois de chamar `get_customer` e `lookup_order`, ele identifica que a disputa envolve um erro de preço promocional que exige aprovação gerencial — acima do nível de autorização do agente.

Como o fluxo de trabalho deve lidar com esse escalonamento no meio do processo?

CorretaB) Compilar um repasse estruturado com os dados do cliente, informações do pedido e o problema identificado antes de chamar `escalate_to_human`.

Correto. Um resumo estruturado (quem, qual pedido, qual problema, por que excede a autorização) permite que o agente humano assuma instantaneamente. Esse é o padrão de escalonamento no meio do processo.

Monitoramento de produção mostra que sua ferramenta `search_catalog` falha 12% do tempo: 8% são timeouts de rede que sucedem ao retentar e 4% são erros de sintaxe de query que nunca sucedem por mais que se retente. Atualmente ambos os tipos de erro são retornados de forma idêntica, causando retentativas desperdiçadas.

Como você deveria modificar o tratamento de erros da ferramenta?

CorretaC) Implementar retry automático com backoff para timeouts de rede dentro da ferramenta; retornar erros de sintaxe imediatamente com detalhes de validação de parâmetro.

Tratar retries no nível da ferramenta para erros transitórios é a fronteira de abstração correta — a ferramenta tem conhecimento definitivo do tipo de erro e pode implementar lógica de retry determinística sem depender do agente para interpretar uma flag (D) ou seguir instruções no nível do prompt (A). Backoff uniforme (B) desperdiça tempo em erros de sintaxe que nunca sucederão.

Os logs de produção revelam um tratamento de erros inconsistente: quando `lookup_order` falha, o agente às vezes tenta novamente mais de 5 vezes (desperdício quando o ID do pedido não existe), às vezes escalona imediatamente (prematuro para problemas temporários de rede) e às vezes pede esclarecimentos ao usuário (inadequado quando o problema é um erro de permissão no backend). A investigação mostra que sua ferramenta MCP retorna respostas de erro uniformes: {"isError": true, "content": [{"type": "text", "text": "Operation failed"}]}. O agente não consegue distinguir entre os tipos de erro.

Qual é a melhoria mais eficaz?

CorretaA) Enriquecer as respostas de erro com metadados estruturados: incluir errorCategory (transient/validation/permission), um booleano isRetryable e uma descrição do que causou a falha.

Correto. Dê ao agente a informação de que ele precisa para tomar a decisão certa: categoria, possibilidade de nova tentativa e uma causa legível por humanos. Isso substitui a adivinhação por uma política determinística.

Ao implementar sua ferramenta MCP `lookup_order`, o backend às vezes retorna erros (por exemplo, "Order not found" ou falhas temporárias de banco de dados).

Qual é o padrão correto para comunicar esses erros de volta ao agente?

CorretaB) Retornar a mensagem de erro no conteúdo do resultado da ferramenta, com a flag isError definida como true.

Correto. O padrão projetado do MCP: colocar o texto do erro no campo content e marcar isError=true. O Claude vê tanto a flag de falha quanto uma mensagem legível para raciocinar.

Sua ferramenta `process_refund` retorna dois tipos de erro: erros técnicos ("503 Service Unavailable", "Connection timeout") que são transitórios (5% das chamadas) e erros de negócio ("Order exceeds 30-day return window", "Item already refunded") que são permanentes (12% das chamadas). O monitoramento mostra que o agente desperdiça de 3 a 4 turnos tentando novamente erros de negócio que nunca podem ter sucesso. Atualmente, ambos os tipos de erro retornam apenas uma mensagem de texto simples ao Claude.

Qual é a forma mais eficaz de reduzir as novas tentativas desperdiçadas e, ao mesmo tempo, melhorar a qualidade das respostas voltadas ao cliente?

CorretaA) Retornar respostas de erro estruturadas com retryable: false para erros de negócio e uma explicação amigável ao cliente para o Claude usar.

Correto. Uma flag retryable diz ao Claude, de forma determinística, "não tente novamente", e uma mensagem amigável ao cliente já pronta melhora a resposta de saída. Resolve os dois problemas de uma vez.

Seu sistema de extração implementa novas tentativas automáticas quando a validação falha. A cada nova tentativa, o erro de validação específico é anexado ao prompt. Essa abordagem de nova tentativa com feedback de erro resolve a maioria das falhas em 2-3 tentativas.

Para qual padrão de falha novas tentativas seriam MENOS eficazes?

CorretaD) O modelo extrai "et al." para coautores quando a lista completa existe apenas em um documento externo que não está na entrada

Correto. Nenhuma quantidade de novas tentativas ensina ao modelo informações que não estão na entrada. A nova tentativa com feedback de erro só corrige erros que o modelo poderia ter acertado a partir da fonte.

Usuários refinam preferências de playlist em vários turnos. Duas mensagens depois de o usuário dizer "amo jazz", Claude pergunta "Quais gêneros você gosta?".

Qual a causa mais provável?

CorretaD) Sua aplicação não está incluindo as mensagens anteriores no array `messages`.

Claude não tem memória do lado do servidor — toda chamada de API é stateless. Sem incluir o histórico completo no array `messages` de cada requisição, Claude não tem conhecimento de turnos anteriores. Bases vetoriais (A) e `session_id` (C) não fazem parte da arquitetura do Claude; estouro de janela de contexto (B) é impossível em troca de duas mensagens.

O agente verifica a identidade do cliente por meio de um processo de múltiplas etapas antes de redefinir senhas. Durante os testes, você nota que, depois que o cliente responde à terceira pergunta de verificação, o agente pede que ele informe o nome novamente, como se a troca anterior nunca tivesse acontecido.

Qual é a causa mais provável desse comportamento?

CorretaC) O histórico da conversa não está sendo repassado nas requisições subsequentes da API.

Correto. A API é stateless. Cada requisição deve incluir o array completo de mensagens. Se você enviar apenas o último turno, o modelo não tem memória dos anteriores — exatamente o sintoma de "pedir o nome de novo".

Depois que seu batch diário de 10.000 documentos é concluído, 300 documentos (3%) falharam com erros "`context_length_exceeded`". O arquivo de resultados identifica cada falha por `custom_id`.

Qual é a abordagem mais econômica para processar essas falhas?

CorretaB) Reenviar apenas os 300 documentos que falharam, após dividi-los em pedaços menores, e então combinar as extrações parciais

Correto. Direcionado, e trata a causa real (entrada longa demais). Divida os documentos superdimensionados, extraia por pedaço e depois mescle — mínimo de tokens, corrige o modo de falha específico.

No seu desenho de sistema, você deu ao agente de análise de documentos acesso a uma ferramenta de uso geral `fetch_url` para que ele pudesse baixar documentos por URL. Logs de produção mostram que esse agente agora frequentemente baixa páginas de resultados de busca para fazer busca web ad hoc — comportamento que deveria passar pelo agente de busca web — causando resultados inconsistentes. Qual correção é mais efetiva?

Qual correção é mais efetiva?

CorretaA) Substituir `fetch_url` por uma ferramenta `load_document` que valida que URLs apontem para formatos de documento.

Substituir uma ferramenta de uso geral por uma específica de documento que valida URLs contra formatos de documento ataca a causa-raiz ao restringir capacidade no nível da interface. Isso segue o princípio do menor privilégio, tornando o comportamento indesejado de busca impossível em vez de meramente desencorajado.

Em testes, você observa que o agente de síntese frequentemente precisa verificar afirmações específicas ao mesclar resultados. Atualmente, quando verificação é necessária, o agente de síntese devolve o controle ao coordenador, que chama o agente de busca web e então re-invoca a síntese com os resultados. Isso adiciona 2–3 loops extras por tarefa e aumenta a latência em 40%. Sua avaliação mostra que 85% dessas verificações são checagens simples (datas, nomes, estatísticas) e 15% exigem pesquisa mais profunda. Qual abordagem é mais efetiva para reduzir overhead preservando confiabilidade?

Qual abordagem é mais efetiva?

CorretaD) Dar ao agente de síntese uma ferramenta `verify_fact` de escopo limitado para checagens simples, enquanto roteia verificações complexas pelo coordenador para o agente de busca web.

Uma ferramenta de verificação de fato de escopo limitado deixa o agente de síntese lidar diretamente com 85% das checagens simples, eliminando a maioria dos loops, enquanto preserva o caminho de delegação pelo coordenador para os 15% de verificações complexas. Aplica menor privilégio enquanto reduz significativamente a latência.

Logs de produção mostram que o agente interpreta mal saídas de suas ferramentas MCP: timestamps Unix de `get_customer`, datas ISO 8601 de `lookup_order` e códigos de status numéricos (1=pendente, 2=enviado). Algumas ferramentas são servidores MCP de terceiros que você não pode modificar. Qual abordagem para normalização de formato de dados é mais mantível?

Qual abordagem é mais mantível?

CorretaA) Usar um hook PostToolUse para interceptar saídas de ferramentas e aplicar transformações de formato antes que o agente processe.

Um hook PostToolUse fornece um ponto centralizado e determinístico para interceptar e normalizar todas as saídas de ferramenta — incluindo dados de servidores MCP de terceiros — antes que o agente as processe. É mais mantível porque transformações vivem em código e se aplicam uniformemente, sem depender da interpretação do LLM.

O agente de análise de documentos tem uma única ferramenta `analyze_document` que recebe um documento e um parâmetro de instrução em texto livre. Durante a avaliação, solicitações como "extrair as principais métricas financeiras" frequentemente retornam resumos narrativos, enquanto "resumir a metodologia" às vezes retorna tabelas de dados brutos. O agente de síntese relata que 35% dos resultados de análise exigem novas solicitações com instruções esclarecidas.

Qual é a forma mais eficaz de melhorar a confiabilidade?

CorretaA) Dividir a ferramenta genérica em ferramentas específicas para cada propósito — `extract_data_points`, `summarize_content`, `verify_claim_against_source` — cada uma com contratos de entrada/saída definidos.

Correto. Instruções em texto livre colocam a semântica na prosa, que o modelo interpreta de forma inconsistente. Ferramentas específicas para cada propósito dão ao modelo um contrato explícito e bem tipado para escolher.

Seu agente precisa inserir uma nova função auxiliar no meio de um módulo utilitário de 150 linhas, entre duas funções existentes. A ferramenta Edit falha porque seu parâmetro `old_string` não consegue encontrar um texto único para correspondência — o arquivo tem docstrings, nomes de variáveis e padrões estruturais repetitivos.

Qual é a maneira mais confiável de concluir essa inserção?

CorretaD) Usar o Read para carregar o arquivo, adicionar a função no local apropriado e, então, usar o Write para gravar o arquivo atualizado

Correto. Quando o contrato de correspondência única do Edit não pode ser satisfeito em um arquivo repetitivo, recorra a Read → modificar em memória na linha pretendida → gravar o arquivo completo de volta com Write.

O agente coordenador tem `AgentDefinitions` configuradas para todos os quatro subagentes especializados, cada um com descrições, prompts e restrições de ferramentas apropriadas. Durante os testes, você percebe que o coordenador raciocina corretamente sobre quando delegar — ele gera mensagens como "Vou pedir ao agente de busca na web que encontre fontes sobre este tópico" — mas nenhuma execução de subagente jamais ocorre. O coordenador então prossegue como se a delegação tivesse acontecido e continua com informações incompletas. Os logs não mostram erros.

Qual é a causa mais provável?

CorretaC) A configuração allowedTools do coordenador não inclui "Task", então, embora ele possa raciocinar sobre a delegação, não consegue invocar a ferramenta necessária para iniciar subagentes.

Correto. Sem a ferramenta Task em allowedTools, o coordenador pode falar sobre delegar, mas não tem como realmente chamar um subagente — o que corresponde ao sintoma 'raciocina sobre isso, sem execução, sem erros'.

Logs de produção mostram um padrão persistente: pedidos como "analise o relatório trimestral enviado" são roteados ao agente de busca web em 45% das vezes em vez de ao agente de análise de documentos. Revisando as definições das ferramentas, você descobre que o agente de busca web tem uma ferramenta `analyze_content` descrita como "analyzes content and extracts key information", enquanto o agente de análise de documentos tem `analyze_document` descrita como "analyzes documents and extracts key information". Como corrigir o problema de roteamento errado?

Como corrigir o problema?

CorretaB) Renomear a ferramenta de busca web para `extract_web_results` e atualizar sua descrição para "processes and returns information retrieved from web search and URLs."

Renomear a ferramenta de busca web para `extract_web_results` e atualizar a descrição para referenciar explicitamente busca web e URLs remove diretamente a causa-raiz ao eliminar a sobreposição semântica entre nomes e descrições. Isso torna o propósito de cada ferramenta inequívoco, permitindo ao coordenador distinguir análise de documentos de busca web de forma confiável.

Em testes, você nota que o agente frequentemente chama `get_customer` quando usuários perguntam sobre status de pedido, embora `lookup_order` fosse mais apropriado. O que você deve checar primeiro para tratar esse problema?

O que você deve checar primeiro?

CorretaD) Verificar as descrições das ferramentas para garantir que diferenciem claramente o propósito de cada uma.

Descrições de ferramentas são a entrada principal que o modelo usa para decidir qual chamar. Quando um agente escolhe consistentemente a ferramenta errada, o primeiro passo de diagnóstico é verificar se as descrições separam claramente o propósito e os limites de uso.

Logs de produção mostram que o agente frequentemente chama `get_customer` quando usuários perguntam sobre pedidos (ex.: "verifique meu pedido #12345") em vez de chamar `lookup_order`. Ambas as ferramentas têm descrições mínimas ("Gets customer information" / "Gets order details") e aceitam formatos de identificador parecidos. Qual é o primeiro passo mais efetivo para melhorar a confiabilidade da seleção de ferramenta?

Qual é o primeiro passo mais efetivo?

CorretaD) Expandir a descrição de cada ferramenta para incluir formatos de entrada, queries de exemplo, casos de borda e fronteiras explicando quando usá-la versus ferramentas similares.

Expandir descrições com formatos de entrada, queries de exemplo, casos de borda e fronteiras claras corrige diretamente a causa-raiz — descrições mínimas que não dão ao LLM informação suficiente para distinguir ferramentas similares. É um primeiro passo de baixo esforço e alto impacto que melhora o mecanismo principal usado pelo LLM para seleção de ferramenta.

Após integrar um servidor MCP local que fornece ferramentas de análise de código (`analyze_dependencies`, `find_dead_code`, `calculate_complexity`), você verifica que o servidor está saudável e que as ferramentas aparecem na resposta de tools/list. No entanto, você observa que o agente usa consistentemente o Grep para buscar declarações de importação em vez de chamar `analyze_dependencies` — mesmo quando os usuários perguntam explicitamente sobre "dependências de código". Ao examinar as definições das ferramentas, você encontra: MCP: `analyze_dependencies` - "Analisa o grafo de dependências" Nativa: Grep - "Busca o conteúdo de arquivos por um padrão usando expressões regulares. Retorna as linhas correspondentes com números de linha e contexto ao redor."

Qual é a abordagem mais eficaz para melhorar a seleção de ferramentas MCP pelo agente?

CorretaD) Expandir as descrições das ferramentas MCP para detalhar capacidades e saídas — por exemplo, "Constrói um grafo de dependências mostrando importações diretas, dependências transitivas e ciclos."

Correto. A seleção de ferramentas é guiada pelas descrições que o modelo vê. Uma descrição de uma linha como 'Analisa o grafo de dependências' perde para a descrição rica do Grep. Reforce a descrição da ferramenta MCP.

Após adicionar um servidor MCP com ferramentas especializadas de refatoração de código (`extract_function`, `rename_variable`, `inline_function`), você nota que o agente ainda usa manipulação básica de texto via Write e comandos sed do Bash para tarefas de refatoração. O servidor MCP está conectado e saudável. Ao examinar a configuração, você descobre que cada ferramenta MCP tem uma descrição mínima como "`extract_function`: extrai uma função do código."

Qual é a maneira mais eficaz de melhorar a adoção das ferramentas de refatoração MCP?

CorretaD) Aprimorar as descrições das ferramentas MCP para explicar quando cada ferramenta é preferível à manipulação de texto e esclarecer as entradas e saídas esperadas.

Correto. A seleção de ferramentas é guiada pelas descrições que o Claude vê. Quando as ferramentas MCP dizem 'extrai uma função do código' e o Write/sed vêm com documentação rica, o Claude escolhe o Write/sed. Reforce as descrições.

Seu pipeline usa uma ferramenta chamada `extract_metadata` com um esquema JSON para detalhes do artigo. Você também definiu as ferramentas `lookup_citations` e `verify_doi` para enriquecimento. Durante os testes, você nota que, quando os usuários incluem pedidos como "extract the metadata and tell me how cited it is", o Claude às vezes chama `lookup_citations` primeiro, o que falha porque ela precisa do DOI que `extract_metadata` forneceria.

Qual é a maneira mais eficaz de garantir que a extração estruturada de metadados aconteça primeiro?

CorretaC) Definir `tool_choice` como {"type": "tool", "name": "`extract_metadata`"} e processar os pedidos de enriquecimento em turnos subsequentes, depois de receber os metadados extraídos.

Correto. `tool_choice`=ferramenta-específica força de forma determinística `extract_metadata` no primeiro turno. Em seguida, você devolve o controle para 'auto' e deixa o modelo usar o enriquecimento de citações/DOI com os metadados em contexto.

Logs de produção mostram um padrão consistente: quando clientes incluem a palavra "conta" em sua mensagem (ex.: "quero verificar minha conta de um pedido que fiz ontem"), o agente chama `get_customer` primeiro 78% das vezes. Quando clientes formulam pedidos similares sem "conta" (ex.: "quero verificar um pedido que fiz ontem"), chama `lookup_order` primeiro 93% das vezes. As descrições das ferramentas são claras e inequívocas. Qual a causa-raiz mais provável dessa discrepância?

Qual a causa-raiz mais provável?

CorretaA) O system prompt contém instruções sensíveis a palavras-chave que direcionam comportamento baseado em termos como "conta", criando padrões não intencionais de seleção de ferramenta.

O padrão sistemático dirigido por palavra-chave (78% vs 93%) indica fortemente lógica explícita de roteamento no system prompt reagindo à palavra "conta" e direcionando o agente a ferramentas relacionadas ao cliente. Como as descrições já são claras, a discrepância aponta para instruções no nível do prompt criando direcionamento comportamental não intencional.

Seu agente lida com pedidos de questão única com 94% de acurácia (ex.: "preciso de reembolso para o pedido #1234"). Mas quando clientes incluem múltiplas questões em uma mensagem (ex.: "preciso de reembolso para o pedido #1234 e também atualizar o endereço de entrega do pedido #5678"), a acurácia de seleção de ferramenta cai para 58%. O agente normalmente resolve apenas uma questão ou mistura parâmetros entre os pedidos. Qual abordagem melhora confiabilidade para pedidos multi-questão de forma mais efetiva?

Qual abordagem é mais efetiva?

CorretaC) Adicionar exemplos few-shot ao prompt demonstrando raciocínio correto e sequenciamento de ferramentas para pedidos multi-questão.

Exemplos few-shot que demonstram raciocínio correto e sequenciamento de ferramentas para pedidos multi-questão são mais efetivos porque o agente já performa bem em questão única — o que precisa é orientação sobre o padrão para decompor e rotear múltiplas questões mantendo parâmetros separados.

Suas reviews automatizadas encontram problemas reais, mas devs reportam que o feedback não é acionável. Achados incluem frases como "lógica complexa de roteamento de tickets" ou "potencial null pointer" sem especificar o que exatamente mudar. Quando você adiciona instruções detalhadas como "sempre inclua sugestões concretas de correção", o modelo ainda produz saída inconsistente — às vezes detalhada, às vezes vaga. Qual técnica de prompting produz feedback consistentemente acionável de forma mais confiável?

Qual técnica de prompting é mais confiável?

CorretaD) Adicionar 3–4 exemplos few-shot mostrando o formato exato exigido: problema identificado, localização no código, sugestão concreta de correção.

Exemplos few-shot são a técnica mais efetiva para alcançar formato consistente quando instruções sozinhas produzem resultados variáveis. Fornecer 3–4 exemplos que mostram a estrutura desejada (issue, location, concrete fix) dá ao modelo um padrão concreto a seguir, mais confiável que instruções abstratas.

Você pediu ao Claude Code para implementar uma função que transforma respostas de API em um formato interno normalizado. Após duas iterações, a estrutura de saída ainda não casa com as expectativas — alguns campos são aninhados de modo diferente e timestamps formatados incorretamente. Você descreveu requisitos em prosa, mas Claude os interpreta de forma diferente a cada vez.

Qual abordagem é mais efetiva para a próxima iteração?

CorretaB) Fornecer 2–3 exemplos concretos de entrada-saída mostrando a transformação esperada para respostas representativas da API.

Exemplos concretos de entrada-saída removem a ambiguidade inerente a descrições em prosa mostrando a Claude o resultado exato esperado da transformação. Isso ataca diretamente a causa-raiz — interpretação errada de requisitos textuais — fornecendo padrões inequívocos para aninhamento e formatação de timestamp.

Seu agente atinge 55% de resolução no primeiro contato, bem abaixo da meta de 80%. Logs mostram que ele escala casos simples (substituições padrão para mercadorias danificadas com prova fotográfica) enquanto tenta lidar autonomamente com situações complexas que exigem exceções de política. Qual é a forma mais efetiva de melhorar a calibração de escalonamento?

Qual é a forma mais efetiva de melhorar a calibração?

CorretaC) Adicionar critérios explícitos de escalonamento ao system prompt com exemplos few-shot mostrando quando escalar vs resolver autonomamente.

Critérios explícitos de escalonamento com exemplos few-shot atacam diretamente a causa-raiz — limites de decisão pouco claros entre casos simples e complexos. É a primeira intervenção mais proporcional e efetiva, ensinando o agente quando escalar e quando resolver autonomamente sem infraestrutura extra.

Logs de produção mostram que o agente às vezes escolhe `get_customer` quando `lookup_order` seria mais apropriado, especialmente para queries ambíguas como "preciso de ajuda com minha compra recente". Você decide adicionar exemplos few-shot ao system prompt para melhorar a seleção. Qual abordagem trata o problema de forma mais efetiva?

Qual abordagem é mais efetiva?

CorretaC) Adicionar 4–6 exemplos direcionados a cenários ambíguos, cada um com justificativa de por que uma ferramenta foi escolhida em detrimento de alternativas plausíveis.

Direcionar exemplos few-shot aos cenários ambíguos específicos onde os erros ocorrem, com justificativa explícita de por que uma ferramenta é preferível, ensina ao modelo o processo de decisão comparativo necessário para casos de borda. Mais efetivo que exemplos genéricos ou regras declarativas.

Durante testes de QA, Claude segue diretrizes do system prompt nos primeiros 10–15 turnos, mas respostas posteriores desviam. A conversa ainda está dentro dos limites de tokens.

Qual a melhor solução?

CorretaC) Inserir mensagens com role user reforçando diretrizes em pontos de interrupção da conversa.

A injeção periódica de lembretes comportamentais combate diretamente a deriva de instrução restabelecendo restrições em intervalos regulares conforme o histórico se acumula. Mover diretrizes para a primeira mensagem do usuário (A) reduz sua autoridade. Iniciar nova conversa (B) destrói contexto. Validação pós-resposta (D) é corretiva em vez de preventiva e adiciona latência significativa.

Usuários reportam aberturas de resposta repetitivas como "Certamente!" e "Ficarei feliz em ajudar!".

Qual a abordagem mais efetiva?

CorretaA) Anexar uma mensagem parcial do assistente com uma abertura direta.

Pré-preencher a resposta do assistente com o início de uma resposta direta evita padrões de saudação no nível de geração — o modelo continua a partir do prefill em vez de gerar novas frases de abertura. Instruções no system prompt (D) podem ajudar mas são menos confiáveis pois o modelo ainda pode produzir variantes. Pós-processamento (C) é um workaround frágil. Temperatura (B) controla aleatoriedade, não padrões específicos de frase.

Seu esquema inclui um campo skills: string[]. O monitoramento em produção revela três problemas de consistência: (1) frases compostas como "Python and SQL" às vezes são mantidas como uma única entrada, às vezes divididas; (2) habilidades implícitas, mas não declaradas, ocasionalmente aparecem nas extrações; (3) documentos semelhantes produzem comprimentos de array muito diferentes (5-10 vs. 40+ entradas). Seu prompt atualmente diz "Extract all skills mentioned."

Qual é a melhoria mais eficaz?

CorretaA) Adicionar exemplos few-shot demonstrando o tratamento de frases compostas, critérios explícitos de menção e a granularidade adequada das entradas.

Correto. Os três problemas dizem respeito à interpretação do modelo sobre o que conta como 'uma habilidade'. Exemplos few-shot ensinam o padrão de forma concreta — dividir ou não dividir, mencionado ou inferido, granularidade adequada.

Depois de implementar o uso de ferramentas com definições de esquema estritas, os erros de sintaxe JSON foram eliminados, mas 5% das extrações ainda têm JSON válido com arrays vazios ou valores nulos para campos obrigatórios como citações e metodologia. Uma verificação por amostragem revela que os documentos de origem contêm essas informações, mas em formatos variados — citações inline vs. bibliografias, seções de metodologia vs. detalhes embutidos nas introduções.

Qual é a maneira mais eficaz de tratar essas falhas?

CorretaD) Adicionar exemplos few-shot demonstrando extrações de documentos com estruturas variadas — mostrando como identificar citações em diferentes formatos e localizar detalhes de metodologia em tipos diferentes de seção.

Correto. O modo de falha é o modelo não reconhecer formatos variados. Exemplos concretos ao longo da distribuição de formatos elevam diretamente a revocação nos 5%.

Seu sistema de extração analisa descrições de produtos de e-commerce para extrair especificações como dimensões, peso e materiais em JSON. Apesar de ter um esquema bem definido, o modelo extrai o campo "materials" de forma inconsistente — às vezes retornando "cotton blend", outras vezes "Cotton/Polyester mix" e, ocasionalmente, omitindo o campo quando a informação de material está claramente presente na fonte.

Qual é a maneira mais eficaz de melhorar a consistência da extração?

CorretaD) Adicionar exemplos few-shot mostrando 2-3 pares completos de entrada-saída com formatos padronizados de descrição de material

Correto. Exemplos few-shot demonstram o formato canônico exato que você quer ('cotton/polyester' como uma lista normalizada) e também elevam a revocação da informação de material que estava sendo ignorada.

Seu tutor de IA tem um system prompt de 2.800 tokens definindo metodologia de ensino e regras de adaptação. Após 12 turnos, o assistente começa a ignorar níveis de proficiência.

Qual a correção mais efetiva?

CorretaB) Substituir regras verbosas por exemplos few-shot demonstrando adaptação por nível de proficiência.

Um system prompt de 2.800 tokens com regras declarativas é vulnerável a deriva porque regras abstratas exigem que o modelo raciocine sobre elas a cada turno. Substituir regras verbosas por exemplos few-shot concretos que demonstram adaptação correta por nível de proficiência dá ao modelo padrões comportamentais claros para casar — isso é seguido de forma mais confiável ao longo de muitos turnos do que instruções abstratas. Injeção de lembretes (A) ajuda mas trata sintomas; posicionamento no fim (C) ajuda inicialmente mas não com deriva por turno; regeneração (D) é cara e corretiva.

Sua review automatizada analisa comentários e docstrings. O prompt atual instrui Claude a "verificar que comentários estão precisos e atualizados". Achados frequentemente sinalizam padrões aceitáveis (marcadores TODO, descrições simples) enquanto perdem comentários que descrevem comportamento que o código não implementa mais. Qual mudança ataca a causa-raiz dessa análise inconsistente?

Qual mudança ataca a causa-raiz?

CorretaD) Especificar critérios explícitos: marcar comentários apenas quando o comportamento que afirmam contradiz o comportamento real do código.

Critérios explícitos — marcar comentários apenas quando o comportamento afirmado contradiz o comportamento real do código — atacam diretamente a causa-raiz substituindo uma instrução vaga por uma definição precisa do que constitui um problema. Isso reduz falsos positivos em padrões aceitáveis e perdas de comentários genuinamente enganosos.

Seu sistema de code review automatizado mostra severidades inconsistentes — questões similares como riscos de null pointer são classificadas "critical" em alguns PRs mas só "medium" em outros. Pesquisas com devs mostram desconfiança crescente — muitos começam a descartar achados sem ler porque "metade está errada". Categorias com altas taxas de falsos positivos minam a confiança em categorias acuradas. Qual abordagem melhor restaura a confiança dos devs enquanto melhora o sistema?

Qual abordagem melhor restaura a confiança dos devs?

CorretaA) Desabilitar temporariamente categorias de alto FP (estilo, naming, documentação) e manter apenas categorias de alta precisão enquanto melhora os prompts.

Desabilitar temporariamente categorias com alto FP interrompe imediatamente a erosão de confiança removendo achados ruidosos que levam devs a descartar tudo, preservando valor de categorias de alta precisão como segurança e correção. Também cria espaço para melhorar prompts das categorias problemáticas antes de reabilitá-las.

Sua review automatizada média 15 achados por PR e devs reportam taxa de FP de 40%. O gargalo é tempo de investigação: devs precisam clicar em cada achado para ler a justificativa do Claude antes de decidir corrigir ou descartar. Seu CLAUDE.md já contém regras abrangentes para padrões aceitáveis e stakeholders rejeitaram qualquer abordagem que filtre achados antes de devs verem. Qual mudança melhor ataca o tempo de investigação?

Qual mudança ataca melhor o tempo de investigação?

CorretaA) Exigir que Claude inclua sua justificativa e estimativa de confiança diretamente em cada achado.

Incluir justificativa e confiança diretamente em cada achado reduz tempo de investigação ao deixar devs triar rapidamente sem abrir cada achado. Satisfaz a restrição de "não filtrar" porque todos os achados permanecem visíveis enquanto acelera a tomada de decisão.

A análise da sua review automatizada de código mostra grandes diferenças nas taxas de falsos positivos por categoria de achado: achados de segurança/correção têm 8% de FP, performance 18%, estilo/naming 52% e documentação 48%. Pesquisas com devs mostram desconfiança crescente — muitos começam a descartar achados sem ler porque "metade está errada". Categorias de alto FP minam a confiança em categorias acuradas. Qual abordagem melhor restaura a confiança dos devs enquanto melhora o sistema?

Qual abordagem melhor restaura a confiança dos devs?

CorretaA) Desabilitar temporariamente categorias de alto FP (estilo, naming, documentação) e manter apenas categorias de alta precisão enquanto melhora os prompts.

Desabilitar temporariamente categorias com alto FP interrompe imediatamente a erosão de confiança removendo achados ruidosos que levam devs a descartar tudo, preservando valor de categorias de alta precisão como segurança e correção. Também cria espaço para melhorar prompts das categorias problemáticas antes de reabilitá-las.

Métricas de produção mostram que ao resolver disputas complexas de cobrança ou devoluções multi-pedido, scores de satisfação do cliente são 15% menores que para casos simples — mesmo quando a resolução está tecnicamente correta. Análise de causa-raiz mostra que o agente fornece soluções acuradas mas explica a justificativa de forma inconsistente: às vezes omitindo detalhes relevantes de política, às vezes perdendo info de timeline ou próximos passos. As lacunas de contexto variam caso a caso. Você quer melhorar qualidade da solução sem adicionar supervisão humana. Qual abordagem é mais efetiva?

Qual abordagem é mais efetiva?

CorretaA) Adicionar uma etapa de auto-crítica em que o agente avalia uma resposta de rascunho quanto à completude — garantindo que resolva o problema, inclua contexto relevante e antecipe perguntas de follow-up.

Uma etapa de auto-crítica (padrão evaluator-optimizer) ataca diretamente a completude inconsistente das explicações forçando o agente a avaliar seu próprio rascunho contra critérios concretos — como contexto de política, timelines e próximos passos — antes de apresentá-lo. Isso captura lacunas específicas do caso sem supervisão humana.

Um usuário está expandindo o sistema de pesquisa além de seu único agente de busca na web, adicionando fontes de dados especializadas. Ele adiciona um agente de API financeira que retorna JSON estruturado com receita, margens e taxas de crescimento; um agente de monitoramento de notícias que retorna resumos em prosa de acontecimentos recentes; e um agente de análise de patentes que retorna listas estruturadas de áreas de tecnologia. O agente de síntese combina tudo isso em briefings executivos. Atualmente, ele converte tudo em tópicos, fazendo com que as comparações financeiras percam a clareza tabular e os resumos de notícias percam o fluxo narrativo.

Qual mudança melhoraria mais a qualidade do briefing?

CorretaC) Atualizar o agente de síntese para renderizar cada tipo de conteúdo de forma apropriada — dados financeiros como tabelas, notícias como prosa.

Correto. Briefings executivos precisam de renderização mista: tabelas para números, prosa para narrativa. Pedir à síntese que preserve o formato nativo de cada entrada é a abstração certa.

Seu sistema opera com revisão humana de 100% há 3 meses. A análise mostra que extrações com confiança do modelo >90% têm 97% de precisão no geral. Para reduzir a carga de trabalho dos revisores, você planeja automatizar as extrações de alta confiança. Antes de implantar, qual etapa de validação é a mais crítica?

CorretaA) Analisar a precisão por tipo de documento e por campo para verificar se as extrações de alta confiança têm desempenho consistente em todos os segmentos, e não apenas no agregado.

Correto. A precisão agregada esconde falhas por segmento — um tipo de documento pode estar em 70% enquanto outros estão em 99%. O roteamento automático apenas pelo número global arrisca erros sistêmicos nos segmentos fracos.

Seu pipeline de extração processa cardápios de restaurantes e deve produzir um JSON estruturado com campos para nomes dos itens, descrições, preços e tags dietéticas. Alguns cardápios usam formatação inconsistente — preços como "$12" vs. "12.00", informação dietética como ícones vs. texto.

Qual é a abordagem mais confiável?

CorretaD) Definir um esquema de saída estrito e incluir regras de normalização de formato no seu prompt.

Correto. Esquema estrito + regras de normalização explícitas ('preços como decimal com duas casas', 'dietético como tags enumeradas') permite ao modelo extrair e normalizar em uma única passada.

Seu sistema extrai metadados de eventos (data, local, organizador, `attendee_count`) de artigos de notícias usando um esquema JSON com todos os campos anuláveis. Durante a avaliação, você observa que o modelo frequentemente gera valores plausíveis, porém incorretos, para campos não mencionados no artigo — por exemplo, gerando "500" para `attendee_count` quando a fonte não contém nenhuma informação de público.

Qual é a maneira mais eficaz de reduzir essas extrações falsas?

CorretaB) Adicionar instruções no prompt para retornar null em qualquer campo cuja informação não esteja diretamente declarada na fonte.

Correto. Os campos já são anuláveis; o modelo só precisa de uma instrução explícita para preferir null em vez de um palpite plausível. Essa é a correção padrão para alucinação consciente do esquema.

Sua extração usa uso de ferramentas com um esquema JSON em que `property_type` é definido como um enum: ['house', 'apartment', 'condo', 'townhouse']. Após a implantação, 8% das extrações falham na validação do esquema. A investigação revela que os anúncios mencionam muitos tipos de imóvel incomuns — "studio", "loft", "duplex", "mobile home", "tiny house", "converted warehouse" — e novos tipos continuam surgindo regularmente.

Qual é a solução de longo prazo mais eficaz?

CorretaB) Adicionar um valor "other" ao seu enum, com um campo string `property_type_detail` separado para as especificidades quando "other" for selecionado.

Correto. Mantém o enum forte para os casos comuns (joins downstream limpos) ao mesmo tempo em que oferece uma válvula de escape bem tipada que preserva o detalhe. Estável no longo prazo.

Seu componente de code review é iterativo: Claude analisa o arquivo modificado, depois pode pedir arquivos relacionados (imports, classes-base, testes) via chamadas de ferramenta para entender contexto antes de prover feedback final. Sua aplicação define uma ferramenta que permite a Claude pedir conteúdo de arquivos; Claude chama a ferramenta, recebe resultados e continua a análise. Você está avaliando processamento em lote para reduzir custo de API. Qual é a principal limitação técnica ao considerar processamento em lote para esse fluxo?

Qual é a principal limitação técnica?

CorretaB) O modelo assíncrono não consegue executar ferramentas no meio da requisição e devolver resultados para Claude continuar a análise.

A natureza assíncrona da Batch API (uma requisição = uma resposta) significa que ela não consegue executar ferramentas no meio da chamada e devolver resultados para o modelo continuar a análise iterativa. Isso torna fundamentalmente incompatível workflows que precisam de tool calling multi-turn. (A está incorreta: `custom_id` existe. C está incorreta: a Batch API aceita ferramentas nos params. D é uma preocupação real mas não é a limitação fundamental — algumas review podem tolerar 24 horas; a limitação fundamental é não conseguir executar tool calls iterativos em meio à requisição.)

Seu sistema CI/CD roda três análises baseadas em Claude: (1) checagens rápidas de estilo em todo PR que bloqueiam o merge até concluir, (2) auditorias semanais e abrangentes de segurança em toda a base, e (3) geração noturna de casos de teste para módulos recém-modificados. A Message Batches API oferece 50% de economia, mas o processamento pode levar até 24 horas. Você quer otimizar custo de API mantendo experiência aceitável para devs. Qual combinação casa corretamente cada tarefa com uma abordagem de API?

Qual combinação está correta?

CorretaB) Use chamadas síncronas para checagens de estilo em PR; use a Message Batches API para auditorias semanais de segurança e geração noturna de testes.

Checagens de estilo em PR bloqueiam devs e exigem respostas imediatas via síncronas, enquanto auditorias semanais e geração noturna de testes são tarefas agendadas com prazos flexíveis que toleram a janela de até 24 horas — capturando 50% de economia em ambas.

Seu pipeline CI inclui dois modos de code review baseados em Claude: um hook pré-merge-commit que bloqueia o merge do PR até concluir, e uma "análise profunda" que roda à noite, faz polling até concluir o lote e posta sugestões detalhadas no PR. Você quer reduzir custo de API usando a Message Batches API, que oferece 50% de economia mas exige polling e pode levar até 24 horas. Qual modo deveria usar processamento em lote?

Qual modo deveria usar processamento em lote?

CorretaB) Apenas a análise profunda.

Análise profunda é candidata ideal para processamento em lote porque já roda à noite, tolera atraso e usa um modelo de polling antes de publicar resultados — o que casa com a arquitetura assíncrona baseada em polling da Message Batches API enquanto captura 50% de economia.

Seu time quer reduzir custos de API para análise automatizada. Atualmente, chamadas síncronas ao Claude atendem dois fluxos: (1) checagem bloqueante pré-merge que precisa concluir antes de devs poderem mergear, e (2) relatório de tech-debt gerado de noite para revisão na manhã seguinte. Seu gerente propõe mover ambos para a Message Batches API para economizar 50%. Como avaliar essa proposta?

Como avaliar essa proposta?

CorretaC) Use processamento em lote apenas para relatórios de tech-debt; mantenha chamadas síncronas para checagens pré-merge.

O processamento da Message Batches API pode levar até 24 horas sem SLA de latência, o que é aceitável para relatórios de tech-debt noturnos mas inaceitável para checagens pré-merge bloqueantes em que devs esperam. Isso casa cada fluxo com a API certa baseada em requisitos de latência.

Seu sistema de extração processa dois tipos de documentos: relatórios mensais padrão (arquivados após o processamento) e relatórios de exceção urgentes (que devem disparar alertas de negócio em até 30 minutos do recebimento). Ambos usam o mesmo esquema JSON. Você quer minimizar os custos de API atendendo aos requisitos de latência.

Como você deve arquitetar o pipeline de processamento?

CorretaD) Rotear os relatórios padrão para a `Batch API`, obtendo 50% de economia de custo, e rotear os relatórios de exceção urgentes para a Messages API em tempo real.

Correto. Combine o perfil de latência com a urgência do documento: batch para o volume (barato), tempo real para as exceções sensíveis à latência (rápido). Minimiza o custo atendendo ao SLA.

Documentos chegam continuamente ao longo do horário comercial e precisam ter dados estruturados extraídos. Para reduzir custos, você quer usar a `Message Batches API` (50% de desconto, janela de processamento de até 24 horas). Seu SLA especifica que os resultados da extração devem estar disponíveis em até 30 horas da chegada do documento, com 99,9% de confiabilidade.

Qual estratégia de batch é a mais apropriada?

CorretaC) Enviar batches a cada 4 horas contendo os documentos daquela janela

Correto. Espera máxima de 4 horas + SLO de batch de até 24 horas = pior caso de 28 horas, deixando uma folga de 2 horas abaixo do SLA de 30 horas para absorver a variação do batch e atingir 99,9%.

Seu pipeline de pesquisa multiagente falhou após processar 12 de 28 documentos. O agente de busca na web havia identificado fontes relevantes, o agente de análise de documentos havia concluído parcialmente a extração e o sintetizador havia iniciado a identificação de padrões. Você precisa retomar o processamento sem repetir trabalho nem perder a fidelidade das descobertas anteriores.

Qual abordagem de gerenciamento de estado equilibra melhor a fidelidade das informações com a eficiência da janela de contexto ao restaurar o estado dos agentes?

CorretaC) Fazer com que cada agente persista um relatório estruturado em um local conhecido. Na retomada, o coordenador carrega os relatórios e injeta o estado relevante nos prompts dos agentes.

Correto. Relatórios estruturados por agente mantêm a fidelidade (as descobertas, com esquema), permitem que o coordenador permaneça no comando da orquestração e mantêm o contexto de cada subagente focado. Este é o padrão de coordenador + artefato compacto.

O monitoramento em produção mostra que consultas de acompanhamento como "resuma o que aprendemos sobre tendências de mercado" levam consistentemente mais de 40 segundos. A investigação revela que o coordenador inicia o subagente de síntese para cada solicitação de resumo, passando mais de 80 mil tokens de descobertas acumuladas. O coordenador já tem essas descobertas em seu contexto por ter orquestrado a pesquisa.

Qual é a forma mais eficaz de melhorar o tempo de resposta para esses resumos de acompanhamento?

CorretaB) Fazer com que o coordenador trate diretamente as solicitações de resumo simples usando seu contexto existente, reservando o início de subagentes para análises complexas.

Correto. Se o coordenador já tem as descobertas, iniciar um subagente para reingerir 80 mil tokens é puro custo adicional. Deixe o coordenador responder a acompanhamentos simples por conta própria.

Um engenheiro usou o agente ontem para analisar um módulo de autenticação legado, identificando duas abordagens distintas de refatoração: extrair um microsserviço versus refatorar no local. Hoje, ele quer explorar ambas as abordagens em profundidade — fazendo o agente propor mudanças de código específicas para cada uma — antes de decidir qual implementar.

Qual é a maneira mais eficaz de estruturar essa exploração?

CorretaD) Usar `fork_session` para criar duas ramificações a partir da análise de ontem, explorando uma abordagem em cada ramificação.

Correto. Ramificar a partir da sessão de ontem dá a cada abordagem seu próprio contexto independente, partindo da mesma linha de base de análise — limpo, paralelo, sem contaminação.

Um engenheiro pede ao seu agente para identificar caminhos de código não testados em um módulo legado de processamento de pagamentos que abrange 45 arquivos. Após ler os primeiros 8 arquivos-fonte, as respostas do agente estão ficando visivelmente menos precisas — ele está esquecendo padrões de código discutidos anteriormente e ainda não localizou todos os arquivos de teste nem rastreou os fluxos de pagamento críticos.

Qual é a abordagem mais eficaz para concluir essa investigação?

CorretaB) Criar subagentes para investigar perguntas específicas (por exemplo, "encontrar todos os arquivos de teste do processamento de pagamentos", "rastrear as dependências do fluxo de reembolso") enquanto o agente principal coordena as descobertas e preserva o entendimento de alto nível.

Correto. Delegue investigações bem delimitadas a subagentes com contexto novo, enquanto o agente principal mantém a visão arquitetural geral. Este é o padrão para escalar a exploração além de uma única janela de contexto.

Seu agente analisou um módulo de serviço complexo — lendo 23 arquivos-fonte, rastreando fluxos de requisição e identificando padrões de tratamento de erros. Um desenvolvedor quer comparar duas estratégias de teste antes de se comprometer com uma: testes ponta a ponta com serviços externos simulados (mocked) versus testes de snapshot que capturam as saídas esperadas. Ele precisa desenvolver ambas as abordagens de forma independente para avaliar os trade-offs.

Como você deve gerenciar as sessões?

CorretaB) Retomar a sessão de análise com `fork_session` habilitado, criando uma ramificação separada para cada estratégia de teste.

Correto. Ramificar dá a cada estratégia seu próprio contexto independente, partindo exatamente da linha de base da análise — sem contaminação cruzada, sem reanálise.

Um cliente retorna 4 horas após a sessão inicial sobre a mesma disputa de cobrança. A sessão anterior, com 32 turnos, contém resultados de `lookup_order` mostrando "Status: PENDING, Resolução prevista: 24-48 horas." Em testes, você observa que, ao retomar sessões com resultados de ferramentas desatualizados, o agente frequentemente faz referência aos dados obsoletos nas respostas (por exemplo, "Vejo que seu reembolso ainda está em processamento"), mesmo após chamadas de ferramentas mais recentes retornarem informações diferentes.

Qual abordagem lida de forma mais confiável com clientes que retornam?

CorretaB) Iniciar uma nova sessão, injetar um resumo estruturado da interação anterior (tipo de problema, ações tomadas, status de resolução) e fazer novas chamadas de ferramentas antes de iniciar o atendimento.

Correto. Uma sessão limpa com um resumo mantém a continuidade narrativa, ao mesmo tempo em que garante que o agente não esteja raciocinando sobre resultados de ferramentas desatualizados.

Seu time criou uma skill `/analyze-codebase` que faz análise profunda de código — varredura de dependências, contagem de cobertura de testes e métricas de qualidade. Após rodar o comando, membros do time relatam que Claude fica menos responsivo na sessão e perde o contexto da tarefa original.

Como você corrige isso de forma mais efetiva mantendo as capacidades plenas de análise?

CorretaA) Adicionar `context: fork` no frontmatter da skill para rodar a análise em contexto isolado de subagente.

`context: fork` roda a análise em contexto de subagente isolado, de modo que a saída grande não polui a janela de contexto da sessão principal e Claude não perde o rastro da tarefa original. Preserva capacidade plena de análise mantendo a sessão principal responsiva.

Você cria uma skill customizada `/explore-alternatives` que seu time usa para fazer brainstorming e avaliar abordagens de implementação antes de escolher uma. Devs reportam que após rodar a skill, respostas subsequentes do Claude são influenciadas pela discussão de alternativas — às vezes referenciando abordagens rejeitadas ou retendo contexto de exploração que interfere na implementação real.

Como configurar essa skill de forma mais efetiva?

CorretaB) Adicionar `context: fork` no frontmatter da skill.

`context: fork` roda a skill em contexto isolado de subagente para que discussões de exploração não poluam o histórico da conversa principal. Isso impede que abordagens rejeitadas e contexto de brainstorming influenciem trabalho subsequente de implementação.

Seu time usa Claude Code para gerar sugestões de código, mas você nota um padrão: questões não-óbvias — otimizações de performance que quebram casos de borda, limpezas que mudam comportamento inesperadamente — só são pegas quando outro membro do time revisa o PR. O raciocínio do Claude durante a geração mostra que ele considerou esses casos mas concluiu que sua abordagem estava correta. Qual abordagem aborda diretamente a causa-raiz dessa limitação de auto-checagem?

Qual abordagem aborda diretamente a causa-raiz?

CorretaA) Rodar uma segunda instância independente do Claude Code para revisar as mudanças sem acesso ao raciocínio do gerador.

Uma segunda instância independente do Claude Code sem acesso ao raciocínio do gerador ataca diretamente a causa-raiz evitando viés de confirmação. Essa perspectiva de "olhos novos" espelha a peer review humana, em que outro revisor pega problemas que o autor racionalizou.

Sua review automatizada gera sugestões de casos de teste para cada PR. Revisando um PR que adiciona tracking de conclusão de curso, Claude sugere 10 casos de teste, mas o feedback dos devs mostra que 6 duplicam cenários já cobertos pela suíte de testes existente. Qual mudança reduz duplicação de forma mais efetiva?

Qual mudança é mais efetiva?

CorretaA) Incluir o arquivo de teste existente no contexto para que Claude possa determinar quais cenários já estão cobertos.

Incluir o arquivo de teste existente corrige a causa-raiz da duplicação: Claude só pode evitar sugerir cenários já cobertos se souber quais testes já existem. Isso dá a Claude a informação necessária para propor testes genuinamente novos e valiosos.

Após uma review automatizada inicial identificar 12 achados, um dev faz push de novos commits para tratar os problemas. Re-rodar a review produz 8 achados, mas devs reportam que 5 duplicam comentários anteriores em código que já foi corrigido nos novos commits. Qual é a forma mais efetiva de eliminar esse feedback redundante mantendo a profundidade?

Qual é a forma mais efetiva de eliminar feedback redundante?

CorretaD) Incluir achados de reviews anteriores no contexto e instruir Claude a reportar apenas problemas novos ou ainda não resolvidos.

Incluir achados de reviews anteriores no contexto deixa Claude distinguir problemas novos dos já tratados em commits recentes. Isso preserva profundidade da review enquanto usa o raciocínio do Claude para evitar feedback redundante em código já corrigido.

O monitoramento de produção mostra qualidade inconsistente de síntese. Quando os resultados agregados têm ~75K tokens, o agente de síntese cita de forma confiável informações dos primeiros 15K tokens (manchetes/snippets de busca web) e dos últimos 10K (conclusões da análise de documentos), mas frequentemente perde achados críticos nos 50K do meio — mesmo quando respondem diretamente à pergunta de pesquisa. Como reestruturar a entrada agregada?

Como reestruturar a entrada agregada?

CorretaC) Posicionar um sumário de achados-chave no início da entrada agregada e organizar resultados detalhados com cabeçalhos de seção explícitos para navegação mais fácil.

Posicionar um sumário de achados-chave no início aproveita o efeito de primazia, colocando informação crítica na posição de processamento mais confiável. Adicionar cabeçalhos de seção explícitos ajuda o modelo a navegar e atender ao conteúdo do meio, mitigando diretamente o fenômeno "lost in the middle".

Em testes, a saída combinada do agente de busca web (85K tokens incluindo conteúdo de páginas) e do agente de análise de documentos (70K tokens incluindo cadeias de raciocínio) totaliza 155K tokens, mas o agente de síntese performa melhor com entradas abaixo de 50K tokens. Qual solução é mais efetiva?

Qual solução é mais efetiva?

CorretaA) Modificar agentes upstream para retornar dados estruturados (fatos-chave, citações, scores de relevância) em vez de conteúdo verboso e raciocínio.

Modificar agentes upstream para retornar dados estruturados ataca a causa-raiz reduzindo o volume de tokens na origem enquanto preserva informação essencial. Evita passar conteúdo volumoso de páginas e traços de raciocínio que inflam tokens sem melhorar a etapa de síntese.

Você está adicionando wrappers de tratamento de erros ao redor de chamadas de API externas em uma base de 120 arquivos. O trabalho tem três fases: (1) descobrir todos os call sites e padrões, (2) desenhar colaborativamente a abordagem de tratamento de erros, e (3) implementar wrappers de forma consistente. Na Fase 1, Claude gera saída grande listando centenas de call sites com contexto, enchendo rapidamente a janela de contexto antes da descoberta terminar.

Qual abordagem é mais efetiva para concluir a tarefa mantendo consistência de implementação?

CorretaA) Usar um subagente Explore para a Fase 1 para isolar saída verbosa de descoberta e retornar um sumário, depois continuar Fases 2–3 na conversa principal.

Um subagente Explore isola a saída verbosa de descoberta em contexto separado e retorna apenas um sumário conciso à conversa principal. Isso preserva a janela de contexto principal para as fases de design colaborativo e implementação consistente, em que contexto retido é mais valioso.

Logs de produção mostram um padrão: clientes referenciam valores específicos (ex.: "o desconto de 15% que mencionei"), mas o agente responde com valores incorretos. Investigação mostra que esses detalhes foram mencionados 20+ turnos atrás e condensados em sumários vagos como "preços promocionais foram discutidos". Qual correção é mais efetiva?

Qual correção é mais efetiva?

CorretaC) Extrair fatos transacionais (valores, datas, números de pedido) para um bloco persistente de "case facts" incluído em todo prompt fora do histórico sumarizado.

Sumarização inerentemente perde detalhes precisos. Extrair fatos transacionais para um bloco estruturado "case facts" fora do histórico sumarizado preserva informação crítica para que esteja disponível de forma confiável em todo prompt, independente de quantos turnos foram sumarizados.

Após uma sessão culinária de 40 minutos, a conversa atinge 78.000 tokens. O histórico inclui alergias, escala de receitas, termos culinários esclarecidos e discussão geral. Você precisa reduzir tokens preservando informação importante.

Qual abordagem melhor balanceia preservação e redução de tokens?

CorretaC) Extrair dados estruturados críticos (alergias, quantidades, preferências), sumarizar a discussão geral e manter trocas recentes verbatim.

A abordagem híbrida preserva a informação de maior valor ao menor custo. Fatos críticos como alergias e quantidades são extraídos para um bloco estruturado compacto (evitando perda de precisão que ocorre na sumarização), discussão geral é sumarizada e trocas recentes mantidas verbatim para coerência conversacional. A e B arriscam perder informação dietética crítica; D é overkill arquitetural para uma única sessão.

Usuários reportam que durante conversas extensas o assistente perde o rastro de tópicos e preferências anteriores. Sua implementação atual mantém apenas os últimos 25 pares de mensagens.

Qual a solução mais efetiva?

CorretaA) Abordagem híbrida: sumarizar mensagens antigas mantendo as recentes verbatim.

A abordagem híbrida ataca ambas as dimensões do problema: retém contexto exato recente (crítico para coerência conversacional) enquanto mantém uma representação comprimida das preferências anteriores (evitando perda total quando pares são descartados). Aumentar a janela (C) só atrasa o mesmo problema. Busca vetorial (B) pode perder contexto importante que não é semanticamente similar à query atual. Sumarização total por turno (D) adiciona overhead e acumula erros de sumarização.

Usuários reportam que latência aumenta e custos sobem quando conversas excedem 50 turnos.

Qual a causa principal?

CorretaA) Todo o histórico da conversa é incluído em cada requisição da API.

A API do Claude é totalmente stateless — toda requisição precisa incluir o histórico completo no array `messages`. Conforme conversas crescem, cada requisição carrega mais tokens, o que aumenta diretamente latência de processamento e custo. O modelo não mantém estado interno entre chamadas (D é falso) e o tamanho da resposta não está intrinsecamente ligado ao tamanho da conversa (B).

Após três meses de sessões semanais, o histórico cresce para 85.000 tokens. Quando um usuário pergunta "O que concluímos sobre o tema do isolamento?", o assistente dá respostas genéricas em vez de referenciar discussões anteriores.

Qual a abordagem mais efetiva?

CorretaC) Embeddings semânticos com recuperação de trocas relevantes.

Busca semântica sobre o histórico de conversa é a única abordagem que escala para três meses de discussão sendo capaz de surfar trocas específicas relevantes sob demanda. Janela rolante (A) descartaria a maior parte do histórico. Sumarização progressiva (B) comprime discussões em abstrações que perdem as conclusões específicas que os usuários estão pedindo. Tags XML (D) exigem reestruturar todo conteúdo passado e não resolvem o problema de recuperação nessa escala.

Seu assistente usa um system prompt de persona "empreiteiro". Os primeiros turnos seguem as regras, mas no turno 7 o assistente passa a dar conselhos genéricos. O comprimento da conversa é de apenas 2.500 tokens.

Qual a causa mais provável?

CorretaC) Respostas acumuladas do assistente diluem a influência do system prompt.

Conforme respostas do assistente se acumulam no histórico, a proporção de texto refletindo as restrições comportamentais do system prompt diminui em relação ao volume crescente de conteúdo gerado pelo assistente. O modelo cada vez mais casa padrão com suas próprias saídas anteriores em vez do system prompt, agravando deriva mesmo em comprimentos curtos de tokens. O system prompt é incluído em toda chamada de API (D é falso isoladamente) e degradação de atenção (B) não opera em 2.500 tokens.

Durante os testes, você observa que em sessões de exploração prolongadas (mais de 30 minutos), o agente começa a dar respostas inconsistentes sobre a estrutura de código que discutiu anteriormente. Os engenheiros relatam ter que repetir o contexto sobre módulos que já exploraram.

Qual é a abordagem mais eficaz para resolver isso?

CorretaA) Fazer o agente manter um arquivo de rascunho que registra as descobertas principais, consultando-o para perguntas subsequentes.

Correto. Um arquivo de rascunho descarrega as descobertas em um armazenamento durável que o agente pode reler sob demanda, dando a ele uma 'memória' estável independente de quão cheia a janela de contexto fique.

Seu agente passou 25 minutos explorando o subsistema de renderização de um motor de jogos — lendo código de shaders, gerenciamento de buffers e a lógica de sincronização de frames. Um engenheiro agora pede que ele entenda como o motor de física se integra à renderização para sobreposições de depuração de colisão. Você nota que respostas recentes fazem referência a "padrões típicos de renderização" em vez das classes específicas VulkanPipeline e FrameGraph que ele descobriu antes.

Qual é a abordagem mais eficaz?

CorretaC) Resumir as descobertas principais de renderização e, então, criar um subagente para a exploração de física com esse resumo em seu contexto inicial.

Correto. Condense o que você aprendeu sobre renderização em um resumo compacto e, então, dê a um subagente novo esse resumo mais a tarefa de física — você preserva o sinal importante e escapa do contexto degradado.

Um engenheiro pede ao agente para entender como funciona a camada de cache antes de adicionar um novo gatilho de invalidação de cache. Após as buscas iniciais com Grep, o agente identificou que a lógica de cache se espalha por 15 arquivos, incluindo decoradores, middleware e classes de serviço (~8.000 linhas no total).

Qual é o próximo passo mais eficaz para construir o entendimento gerenciando as restrições de contexto?

CorretaB) Analisar as importações e hierarquias de classe para identificar a classe base de cache, ler esse arquivo para entender a interface e, então, rastrear as implementações específicas de invalidação.

Correto. Comece pela raiz arquitetural (a interface) e, então, navegue apenas pelas implementações específicas que importam para a invalidação — leitura focada, baixo custo de contexto.

Um cliente levanta três questões distintas durante uma sessão: uma consulta de reembolso (turnos 1-15), uma dúvida sobre assinatura (turnos 16-30) e uma atualização de método de pagamento (turnos 31-45). No turno 48, o cliente pergunta "O que aconteceu com o meu reembolso?" A conversa está se aproximando dos limites de contexto.

Qual estratégia mantém melhor a capacidade do agente de tratar todas as questões ao longo da sessão?

CorretaC) Resumir os turnos anteriores em uma descrição narrativa, preservando o histórico completo de mensagens apenas para a questão ativa.

Correto. A sumarização progressiva comprime tópicos estáveis já resolvidos, mantendo a thread ativa na íntegra — o padrão clássico para conversas longas com múltiplas questões próximas do limite de contexto.

Seu agente chamou `lookup_order` várias vezes enquanto investigava os pedidos de devolução de um cliente. Cada resposta inclui mais de 40 campos (itens, detalhes de envio, informações de pagamento, histórico de status). As saídas das ferramentas agora representam a maior parte do contexto da conversa. O cliente menciona mais dois pedidos que deseja discutir.

Qual é a abordagem mais eficaz antes de fazer consultas adicionais?

CorretaA) Extrair apenas os campos relevantes para a devolução (itens, data da compra, prazo de devolução, status) de cada resposta de pedido existente, removendo os detalhes verbosos.

Correto. Mantenha os campos que importam para a tarefa e descarte o resto. Isso aborda diretamente o problema de inchaço do contexto antes de você adicionar mais duas consultas.

Seu script de pipeline executa `claude "Analyze this pull request for security issues"`, mas o job trava indefinidamente. Logs mostram que o Claude Code está esperando entrada interativa. Qual é a abordagem correta para rodar Claude Code em pipeline automatizado?

Qual é a abordagem correta?

CorretaB) Adicionar a flag `-p`: `claude -p "Analyze this pull request for security issues"`.

A flag `-p` (ou `--print`) é a forma documentada de rodar Claude Code em modo não-interativo. Processa o prompt, imprime o resultado no stdout e encerra sem esperar entrada do usuário — ideal para pipelines CI/CD.

Seu CLAUDE.md cresceu para 400+ linhas contendo padrões de código, convenções de testes, um checklist detalhado de PR review, instruções de deploy e procedimentos de migração de banco. Você quer que Claude sempre siga padrões de código e convenções de testes, mas aplique guias de PR review, deploy e migration apenas quando estiver fazendo essas tarefas.

Qual abordagem de reestruturação é mais efetiva?

CorretaD) Manter padrões universais no CLAUDE.md e criar Skills para guias específicos de fluxo (PR review, deploy, migrations) com palavras-chave de gatilho.

Conteúdo do CLAUDE.md carrega em toda sessão, garantindo que padrões de código e convenções de teste sempre se apliquem, enquanto Skills são invocadas sob demanda quando Claude detecta palavras-chave de gatilho — ideal para guias específicos de fluxo como PR review, deploy e migrations.

Seu time usa uma skill `/commit` em `.claude/skills/commit/SKILL.md`. Um dev quer customizá-la para seu fluxo pessoal (formato diferente de commit message, checagens extras) sem afetar colegas.

O que você recomenda?

CorretaC) Criar uma versão pessoal em `~/.claude/skills/commit/SKILL.md` com o mesmo nome.

Skills pessoais têm precedência sobre skills de projeto com o mesmo nome. Uma skill pessoal em `~/.claude/skills/commit/SKILL.md` sobrescreverá a do time, permitindo ao dev customizar seu fluxo enquanto mantém o nome familiar `/commit` para uso pessoal. Essa abordagem é melhor que A porque preserva o nome de comando original, melhorando o fluxo do dev sem afetar colegas.

Seu time usa Claude Code há meses. Recentemente, três devs reportam que Claude segue a orientação "sempre incluir tratamento abrangente de erros", mas um quarto dev recém-chegado diz que Claude não a segue. Os quatro trabalham no mesmo repo e têm código atualizado.

Qual a causa mais provável e correção?

CorretaA) A orientação está nos arquivos de nível usuário `~/.claude/CLAUDE.md` dos devs originais, não no `.claude/CLAUDE.md` do projeto. Mover a instrução para o arquivo de nível projeto para que todos os membros recebam.

Se a orientação foi adicionada apenas aos configs de nível usuário dos devs originais e não ao `.claude/CLAUDE.md` do projeto, novos membros não a recebem. Mover para a configuração de nível projeto garante que todos os membros atuais e futuros recebam a orientação automaticamente.

Você descobre que incluir 2–3 implementações completas de endpoint como contexto melhora significativamente a consistência ao gerar novos endpoints de API. Porém, esse contexto só é útil ao criar novos endpoints — não ao depurar, revisar código ou outros trabalhos no diretório de API.

Qual abordagem de configuração é mais efetiva?

CorretaD) Criar uma skill que referencie os exemplos de endpoint e contenha instruções de seguimento de padrão, invocada sob demanda via slash command.

Uma skill invocada sob demanda carrega o contexto de exemplo apenas ao gerar novos endpoints, não em tarefas não relacionadas como depuração ou review. Isso mantém o contexto principal limpo enquanto preserva geração de alta qualidade quando necessária.

Seu time criou uma skill `/migration` que gera arquivos de migração de banco. Recebe o nome da migração via `$ARGUMENTS`. Em produção você observa três problemas: (1) devs frequentemente rodam a skill sem argumentos, causando arquivos mal nomeados, (2) a skill às vezes usa detalhes de schema de conversas anteriores não relacionadas, e (3) um dev rodou acidentalmente cleanup destrutivo de teste quando a skill tinha acesso amplo a ferramentas.

Qual abordagem de configuração corrige todos os três problemas?

CorretaB) Adicionar `argument-hint` no frontmatter para pedir parâmetros obrigatórios, usar `context: fork` para isolar a execução, e restringir `allowed-tools` a operações de escrita de arquivo.

Usa três features de configuração separadas para tratar cada problema: `argument-hint` melhora a entrada de argumentos e reduz argumentos faltando, `context: fork` impede vazamento de contexto de conversas anteriores e `allowed-tools` restringe a skill a operações seguras de escrita de arquivo, prevenindo ações destrutivas.

Sua base contém áreas com convenções de código diferentes: componentes React usam estilo funcional com hooks, handlers de API usam async/await com tratamento específico de erros e modelos de banco seguem o padrão repository. Arquivos de teste estão distribuídos pela base ao lado do código sob teste (ex.: `Button.test.tsx` ao lado de `Button.tsx`), e você quer que todos os testes sigam as mesmas convenções independentemente da localização.

Qual é a forma mais suportada de garantir que Claude aplique automaticamente as convenções corretas ao gerar código?

CorretaD) Criar arquivos de regra em `.claude/rules/` com frontmatter YAML especificando padrões glob para aplicar convenções condicionalmente baseadas em paths.

Arquivos `.claude/rules/` com frontmatter YAML e padrões glob (ex.: `**/*.test.tsx`, `src/api/**/*.ts`) permitem aplicação determinística e baseada em path de convenções independente da estrutura de diretórios. É a abordagem mais suportada para padrões cross-cutting como arquivos de teste distribuídos.

Você quer criar um slash command customizado `/review` que rode o checklist padrão de code review do seu time. Ele deve estar disponível para todo dev quando clonar ou atualizar o repositório.

Onde criar o arquivo do comando?

CorretaB) No repositório do projeto sob `.claude/commands/`.

Colocar slash commands customizados sob `.claude/commands/` dentro do repositório do projeto garante que estejam versionados e disponíveis automaticamente para todo dev que clone ou atualize o repo. É o local previsto para comandos customizados de nível projeto no Claude Code.

O CLAUDE.md do seu time cresceu além de 500 linhas misturando convenções TypeScript, orientação de testes, padrões de API e procedimentos de deploy. Devs têm dificuldade de localizar e atualizar as seções certas.

Qual abordagem o Claude Code suporta para organizar instruções de nível projeto em módulos tópicos focados?

CorretaB) Criar arquivos Markdown separados em `.claude/rules/`, cada um cobrindo um tópico (ex.: `testing.md`, `api-conventions.md`).

Claude Code suporta um diretório `.claude/rules/` onde você pode criar arquivos Markdown separados para guias tópicos (ex.: `testing.md`, `api-conventions.md`), permitindo a times organizar grandes conjuntos de instruções em módulos focados e mantíveis.

Seu time quer adicionar um servidor MCP do GitHub para buscar PRs e checar status de CI via Claude Code. Cada um dos seis devs tem seu próprio token pessoal de acesso ao GitHub. Você quer ferramental consistente em todo o time sem commitar credenciais no controle de versão.

Qual abordagem de configuração é mais efetiva?

CorretaC) Adicionar o servidor ao `.mcp.json` do projeto usando substituição de variável de ambiente (`${GITHUB_TOKEN}`) para auth e documentar a variável necessária no README.

Um `.mcp.json` de projeto com substituição de variável de ambiente é idiomático: fornece uma única fonte versionada de verdade para a configuração MCP enquanto deixa cada dev fornecer credenciais via variáveis de ambiente. Documentar a variável facilita o onboarding sem commitar segredos.

Uma engenheira usou o `Claude Code` ontem para investigar fluxos de autenticação em um monolito legado, acumulando um contexto significativo ao longo de uma sessão de 2 horas. Hoje ela quer continuar essa investigação específica. Ela trabalhou em outras três bases de código desde então e sabe que a sessão se chamava "auth-deep-dive".

Como ela deve retomar?

CorretaD) Usar `--resume` auth-deep-dive para carregar essa sessão específica pelo nome

Correto. `--resume` com o nome da sessão foi projetado exatamente para isso: escolher uma sessão anterior específica dentre muitas, pelo nome que você deu a ela.

Seu assistente precisa manter um tom entusiástico, explicar seu raciocínio e fazer perguntas esclarecedoras. Onde essas diretrizes comportamentais devem ser definidas?

Onde essas diretrizes comportamentais devem ser definidas?

CorretaB) No system prompt.

O system prompt é especificamente desenhado para restrições e diretrizes comportamentais persistentes que se aplicam ao longo de toda a conversa. Prependê-las a cada mensagem do usuário (A) é overhead redundante. A primeira mensagem do assistente (C) não é confiável porque o modelo pode desviar de suas próprias declarações anteriores. Variáveis de ambiente (D) não têm efeito sobre o comportamento do modelo.

Um webhook notifica seu sistema de que o pacote do usuário foi enviado enquanto o usuário está conversando ativamente. Você quer que o assistente incorpore isso naturalmente na próxima resposta.

Qual a melhor abordagem?

CorretaD) Anexar a atualização de status como prefixo à próxima mensagem do usuário.

Prefixar a atualização de status à próxima mensagem do usuário injeta contexto em tempo real em uma fronteira natural da conversa sem perturbar o fluxo. Modificar o system prompt (A) exige reconstruir a sessão ou é arquiteturalmente custoso. Uma mensagem sintética do usuário (B) pode quebrar o fluxo natural do diálogo e confundir atribuição. Forçar uma chamada de ferramenta a cada turno (C) é desperdício quando eventos são raros.

O agente de síntese recebe descobertas resumidas dos agentes de busca na web e de análise de documentos e, em seguida, passa um resumo consolidado para o gerador de relatórios. Durante os testes, você descobre que os relatórios gerados fazem afirmações factuais sem as devidas citações — o gerador de relatórios não consegue atribuir as declarações às suas fontes originais porque esses metadados foram perdidos durante as etapas de resumo.

Qual é a abordagem mais eficaz para garantir a atribuição correta de fontes nos relatórios finais?

CorretaA) Fazer com que cada agente produza dados estruturados que separem os resumos de conteúdo dos metadados de fonte (URLs, nomes de documentos, números de página).

Correto. Conteúdo estruturado + metadados de fonte separados preservam o mapeamento de ponta a ponta, de modo que o gerador de relatórios recebe tanto o que foi dito quanto de onde veio.

Em produção, os relatórios finais frequentemente contêm afirmações sem a devida atribuição de fonte. A investigação mostra que, embora os agentes de busca na web e de análise de documentos anexem corretamente as citações às suas saídas, o agente de síntese perde o controle de quais fontes sustentam quais conclusões ao combinar as descobertas.

Qual é a mudança arquitetural mais eficaz?

CorretaB) Exigir que todos os subagentes produzam mapeamentos estruturados de afirmação-fonte que o agente de síntese deve preservar e mesclar ao combinar descobertas de várias fontes.

Correto. Mapeamentos explícitos de afirmação-fonte são uma saída de primeira classe que o agente de síntese pode mesclar de forma determinística — nenhuma atribuição é descartada durante o resumo.

A conformidade exige que reembolsos acima de US$ 500 sejam automaticamente escalonados para um agente humano — essa regra não pode ficar a critério do modelo. Apesar de instruções claras no prompt do sistema, os logs de produção mostram que o agente ocasionalmente processa reembolsos de alto valor diretamente (taxa de falha de 3%).

Como você deve garantir conformidade assegurada?

CorretaC) Implementar um hook para interceptar as chamadas de ferramenta; quando o valor do processo de reembolso exceder US$ 500, bloqueá-lo e invocar o escalonamento humano.

Correto. Regras de nível de conformidade pertencem fora do modelo — um hook determinístico na chamada de ferramenta é garantido de disparar sempre, independentemente do comportamento do modelo.

Logs de produção mostram que em 12% dos casos seu agente pula `get_customer` e chama `lookup_order` diretamente usando apenas o nome fornecido pelo cliente, às vezes levando a contas mal identificadas e reembolsos incorretos. Qual mudança corrige esse problema de confiabilidade de forma mais efetiva?

Qual mudança é mais efetiva?

CorretaC) Adicionar uma pré-condição programática que bloqueia `lookup_order` e `process_refund` até que `get_customer` retorne um identificador verificado.

Uma pré-condição programática fornece garantia determinística de que o sequenciamento exigido seja seguido. É a abordagem mais efetiva porque elimina a possibilidade de pular a verificação, independentemente do comportamento do LLM.

Sua ferramenta `remove_team_member` usa um parâmetro `dry_run: boolean` para visualizar impactos antes da execução. Monitoramento de produção mostra que o agente burla o passo de preview chamando com `dry_run=false` diretamente. Você precisa garantir que toda remoção seja precedida por um preview que o usuário confirme explicitamente.

Qual é a abordagem mais confiável?

CorretaD) Substituir por duas ferramentas: `preview_remove_member` retorna detalhes de impacto e um token de confirmação de uso único; `execute_remove_member` exige esse token, ligando a execução ao preview.

A abordagem de duas ferramentas com binding por token torna arquiteturalmente impossível executar sem um preview prévio — a ferramenta de execução literalmente exige um token que só a ferramenta de preview pode gerar. É a única abordagem que aplica a restrição no nível de código em vez de depender de conformidade do LLM com instruções (C), heurísticas de timing (A) ou infraestrutura de orquestração (B).

Seu pipeline de CI executa o Claude Code CLI (em modo `--print`) usando CLAUDE.md para fornecer contexto do projeto para code review, e os devs em geral acham as reviews substantivas. Porém, eles relatam que integrar achados ao workflow é difícil — Claude emite parágrafos narrativos que precisam ser copiados manualmente para comentários no PR. O time quer postar automaticamente cada achado como comentário inline separado no local relevante do código, o que exige dados estruturados com path do arquivo, número da linha, nível de severidade e correção sugerida. Qual abordagem é mais efetiva?

Qual abordagem é mais efetiva?

CorretaB) Usar as flags do CLI `--output-format json` e `--json-schema` para forçar achados estruturados, depois parsear a saída para postar comentários inline via API do GitHub.

Usar `--output-format json` com `--json-schema` força saída estruturada no nível do CLI, garantindo JSON bem formado com os campos exigidos (path, linha, severidade, correção sugerida) que pode ser parseado de forma confiável e postado como comentários inline via API do GitHub. Aproveita capacidades nativas do CLI projetadas justamente para saída estruturada.

Seu pipeline de extração processa faturas e extrai itens de linha, subtotais, valores de impostos e totais gerais. Durante a avaliação, você descobre que em 18% das extrações a soma dos valores dos itens de linha extraídos não corresponde ao total geral extraído — às vezes por erros de OCR no documento de origem, às vezes por erros de extração do modelo. Os sistemas contábeis downstream rejeitam registros com totais discrepantes.

Qual é a abordagem mais eficaz para melhorar a confiabilidade da extração?

CorretaA) Adicionar um campo "`calculated_total`", em que o modelo soma os itens de linha extraídos, ao lado de um campo "`stated_total`". Sinalizar os registros para revisão humana quando os valores diferirem.

Correto. Capturar ambos os valores transforma a discrepância em um sinal de primeira classe — você detecta erros de OCR e erros de extração de forma uniforme e pode rotear apenas os 18% discrepantes para humanos.

Após a implantação, você descobre que 12% das extrações contêm erros semânticos que passam na validação do esquema JSON (por exemplo, uma duração como "30 minutes" colocada incorretamente em um campo de quantidade de ingrediente). Os revisores humanos têm capacidade para verificar apenas 20% das extrações.

Qual abordagem aloca a atenção dos revisores de forma mais eficaz?

CorretaA) Fazer o modelo gerar pontuações de confiança no nível de campo e, então, calibrar os limiares de revisão usando um conjunto de validação rotulado.

Correto. A confiança no nível de campo permite rotear os 20% de baixa confiança — onde se concentram os 12% de erros semânticos — para humanos. A calibração torna a escolha do limiar orientada por dados.

O coordenador fornece instruções detalhadas passo a passo ao subagente de busca na web, especificando consultas de busca exatas, prioridades de fontes e filtros de data. O monitoramento em produção revela três problemas: (1) o subagente relata "resultados insuficientes" em vez de tentar abordagens alternativas quando as buscas pré-especificadas falham, (2) a qualidade da pesquisa cai para tópicos emergentes que não correspondem aos padrões esperados e (3) o subagente raramente traz à tona fontes tangenciais valiosas.

Qual é a forma mais eficaz de melhorar a adaptabilidade do subagente?

CorretaD) Especificar metas de pesquisa e critérios de qualidade (amplitude de cobertura, diversidade de fontes, atualidade) em vez de etapas procedurais, deixando que o subagente determine sua estratégia de busca.

Correto. Delegue intenção e parâmetros de qualidade, não procedimentos. O subagente pode então escolher consultas, seguir tangentes promissoras e se recuperar de becos sem saída por conta própria.

Um engenheiro pede ao agente para encontrar todos os chamadores de uma função antes de removê-la. A função é definida em uma biblioteca central, mas também é exposta por meio de módulos wrapper que renomeiam a função para uso específico de domínio (por exemplo, calculateTax na biblioteca torna-se computeOrderTax no módulo de pedidos).

Qual estratégia de exploração identificará de forma mais confiável todos os chamadores?

CorretaA) Ler a biblioteca e os módulos wrapper para identificar todos os nomes sob os quais a função é exposta e, em seguida, usar o Grep para cada nome em toda a base de código.

Correto. Você precisa enumerar cada nome sob o qual a função é exposta — caso contrário, wrappers renomeados ocultam chamadores. Leia os módulos relevantes, reúna todos os aliases e então faça grep para cada um.

Você precisa adicionar Slack como novo canal de notificação. A base existente tem padrões claros e estabelecidos para email, SMS e push. Porém, a API do Slack oferece abordagens fundamentalmente diferentes — webhooks de entrada (simples, unidirecional), bot tokens (suporte a confirmação de entrega e controle programático), ou Slack Apps (eventos bidirecionais, requer aprovação do workspace). Sua tarefa diz "adicionar suporte a Slack" sem especificar método de integração ou exigir features avançadas como tracking de entrega.

Como abordar essa tarefa?

CorretaB) Mudar para modo de planejamento para explorar opções de integração e implicações arquiteturais, depois apresentar uma recomendação antes da implementação.

Integração com Slack tem múltiplas abordagens válidas com implicações arquiteturais significativamente diferentes, e os requisitos são ambíguos. O modo de planejamento deixa avaliar trade-offs entre webhooks, bot tokens e Slack Apps e alinhar uma abordagem antes de implementar.

Você foi designado para reestruturar a aplicação monolítica do seu time em microsserviços. Isso impacta mudanças em dezenas de arquivos e exige decisões sobre fronteiras de serviço e dependências de módulos.

Qual abordagem você deve escolher?

CorretaA) Mudar para modo de planejamento para explorar a base, entender dependências e desenhar a abordagem de implementação antes de fazer mudanças.

Modo de planejamento é a estratégia certa para reestruturação arquitetural complexa como dividir um monolito: permite exploração segura e decisões informadas sobre fronteiras antes de comprometer-se com mudanças potencialmente caras em muitos arquivos.

Usuários frequentemente enviam pedidos como "Reserve um local para a festa". O assistente faz 4+ perguntas esclarecedoras, causando 35% de abandono.

Qual abordagem melhora melhor o trade-off?

CorretaC) Declarar suposições explicitamente e prosseguir convidando correções.

Declarar suposições explicitamente e prosseguir dá ao usuário uma resposta imediata e útil enquanto preserva sua capacidade de corrigir suposições erradas. Defaults ocultos (A) deixam o usuário sem saber o que foi assumido. Uma lista composta de perguntas (B) ainda exige esforço inicial do usuário. Um formulário estruturado (D) adiciona mais atrito, não menos — contradiz o objetivo de reduzir abandono.

Usuários fazem pedidos vagos como "Pode ajudar com o relatório?". O assistente responde fazendo várias perguntas (qual relatório? que ajuda? prazo?), causando 40% de abandono.

Qual a melhor solução?

CorretaA) Fazer suposições razoáveis, declará-las explicitamente e oferecer ajustes.

Prosseguir com suposições razoáveis declaradas elimina totalmente o vai-e-vem mantendo o usuário informado e no controle. Interpretações silenciosas predefinidas (C) deixam usuários confusos quando a resposta não casa com sua intenção. Um limite de uma pergunta (D) ainda exige turnos de vai-e-vem. Um modelo menor de classificação (B) adiciona latência e complexidade de infraestrutura sem resolver o problema central de UX.

Os agentes de busca web e de análise de documentos concluíram suas tarefas e retornaram resultados ao coordenador. Qual é o próximo passo para criar um relatório de pesquisa integrado?

Qual próximo passo é mais apropriado?

CorretaC) O coordenador passa ambos os conjuntos de resultados ao agente de síntese para uma integração unificada.

Em uma arquitetura coordenador–subagente, o coordenador encaminha ambos os conjuntos de resultados ao agente de síntese para uma integração centralizada, preservando o controle e garantindo uma fusão de alta qualidade.

Após executar o sistema sobre "impacto da IA nas indústrias criativas", você observa que cada subagente conclui com sucesso: o agente de busca web encontra artigos relevantes, o agente de análise de documentos os sumariza corretamente e o agente de síntese produz um texto coerente. No entanto, os relatórios finais cobrem somente artes visuais e perdem totalmente música, literatura e cinema. Nos logs do coordenador, você vê que ele decompôs o tema em três subtarefas: "IA em arte digital", "IA em design gráfico" e "IA em fotografia". Qual é a causa-raiz mais provável?

Qual é a causa-raiz mais provável?

CorretaC) A decomposição de tarefas do coordenador é estreita demais, atribuindo aos subagentes trabalho que não cobre todas as áreas relevantes.

O coordenador decompôs um tema amplo apenas em subtarefas de artes visuais, perdendo totalmente música, literatura e cinema. Como os subagentes executaram suas atribuições corretamente, a decomposição estreita é a causa-raiz óbvia.

Um colega propõe que o agente de análise de documentos envie seus resultados diretamente ao agente de síntese, contornando o coordenador. Qual é a vantagem principal de manter o coordenador como hub central para toda comunicação entre subagentes?

Qual é a vantagem principal de manter o coordenador como hub central?

CorretaA) O coordenador pode observar todas as interações, tratar erros de forma uniforme e decidir que informação cada subagente deve receber.

O padrão coordenador fornece visibilidade central sobre todas as interações, tratamento de erros uniforme em todo o sistema e controle granular sobre que informação cada subagente recebe — essas são as principais vantagens de uma topologia de comunicação em estrela.

Ao pesquisar um tema amplo, você observa que o agente de busca web e o agente de análise de documentos investigam os mesmos subtemas, levando a duplicação substancial em suas saídas. O uso de tokens quase dobra sem aumento proporcional na amplitude ou profundidade da pesquisa. Qual é a forma mais efetiva de tratar isso?

Qual é a forma mais efetiva de tratar isso?

CorretaB) O coordenador particiona explicitamente o espaço de pesquisa antes de delegar, atribuindo a cada agente subtemas distintos ou tipos de fonte distintos.

Fazer o coordenador particionar explicitamente o espaço de pesquisa antes de delegar é mais efetivo porque ataca a causa-raiz — fronteiras de tarefa pouco claras — antes de qualquer trabalho começar. Preserva paralelismo prevenindo esforço duplicado e tokens desperdiçados.

Logs de produção mostram que para pedidos simples como "reembolso para o pedido #1234", seu agente resolve em 3–4 chamadas de ferramenta com 91% de sucesso. Mas para pedidos complexos como "fui cobrado em dobro, meu desconto não foi aplicado e quero cancelar", o agente faz em média 12+ chamadas com apenas 54% de sucesso — frequentemente investigando questões sequencialmente e buscando dados redundantes do cliente para cada uma. Qual mudança melhora o tratamento de pedidos complexos de forma mais efetiva?

Qual mudança é mais efetiva?

CorretaC) Decompor o pedido em questões separadas, depois investigar cada uma em paralelo usando contexto compartilhado do cliente antes de sintetizar uma resolução final.

Decompor em questões separadas e investigar em paralelo com contexto compartilhado do cliente corrige ambos os problemas-chave: elimina recuperação redundante de dados reutilizando contexto compartilhado entre questões e reduz total de loops de chamada paralelizando investigação antes de sintetizar uma única resolução.

Métricas de produção mostram que seu agente faz em média 4+ loops de API por resolução. A análise revela que Claude frequentemente solicita `get_customer` e `lookup_order` em turnos sequenciais separados, mesmo quando ambos são necessários inicialmente. Qual é a forma mais efetiva de reduzir o número de loops?

Qual é a forma mais efetiva de reduzir loops?

CorretaD) Instruir Claude no prompt a agrupar solicitações de ferramenta em um turno e retornar todos os resultados juntos antes da próxima chamada de API.

Pedir a Claude que agrupe solicitações de ferramenta relacionadas em um único turno aproveita sua capacidade nativa de pedir múltiplas ferramentas de uma vez. Corrige diretamente o padrão de chamadas sequenciais com mudança arquitetural mínima.

Depois que o agente de busca na web encontra 25 fontes (120 mil tokens de conteúdo bruto), o agente de análise de documentos extrai os principais insights (15 mil tokens) e o agente de síntese produz um rascunho de narrativa coerente (3 mil tokens), o coordenador deve passar o contexto para o agente de geração de relatórios para a saída final com as devidas citações de fonte.

Qual estratégia de passagem de contexto oferece o melhor equilíbrio entre completude e eficiência?

CorretaB) Passar o rascunho de síntese junto com um índice de fontes estruturado que mapeia as principais afirmações às URLs de suas fontes e aos trechos relevantes.

Correto. A síntese fornece a narrativa; o índice de fontes dá ao gerador de relatórios exatamente o vínculo de que ele precisa para citar sem reler 120 mil tokens de conteúdo bruto.

O agente de busca na web reuniu várias fontes relevantes para um tópico de pesquisa. O agente de análise de documentos agora precisa examinar essas fontes.

Como as informações normalmente fluem entre esses dois subagentes especializados?

CorretaC) O agente coordenador recebe a saída do agente de busca na web e inclui as descobertas relevantes no prompt ao invocar o agente de análise de documentos.

Correto. Em um padrão coordenador-trabalhador, o coordenador é o hub. Ele coleta a saída de cada subagente e encaminha explicitamente as partes relevantes para o prompt do próximo subagente.

Em produção, você observa que consultas simples de verificação de fatos (por exemplo, "Em que ano o Acordo de Paris sobre o Clima foi assinado?") percorrem todos os quatro subagentes sequencialmente, consumindo mais de 40 segundos e tokens significativos por consulta. Pesquisas comparativas complexas se beneficiam do pipeline completo. Sua distribuição de consultas é diversa e está evoluindo à medida que os usuários descobrem novas aplicações.

Qual é a abordagem mais eficaz para otimizar para variações de complexidade das consultas?

CorretaC) Fazer com que o coordenador analise cada consulta e decida dinamicamente quais subagentes invocar com base em sua avaliação dos requisitos da consulta.

Correto. Permitir que o LLM coordenador raciocine sobre cada consulta e escolha apenas os subagentes de que precisa se adapta naturalmente a uma distribuição de consultas diversa e em evolução — esta é a força do padrão de coordenador.

Depois que o agente de busca na web e o agente de análise de documentos concluem suas tarefas, o coordenador invoca o agente de síntese. No entanto, o agente de síntese responde que não consegue concluir a tarefa porque nenhuma descoberta de pesquisa foi fornecida.

Qual é a causa mais provável desse problema?

CorretaB) O coordenador não incluiu as saídas dos agentes anteriores no prompt do agente de síntese.

Correto. As invocações de subagentes são isoladas — nada flui entre eles a menos que o coordenador coloque explicitamente no prompt. A mensagem 'nenhuma descoberta fornecida' é exatamente o que você veria.

Ao analisar casos jurídicos complexos que citam vários precedentes, o subagente de análise de documentos processa cada um sequencialmente. Um caso paradigmático que cita 12 precedentes leva mais de 3 minutos para ser analisado completamente.

Qual é a forma mais eficaz de reduzir essa latência, preservando a capacidade do coordenador de monitorar e depurar o sistema?

CorretaC) Fazer com que o coordenador inicie subagentes de análise de documentos em paralelo, cada um tratando um subconjunto de precedentes, e depois agregue os resultados antes da síntese.

Correto. O paralelismo gerenciado pelo coordenador distribui o trabalho, mantém o escopo de cada subagente restrito e preserva um único hub para monitoramento e agregação.

Um desenvolvedor pede ao agente para investigar por que um endpoint de API específico retorna erros 500 de forma intermitente. A base de código tem mais de 200 arquivos e o desenvolvedor não sabe quais componentes estão envolvidos. O agente precisa rastrear o erro pelas camadas de roteamento, middleware, lógica de negócio e banco de dados.

Qual abordagem de decomposição de tarefas seria mais eficaz?

CorretaB) Fazer o agente gerar dinamicamente subtarefas de investigação com base no que descobre a cada passo, adaptando seu plano de exploração à medida que novas informações sobre o caminho do erro surgem.

Correto. A depuração é adaptativa por natureza — cada arquivo que você lê muda qual é o próximo passo mais útil. Deixe o agente seguir as evidências.

Um engenheiro que acabou de entrar na equipe pede ao agente para ajudá-lo a entender a arquitetura de autenticação e autorização antes de fazer melhorias de segurança. A base de código tem mais de 800 arquivos espalhados por múltiplos serviços.

Qual estratégia de exploração construirá o entendimento de forma mais eficaz, considerando as ferramentas nativas do Claude e os limites de contexto?

CorretaC) Usar o Grep para encontrar os pontos de entrada de autenticação, ler esses arquivos e, então, seguir as importações e chamadas de função para mapear o fluxo de autenticação de forma incremental.

Correto. Comece pelos pontos de entrada (login, verificação de token, middleware) e, então, rastreie para fora seguindo as conexões reais do código. Incremental, fundamentado e dentro dos limites de contexto.

Um pull request altera 14 arquivos em um módulo de tracking de inventário. Uma review de única passagem que analisa todos os arquivos juntos produz resultados inconsistentes: feedback detalhado em alguns arquivos mas comentários superficiais em outros, bugs óbvios não detectados e feedback contraditório (um padrão é marcado em um arquivo mas código idêntico aprovado em outro arquivo no mesmo PR). Como reestruturar a review?

Como reestruturar a review?

CorretaB) Dividir em passagens focadas: revisar cada arquivo individualmente para problemas locais, depois rodar uma passagem separada orientada a integração para examinar fluxos de dados cross-file.

Passagens focadas por arquivo atacam a causa-raiz — diluição de atenção — garantindo profundidade consistente e detecção confiável de problemas locais. Uma passagem separada de integração cobre questões cross-file como dependências e interações de fluxo de dados.