Guia de Memória

InicianteGrátis34 minatualizado 2026-10-21

Gaveta de arquivo de metal aberta, com fichas de vidro iluminadas.

A memória permite ao Claude reter o contexto entre sessões e conversas. Existe em duas formas: síntese automática no claude.ai e CLAUDE.md baseado no sistema de ficheiros no Claude Code.

Visão Geral

A memória no Claude Code fornece contexto persistente que se mantém ao longo de várias sessões e conversas. Ao contrário das janelas de contexto temporárias, os ficheiros de memória permitem:

Partilhar os padrões do projeto com a sua equipa
Guardar preferências pessoais de desenvolvimento
Manter regras e configurações específicas de cada diretório
Importar documentação externa
Colocar a memória em controlo de versões como parte do seu projeto

O sistema de memória funciona em vários níveis, desde as preferências pessoais globais até subdiretórios específicos, permitindo um controlo granular sobre o que o Claude memoriza e como aplica esse conhecimento.

Referência Rápida de Comandos de Memória

Comando	Finalidade	Utilização	Quando Utilizar
`/init`	Inicializar a memória do projeto	`/init`	Início de um novo projeto, primeira configuração do CLAUDE.md
`/memory`	Editar ficheiros de memória no editor	`/memory`	Atualizações extensas, reorganização, revisão de conteúdo
Prefixo `#`	~~Adição rápida de memória numa única linha~~ Descontinuado	-	Use `/memory` ou pergunte de forma conversacional em alternativa
`@path/to/file`	Importar conteúdo externo	`@README.md` ou `@docs/api.md`	Referenciar documentação existente no CLAUDE.md

Início Rápido: Inicializar a Memória

O Comando `/init`

O comando /init é a forma mais rápida de configurar a memória do projeto no Claude Code. Inicializa um ficheiro CLAUDE.md com documentação fundamental do projeto.

Utilização:

Terminal

/init

O que faz:

Cria um novo ficheiro CLAUDE.md no seu projeto (normalmente em ./CLAUDE.md ou ./.claude/CLAUDE.md)
Estabelece convenções e diretrizes do projeto
Prepara as bases para a persistência do contexto entre sessões
Fornece uma estrutura de modelo para documentar os padrões do seu projeto

Modo interativo melhorado: Defina CLAUDE_CODE_NEW_INIT=1 para ativar um fluxo interativo em várias fases que o acompanha passo a passo na configuração do projeto:

Terminal

CLAUDE_CODE_NEW_INIT=1 claude
/init

Quando utilizar /init:

Iniciar um novo projeto com o Claude Code
Estabelecer as normas e convenções de programação da equipa
Criar documentação sobre a estrutura da sua base de código
Configurar a hierarquia de memória para desenvolvimento colaborativo

Exemplo de fluxo de trabalho:

Terminal

# In your project directory
/init

# Claude creates CLAUDE.md with structure like:
# Project Configuration
## Project Overview
- Name: Your Project
- Tech Stack: [Your technologies]
- Team Size: [Number of developers]

## Development Standards
- Code style preferences
- Testing requirements
- Git workflow conventions

Atualizações rápidas de memória

Nota: O atalho # para memória inline foi descontinuado. Use /memory para editar diretamente os ficheiros de memória, ou peça ao Claude, de forma conversacional, que se lembre de algo (por exemplo, "lembre-se de que usamos sempre o modo strict do TypeScript").

As formas recomendadas de adicionar informação à memória são:

Opção 1: Use o comando /memory

Terminal

/memory

Abre os seus ficheiros de memória no editor do sistema para edição direta.

Opção 2: Pergunte de forma conversacional

Terminal

Remember that we always use TypeScript strict mode in this project.
Please add to memory: prefer async/await over promise chains.

Pedir ao Claude para memorizar algo guarda essa informação na memória automática. Para alterar o CLAUDE.md, diga "adicione isto ao CLAUDE.md" ou edite o ficheiro diretamente com /memory.

Referência histórica (já não funcional):

O atalho com o prefixo # permitia antes adicionar regras diretamente na linha de comandos:

Terminal

# Always use TypeScript strict mode in this project  ← no longer works

Se dependia deste padrão, passe a utilizar o comando /memory ou pedidos conversacionais.

O comando `/memory`

O comando /memory dá acesso direto à edição dos seus ficheiros de memória CLAUDE.md nas sessões do Claude Code. Abre os seus ficheiros de memória no editor do sistema para uma edição abrangente. Quando o ficheiro abre num editor gráfico (GUI), a sessão já não fica bloqueada enquanto o ficheiro estiver aberto, pelo que pode continuar a trabalhar em paralelo (v2.1.216); os editores de terminal como o Vim continuam a assumir o controlo do terminal até sair.

Utilização:

Terminal

/memory

O que faz:

Abre os seus ficheiros de memória no editor predefinido do seu sistema
Permite fazer adições, modificações e reorganizações extensas
Proporciona acesso direto a todos os ficheiros de memória na hierarquia
Possibilita gerir o contexto persistente entre sessões

Quando utilizar /memory:

Rever o conteúdo existente da memória
Fazer atualizações extensas às normas do projeto
Reorganizar a estrutura da memória
Adicionar documentação ou diretrizes detalhadas
Manter e atualizar a memória à medida que o seu projeto evolui

Comparação: /memory vs /init

Aspeto	`/memory`	`/init`
Objetivo	Editar ficheiros de memória existentes	Inicializar um novo CLAUDE.md
Quando utilizar	Atualizar/modificar o contexto do projeto	Iniciar novos projetos
Ação	Abre o editor para alterações	Gera um modelo inicial
Fluxo de trabalho	Manutenção contínua	Configuração única

Exemplo de fluxo de trabalho:

Terminal

# Open memory for editing
/memory

# Claude presents options:
# 1. Managed Policy Memory
# 2. Project Memory (./CLAUDE.md)
# 3. User Memory (~/.claude/CLAUDE.md)
# 4. Local Project Memory

# Choose option 2 (Project Memory)
# Your default editor opens with ./CLAUDE.md content

# Make changes, save, and close editor
# Claude automatically reloads the updated memory

Utilizar Importações de Memória:

Os ficheiros CLAUDE.md suportam a sintaxe @path/to/file para incluir conteúdo externo:

Terminal

# Project Documentation
See @README.md for project overview
See @package.json for available npm commands
See @docs/architecture.md for system design

# Import from home directory using absolute path
@~/.claude/my-project-instructions.md

Funcionalidades de importação:

São suportados tanto caminhos relativos como absolutos (por exemplo, @docs/api.md ou @~/.claude/my-project-instructions.md)
As importações recursivas são suportadas com uma profundidade máxima de 4 saltos
As primeiras importações a partir de localizações externas acionam uma caixa de diálogo de aprovação por motivos de segurança
As diretivas de importação não são avaliadas dentro de trechos de código ou blocos de código markdown (por isso, documentá-las em exemplos é seguro)
Ajuda a evitar duplicação ao referenciar documentação existente
Inclui automaticamente o conteúdo referenciado no contexto do Claude

Arquitetura de memória

A memória no Claude Code segue um sistema hierárquico em que diferentes âmbitos servem propósitos diferentes. Ao contrário do ciclo de síntese de 24 horas do Claude Web/Desktop (consulte Memória no Claude Web/Desktop abaixo), o Claude Code tem dois sistemas de memória que são ambos carregados no início de cada sessão e se atualizam continuamente, não segundo um temporizador:

Terminal

graph TB
    A["Session Start"]
    B["CLAUDE.md Files<br/>(you write)"]
    C["Auto Memory<br/>(Claude writes)"]
    D["Claude Session"]
    E["Your Correction /<br/>Preference"]

    B -->|loaded in full| A
    C -->|MEMORY.md loaded| A
    A --> D
    D -->|"Remember that..."| E
    E -->|writes during session| C
    D -->|"add this to CLAUDE.md"| B

Hierarquia de memória no Claude Code

O Claude Code tem dois sistemas de memória complementares, ambos carregados no início de cada conversa: ficheiros CLAUDE.md (instruções que você escreve) e memória automática (notas que o próprio Claude escreve). Os ficheiros CLAUDE.md são concatenados no contexto em vez de se substituírem entre si: não é uma cadeia estrita de precedência em que um nível superior substitui um inferior. Os ficheiros .claude/rules/*.md são um mecanismo separado e relacionado para instruções com âmbito de tópico ou de caminho.

Localizações dos ficheiros CLAUDE.md, pela ordem de carregamento (do âmbito mais abrangente para o mais específico):

Âmbito	Localização	Finalidade
Política gerida	macOS: `/Library/Application Support/ClaudeCode/CLAUDE.md`<br>Linux/WSL: `/etc/claude-code/CLAUDE.md`<br>Windows: `C:\Program Files\ClaudeCode\CLAUDE.md`	Instruções de toda a organização geridas por IT/DevOps. Não podem ser excluídas pelas definições individuais.
Instruções do utilizador	`~/.claude/CLAUDE.md`	Preferências pessoais para todos os projetos
Instruções do projeto	`./CLAUDE.md` ou `./.claude/CLAUDE.md`	Instruções partilhadas pela equipa, com controlo de versões. Desde a v2.1.277, o ficheiro `./AGENTS.md` é carregado neste mesmo nível, em alternativa, quando não existe nenhum `CLAUDE.md` ou `CLAUDE.local.md` no diretório de trabalho ou acima dele: controlado por Project instructions em `/config`
Instruções locais	`./CLAUDE.local.md`	Preferências pessoais específicas do projeto; adicione ao `.gitignore`

Dentro da árvore de diretórios, o Claude Code sobe a partir do seu diretório de trabalho: foo/CLAUDE.md é carregado antes de foo/bar/CLAUDE.md se você iniciar em foo/bar/, pelo que as instruções mais próximas do local de arranque são lidas por último: não são de "prioridade máxima" no sentido de substituição, apenas as mais recentes no contexto. Dentro de cada diretório, CLAUDE.local.md é anexado depois de CLAUDE.md. Os ficheiros CLAUDE.md e CLAUDE.local.md em subdiretórios sob o seu diretório de trabalho são carregados a pedido, quando o Claude lê ficheiros nesses subdiretórios, e não no arranque.

As organizações também podem colocar conteúdo gerido de CLAUDE.md diretamente dentro de managed-settings.json através da chave claudeMd, em vez de implementar um ficheiro separado. Isto só é respeitado nas definições geridas/de política: definir claudeMd nas definições do utilizador ou do projeto não tem qualquer efeito.

**.claude/rules/*.md**: instruções modulares e específicas por tópico, opcionalmente com âmbito limitado a caminhos de ficheiros através de frontmatter paths. As regras sem um campo paths são carregadas incondicionalmente com a mesma prioridade que .claude/CLAUDE.md; as regras com âmbito de caminho são carregadas a pedido quando o Claude lê, escreve ou edita um ficheiro correspondente, incluindo ao vê-lo com uma leitura Bash de um único ficheiro, como cat, head, tail, sed -n ou grep (Write/Edit desde a v2.1.288, leituras Bash desde a v2.1.293). As regras ao nível do utilizador (~/.claude/rules/) são carregadas antes das regras do projeto.

Memória automática (~/.claude/projects/<project>/memory/) é um sistema separado: notas do próprio Claude, não conteúdo de CLAUDE.md, e não faz parte da ordem de concatenação acima. Consulte Auto Memory abaixo.

Nota: o CLAUDE.local.md é totalmente suportado e documentado na documentação oficial. Fornece preferências pessoais específicas do projeto que não são submetidas ao controlo de versões. Adicione CLAUDE.local.md ao seu .gitignore.

Comportamento de deteção da memória:

Terminal

graph TD
    A["Managed Policy<br/>/Library/.../ClaudeCode/CLAUDE.md"] -->|loads first| B["User Instructions<br/>~/.claude/CLAUDE.md"]
    B --> C["Project Instructions<br/>./CLAUDE.md or ./.claude/CLAUDE.md"]
    C --> D["Local Instructions<br/>./CLAUDE.local.md"]

    C -->|imports| H["@docs/architecture.md"]
    H -->|imports| I["@docs/api-standards.md"]

    style A fill:#fce4ec,stroke:#333,color:#333
    style B fill:#f3e5f5,stroke:#333,color:#333
    style C fill:#e1f5fe,stroke:#333,color:#333
    style D fill:#e8f5e9,stroke:#333,color:#333
    style H fill:#e1f5fe,stroke:#333,color:#333
    style I fill:#e1f5fe,stroke:#333,color:#333

Todos os ficheiros apresentados são concatenados num único contexto, não selecionados por override: as caixas posteriores aparecem mais tarde no contexto, não "em vez de" as anteriores.

AGENTS.md

AGENTS.md é um ficheiro de contexto de projeto multi-ferramenta: da mesma categoria de documento que o CLAUDE.md, escrito para que vários agentes de programação possam partilhar um único conjunto de convenções de projeto. Desde a v2.1.277, o Claude Code lê-o diretamente como instruções de projeto, em vez de exigir que o importe.

Comportamento predefinido (claude-md-or-agents-md):

O que o projeto contém	O que o Claude Code lê
`AGENTS.md`, sem `CLAUDE.md`	`AGENTS.md`
Tanto `AGENTS.md` como `CLAUDE.md`	Apenas `CLAUDE.md`
Um `CLAUDE.md` que importa `AGENTS.md` com `@AGENTS.md`	`CLAUDE.md`, com a importação expandida

Que ficheiros suprimem o AGENTS.md. O Claude Code procura CLAUDE.md, .claude/CLAUDE.md ou CLAUDE.local.md no diretório de trabalho e em todos os diretórios acima deste. Se encontrar algum deles, o AGENTS.md não é lido. O ~/.claude/CLAUDE.md, o CLAUDE.md gerido e .claude/rules/ não contam para esta verificação e continuam a ser carregados juntamente com o ficheiro de projeto que prevalecer.

Aviso: adicionar um CLAUDE.local.md impede silenciosamente a leitura do AGENTS.md. Se as suas instruções de projeto parecerem desaparecer depois de criar um override local, normalmente é por esta razão.

O que é lido. Todos os AGENTS.md e .claude/AGENTS.md no diretório de trabalho e acima deste são carregados no início da sessão; os ficheiros em subdiretórios são carregados a pedido, quando o Claude lê ficheiros aí. As importações @path expandem-se da mesma forma que no CLAUDE.md, e claudeMdExcludes aplica-se.

O que nunca é lido: AGENTS.local.md, AGENTS.override.md e tudo o que estiver em .agents/.

Escolher o comportamento. A definição Project instructions assume quatro valores:

Valor	Efeito
`claude-md-or-agents-md`	Predefinido - `AGENTS.md` apenas quando não é encontrado nenhum ficheiro CLAUDE.md
`claude-md-and-agents-md`	Ambos são lidos quando ambos existem
`claude-md`	Apenas ficheiros CLAUDE.md; `AGENTS.md` é ignorado
`managed-only`	Apenas instruções de política geridas

Defina-o através de /config ou nas definições:

Terminal

{
  "pluginConfigs": {
    "agents-md@builtin": {
      "options": {
        "instructionFiles": "claude-md-and-agents-md"
      }
    }
  }
}

Esta chave é respeitada apenas nas definições de utilizador e nas definições geridas: configurá-la nas definições de projeto ou locais não tem qualquer efeito.

Quando a leitura direta não está disponível. Em versões anteriores à v2.1.277 (ou à v2.1.281 no Bedrock/Vertex/Foundry, atrás de gateways de LLM, ou com a telemetria desativada), durante a primeira sessão após a atualização, ou com o plugin incorporado agents-md desativado, o Claude Code não detetará o AGENTS.md por si próprio. Nesses casos, importe-o a partir do CLAUDE.md:

Terminal

@AGENTS.md

Excluir ficheiros CLAUDE.md com `claudeMdExcludes`

Em monorepos de grandes dimensões, alguns ficheiros CLAUDE.md podem ser irrelevantes para o seu trabalho atual. A definição claudeMdExcludes permite ignorar ficheiros CLAUDE.md específicos para que não sejam carregados para o contexto:

Terminal

// In ~/.claude/settings.json or .claude/settings.json
{
  "claudeMdExcludes": [
    "**/packages/legacy-app/CLAUDE.md",
    "**/vendors/**/CLAUDE.md"
  ]
}

Os padrões são comparados com caminhos absolutos de ficheiros usando a sintaxe glob, por isso comece os padrões relativos ao repositório com **/. Isto é especialmente útil para:

Monorepos com muitos subprojetos, onde só alguns são relevantes
Repositórios que contêm ficheiros CLAUDE.md copiados (vendored) ou de terceiros
Redução do ruído na janela de contexto do Claude, excluindo instruções obsoletas ou não relacionadas

Hierarquia dos Ficheiros de Definições

As definições do Claude Code (incluindo autoMemoryDirectory, claudeMdExcludes e outra configuração) são resolvidas por precedência. Ao contrário dos ficheiros CLAUDE.md acima, as definições substituem-se umas às outras em vez de se concatenarem. Quando a mesma definição aparece em vários âmbitos, o nível superior prevalece:

Nível	Localização	Âmbito
1 (Mais alto)	Gerido: `managed-settings.json`, plist/registo ou gerido pelo servidor	Imposto a toda a organização; não pode ser substituído
2	Argumentos da linha de comandos	Substituições temporárias na sessão
3	`.claude/settings.local.json`	Substituições locais (ignoradas pelo git)
4	`.claude/settings.json`	Nível do projeto (guardado no git)
5 (Mais baixo)	`~/.claude/settings.json`	Preferências do utilizador

As definições geridas suportam também um diretório de fragmentos, managed-settings.d/, ao lado de managed-settings.json: o ficheiro base é combinado primeiro e, depois, os ficheiros *.json do diretório de fragmentos são combinados por cima, por ordem alfabética (os valores escalares substituem, os arrays concatenam-se e eliminam duplicados, os objetos são combinados em profundidade). Assim, equipas diferentes podem distribuir fragmentos de política independentes sem editar um ficheiro partilhado. Note que este é um mecanismo de settings.json e não de CLAUDE.md: não se aplica às localizações de ficheiros CLAUDE.md descritas acima.

As regras de permissão (allow/ask/deny) comportam-se de forma diferente das restantes definições: são combinadas entre âmbitos, em vez de o nível superior substituir o inferior.

Configuração específica da plataforma (v2.1.51+):

As definições podem também ser configuradas através de:

macOS: ficheiros de lista de propriedades (plist)
Windows: Registo do Windows

Estes mecanismos nativos da plataforma são lidos em conjunto com os ficheiros de definições JSON e seguem as mesmas regras de precedência.

Nota (v2.1.119): As alterações feitas com /config passam agora a ser guardadas em ~/.claude/settings.json. Os valores escritos através de /config participam na cadeia normal de precedência de política/local/projeto descrita acima e deixam de ser apenas da sessão. Use /config para edições interativas e edite os ficheiros settings.json diretamente para configuração automatizada ou gerida.

Definições de Retenção e Limpeza

Definição	Tipo	Predefinido	Descrição
`cleanupPeriodDays`	inteiro (dias)	30	Janela de retenção das transcrições de sessões e de outros dados da aplicação em `~/.claude/`, incluindo `file-history/` (instantâneos de checkpoints), `plans/`, `debug/`, `tasks/`, `shell-snapshots/` e `backups/`. Não existe uma pasta `~/.claude/checkpoints/`. Os ficheiros mais antigos do que a janela são eliminados no arranque.

Terminal

// ~/.claude/settings.json
{
  "cleanupPeriodDays": 14
}

Atribuição, voz e definições de URL de PR

Definição	Tipo	Descrição
`attribution.commit`	string	Texto acrescentado aos commits que o Claude cria (por predefinição, o `Co-Authored-By: Claude`); `""` oculta-o. Substitui a flag obsoleta `includeCoAuthoredBy`.
`attribution.pr`	string	Texto acrescentado às descrições de pull requests que o Claude cria; `""` oculta-o. Substitui a flag obsoleta `includeCoAuthoredBy` para os PRs.
`attribution.sessionUrl`	boolean	Omite a ligação da sessão claude.ai dos commits e PRs criados em sessões web e de Controlo Remoto (v2.1.183+).
`voice.enabled`	boolean	Ativa o ditado por voz com premir para falar (`/voice`). Substitui a flag obsoleta `voiceEnabled`.
`prUrlTemplate`	string	Novo na v2.1.119. Modelo de URL personalizado para o distintivo de PR no rodapé; útil para GitLab, Bitbucket ou plataformas internas de revisão de código. Suporta os marcadores `{host}`, `{owner}`, `{repo}`, `{number}` e `{url}`; as ligações de merge requests do GitLab mantêm-se inalteradas.

Terminal

// ~/.claude/settings.json
{
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "voice": {
    "enabled": true
  },
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}

An empty string ("") oculta essa atribuição; "attribution": false oculta toda ela (v2.1.281+).

Nomes de definições obsoletos

As seguintes chaves de definições legadas continuam a funcionar, mas estão obsoletas. Prefira as substituições indicadas acima.

Chave obsoleta	Substituição	Notas
`includeCoAuthoredBy`	`attribution.commit` / `attribution.pr`	A antiga flag única foi dividida em opções separadas para commits e PRs. Os utilizadores de versões mais antigas podem manter a chave legada; os projetos novos devem usar a forma aninhada.
`voiceEnabled`	`voice.enabled`	Agrupada no espaço de nomes `voice`, juntamente com futuras opções relacionadas com voz.

Sistema modular de regras

Crie regras organizadas e específicas por caminho, usando a estrutura de diretórios .claude/rules/. As regras podem ser definidas tanto ao nível do projeto como ao nível do utilizador:

Terminal

your-project/
├── .claude/
│   ├── CLAUDE.md
│   └── rules/
│       ├── code-style.md
│       ├── testing.md
│       ├── security.md
│       └── api/                  # Subdirectories supported
│           ├── conventions.md
│           └── validation.md

~/.claude/
├── CLAUDE.md
└── rules/                        # User-level rules (all projects)
    ├── personal-style.md
    └── preferred-patterns.md

As regras são detetadas recursivamente dentro do diretório rules/, incluindo quaisquer subdiretórios. As regras ao nível do utilizador em ~/.claude/rules/ são carregadas antes das regras ao nível do projeto, permitindo predefinições pessoais que os projetos podem substituir.

Regras específicas de caminhos com frontmatter YAML

Defina regras que se aplicam apenas a caminhos de ficheiros específicos:

Terminal

---
paths: src/api/**/*.ts
---

# API Development Rules

- All API endpoints must include input validation
- Use Zod for schema validation
- Document all parameters and response types
- Include error handling for all operations

Exemplos de padrões glob:

**/*.ts - Todos os ficheiros TypeScript
src/**/* - Todos os ficheiros em src/
src/**/*.{ts,tsx} - Múltiplas extensões
{src,lib}/**/*.ts, tests/**/*.test.ts - Múltiplos padrões

Subdiretórios e ligações simbólicas

As regras em .claude/rules/ suportam duas funcionalidades de organização:

Subdiretórios: As regras são detetadas recursivamente, pelo que as pode organizar em pastas por tema (por exemplo, rules/api/, rules/testing/, rules/security/)
Ligações simbólicas: As ligações simbólicas são suportadas para partilhar regras entre vários projetos. Por exemplo, pode criar, no diretório .claude/rules/ de cada projeto, uma ligação simbólica para um ficheiro de regra partilhado numa localização central. Desde a v2.1.284, uma regra com ligação simbólica de fora do projeto, ou um diretório .claude com ligação simbólica de fora, mostra o mesmo prompt de aprovação de importações externas que uma importação @path

Tabela de localizações de memória

Os ficheiros CLAUDE.md e as regras são concatenados no contexto, não selecionados por sobreposição estrita: a "Ordem de carregamento" abaixo significa onde aparece no contexto, não qual prevalece. A memória automática é um mecanismo separado com a sua própria localização de armazenamento.

Localização	Tipo	Ordem de carregamento	Partilhado	Acesso	Melhor para
`/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS)	Política gerida	1.ª (carrega primeiro)	Organização	Sistema	Políticas de toda a empresa
`/etc/claude-code/CLAUDE.md` (Linux/WSL)	Política gerida	1.ª (carrega primeiro)	Organização	Sistema	Normas da organização
`C:\Program Files\ClaudeCode\CLAUDE.md` (Windows)	Política gerida	1.ª (carrega primeiro)	Organização	Sistema	Diretrizes corporativas
`~/.claude/rules/*.md`	Regras de utilizador	2.ª	Individual	Sistema de ficheiros	Regras pessoais (todos os projetos)
`~/.claude/CLAUDE.md`	Memória de utilizador	3.ª	Individual	Sistema de ficheiros	Preferências pessoais (todos os projetos)
`./.claude/rules/*.md`	Regras do projeto	4.ª	Equipa	Git	Regras modulares específicas de caminho
`./CLAUDE.md` ou `./.claude/CLAUDE.md`	Memória do projeto	5.ª	Equipa	Git	Normas da equipa, arquitetura partilhada
`./CLAUDE.local.md`	Projeto local	6.ª (carrega em último lugar)	Individual	Git (ignorado)	Preferências pessoais específicas do projeto
`~/.claude/projects/<project>/memory/`	Memória automática	N/D (mecanismo separado)	Individual	Sistema de ficheiros	Notas e aprendizagens automáticas do Claude

Ciclo de vida das atualizações de memória

Eis como as atualizações de memória fluem pelas suas sessões do Claude Code:

Terminal

sequenceDiagram
    participant User
    participant Claude as Claude Code
    participant Editor as File System
    participant Memory as CLAUDE.md

    User->>Claude: "Add async/await rule to CLAUDE.md"
    Claude->>User: "Which memory file?"
    User->>Claude: "Project memory"
    Claude->>Editor: Open ./CLAUDE.md
    Claude->>Memory: Write to ./CLAUDE.md
    Memory-->>Claude: File saved
    Claude->>Claude: Load updated memory
    Claude-->>User: "Memory saved!"

Memória automática

A memória automática é um diretório persistente onde o Claude guarda automaticamente notas tipificadas (user, feedback, project, reference) à medida que trabalha com o seu projeto. Não guarda o que pode ser deduzido da base de código, como a arquitetura, os caminhos de ficheiros ou as correções de depuração. Ao contrário dos ficheiros CLAUDE.md, que você escreve e mantém manualmente, a memória automática é escrita pelo próprio Claude durante as sessões.

Como funciona a memória automática

Localização: ~/.claude/projects/<project>/memory/
Ponto de entrada: MEMORY.md é o ficheiro principal no diretório da memória automática
Ficheiros de tópicos: ficheiros adicionais opcionais, um por memória (por exemplo, prefers-pnpm.md, release-checklist.md)
Comportamento de carregamento: as primeiras 200 linhas de MEMORY.md (ou os primeiros 25 KB, consoante o que for atingido primeiro) são carregadas no contexto no início da sessão. Os ficheiros de tópicos são carregados sob pedido, não no arranque.
Leitura e escrita: o Claude lê e escreve ficheiros de memória durante as sessões à medida que aprende as suas preferências, o feedback e o contexto do projeto
Frontmatter: os ficheiros que começam com frontmatter YAML recebem um campo modified, um carimbo temporal ISO 8601 que o Claude Code regista sempre que escreve o ficheiro (v2.1.214)

Arquitetura da memória automática

Terminal

graph TD
    A["Claude Session Starts"] --> B["Load MEMORY.md<br/>(first 200 lines / 25KB)"]
    B --> C["Session Active"]
    C --> D["Claude learns<br/>preferences & feedback"]
    D --> E{"Write to<br/>auto memory"}
    E -->|General notes| F["MEMORY.md"]
    E -->|Topic-specific| G["prefers-pnpm.md"]
    E -->|Topic-specific| H["release-checklist.md"]
    C --> I["On-demand load<br/>topic files"]
    I --> C

    style A fill:#e1f5fe,stroke:#333,color:#333
    style B fill:#e1f5fe,stroke:#333,color:#333
    style C fill:#e8f5e9,stroke:#333,color:#333
    style D fill:#f3e5f5,stroke:#333,color:#333
    style E fill:#fff3e0,stroke:#333,color:#333
    style F fill:#fce4ec,stroke:#333,color:#333
    style G fill:#fce4ec,stroke:#333,color:#333
    style H fill:#fce4ec,stroke:#333,color:#333
    style I fill:#f3e5f5,stroke:#333,color:#333

Estrutura do Diretório de Memória Automática

Terminal

~/.claude/projects/<project>/memory/
├── MEMORY.md              # Entrypoint (first 200 lines / 25KB loaded at startup)
├── prefers-pnpm.md        # Topic file (loaded on demand)
├── release-checklist.md   # Topic file (loaded on demand)
└── team-contacts.md       # Topic file (loaded on demand)

Requisito de versão

A memória automática requer Claude Code v2.1.59 ou posterior. Se estiver numa versão anterior, atualize primeiro:

Terminal

npm install -g @anthropic-ai/claude-code@latest

Ativar ou desativar a memória automática

A memória automática está ativada por predefinição. A definição autoMemoryEnabled (predefinição true) controla-a; quando é false, o Claude não lê nem escreve no diretório da memória automática. Também pode ativá-la ou desativá-la com /memory durante uma sessão.

Terminal

{
  "autoMemoryEnabled": false
}

Em alternativa, para a desativar através de uma variável de ambiente, defina CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Defini-la como 0 força a memória automática a ficar ativa, mesmo quando o modo --bare ou autoMemoryEnabled: false a desativaria.

Diretório de memória automática personalizado

Por predefinição, a memória automática é guardada em ~/.claude/projects/<project>/memory/. Pode alterar esta localização através da definição autoMemoryDirectory (disponível desde a v2.1.74):

Terminal

// In any settings file: user, project, local, or managed policy
{
  "autoMemoryDirectory": "/path/to/custom/memory/directory"
}

Nota: autoMemoryDirectory é lido a partir de qualquer âmbito de definições: utilizador, projeto, local, política gerida ou --settings. O valor tem de ser um caminho absoluto ou começar por ~/.

Isto é útil quando pretende:

Guardar a memória automática numa localização partilhada ou sincronizada
Separar a memória automática do diretório de configuração predefinido do Claude
Usar um caminho específico do projeto fora da hierarquia predefinida

Partilha entre worktrees e repositório

Todos os worktrees e subdiretórios dentro do mesmo repositório git partilham um único diretório de memória automática. Isto significa que alternar entre worktrees ou trabalhar em diferentes subdiretórios do mesmo repositório lê e escreve nos mesmos ficheiros de memória.

Memória dos subagentes

Os subagentes (criados através da ferramenta Agent) podem manter a sua própria memória persistente. O campo memory do frontmatter na definição do subagente escolhe onde fica esse diretório de memória:

Terminal

memory: user      # ~/.claude/agent-memory/<agent-name>/
memory: project   # .claude/agent-memory/<agent-name>/ (shareable via git)
memory: local     # .claude/agent-memory-local/<agent-name>/ (not checked in)

O subagente lê as primeiras 200 linhas / 25 KB do MEMORY.md desse diretório no arranque e recebe as ferramentas Read/Write/Edit para o manter. Não tem efeito quando a memória automática está desativada.

Nota: Os subagentes também podem manter a sua própria memória automática. Consulte a documentação oficial sobre memória de subagentes para mais detalhes.

Controlar a memória automática

A memória automática pode ser controlada através da variável de ambiente CLAUDE_CODE_DISABLE_AUTO_MEMORY:

Valor	Comportamento
`0`	Força a memória automática ativada
`1`	Força a memória automática desativada
(não definido)	Comportamento predefinido (memória automática ativada)

Terminal

# Disable auto memory for a session
CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

# Force auto memory on explicitly
CLAUDE_CODE_DISABLE_AUTO_MEMORY=0 claude

Diretórios adicionais com `--add-dir`

A flag --add-dir permite ao Claude Code carregar ficheiros CLAUDE.md de diretórios adicionais para além do diretório de trabalho atual. Isto é útil para monorepos ou configurações multiprojeto em que o contexto de outros diretórios é relevante.

Para ativar esta funcionalidade, defina a variável de ambiente:

Terminal

CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1

Em seguida, inicie o Claude Code com a flag:

Terminal

claude --add-dir /path/to/other/project

O Claude carregará o CLAUDE.md do diretório adicional especificado, juntamente com os ficheiros de memória do seu diretório de trabalho atual.

Exemplos Práticos

Exemplo 1: Estrutura da Memória do Projeto

Ficheiro: ./CLAUDE.md

Terminal

# Project Configuration

## Project Overview
- **Name**: E-commerce Platform
- **Tech Stack**: Node.js, PostgreSQL, React 18, Docker
- **Team Size**: 5 developers
- **Deadline**: Q4 2025

## Architecture
@docs/architecture.md
@docs/api-standards.md
@docs/database-schema.md

## Development Standards

### Code Style
- Use Prettier for formatting
- Use ESLint with airbnb config
- Maximum line length: 100 characters
- Use 2-space indentation

### Naming Conventions
- **Files**: kebab-case (user-controller.js)
- **Classes**: PascalCase (UserService)
- **Functions/Variables**: camelCase (getUserById)
- **Constants**: UPPER_SNAKE_CASE (API_BASE_URL)
- **Database Tables**: snake_case (user_accounts)

### Git Workflow
- Branch names: `feature/description` or `fix/description`
- Commit messages: Follow conventional commits
- PR required before merge
- All CI/CD checks must pass
- Minimum 1 approval required

### Testing Requirements
- Minimum 80% code coverage
- All critical paths must have tests
- Use Jest for unit tests
- Use Cypress for E2E tests
- Test filenames: `*.test.ts` or `*.spec.ts`

### API Standards
- RESTful endpoints only
- JSON request/response
- Use HTTP status codes correctly
- Version API endpoints: `/api/v1/`
- Document all endpoints with examples

### Database
- Use migrations for schema changes
- Never hardcode credentials
- Use connection pooling
- Enable query logging in development
- Regular backups required

### Deployment
- Docker-based deployment
- Kubernetes orchestration
- Blue-green deployment strategy
- Automatic rollback on failure
- Database migrations run before deploy

## Common Commands

| Command | Purpose |
|---------|---------|
| `npm run dev` | Start development server |
| `npm test` | Run test suite |
| `npm run lint` | Check code style |
| `npm run build` | Build for production |
| `npm run migrate` | Run database migrations |

## Team Contacts
- Tech Lead: Sarah Chen (@sarah.chen)
- Product Manager: Mike Johnson (@mike.j)
- DevOps: Alex Kim (@alex.k)

## Known Issues & Workarounds
- PostgreSQL connection pooling limited to 20 during peak hours
- Workaround: Implement query queuing
- Safari 14 compatibility issues with async generators
- Workaround: Use Babel transpiler

## Related Projects
- Analytics Dashboard: `/projects/analytics`
- Mobile App: `/projects/mobile`
- Admin Panel: `/projects/admin`

Exemplo 2: Memória Específica do Diretório

Ficheiro: ./src/api/CLAUDE.md

Terminal

# API Module Standards

This file supplements root CLAUDE.md for everything in /src/api/. Memory files are
concatenated, not overridden - the root CLAUDE.md still applies, and Claude Code
loads this file on demand when it reads, writes, or edits files in this subtree.

## API-Specific Standards

### Request Validation
- Use Zod for schema validation
- Always validate input
- Return 400 with validation errors
- Include field-level error details

### Authentication
- All endpoints require JWT token
- Token in Authorization header
- Token expires after 24 hours
- Implement refresh token mechanism

### Response Format

All responses must follow this structure:

```json
{
  "success": true,
  "data": { /* actual data */ },
  "timestamp": "2025-11-06T10:30:00Z",
  "version": "1.0"
}
```

Error responses:
```json
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "User message",
    "details": { /* field errors */ }
  },
  "timestamp": "2025-11-06T10:30:00Z"
}
```

### Pagination
- Use cursor-based pagination (not offset)
- Include `hasMore` boolean
- Limit max page size to 100
- Default page size: 20

### Rate Limiting
- 1000 requests per hour for authenticated users
- 100 requests per hour for public endpoints
- Return 429 when exceeded
- Include retry-after header

### Caching
- Use Redis for session caching
- Cache duration: 5 minutes default
- Invalidate on write operations
- Tag cache keys with resource type

Exemplo 3: Memória pessoal

Ficheiro: ~/.claude/CLAUDE.md

Terminal

# My Development Preferences

## About Me
- **Experience Level**: 8 years full-stack development
- **Preferred Languages**: TypeScript, Python
- **Communication Style**: Direct, with examples
- **Learning Style**: Visual diagrams with code

## Code Preferences

### Error Handling
I prefer explicit error handling with try-catch blocks and meaningful error messages.
Avoid generic errors. Always log errors for debugging.

### Comments
Use comments for WHY, not WHAT. Code should be self-documenting.
Comments should explain business logic or non-obvious decisions.

### Testing
I prefer TDD (test-driven development).
Write tests first, then implementation.
Focus on behavior, not implementation details.

### Architecture
I prefer modular, loosely-coupled design.
Use dependency injection for testability.
Separate concerns (Controllers, Services, Repositories).

## Debugging Preferences
- Use console.log with prefix: `[DEBUG]`
- Include context: function name, relevant variables
- Use stack traces when available
- Always include timestamps in logs

## Communication
- Explain complex concepts with diagrams
- Show concrete examples before explaining theory
- Include before/after code snippets
- Summarize key points at the end

## Project Organization
I organize my projects as:

   project/
   ├── src/
   │   ├── api/
   │   ├── services/
   │   ├── models/
   │   └── utils/
   ├── tests/
   ├── docs/
   └── docker/

## Tooling
- **IDE**: VS Code with vim keybindings
- **Terminal**: Zsh with Oh-My-Zsh
- **Format**: Prettier (100 char line length)
- **Linter**: ESLint with airbnb config
- **Test Framework**: Jest with React Testing Library

_My Test_

Peça ao Claude para guardar uma nova regra

O Claude não guardou a regra porque não tinha nenhum ficheiro Claude.md em lado nenhum. Depois pedi ao Claude para confirmar a localização.

Exemplo 4: Atualização da memória durante a sessão

Pode adicionar novas regras ao CLAUDE.md durante uma sessão ativa do Claude Code, pedindo diretamente ao Claude (pedir-lhe para lembrar algo guarda na memória automática em vez disso):

Terminal

User: Add this to CLAUDE.md: I prefer using React hooks instead of class components
     for all new components.

Claude: I'm adding that to your memory. Which memory file should this go in?
        1. Project memory (./CLAUDE.md)
        2. Personal memory (~/.claude/CLAUDE.md)

User: Project memory

Claude: ✅ Memory saved!

Added to ./CLAUDE.md:
---

### Component Development
- Use functional components with React Hooks
- Prefer hooks over class components
- Custom hooks for reusable logic
- Use useCallback for event handlers
- Use useMemo for expensive computations

Ou use /memory para editar diretamente os ficheiros de memória, para atualizações extensas ou reorganização.

Sugestões para adicionar memória

Seja específico e acionável nas suas regras
Agrupe as regras relacionadas sob um cabeçalho de secção
Atualize as secções existentes em vez de duplicar conteúdo
Escolha o âmbito de memória adequado (projeto vs. pessoal)

Comparação de funcionalidades de memória

Funcionalidade	Claude Web/Desktop	Claude Code (CLAUDE.md)
Síntese automática	✅ A cada 24h	✅ Memória automática
Entre projetos	✅ Partilhado	❌ Específico do projeto
Acesso da equipa	✅ Projetos partilhados	✅ Versionado no Git
Pesquisável	✅ Integrado	✅ Através de `/memory`
Editável	✅ No chat	✅ Edição direta do ficheiro
Importação/Exportação	✅ Sim	✅ Copiar/colar
Persistente	✅ 24h+	✅ Indefinido

Memória no Claude Web/Desktop

Cronologia da síntese de memória

Terminal

graph LR
    A["Day 1: User<br/>Conversations"] -->|24 hours| B["Day 2: Memory<br/>Synthesis"]
    B -->|Automatic| C["Memory Updated<br/>Summarized"]
    C -->|Loaded in| D["Day 2-N:<br/>New Conversations"]
    D -->|Add to| E["Memory"]
    E -->|24 hours later| F["Memory Refreshed"]

Exemplo de resumo de memória:

Terminal

## Claude's Memory of User

### Professional Background
- Senior full-stack developer with 8 years experience
- Focus on TypeScript/Node.js backends and React frontends
- Active open source contributor
- Interested in AI and machine learning

### Project Context
- Currently building e-commerce platform
- Tech stack: Node.js, PostgreSQL, React 18, Docker
- Working with team of 5 developers
- Using CI/CD and blue-green deployments

### Communication Preferences
- Prefers direct, concise explanations
- Likes visual diagrams and examples
- Appreciates code snippets
- Explains business logic in comments

### Current Goals
- Improve API performance
- Increase test coverage to 90%
- Implement caching strategy
- Document architecture

Boas Práticas

O Que Fazer - O Que Incluir

Seja específico e detalhado: Use instruções claras e detalhadas em vez de orientações vagas
✅ Bom: "Use indentação de 2 espaços em todos os ficheiros JavaScript"
❌ Evite: "Siga as boas práticas"

Mantenha tudo organizado: Estruture os ficheiros de memória com secções e títulos markdown claros

Use níveis de hierarquia adequados:
Política gerida: Políticas de toda a empresa, normas de segurança, requisitos de conformidade
Memória de projeto: Normas da equipa, arquitetura, convenções de código (faça commit no git)
Memória de utilizador: Preferências pessoais, estilo de comunicação, escolhas de ferramentas
Memória de diretório: Regras e substituições específicas de módulos

Aproveite as importações: Use a sintaxe @path/to/file para referenciar documentação existente
Suporta uma profundidade máxima de 4 saltos para importações recursivas
Evita duplicação entre ficheiros de memória
Exemplo: See @README.md for project overview

Documente comandos frequentes: Inclua comandos que usa repetidamente para poupar tempo

Mantenha a memória de projeto sob controlo de versões: Faça commit dos ficheiros CLAUDE.md de nível de projeto no git para benefício da equipa

Reveja periodicamente: Atualize a memória regularmente à medida que os projetos evoluem e os requisitos mudam

Forneça exemplos concretos: Inclua fragmentos de código e cenários específicos

O Que Não Fazer - O Que Evitar

Não guarde segredos: Nunca inclua chaves de API, palavras-passe, tokens ou credenciais

Não inclua dados sensíveis: Nada de PII, informação privada ou segredos proprietários

Não duplique conteúdo: Em vez disso, use importações (@path) para referenciar documentação existente

Não seja vago: Evite declarações genéricas como "siga as boas práticas" ou "escreva bom código"

Não o torne demasiado longo: Procure manter menos de 200 linhas por CLAUDE.md. Ficheiros mais longos ainda são carregados na íntegra, mas a adesão diminui - consulte Manter o CLAUDE.md pequeno abaixo

Não organize em excesso: Use a hierarquia estrategicamente; não crie substituições excessivas em subdiretórios

Não se esqueça de atualizar: Memória obsoleta pode causar confusão e práticas desatualizadas

Não exceda os limites de aninhamento: As importações de memória suportam uma profundidade máxima de 4 saltos

Manter o CLAUDE.md Pequeno

A orientação atual da Anthropic é o oposto de "pôr tudo no CLAUDE.md". O ficheiro é carregado em todas as sessões, por isso cada linha que adicionar é uma linha que compete por atenção em tarefas com que não tem nada a ver.

Regra prática: mantenha o CLAUDE.md com menos de 200 linhas. Ficheiros mais longos ainda são carregados na íntegra, mas a adesão às instruções degrada à medida que o ficheiro cresce.

Quando começar a crescer, mova o conteúdo para fora em vez de cortar texto:

Conteúdo	Onde deve ficar	Porquê
Procedimentos de vários passos	Uma skill	Carrega a pedido, apenas quando relevante
Regras específicas de diretório ou de tipo de ficheiro	`.claude/rules/*.md` com frontmatter `paths:`	Delimitado por glob; carrega apenas quando editar ficheiros correspondentes
Material de referência e exemplos longos	O diretório `references/` de uma skill	Lido apenas quando a skill precisar
Coisas que o Claude deve lembrar sobre você	Memória automática (ativada por predefinição)	Escrita e carregada automaticamente

Nota: As importações @path organizam um CLAUDE.md grande mas não poupam contexto - os ficheiros importados são carregados no arranque da mesma forma. Dividir em regras delimitadas por caminhos é o que realmente reduz o que é carregado.

/doctor (v2.1.206+) inspeciona a sua configuração e propõe cortes quando o CLAUDE.md cresceu para além do ponto de utilidade.

Não Escreva Lembretes de Verificação

Orientações mais antigas encorajavam linhas como "execute sempre os testes antes de dizer que terminou" ou "verifique duas vezes o seu trabalho". No Claude Opus 5 e Fable 5, estas causam agora sobreverificação - o Claude volta a verificar trabalho que já estava correto, gastando turnos e tokens.

A Anthropic removeu mais de 80% do próprio system prompt do Claude Code para a geração Claude 5 sem regressão medida. O mesmo princípio se aplica ao seu CLAUDE.md: prefira enunciar o objetivo e deixar o Claude exercer o julgamento em vez de enumerar as verificações que deve executar.

Elimine os lembretes de verificação dos ficheiros CLAUDE.md existentes destinados ao Opus 5 ou ao Fable 5. Mantenha os requisitos de projeto genuinamente não óbvios - "os testes de integração precisam do Docker a correr" é informação, não um lembrete.

Dicas de Gestão de Memória

Escolha o nível de memória certo:

Caso de Utilização	Nível de Memória	Justificação
Política de segurança da empresa	Política Gerida	Aplica-se a todos os projetos em toda a organização
Guia de estilo de código da equipa	Projeto	Partilhado com a equipa via git
Atalhos do seu editor preferido	Utilizador	Preferência pessoal, não partilhada
Normas do módulo de API	Diretório	Específico apenas desse módulo

Fluxo de trabalho de atualização rápida:

Para uma única regra: Use /memory para abrir o editor, ou pergunte conversacionalmente
Para várias alterações: Use /memory para abrir o editor
Para configuração inicial: Use /init para criar um modelo

Boas práticas de importação:

Terminal

# Good: Reference existing docs
@README.md
@docs/architecture.md
@package.json

# Avoid: Copying content that exists elsewhere
# Instead of copying README content into CLAUDE.md, just import it

Instruções de Instalação

Configurar a Memória do Projeto

Método 1: Utilizar o comando `/init` (Recomendado)

A forma mais rápida de configurar a memória do projeto:

Navegue para o diretório do seu projeto:

Terminal

cd /path/to/your/project

Execute o comando init no Claude Code:

Terminal

/init

O Claude criará e preencherá o CLAUDE.md com uma estrutura de modelo

Personalize o ficheiro gerado de acordo com as necessidades do seu projeto

Faça commit para o git:

Terminal

git add CLAUDE.md
git commit -m "Initialize project memory with /init"

Método 2: Criação manual

Se preferir uma configuração manual:

Crie um CLAUDE.md na raiz do seu projeto:

Terminal

cd /path/to/your/project
touch CLAUDE.md

Adicione as normas do projeto:

Terminal

cat > CLAUDE.md << 'EOF'
# Project Configuration

## Project Overview
- **Name**: Your Project Name
- **Tech Stack**: List your technologies
- **Team Size**: Number of developers

## Development Standards
- Your coding standards
- Naming conventions
- Testing requirements
EOF

Faça commit no git:

Terminal

git add CLAUDE.md
git commit -m "Add project memory configuration"

Configurar a memória pessoal

Crie o diretório ~/.claude:

Terminal

mkdir -p ~/.claude

Crie um CLAUDE.md pessoal:

Terminal

touch ~/.claude/CLAUDE.md

Adicione as suas preferências:

Terminal

cat > ~/.claude/CLAUDE.md << 'EOF'
# My Development Preferences

## About Me
- Experience Level: [Your level]
- Preferred Languages: [Your languages]
- Communication Style: [Your style]

## Code Preferences
- [Your preferences]
EOF

Configurar memória específica de diretório

Crie memória para diretórios específicos:

Terminal

mkdir -p /path/to/directory/.claude
touch /path/to/directory/CLAUDE.md

Adicione regras específicas do diretório:

Terminal

cat > /path/to/directory/CLAUDE.md << 'EOF'
# [Directory Name] Standards

This file supplements root CLAUDE.md for this directory. Memory files are
concatenated, not overridden - Claude Code loads this file on demand when it
reads, writes, or edits files in this directory.

## [Specific Standards]
EOF

Faça commit no controlo de versões:

Terminal

git add /path/to/directory/CLAUDE.md
git commit -m "Add [directory] memory configuration"

Verificar a Configuração

Verifique as localizações da memória:

Terminal

# Project root memory
ls -la ./CLAUDE.md

# Personal memory
ls -la ~/.claude/CLAUDE.md

O Claude Code carrega automaticamente estes ficheiros ao iniciar uma sessão

Teste com o Claude Code iniciando uma nova sessão no seu projeto

Documentação Oficial

Para informação mais atualizada, consulte a documentação oficial do Claude Code:

Documentação de Memória - Referência completa do sistema de memória
Referência de Comandos Slash - Todos os comandos integrados, incluindo /init e /memory
Referência da CLI - Documentação da interface de linha de comandos

Detalhes Técnicos Principais da Documentação Oficial

Carregamento de Memória:

Todos os ficheiros de memória são carregados automaticamente quando o Claude Code é iniciado
O Claude percorre a árvore de diretórios a partir do diretório de trabalho atual para encontrar ficheiros CLAUDE.md
Os ficheiros de subárvores são descobertos e carregados de forma contextual ao aceder a esses diretórios

Sintaxe de Importação:

Use @path/to/file para incluir conteúdo externo (por exemplo, @~/.claude/my-project-instructions.md)
Suporta caminhos relativos e absolutos (os caminhos relativos são resolvidos em relação ao ficheiro que contém a importação, e não ao diretório de trabalho)
São suportadas importações recursivas, com profundidade máxima de 4 níveis
As importações externas feitas pela primeira vez disparam uma caixa de diálogo de aprovação
Não são avaliadas dentro de trechos de código markdown nem de blocos de código
Inclui automaticamente o conteúdo referenciado no contexto do Claude

Ordem de Carregamento do CLAUDE.md (concatenada no contexto, não como substituição estrita - ver Hierarquia de Memória no Claude Code acima):

Política Gerida (carrega primeiro)
Regras ao Nível do Utilizador (~/.claude/rules/)
Memória do Utilizador
Regras do Projeto (.claude/rules/)
Memória do Projeto
Memória Local do Projeto (carrega por último)

A Memória Automática é um mecanismo separado (~/.claude/projects/<project>/memory/), não fazendo parte desta ordem de concatenação.

Ligações de Conceitos Relacionados

Pontos de Integração

Protocolo MCP - Acesso a dados em tempo real em conjunto com a memória
Comandos Slash - Atalhos específicos da sessão
Skills - Fluxos de trabalho automatizados com contexto de memória

Outras Funcionalidades Relacionadas do Claude

Memória Web do Claude - Síntese automática
Documentação Oficial de Memória - Documentação da Anthropic

Última Atualização: 18 de outubro de 2026

Versão do Claude Code: 2.1.302

Fontes:

https://code.claude.com/docs/en/memory
https://code.claude.com/docs/en/memory#agents-md
https://code.claude.com/docs/en/memory#when-agents-md-support-is-unavailable
https://github.com/anthropics/claude-code/releases/tag/v2.1.284
https://github.com/anthropics/claude-code/releases/tag/v2.1.288
https://github.com/anthropics/claude-code/releases/tag/v2.1.293
https://code.claude.com/docs/en/sub-agents#enable-persistent-memory
https://code.claude.com/docs/en/settings-reference
https://code.claude.com/docs/en/claude-directory

Modelos Compatíveis: Claude Fable 5, Claude Opus 5, Claude Sonnet 5, Claude Sonnet 4.6, Claude Opus 4.8, Claude Haiku 4.5

Exemplos e recursos deste módulo

Padrões do Módulo de API
Este ficheiro complementa o CLAUDE.md da raiz para tudo o que está em /src/api/. Os ficheiros de memória são concatenados, não substituídos: o CLAUDE.md da raiz continua a aplicar-se, e o Claude Code carrega este ficheiro a pedido quando lê, escreve ou edita ficheiros nesta subárvore.
2 min
As Minhas Preferências de Desenvolvimento
Nível de Experiência: 8 anos de desenvolvimento full-stack; Linguagens Preferidas: TypeScript, Python; Estilo de Comunicação: Direto, com exemplos; Estilo de Aprendizagem: Diagramas visuais com código
2 min
Configuração do Projeto
Nome: Plataforma de E-commerce; Stack Tecnológica: Node.js, PostgreSQL, React 18, Docker; Dimensão da Equipa: 5 programadores; Prazo: 4.º trimestre de 2025
2 min

Guia da comunidade open-source (MIT) · tradução e manutenção Doutor AI.

Precisa de uma solução à medida?

Não sabe por onde começar a usar IA no seu negócio? Receba uma avaliação gratuita e um plano à medida - sem compromisso.

Poupe horas todas as semanas com IA, sem complicações

O Doutor AI dá-lhe 1859 prompts de IA prontos a copiar, por indústria e em português simples - mais uma biblioteca técnica completa para quem quer ir mais longe.

Ver planos

Guia de Memória

Visão Geral

Referência Rápida de Comandos de Memória

Início Rápido: Inicializar a Memória

O Comando /init

Atualizações rápidas de memória

O comando /memory

Arquitetura de memória

Hierarquia de memória no Claude Code

AGENTS.md

Excluir ficheiros CLAUDE.md com claudeMdExcludes

Hierarquia dos Ficheiros de Definições

Definições de Retenção e Limpeza

Atribuição, voz e definições de URL de PR

Nomes de definições obsoletos

Sistema modular de regras

Regras específicas de caminhos com frontmatter YAML

Subdiretórios e ligações simbólicas

Tabela de localizações de memória

Ciclo de vida das atualizações de memória

Memória automática

Como funciona a memória automática

Arquitetura da memória automática

Estrutura do Diretório de Memória Automática

Requisito de versão

Ativar ou desativar a memória automática

Diretório de memória automática personalizado

Partilha entre worktrees e repositório

Memória dos subagentes

Controlar a memória automática

Diretórios adicionais com --add-dir

Exemplos Práticos

Exemplo 1: Estrutura da Memória do Projeto

Exemplo 2: Memória Específica do Diretório

Exemplo 3: Memória pessoal

Exemplo 4: Atualização da memória durante a sessão

Sugestões para adicionar memória

Comparação de funcionalidades de memória

Memória no Claude Web/Desktop

Cronologia da síntese de memória

Boas Práticas

O Que Fazer - O Que Incluir

O Que Não Fazer - O Que Evitar

Manter o CLAUDE.md Pequeno

Não Escreva Lembretes de Verificação

Dicas de Gestão de Memória

Instruções de Instalação

Configurar a Memória do Projeto

Método 1: Utilizar o comando /init (Recomendado)

Método 2: Criação manual

Configurar a memória pessoal

Configurar memória específica de diretório

Verificar a Configuração

Documentação Oficial

Detalhes Técnicos Principais da Documentação Oficial

Ligações de Conceitos Relacionados

Pontos de Integração

Outras Funcionalidades Relacionadas do Claude

Exemplos e recursos deste módulo

Padrões do Módulo de API

As Minhas Preferências de Desenvolvimento

Configuração do Projeto

Poupe horas todas as semanas com IA, sem complicações

O Comando `/init`

O comando `/memory`

Excluir ficheiros CLAUDE.md com `claudeMdExcludes`

Diretórios adicionais com `--add-dir`

Método 1: Utilizar o comando `/init` (Recomendado)