---
title: Claude Code + Obsidian: Como Montar um Sistema Operacional de Conhecimento que Produz por Você
description: Tutorial passo a passo: como usar Claude Code para automatizar, organizar e transformar seu vault do Obsidian em uma máquina de produtividade. Inclui skills prontas.
date: 2026-04-02
url: https://caminhosolo.com.br/2026/04/claude-code-obsidian-sistema-conhecimento/
tags: [claude-code, obsidian, automacao, produtividade, sistema-de-conhecimento, solo-builder]
---


## TL;DR

Você não vai organizar notas com IA. Você vai construir um sistema onde o Claude Code lê, escreve, organiza e executa workflows diretamente dentro do seu vault do Obsidian — como se fosse um operador que entende a estrutura do seu conhecimento.

**Resultado:** um vault que funciona como sistema operacional pessoal — não só armazena informação, mas transforma informação em ação.

---

## O que você vai construir

Ao final deste tutorial, você terá:

- Um vault do Obsidian com estrutura definida para operação automatizada
- Um arquivo `CLAUDE.md` que instrui o Claude sobre como se comportar dentro do vault
- Pelo menos 3 skills customizadas funcionando (weekly review, organização de inbox, transformação de ideias em conteúdo)
- Um sistema operacional de conhecimento que você pode operar diariamente via terminal

**Para quem é:** solo builders técnicos que já usam (ou querem usar) o Obsidian como base de conhecimento e querem ir além de "anotações bonitas" — querem um sistema que trabalha por eles.

**Tempo de implementação:** ~2 horas para o setup inicial, depois ~15 minutos por operação diária.

**Pré-requisitos:**
- Obsidian instalado (gratuito)
- Claude Code (assinatura Claude Pro ou superior)
- [Terminal básico](/2026/03/por-que-aprender-terminal) (navegar entre pastas, rodar comandos)

---

## Stack mínima necessária

| Componente | Custo | Função |
|---|---|---|
| Obsidian | Gratuito | Base do vault — onde seu conhecimento vive |
| Claude Code | $20/mês (Pro) | Agente que opera dentro do vault |
| Terminal (zsh/bash) | Nativo do OS | Interface de execução |

**Total mensal:** ~$20/mês (já considerando que você provavelmente tem Claude Pro)

Nenhum banco de dados externo, nenhum servidor, nenhuma ferramenta adicional. Tudo roda local.

---

## Arquitetura do sistema

```
┌─────────────────────────────────────────────┐
│              SEU VAULT OBSIDIAN              │
│                                             │
│  ┌─────────────┐    ┌──────────────────┐   │
│  │  CLAUDE.md  │───▶│  Claude Code     │   │
│  │ (cérebro)   │    │  (operador)      │   │
│  └─────────────┘    └───────┬──────────┘   │
│                             │               │
│         ┌───────────────────┼───────────┐   │
│         │                   │           │   │
│         ▼                   ▼           ▼   │
│  ┌────────────┐  ┌──────────────┐ ┌──────┐ │
│  │  Inbox/    │  │  Areas/      │ │Skills/│ │
│  │  (entrada) │  │  (conhecim.) │ │(auto) │ │
│  └─────┬──────┘  └──────┬───────┘ └──┬───┘ │
│        │                │             │     │
│        ▼                ▼             ▼     │
│  ┌──────────────────────────────────────┐  │
│  │         Output / Produtos            │  │
│  │  (artigos, docs, cursos, produtos)   │  │
│  └──────────────────────────────────────┘  │
└─────────────────────────────────────────────┘
```

**Fluxo de dados:**
1. **Entrada** → Ideias, notas, links, capturas vão para `Inbox/`
2. **Processamento** → Claude lê, organiza, conecta e transforma
3. **Armazenamento** → Conhecimento estruturado em `Areas/`, `Projects/`, `Resources/`
4. **Output** → Conteúdo pronto, produtos, documentação

**Pontos de falha:** Claude depende do CLAUDE.md para entender a estrutura. Se o CLAUDE.md for vago, o comportamento fica genérico. Essa é a parte crítica do sistema.

---

## Componentes principais

### 1. CLAUDE.md — O cérebro operacional

O `CLAUDE.md` é o arquivo que define **como o Claude se comporta** dentro do seu vault. Não é documentação — é instrução operacional.

**Responsabilidade:** controlar leitura, escrita, organização e execução de workflows.

**Localização:** raiz do vault do Obsidian.

### 2. Skills — Automações reutilizáveis

Skills são instruções guardadas em `.claude/skills/` dentro do vault. Cada skill define um workflow específico que pode ser executado repetidamente. Se você já conhece o conceito de [skills no Claude Code](/2026/03/skills-claude-code-guia-completo), aqui a aplicação é a mesma — mas operando dentro do seu vault como sistema de conhecimento.

**Responsabilidade:** encapsular lógica recorrente em execuções reutilizáveis.

### 3. Estrutura de pastas — A arquitetura do conhecimento

A organização do vault determina o que o Claude consegue fazer. Uma estrutura confusa = um sistema que não funciona.

**Responsabilidade:** fornecer mapa navegável para o agente.

### 4. Terminal — A interface de execução

Você opera o sistema pelo terminal. Não existe GUI para isso (ainda). Isso é feature, não bug — controle total.

**Responsabilidade:** disparar execuções, navegar o vault, rodar comandos.

---

## Fluxo completo de operação

```
Você abre o terminal
        │
        ▼
cd ~/meu-vault-obsidian
        │
        ▼
claude
        │
        ▼
Claude lê CLAUDE.md → entende a estrutura
        │
        ▼
Você pede: "roda a weekly review"
        │
        ▼
Claude lê skill correspondente
        │
        ▼
Claude executa:
  - lê notas da semana
  - identifica padrões
  - gera resumo
  - sugere ações
  - escreve output
        │
        ▼
Você revisa e aprova (ou ajusta)
        │
        ▼
Sistema atualizado. Pronto pra próxima operação.
```

**Pontos de decisão:**
- Você sempre pode revisar antes de aprovar
- Claude pergunta antes de sobrescrever arquivos importantes
- O CLAUDE.md define quando agir sem pedir permissão vs. quando consultar

**Timeline:** operações como weekly review rodam em ~5 min. Organização de inbox em ~3 min. Transformação de ideias em conteúdo em ~15 min.

---

## Implementação passo a passo

### Passo 1: Criar a estrutura do vault

Abra o terminal e crie a estrutura base do vault:

```bash
mkdir -p ~/vault-solo/{Inbox,Areas,Projects,Resources,Archives,Output,.claude/skills,.claude/agents}
```

Se você já tem um vault do Obsidian, substitua `~/vault-solo` pelo caminho do seu vault existente. Adicione as pastas que faltarem.

**Estrutura esperada:**

```
vault-solo/
├── Inbox/              ← capturas rápidas, notas soltas
├── Areas/              ← conhecimento contínuo (saúde, finanças, código)
├── Projects/           ← projetos ativos com início e fim
├── Resources/          ← referências, tutoriais, templates
├── Archives/           ← notas inativas ou concluídas
├── Output/             ← conteúdo pronto para publicação
├── .claude/
│   ├── CLAUDE.md       ← instruções do operador
│   ├── skills/         ← automações reutilizáveis
│   └── agents/         ← configurações de agentes
└── .obsidian/          ← configuração do Obsidian (já existe)
```

**Validação:** rode `ls -la ~/vault-solo/` e confirme que todas as pastas existem.

### Passo 2: Criar o CLAUDE.md

Este é o passo mais importante do sistema inteiro. O CLAUDE.md é onde você define o comportamento do agente.

```bash
touch ~/vault-solo/.claude/CLAUDE.md
```

Agora edite o arquivo com o conteúdo abaixo. Ajuste para o seu contexto:

```markdown
# CLAUDE.md — Vault Operacional

## Identidade
Você é o operador deste vault do Obsidian. Seu trabalho é ler, organizar,
escrever e executar workflows de conhecimento.

## Estrutura do vault
- Inbox/ → notas brutas, capturas, ideias soltas
- Areas/ → conhecimento contínuo organizado por tema
- Projects/ → projetos ativos (cada um em sua pasta)
- Resources/ → referências, tutoriais, templates
- Archives/ → conteúdo inativo
- Output/ → conteúdo pronto para publicação

## Regras de comportamento
1. Sempre perguntar antes de mover ou deletar arquivos de Areas/ ou Projects/
2. Pode organizar Inbox/ livremente (renomear, mover, categorizar)
3. Ao criar notas, usar formato: YYYY-MM-DD-titulo-curto.md
4. Nunca criar notas sem frontmatter mínimo (title, date, tags)
5. Ao resumir, manter o tom original — não "IAificar" o texto
6. Sempre manter links [[wikilinks]] quando fizer sentido

## Workflows disponíveis
Consultar .claude/skills/ para ver automações disponíveis.

## Formato de notas
Todas as notas devem ter frontmatter:
---
title: "Título"
date: YYYY-MM-DD
tags: []
status: draft | active | archived
---
```

**Validação:** abra o Obsidian, navegue até `.claude/CLAUDE.md` e confirme que o conteúdo aparece corretamente.

### Passo 3: Criar a primeira skill — Weekly Review

```bash
mkdir -p ~/vault-solo/.claude/skills/weekly-review
```

```bash
cat > ~/vault-solo/.claude/skills/weekly-review/SKILL.md << 'EOF'
---
name: weekly-review
description: Executa uma revisão semanal automatizada do vault
---

# Weekly Review

Executa revisão semanal do vault do Obsidian.

## Passos
1. Listar notas criadas nos últimos 7 dias em Inbox/, Areas/ e Projects/
2. Identificar notas sem tags ou com status "draft" há mais de 3 dias
3. Para cada nota, gerar um resumo de 1-2 linhas
4. Identificar conexões possíveis entre notas (sugerir wikilinks)
5. Listar projetos ativos e seu status
6. Gerar nota de resumo em Output/weekly-review-YYYY-MM-DD.md
7. Sugerir 3 ações prioritárias para a próxima semana

## Formato da saída
A nota de resumo deve conter:
- Notas da semana (com resumo)
- Notas órfãs (sem categoria clara)
- Projetos e status
- Conexões descobertas
- Ações sugeridas para próxima semana
EOF
```

**Validação:** rode o Claude no vault e peça "roda a weekly review". Ele deve seguir os passos definidos.

### Passo 4: Criar a segunda skill — Organizar Inbox

```bash
mkdir -p ~/vault-solo/.claude/skills/organizar-inbox
```

```bash
cat > ~/vault-solo/.claude/skills/organizar-inbox/SKILL.md << 'EOF'
---
name: organizar-inbox
description: Processa e organiza notas da Inbox automaticamente
---

# Organizar Inbox

Processa todas as notas em Inbox/ e organiza.

## Passos
1. Listar todas as notas em Inbox/
2. Para cada nota:
   a. Ler o conteúdo
   b. Classificar: ideia, referência, captura, tarefa, rascunho
   c. Sugerir destino (Areas/, Projects/, Resources/, Archives/)
   d. Adicionar tags relevantes se não tiver
   e. Adicionar frontmatter se não tiver
3. Apresentar plano de organização ao usuário
4. Após aprovação, mover arquivos e atualizar frontmatter
5. Criar nota de log em Output/inbox-process-YYYY-MM-DD.md

## Reglas
- Nunca mover sem apresentar o plano primeiro
- Manter o conteúdo original intacto
- Adicionar campo "source: inbox" no frontmatter
- Se a nota for sobre um projeto existente, sugerir adicionar ao projeto
EOF
```

### Passo 5: Criar a terceira skill — Ideias em Conteúdo

```bash
mkdir -p ~/vault-solo/.claude/skills/ideia-em-conteudo
```

```bash
cat > ~/vault-solo/.claude/skills/ideia-em-conteudo/SKILL.md << 'EOF'
---
name: ideia-em-conteudo
description: Transforma uma ideia anotada em rascunho de conteúdo estruturado
---

# Ideia em Conteúdo

Transforma uma ideia bruta em um rascunho de conteúdo estruturado.

## Entrada
- Caminho da nota com a ideia
- Tipo de output desejado: artigo | thread | email | documentação | landing page

## Passos
1. Ler a nota da ideia
2. Extrair: tema principal, problema que resolve, público-alvo
3. Criar estrutura de conteúdo baseada no tipo escolhido:
   - artigo: título, intro, 3-5 seções, conclusão
   - thread: hook, 5-8 tweets, CTA
   - email: assunto, abertura, valor, CTA
   - documentação: overview, setup, uso, exemplos
   - landing page: headline, problema, solução, features, CTA
4. Escrever rascunho em Output/
5. Adicionar frontmatter completo
6. Referenciar a nota original via wikilink

## Formato do rascunho
---
title: "Título provisório"
date: YYYY-MM-DD
type: artigo | thread | email | docs | landing
status: draft
source: [[nota-original]]
---

[rascunho completo]
EOF
```

### Passo 6: Instalar Claude Code e operar o sistema

Se você ainda não tem o Claude Code instalado:

```bash
# Instalar via npm
npm install -g @anthropic-ai/claude-code

# ou via Homebrew (macOS)
brew install claude-code
```

Agora, para operar o sistema:

```bash
# Navegar até o vault
cd ~/vault-solo

# Iniciar o Claude Code
claude
```

O Claude vai automaticamente ler o `CLAUDE.md` e entender a estrutura do vault. Agora você pode pedir operações:

```
> roda a weekly review
> organiza a inbox
> transforma a nota Inbox/ideia-saas-produtividade.md em artigo
```

### Passo 7: Configurar o Obsidian para reconhecer a estrutura

Abra o Obsidian e aponte para a pasta `~/vault-solo` como vault.

Em Settings → Files & Links:
- "Detect all file extensions" → ON (para o Claude poder ler/escrever tudo)
- "Use [[Wikilinks]]" → ON

Em Settings → Community Plugins (opcional mas recomendado):
- **Dataview** — para criar dashboards dinâmicos das suas notas
- **Templater** — para templates que o Claude pode preencher

---

## Execução prática

### Cenário 1: Weekly Review automatizada

**Situação:** É sexta-feira. Você capturou 12 notas durante a semana na Inbox. Algumas são ideias de produto, outras são referências técnicas, algumas são tarefas soltas.

**Execução:**

```bash
cd ~/vault-solo && claude
```

```
> roda a weekly review
```

**O que o Claude faz:**
1. Lê todas as notas dos últimos 7 dias
2. Gera resumo em `Output/weekly-review-2026-04-02.md`:
   - "12 notas processadas"
   - "3 ideias de SaaS identificadas"
   - "2 notas sem categoria → sugestão: mover para Areas/codigo"
   - "1 nota duplicada (mesmo tema, duas versões)"
3. Identifica conexões: "nota sobre MCP e nota sobre automação podem se conectar"
4. Sugere ações: "Projeto micro-saas-financeiro tem nota há 5 dias sem atualização"

**Tempo:** ~5 minutos. Semanal. Automatizável via cron job se quiser.

### Cenário 2: Organizar Inbox acumulada

**Situação:** Você tem 30 notas na Inbox acumuladas de 2 semanas.

```
> organiza a inbox
```

**O que o Claude faz:**
1. Lê as 30 notas
2. Classifica cada uma (ideia, referência, captura, tarefa)
3. Apresenta plano: "20 vão para Areas/, 5 para Resources/, 3 para Projects/, 2 para Archives/"
4. Após sua aprovação, move e organiza
5. Gera log

**Resultado:** Inbox zerada. Conhecimento organizado. Pronto para próxima rodada.

### Cenário 3: Transformar ideia em artigo

**Situação:** Você tem uma nota rápida na Inbox: "E se o Obsidian pudesse gerar meus relatórios semanais sozinho? Tipo um CEO assistant local."

```
> transforma Inbox/ideia-ceo-assistant.md em artigo
```

**O que o Claude faz:**
1. Lê a nota
2. Identifica o tema: automação pessoal com IA local
3. Gera estrutura de artigo
4. Escreve rascunho em `Output/artigo-ceo-assistant-local-2026-04-02.md`
5. Inclui frontmatter completo e link para a nota original

Você tem um rascunho de artigo em ~15 minutos, partindo de uma nota de 2 linhas.

---

## Monitoramento e controle

### Verificar saúde do sistema

Rode semanalmente:

```
> mostra o estado do vault: quantas notas em cada pasta, notas sem tags, projetos sem atualização há mais de 7 dias
```

### Custos operacionais

- Claude Code (Pro): $20/mês — ilimitado para uso local
- Obsidian: $0
- Terminal: $0
- **Custo total: $20/mês**

### Logs e rastreabilidade

Cada operação gera uma nota de log em `Output/`. Isso cria um histórico de:
- O que foi organizado
- O que foi criado
- O que foi sugerido
- Decisões tomadas

### Escalabilidade

O sistema funciona bem até ~5.000 notas. Acima disso, considere:
- Dividir vaults por domínio (trabalho, pessoal, projetos)
- Usar `.gitignore` para vaults grandes
- Configurar `CLAUDE.md` com instruções específicas por vault

---

## Monetização

### Modelo 1: Pipeline de conteúdo escalável

**Como:** Use a skill "ideia-em-conteúdo" como motor de produção. Toda ideia que aparece na Inbox vira um rascunho estruturado.

**Execução:**
1. Capture ideias durante a semana (sempre na Inbox)
2. Toda sexta, rode a skill em batch: `> transforma todas as ideias da Inbox em artigos`
3. Revise os rascunhos no fim de semana
4. Publique 2-3 artigos por semana com 1/10 do esforço manual

**Receita potencial:** se você monetiza via blog (AdSense, afiliados, produtos próprios), 2-3 artigos/semana consistentes geram tráfego orgânico crescente. Em 6 meses, isso pode significar $500-2000/mês em receita recorrente dependendo do nicho.

### Modelo 2: Documentação como produto

**Como:** Transforme o conhecimento organizado no vault em documentação vendável.

**Exemplos:**
- Notas organizadas sobre uma tecnologia → ebook ou curso
- Processos documentados → templates vendáveis
- Workflows validados → consultoria ou mentoria

**Receita potencial:** um ebook bem posicionado pode gerar $1000-5000 em vendas únicas. Um curso recorrente, $200-1000/mês.

### Modelo 3: Solo builder com sistema aumentado

**Como:** O vault como sistema operacional do seu negócio solo — uma abordagem complementar ao [Claude como operador invisível no backend](/2026/03/claude-operador-invisivel-negocio-solo), mas operando via filesystem em vez de API.

**Aplicações reais:**
- Usar o vault como base de conhecimento de um micro-SaaS (documentação, decisões, roadmap)
- Gerar specs de produto a partir de ideias capturadas
- Manter contexto entre sessões de trabalho (o Claude lembra o que está no vault)
- Automatizar relatórios para clientes (se você vende serviços)

**Receita potencial:** indireta, mas significativa. Se o sistema te faz 3x mais rápido, você consegue entregar 3x mais valor com a mesma quantidade de pessoas (você).

---

## Limitações e riscos

### Limitações técnicas

- **Claude Code é local:** não funciona como serviço cloud. Você precisa do terminal aberto.
- **Sem GUI:** tudo é por comando. Se você não gosta de terminal, a curva é maior.
- **Contexto limitado:** se o vault tiver 10.000+ notas, o Claude pode não processar tudo de uma vez.
- **Sem tempo real:** o Claude não "observa" o vault. Ele age quando você pede.

### Riscos operacionais

- **CLAUDE.md vago:** se as instruções forem genéricas, o comportamento será genérico. Invista tempo no CLAUDE.md.
- **Dependência do modelo:** se a Anthropic mudar preços ou features, seu sistema é afetado.
- **Dados locais:** se você perder o vault sem backup, perde tudo. Use Git para versionar o vault:

```bash
cd ~/vault-solo
git init
git add .
git commit -m "vault inicial"
```

### O que NÃO fazer

- **Não trate como assistente genérico.** O valor está na personalização via CLAUDE.md e skills.
- **Não pule a estrutura de pastas.** Sem ela, o Claude não navega direito.
- **Não sobrecarregue o vault.** Mantenha separação clara entre áreas.
- **Não confie cegamente.** Sempre revise a saída antes de publicar ou agir.

### Dependências de vendor

- **Claude Code:** dependência direta da Anthropic. Alternativas: Cursor (parcial), Copilot Workspace (limitado).
- **Obsidian:** pode ser substituído por qualquer editor de markdown + filesystem. O sistema não depende do Obsidian em si — depende da estrutura de arquivos.

---

## Diferencial: isso NÃO é organização de notas

Se você leu até aqui e pensou "isso é só um [Notion](/2026/03/notion-solopreneurs) com IA", leia de novo.

A diferença é que:

1. **O sistema opera no filesystem.** Não tem cloud, não tem vendor lock-in de plataforma, não tem "plano gratuito limitado". Seus arquivos são seus.

2. **O comportamento é programável.** O CLAUDE.md e as skills definem regras que são reutilizáveis. Não é "peça o que quiser e veja o que acontece" — é "siga estes processos e obtenha estes resultados".

3. **O output é tangível.** Não é "eu organizei suas notas bonitinho". É "eu transformei 30 notas em 5 artigos estruturados, 2 documentações e 1 roadmap".

4. **A vantagem é cumulativa.** Quanto mais você usa, mais conhecimento estruturado o vault acumula. Em 6 meses, você tem um sistema que entende seu negócio, seus projetos e seu conhecimento melhor do que qualquer ferramenta genérica.

Você não precisa de equipe. Você precisa de sistema.

---

## Perguntas frequentes

### Claude Code funciona offline?

Não. O Claude Code precisa de conexão com a API da Anthropic. O que roda local é o acesso ao filesystem (leitura e escrita do vault), mas o processamento de linguagem acontece nos servidores da Anthropic. Para rodar IA completamente offline, você precisaria de modelos locais como Ollama — mas a qualidade de compreensão e execução de workflows seria significativamente inferior.

### Preciso saber programar para usar Claude Code com Obsidian?

Não necessariamente. Você precisa saber navegar pelo terminal (cd, ls, rodar comandos básicos) e entender a estrutura de pastas. O CLAUDE.md e as skills são arquivos de texto em markdown — não código. Se você consegue editar um arquivo de texto, consegue configurar o sistema.

### Qual a diferença entre usar Claude Code e plugins do Obsidian?

Plugins do Obsidian (como Dataview, Templater) operam dentro do app e têm escopo limitado ao que o plugin oferece. O Claude Code opera no filesystem inteiro — ele lê, escreve, reorganiza e executa lógica condicional. É a diferença entre ter um assistente dentro de um app e ter um operador que controla o app inteiro.

### Claude Code ou Cursor — qual é melhor para automação de vault?

Claude Code é mais adequado para esse caso porque foi projetado para operar em filesystems com instruções definidas (CLAUDE.md). Cursor é um editor de código com IA embutida — excelente para programar, mas não otimizado para operar um sistema de notas como se fosse um workflow engine.

### Meu vault tem mais de 5.000 notas — o sistema funciona?

Funciona, mas com ressalvas. O Claude tem limite de contexto. Para vaults muito grandes, divida por domínios (vault-trabalho, vault-pessoal) e crie CLAUDE.md específicos para cada um. Também considere usar `.gitignore` para excluir pastas que não precisam de processamento.

---

## Próximos passos

1. **Execute o Passo 1 e 2 agora** (~15 min) — estrutura + CLAUDE.md
2. **Crie a skill de weekly review** (~10 min) — teste imediatamente
3. **Capture 5 ideias na Inbox esta semana** — material para testar
4. **Na sexta, rode a primeira weekly review** — veja o sistema funcionando
5. **Itere o CLAUDE.md** — ajuste com base no que funcionou e não funcionou

