Edição em Markdown

AI-translated from English; not yet reviewed by a fluent editor.

# Confira o alcance das instruções do Claude Code em dois projetos de clientes

> Compare as instruções carregadas em duas sessões novas de projeto no Claude Code e verifique quando um arquivo de instruções aninhado entra no contexto após uma leitura autorizada.

By BIG CHANGE Editorial

Published: 2026-10-20T00:44:54.031Z
Updated: 2026-10-20T00:44:54.031Z
Canonical: https://bigchange.ai/blog/claude-code-client-project-instruction-scope-guide

![Conceptual charcoal illustration of two open filing drawers with separate blank folders; a smaller orange-edged folder is nested in the right drawer.](https://bigchange.ai/api/media/file/client-project-instruction-scope-hero-v1.png)
AI-generated conceptual illustration by BIG CHANGE; no actual client files, Claude Code interface or tested result is depicted.

O Claude Code pode carregar instruções de vários lugares ao mesmo tempo. Se você mantém dois projetos de clientes, uma sessão nova em cada diretório permite verificar quais arquivos realmente entraram em cada contexto. O resultado útil são duas listas registradas, não a suposição de que pastas irmãs separam informações dos clientes.

## A grande mudança

**O que mudou:** Este guia transforma a hierarquia documentada de instruções do Claude Code em uma comparação repetível entre dois diretórios existentes e autorizados. Você registra os arquivos carregados na inicialização e verifica se um arquivo aninhado aparece após uma leitura permitida.

**Por que importa:** Um diretório pai compartilhado, instrução pessoal, importação, regra ou configuração podem afetar os dois projetos. `/context` mostra quais arquivos de memória estão carregados na sessão ativa, permitindo investigar um caminho inesperado antes do trabalho para o cliente.

**O que observar:** Instruções carregadas não limitam quais arquivos Claude acessa nem garantem que ele as siga. Revise conta, permissões, importações, hooks e termos de uso de dados antes de enviar conteúdo do cliente ao provedor escolhido.

## O que você precisa

Este procedimento é para um desenvolvedor autorizado a inspecionar dois repositórios de clientes **existentes** e sua configuração do Claude Code. Obtenha autorização separada para enviar o conteúdo específico à conta Claude ou ao provedor escolhido. Permissão para editar arquivos locais não resolve essa decisão. Você precisa de terminal, Claude Code instalado, conta ou provedor elegível e um arquivo existente sem dados sensíveis em um subdiretório de um projeto. Confira a documentação da Anthropic sobre [instalação](https://code.claude.com/docs/en/setup), [custos](https://code.claude.com/docs/en/costs) e [uso de dados](https://code.claude.com/docs/en/data-usage) para a forma de acesso utilizada.

A estrutura abaixo mostra os caminhos a identificar; não pede a criação de novos projetos. Troque cada caminho ilustrativo pelo real e autorizado. Um arquivo pai `CLAUDE.md` é opcional e deve conter apenas instruções aprovadas para ambos os projetos. O arquivo aninhado e o documento sem dados sensíveis já devem ser adequados ao fluxo de dados da conta escolhida.

```text
AUTHORIZED_PARENT/
  CLAUDE.md                 optional shared instructions
  project-A/
    CLAUDE.md               A's project instructions
  project-B/
    CLAUDE.md               B's project instructions
    subdir/
      CLAUDE.md             B's nested instructions
      README.md             authorized, nonsensitive read target
```

## 1. Resolva os dois caminhos de projeto

Use **uma das opções:** PowerShell ou Bash. Defina as variáveis com os diretórios reais. As verificações exigem caminhos existentes, comparam as strings resultantes e confirmam o alvo de leitura de B. O comando PowerShell `Resolve-Path` pode preservar um alias de link simbólico ou junção; strings diferentes não comprovam projetos fisicamente distintos. Inspecione links e junções nos caminhos de início e em seus ancestrais, siga os destinos e confirme que A e B são distintos antes de continuar. Guarde caminhos, verificações e listas de contexto em um registro privado.

```powershell
$a = (Resolve-Path -LiteralPath 'C:\actual\authorized\project-A' -ErrorAction Stop).Path
$b = (Resolve-Path -LiteralPath 'C:\actual\authorized\project-B' -ErrorAction Stop).Path
if (-not (Test-Path -LiteralPath $a -PathType Container)) { throw 'A must be an existing directory' }
if (-not (Test-Path -LiteralPath $b -PathType Container)) { throw 'B must be an existing directory' }
if ($a -eq $b) { throw 'A and B must be different directories' }
$target = Join-Path $b 'subdir/README.md'
if (-not (Test-Path -LiteralPath $target -PathType Leaf)) { throw 'Choose an existing authorized nonsensitive file in B/subdir' }
$a
$b
$target
```

```bash
a=$(realpath -- /actual/authorized/project-A) || exit 1
b=$(realpath -- /actual/authorized/project-B) || exit 1
test -d "$a" || { printf '%s\n' 'A must be an existing directory' >&2; exit 1; }
test -d "$b" || { printf '%s\n' 'B must be an existing directory' >&2; exit 1; }
test "$a" != "$b" || { printf '%s\n' 'A and B must be different directories' >&2; exit 1; }
target="$b/subdir/README.md"
test -f "$target" || { printf '%s\n' 'Choose an existing authorized nonsensitive file in B/subdir' >&2; exit 1; }
printf '%s\n' "$a" "$b" "$target"
```

Se os projetos não forem irmãos, registre suas cadeias reais de ancestrais separadamente. Não deduza um pai compartilhado a partir do desenho.

## 2. Audite as fontes possíveis antes de abrir os projetos

Para **cada** diretório de início resolvido, inspecione `CLAUDE.md`, `.claude/CLAUDE.md`, `CLAUDE.local.md`, `AGENTS.md` e `.claude/AGENTS.md` nele e em todos os ancestrais até a raiz do sistema de arquivos. Inspecione também as instruções gerenciadas do sistema, `~/.claude/CLAUDE.md`, regras de usuário e arquivos `.claude/rules/` do projeto. O [manual de memória](https://code.claude.com/docs/en/memory) diz que os arquivos `CLAUDE.md` encontrados são concatenados; um arquivo mais próximo não apaga o texto de um ancestral. Um arquivo aninhado `CLAUDE.md` normalmente é carregado depois que Claude lê, escreve ou edita outro arquivo naquele diretório. Regras com escopo de caminho podem carregar ao acessar um arquivo correspondente.

Esses comandos mostram somente caminhos e inventariam ancestrais sem exibir conteúdo. Examine os arquivos encontrados com autorização do respectivo proprietário. Repita com as duas variáveis; no Bash, o laço cobre ambas automaticamente.

```powershell
foreach ($start in @($a, $b)) {
  $dir = [System.IO.DirectoryInfo]::new($start)
  while ($null -ne $dir) {
    Get-Item -LiteralPath $dir.FullName -Force | Select-Object FullName,LinkType,Target
    foreach ($name in @('CLAUDE.md', 'CLAUDE.local.md', 'AGENTS.md', '.claude/CLAUDE.md', '.claude/AGENTS.md')) {
      $candidate = Join-Path $dir.FullName $name
      if (Test-Path -LiteralPath $candidate -PathType Leaf) { $candidate }
    }
    $dir = $dir.Parent
  }
}
```

```bash
for start in "$a" "$b"; do
  dir=$start
  while :; do
    for name in CLAUDE.md CLAUDE.local.md AGENTS.md .claude/CLAUDE.md .claude/AGENTS.md; do
      test -f "$dir/$name" && printf '%s\n' "$dir/$name"
    done
    test "$dir" = / && break
    dir=$(dirname -- "$dir")
  done
done
```

Leia os arquivos reais de instruções e suas importações `@path` ; importações relativas são resolvidas a partir do arquivo que as contém. Siga links simbólicos ou junções nos caminhos PowerShell e em seus ancestrais, depois audite as hierarquias nomeadas e de destino que podem afetar a sessão. Confira destinos dos links de arquivos de instruções e padrões `claudeMdExcludes` . Inspecione `.claude/settings.json`, `.claude/settings.local.json`, configurações de usuário e gerenciadas, opções de inicialização `--settings` ou `--setting-sources` , hooks configurados e a confiança de cada projeto. `CLAUDE_CONFIG_DIR` pode mudar a pasta de configuração do usuário; confira antes de presumir `~/.claude`. Revise os comandos possíveis de um hook antes de aceitar a confiança no espaço de trabalho. Uma importação externa pode pedir aprovação; se recusada, não aparecerá como esperado. O [manual de configurações](https://code.claude.com/docs/en/settings) explica qual camada fornece cada ajuste e quais configurações de projeto aguardam confiança.

Confira a opção **Project instructions** em `/config` ou na configuração de plugin de usuário/gerenciada correspondente. A documentação atual descreve `AGENTS.md` como alternativa condicional quando nenhum arquivo de projeto ou ancestral `CLAUDE.md` ou `CLAUDE.local.md` atende aos critérios; `claude-md-and-agents-md` carrega ambos. O suporte direto a `AGENTS.md` depende da versão e do plugin ativado. Versões antigas e algumas configurações podiam omiti-lo, incluindo o problema tratado na [reportagem do BIG CHANGE sobre a opção de recurso AGENTS.md](https://bigchange.ai/blog/claude-code-agents-md-telemetry-feature-flags). Use sua versão real, configuração e resultado de `/context` em vez de presumir carregamento constante.

Registre os argumentos `--add-dir` e `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` separadamente. `--add-dir` amplia o acesso a arquivos; por padrão, não carrega o `CLAUDE.md` do diretório adicional. A opção de ambiente ativa esse carregamento. Verifique a memória automática com `/memory` como canal separado: ela pode ser compartilhada entre worktrees e subdiretórios de um repositório, e seu local pode ser substituído. Confira local e conteúdo reais antes de interpretar a comparação. Nunca coloque credenciais ou fatos não publicados de clientes em exemplos de instruções ou registros públicos.

Antes de iniciar, confira estes valores de ambiente no mesmo shell. Um valor Bash vazio significa ausente ou vazio; o PowerShell lista somente variáveis presentes. Isso não descarta valores em arquivos de configuração: confirme os ajustes ativos dentro de cada sessão.

```powershell
Get-Item Env:CLAUDE_CONFIG_DIR,Env:CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD -ErrorAction SilentlyContinue | Select-Object Name,Value
```

```bash
printf 'CLAUDE_CONFIG_DIR=%s\n' "${CLAUDE_CONFIG_DIR-}"
printf 'CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=%s\n' "${CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD-}"
```

## 3. Inicie uma sessão nova no projeto A

Registre `claude --version` e o comando exato de início. Abra um processo novo a partir de A, sem `--resume` ou `--continue`. Aceite a confiança apenas após auditar configurações e hooks. Execute `/context` **antes** de pedir a Claude que abra B ou qualquer arquivo aninhado. Anote os caminhos exatos de memória e regras; use a lista para verificar presença, não ordem de injeção. Use `/memory` para inspecionar entradas pessoais, de projeto e de memória automática exibidas e seus locais. Depois saia da sessão.

```powershell
claude --version
Set-Location -LiteralPath $a -ErrorAction Stop
claude
```

```bash
claude --version
cd -- "$a" && claude
```

Dentro do Claude Code, `/status` identifica as fontes ativas de configuração, e `/permissions` mostra as regras de ferramentas e suas fontes. Registre isso junto à lista de instruções:

```text
/context
/memory
/status
/permissions
/exit
```

As instruções aplicáveis de A e ancestrais compartilhados devem aparecer conforme configurações e exclusões auditadas. Um arquivo específico de B não deveria pertencer à hierarquia inicial de A. Se aparecer por importação, link, diretório adicional ou outro canal, registre o mecanismo. Sua ausência não prova que os arquivos de B são inacessíveis.

## 4. Inicie uma sessão separada em B e leia um arquivo aninhado

Use um processo **novo** do Claude Code em B com a mesma versão e forma de conta/provedor. Registre `/context` e `/memory` antes de qualquer leitura aninhada. Peça que Claude leia somente o arquivo exato aprovado e sem dados sensíveis. Confirme que a leitura ocorreu e execute `/context` novamente para comparar os caminhos presentes. A [regra de carregamento do manual](https://code.claude.com/docs/en/memory) prevê que o arquivo de B `subdir/CLAUDE.md` entre no contexto após Claude acessar outro arquivo naquele diretório, salvo mudança por configuração, exclusão ou versão.

```powershell
Set-Location -LiteralPath $b -ErrorAction Stop
claude
```

```bash
cd -- "$b" && claude
```

Dentro do Claude Code, substitua a solicitação de leitura apenas se o alvo autorizado tiver outro caminho relativo:

```text
/context
/memory
/status
/permissions
Read only subdir/README.md. Tell me whether that exact file was read; do not open other files or display its contents.
/context
/exit
```

O Claude Code pode pedir permissão de ferramenta ou propor outra ação. Aprove somente a leitura autorizada e confirme que a ferramenta abriu realmente o arquivo. Uma resposta alegando ter lido não basta como evidência.

## 5. Compare as listas e esclareça diferenças

Mantenha uma tabela privada com caminhos A e B resolvidos, raízes de repositórios, versão do Claude Code, conta/provedor, comandos, confiança, fontes de configuração, diretórios extras, caminhos de instruções e regras, importações, locais de memória automática e as três listas `/context` observadas: A no início, B antes da leitura, B após a leitura. Marque cada arquivo esperado como presente, ausente ou inexplicado. Não copie instruções do cliente em relatório público.

Se faltar um arquivo esperado, confira primeiro diretório de início e caminho real. Depois examine Project instructions e plugin/versão, `claudeMdExcludes`, `--setting-sources`, importações e aprovação externa, padrões de regras, links simbólicos e a leitura aninhada confirmada. Se aparecer arquivo inesperado, siga ancestrais, instruções de usuário ou gerenciadas, importações, regras, hooks, memória de diretórios adicionais e memória automática. Um ancestral compartilhado ou instrução pessoal pode ser intencional; origem e conteúdo determinam se deve afetar os dois projetos.

Altere instruções ou configurações somente com autorização do cliente correspondente. Revise a diferença proposta, preserve restrições e repita as duas observações em sessões novas após a mudança. Se não conseguir explicar um caminho ou não tiver permissão para um canal, pause o trabalho e peça ao proprietário ou administrador que resolva aquela incerteza específica.

O exercício termina quando existem duas listas de início, a lista verificada de B antes/depois da leitura aninhada e uma explicação para cada caminho inesperado relevante. Isso estabelece a presença observada das instruções naquelas sessões. Não estabelece limite de confidencialidade, isolamento de acesso, obediência garantida ou ordem exata de uso das instruções pelo modelo. Para inspecionar e continuar uma conversa existente, consulte nosso [guia de contexto de sessão do Claude Code](https://bigchange.ai/blog/claude-code-session-context-continue-guide).

Cobrança e limites dependem de plano, autenticação e provedor. O [guia de custos](https://code.claude.com/docs/en/costs) da Anthropic traz os termos atuais. Este artigo foi preparado a partir da documentação: o BIG CHANGE não inspecionou arquivos de clientes, executou sessões A/B, testou resultado de modelo nem mediu tempo ou custo.

## Fontes e leitura adicional

- [Anthropic, “Como Claude lembra do seu projeto”](https://code.claude.com/docs/en/memory): escopo de instruções, importações, carregamento aninhado, `AGENTS.md`, regras, exclusões, diretórios adicionais, memória automática e `/memory`. As opções exatas podem mudar conforme a versão do Claude Code.
- [Anthropic, “Arquivos de configuração e precedência”](https://code.claude.com/docs/en/settings): configurações de usuário, projeto, locais e gerenciadas, incluindo `/status`, confiança e hooks.
- [Anthropic, “Configurar permissões”](https://code.claude.com/docs/en/permissions): `/permissions` mostra regras de ferramentas ativas e suas fontes; instruções não impõem acesso por si mesmas.
- [Anthropic, “Explorar a janela de contexto”](https://code.claude.com/docs/en/context-window): `/context` mostra arquivos de memória carregados na sessão ativa; a presença exibida não prova a ordem de injeção.
- [Anthropic, instalação, custos e uso de dados](https://code.claude.com/docs/en/setup): confirme requisitos de instalação e conta; leia também os termos separados de [custos](https://code.claude.com/docs/en/costs) e [uso de dados](https://code.claude.com/docs/en/data-usage) para sua forma de acesso.

## Sources

- [Anthropic: como Claude lembra do projeto](https://code.claude.com/docs/en/memory) — Manual primário de instruções gerenciadas, de usuário, projeto e locais; carregamento de ancestrais e arquivos aninhados; arquivos cumulativos; importações; regras; alternativa AGENTS.md e limites de versão/configuração; exclusões; acesso a diretórios extras versus carregamento de memória; e memória automática. Descreve comportamento documentado, não presença observada em duas sessões de clientes.
- [Anthropic: arquivos de configuração e precedência](https://code.claude.com/docs/en/settings) — Manual primário de camadas de configuração, CLAUDE_CONFIG_DIR, consulta de fontes com /status, configurações locais, confiança e hooks. O leitor deve inspecionar ajustes reais e hooks existentes; nenhuma configuração de cliente foi examinada aqui.
- [Anthropic: configurar permissões](https://code.claude.com/docs/en/permissions) — Documenta /permissions como visualização de regras de ferramentas ativas e seus arquivos de configuração de origem. Instruções não impõem acesso a ferramentas; aprove apenas a leitura aninhada autorizada.
- [Anthropic: explorar a janela de contexto](https://code.claude.com/docs/en/context-window) — Documenta /context como verificação ao vivo de arquivos de memória carregados e /memory para inspecionar memória. Presença na lista é a observação proposta; ordem de exibição não é apresentada como ordem de injeção no modelo.
- [Anthropic: configuração avançada](https://code.claude.com/docs/en/setup) — Requisitos de instalação e conta/provedor para uma sessão Claude Code operada pelo leitor. O BIG CHANGE não realizou instalação nem sessão.
- [Anthropic: gerenciar custos com eficiência](https://code.claude.com/docs/en/costs) — Cobrança e limites variam por plano, autenticação e provedor. O guia não afirma preço fixo, cota, economia de tempo ou uso medido para o exercício.
- [Anthropic: uso de dados](https://code.claude.com/docs/en/data-usage) — O tratamento difere entre vias de consumo, comerciais e de provedores. A autorização do cliente para o conteúdo específico deve preceder o envio ao modelo; não há afirmação de privacidade universal.
- [BIG CHANGE: como inspecionar contexto e continuar uma sessão Claude Code](https://bigchange.ai/blog/claude-code-session-context-continue-guide) — Cobertura relacionada sobre continuar uma sessão existente. A tarefa difere desta comparação de instruções em sessões novas de dois projetos e não fundamenta os passos novos.
- [BIG CHANGE: Claude Code pode ignorar AGENTS.md com a telemetria desligada](https://bigchange.ai/blog/claude-code-agents-md-telemetry-feature-flags) — Reportagem relacionada sobre opção de recurso específica de versão. O artigo usa o manual oficial atual e a versão, configurações e consulta do leitor, nunca uma afirmação incondicional de carregamento de AGENTS.md.