Claude Code + Obsidian
Como construir a Smart Memory do seu time: a memória coletiva versionada que todos os agentes leem e escrevem, para nenhuma sessão começar do zero.
O que é
Claude Code + Obsidian
Você vai montar a smart-memory do seu projeto: uma pasta de arquivos em texto, no padrão Obsidian, que funciona como o cérebro compartilhado do seu time de agentes. Na primeira vez que você roda `/team-os`, o sistema lê o seu código e constrói a estrutura inicial sozinho. O seu trabalho é entender o que ele montou, preencher os pontos que só você conhece e manter tudo vivo ao longo do tempo.
Contexto que não se perde é o que separa uma operação séria de uma brincadeira. Sem memória compartilhada, cada agente começa do zero — alguém sempre precisa explicar o projeto, a stack, as convenções. Com a smart-memory, o sistema lê o projeto uma vez e todos os agentes passam a compartilhar a mesma fonte. A memória sobrevive entre sessões, cresce junto com o projeto e é herdada por qualquer pessoa que clone o repositório.
A smart-memory fica em `docs/smart-memory/` e é versionada com o código. O formato Obsidian usa frontmatter (metadados no topo do arquivo) e wikilinks — links entre arquivos escritos com colchetes duplos, como `[[tech-stack]]` — que criam uma teia navegável. O processo de Discovery, disparado pelo `/team-os`, lê o código real e gera os arquivos iniciais; o que o código não revela ele marca como TODO para você completar.
Antes de começar você precisa ter uma squad instalada no projeto (o tutorial 'dividir o time por função' cobre isso com `/team-os-creator *install`), a skill `/team-os` disponível e o Claude Code aberto dentro da pasta do projeto. O Obsidian é opcional, mas recomendado para navegar pelos wikilinks com conforto.
Discovery automático
Na primeira execução, o `/team-os` lê o código do projeto e gera a memória inicial: overview, stack técnica e convenções — sem você precisar escrever do zero.
Formato Obsidian e wikilinks
Cada arquivo usa frontmatter e wikilinks que conectam as notas em uma teia navegável. O Obsidian abre esse formato de forma nativa, mas qualquer editor de texto funciona.
Contexto versionado com o código
A smart-memory fica em `docs/smart-memory/` e viaja com o repositório. O Git guarda o histórico de mudanças e qualquer pessoa que clonar o projeto herda o contexto.
TODO honesto, não achismo
O que o código não revela — propósito de negócio, responsabilidade de módulos — é marcado como TODO para você completar. O sistema prefere deixar marcado a inventar.
Memória que persiste entre sessões
A cada `/team-os` seguinte, o sistema encontra a memória existente, lembra das stories ativas e retoma de onde parou. O time não começa do zero nunca mais.
Nível: intermediário · Tempo estimado: 30 min
Pré-requisitos
- Uma squad já instalada no projeto (o tutorial 'dividir o time por função' cobre isso com `/team-os-creator *install`).
- A skill `/team-os` disponível no projeto — ela vem junto na instalação da squad.
- O Claude Code aberto dentro da pasta do projeto (não do Centro de Treinamento).
- Opcional, mas recomendado: o Obsidian instalado (obsidian.md), para ler e editar a memória de forma confortável. Não é obrigatório — são arquivos de texto comuns.
Conceitos-chave
- 01
Smart Memory
A memória do time, guardada em `docs/smart-memory/` dentro do projeto. Versionada junto com o código, ela é compartilhada por todos os agentes e por qualquer pessoa que clone o repositório.
- 02
Formato Obsidian
Cada arquivo tem um cabeçalho de metadados (o frontmatter, o bloco no topo entre `---`) e usa wikilinks — links entre arquivos escritos com colchetes duplos, tipo `[[tech-stack]]`. É isso que conecta as notas em uma teia navegável. O Obsidian lê esse formato de forma nativa.
- 03
Discovery
O processo que o `/team-os` roda na primeira vez. Ele lê o código de verdade — linguagem, framework, banco de dados, gerenciador de pacotes, estrutura de módulos — e gera a memória inicial.
- 04
TODO
Os campos que o sistema deixa marcados porque o código não revela sozinho — como propósito de negócio ou responsabilidade de cada módulo. O sistema prefere marcar a chutar; você preenche com o contexto que só você tem.
Passo a passo
Montando a smart-memory
- 01
Passo 1 — Confirme que a memória ainda não existe
Abra a pasta do projeto e verifique que não há uma pasta `docs/smart-memory/`. A instalação da squad traz os agentes, a skill e a configuração — mas não a memória. Ela é construída depois, lendo o código de destino. Ver que ela não existe ainda é o ponto de partida correto. Você deve encontrar apenas a pasta de agentes, a skill `/team-os` e o `settings.json`. Se você encontrar a pasta logo após instalar a squad e achar que faltou algo, não faltou — ela nasce no próximo passo.
- 02
Passo 2 — Rode o `/team-os` pela primeira vez
Com o Claude Code aberto no projeto, digite o comando que liga a operação. Esse comando é o ritual de abertura de toda sessão. Na primeira vez, ele detecta que não há memória e propõe construir antes de qualquer trabalho — ele não pula essa etapa porque, sem memória, o time inteiro trabalharia às cegas. Espere um scan rápido do ambiente (ele confirma a configuração de time e lista os agentes instalados), depois uma mensagem dizendo que a smart-memory não existe e perguntando se pode construir. Você confirma. Se parecer que travou durante a leitura do código, aguarde — o Discovery leva alguns instantes porque está lendo os arquivos de verdade, não inventando.
/team-os - 03
Passo 3 — Deixe o Discovery ler o código e gerar a estrutura
Confirme o Discovery e acompanhe. O sistema vai varrer o projeto — linguagem, framework, banco de dados, gerenciador de pacotes, estrutura de módulos — e criar os arquivos. É essa leitura do código real que garante que a memória descreve o seu projeto, e não um genérico. Tudo o que o código revela, ele preenche; o que o código não revela, ele marca como `TODO`. Dentro de `docs/smart-memory/` vão aparecer: `INDEX.md` (a porta de entrada, com os wikilinks para o resto), `project/overview.md` (o resumo do projeto), `project/tech-stack.md` (a stack técnica detectada) e `project/convenções.md` (as convenções de código encontradas). Os campos `TODO` não são erro — são honestidade. O sistema preferiu marcar a chutar.
- 04
Passo 4 — Valide o que o sistema entendeu
O `/team-os` mostra um resumo do que descobriu e pede para você confirmar ou corrigir. Leia o overview, o stack e os módulos. Corrija o que estiver errado ali mesmo. A leitura de código acerta a parte técnica, mas pode interpretar mal o desenho do projeto — este é o momento barato de corrigir, antes de qualquer agente usar a memória como verdade. Depois da sua confirmação, o dashboard do time abre e pergunta qual é o objetivo da sessão. Não confirme no automático sem ler: se o overview estiver torto, todos os agentes herdam o erro.
- 05
Passo 5 — Preencha os campos TODO
Abra os arquivos gerados (no Obsidian ou em qualquer editor) e complete os `TODO`. Os principais: o propósito de negócio do projeto (para que ele existe, para quem) e a responsabilidade de cada módulo (o que cada parte faz na prática). O código mostra como as coisas são feitas, mas não por quê. Essa camada de contexto de negócio é justamente a que você, como dono, tem e o código não — é ela que faz os agentes tomarem decisões alinhadas ao negócio, não só tecnicamente corretas. Escreva em linguagem simples; duas ou três frases certeiras por campo valem mais que um texto longo que ninguém relê.
- 06
Passo 6 — Mantenha a memória viva
Trate a smart-memory como parte do projeto. Quando algo mudar (nova decisão, novo módulo, mudança de rumo), atualize o arquivo correspondente. Como ela é versionada com o código, o Git guarda o histórico. Memória parada envelhece e vira mentira — os agentes leem a memória ao começar e gravam nela ao terminar, e o que descobrirem numa sessão fica registrado para a próxima herdar. A cada `/team-os` futuro, o sistema encontra a memória existente, lembra das stories ativas e de onde a equipe parou. Reserve 10 minutos de vez em quando para limpar duplicações e corrigir o que ficou desatualizado.
Prompt: Abrir o time no projeto
/team-os
Prompt: Pedir ajuda para preencher os TODO de contexto de negócio
Leia docs/smart-memory/project/overview.md e me faça as perguntas que faltam para eu preencher os campos TODO de propósito de negócio e responsabilidade de cada módulo. Uma pergunta de cada vez.
Prompt: Registrar uma decisão nova na memória
Acabamos de decidir: [descreva a decisão em uma ou duas frases]. Atualize a smart-memory no arquivo certo, resuma a decisão e o motivo, e me mostre o que mudou antes de salvar.
Erros comuns
- O `/team-os` foi direto pro dashboard e não construiu memória: A memória provavelmente já existe de uma sessão anterior. Confira a pasta `docs/smart-memory/`.
- Os arquivos têm muitos TODO: Esperado numa primeira rodada. Priorize os TODO de overview e de propósito de negócio; o resto você preenche conforme o projeto anda.
- Editei a memória e os agentes não usaram: Eles leem a memória no início da sessão. Rode `/team-os` de novo para eles recarregarem o contexto.
- Não uso Obsidian: Sem problema. São arquivos de texto — qualquer editor abre. O Obsidian só deixa a navegação por wikilinks mais confortável.
Checklist final
- Confirmei que a memória não existia antes de rodar `/team-os`.
- Rodei `/team-os` e confirmei o Discovery.
- Vi o `INDEX.md` e a pasta `project/` (overview, tech-stack, convenções) criados.
- Validei o resumo do que o sistema entendeu.
- Preenchi os campos TODO de propósito de negócio e responsabilidade dos módulos.
- Defini uma rotina simples para manter a memória atualizada.
- Repositório do time de agentes — Centro de Treinamento e squads prontas (https://github.com/joaoguirunas/team-os)
- Claude Code — o motor que roda os agentes e o comando `/team-os` (https://www.npmjs.com/package/@anthropic-ai/claude-code)
- Obsidian — para ler e editar a memória com wikilinks (https://obsidian.md)
Próximo passo
Veja os outros recursos do catálogo
Dezenas de recursos entre squads, skills, apps e integrações — todos usados em produção pelo João.
Voltar ao catálogo