Updated 2026-01-13: Clarified that folder names can differ between computers (it’s the Folder ID that matters), simplified path examples throughout.

A friend and I both run Claude Code with Obsidian vaults. We keep discovering things independently—useful prompts, workflow patterns, CLAUDE.md snippets—then sharing them over chat. Screenshots, code blocks, “here’s what worked for me.”

This is inefficient. The insights are scattered across message histories. Neither of us can search them. Good ideas get lost.

The obvious fix: a shared folder that lives in both our vaults.

Syncthing

Syncthing keeps folders in sync between computers. Think Dropbox, but:

  • No account to create
  • No cloud server in the middle — files go directly between your computers
  • Free, open source, runs locally

You install it on both computers, tell it which folders to sync, and it handles the rest. When you save a file, it appears on your friend’s computer within seconds (as long as you’re both online).

Why this works well:

  • Zero friction once set up — just save files
  • The folder lives in your Obsidian vault, so you can link to it from other notes
  • Nothing goes through a third party

Limitations:

  • Both computers need to be online at the same time for sync to happen. If your friend’s laptop is off, changes queue up and sync when they come back online.
  • No built-in version history — if you delete something, it’s gone (unless your friend still has it, or you have backups). That said, if you run automatic git commits on your vault (e.g., hourly via cron), you get versioning of your copy as a side effect. If your friend deletes a file and Syncthing propagates the deletion to your machine, you can recover it from your git history — as long as a commit ran before the deletion synced over.

Folder Structure

Name the folder whatever you want — I use Shared - [Friend's Name]/ so it’s clear who I’m sharing with. Your friend can name theirs differently (see “Setting Up the Shared Folder” below for how this works).

Suggested internal layout:

Shared - [Friend's Name]/
├── Claude Code/
│   ├── Prompts.md           # Good prompts that worked
│   ├── CLAUDE.md Snippets.md # Reusable context file sections
│   └── Workflows.md          # Multi-step patterns
├── Discoveries/
│   └── [dated entries].md    # "Found this today" notes
└── Questions.md              # Async back-and-forth

Structure Conventions

Agree on a few rules upfront:

  1. Namespacing: Prefix files with your initials if you’re both adding to the same folder. Or use subfolders per person.

  2. Dating discoveries: 2026-01-13 - Vim mode trick.md makes the timeline scannable. Add initials if you want attribution.

  3. Questions file: A shared scratchpad for async “have you figured out X?” exchanges. Cheaper than switching to chat.

  4. Prompts format: When adding a prompt, include context—what it’s for, when it works well, any caveats.

Example:

## Summarise with page references
Use when: You want a summary of a long document with citations back to source.

Prompt:
> Summarise [file] in ~500 words. For each major point, include the
> page number or section heading where you found it.

Notes: Works well for PDFs. Less useful for unstructured text dumps.

What About Conflicts?

If you both edit the same file simultaneously, Syncthing creates a .sync-conflict file rather than overwriting. Rare in practice—you’re typically adding new files, not editing the same one at the same time.

If conflicts become common, switch to an append-only pattern: each person has their own files, and you read each other’s rather than editing shared ones.

Privacy Considerations

Everything in this folder is visible to both people. Don’t put anything here you wouldn’t share with your friend.

If you want selective sharing, use Syncthing’s ignore patterns (.stignore) to exclude specific files from sync.

Git Considerations

If you version your vault with git, the shared Syncthing folder creates a decision point. You have three options:

Option 1: Include in git (both repos track it)

Both people commit the shared folder to their vault’s git history.

# No .gitignore entry needed

What happens:

  • Your commits include changes your friend made (via Syncthing)
  • Their commits include changes you made
  • Both repos have the full history, but with different commit authors

Problem: The history gets confusing. A file your friend wrote appears in your commit because Syncthing delivered it before you committed. Git blame shows you as the author of their work. If you diff between commits, shared folder changes are mixed in with your personal vault changes.

When it works: If you’re both comfortable with intertwined history and don’t care about clean attribution.

Add the shared folder to .gitignore in both vaults.

# .gitignore
Shared - */

What happens:

  • Git ignores the folder entirely
  • Syncthing handles all sync for that folder
  • Your vault’s git history only contains your personal files

Benefits:

  • Clean separation: git for your stuff, Syncthing for shared stuff
  • No attribution confusion
  • Smaller repo size (no duplicate content in both people’s git history)
  • Simpler diffs and commits

Downside: No version history for the shared folder beyond Syncthing’s conflict files. If you accidentally delete something, it’s gone (unless your friend still has it, or you have separate backups).

Mitigation: If you want version history for the shared content, one person can maintain a separate git repo just for the shared folder:

cd "Shared - Friend/"
git init
git add .
git commit -m "Initial shared knowledge base"

This gives you history without polluting your main vault repo. The other person doesn’t need to touch it—Syncthing delivers the .git folder too (unless you .stignore it).

Option 3: One person tracks, one ignores

Asymmetric setup: one vault includes the shared folder in git, the other excludes it.

When this makes sense:

  • One person cares about version history, the other doesn’t
  • One person is the “archivist” who maintains the canonical history

Setup:

  • Person A: normal git tracking of the shared folder
  • Person B: adds folder to .gitignore

Person A’s repo becomes the source of truth for history. Person B gets the live content via Syncthing but doesn’t maintain git history locally.

Recommendation

Option 2 (exclude from git) is cleanest for most setups. Let each tool do one job: git for your personal vault versioning, Syncthing for shared folder sync. If you need history for the shared content, initialise a separate repo inside the shared folder.

Getting Started

Installing Syncthing

macOS (Sequoia 15.x):

Option A — Homebrew (recommended):

brew install syncthing
brew services start syncthing

This installs Syncthing and runs it as a background service that starts automatically on login.

Option B — Standalone app:

  1. Download Syncthing for macOS (the “macOS” link under “Base Syncthing”)
  2. Move to Applications
  3. Open it — it runs in the menu bar
  4. On first launch, macOS will ask for permission to access folders. Grant it for your Obsidian vault location.

Note: macOS 15 may show a security prompt (“Syncthing is from an unidentified developer”). Go to System Settings > Privacy & Security and click “Open Anyway”.

Linux (Ubuntu/Debian):

sudo apt install syncthing
systemctl --user enable syncthing
systemctl --user start syncthing

Windows: Download the installer from syncthing.net/downloads or use:

winget install Syncthing.Syncthing

Accessing the Web UI

Syncthing runs a local web interface at http://localhost:8384. This is where you configure devices and folders.

  • macOS (Homebrew): Open http://localhost:8384 in your browser, or click the Syncthing icon in the menu bar
  • macOS (standalone app): Click the menu bar icon → “Open Web UI”
  • Linux: xdg-open http://localhost:8384 or just open the URL in a browser

Connecting Two Devices

  1. On each device, open the Syncthing web UI
  2. Go to Actions (top right) → Show ID
  3. Copy your Device ID (a long alphanumeric string)
  4. Exchange IDs with your friend (via chat, email, whatever)
  5. On each device: Add Remote Device → paste the other person’s ID → Save
  6. Both devices need to accept the connection

Setting Up the Shared Folder

Important concept: Syncthing doesn’t care what you name the folder on your computer. It uses a Folder ID to know which folders should stay in sync. You and your friend can have completely different folder names and paths — as long as you use the same Folder ID, Syncthing treats them as the same folder.

Example:

  • Alice’s path: /Users/alice/Notes/Shared - Bob/
  • Bob’s path: /Users/bob/Obsidian/Shared - Alice/
  • Both use Folder ID: shared-knowledge

The contents stay identical. The names don’t matter.

Steps:

  1. Create a folder in your vault. Name it whatever makes sense to you (e.g., Shared - [Your Friend's Name]/)
  2. In Syncthing web UI: click “Add Folder”
  3. Folder ID: Pick something short, like shared-knowledge. Tell your friend this ID — they’ll need to use the exact same one.
  4. Folder Path: Click Browse and select the folder you just created (or paste the full path)
  5. Sharing tab: Check the box next to your friend’s device
  6. Save

Your friend does the same on their end: creates a folder wherever they want, adds it in Syncthing with the same Folder ID, and shares it with your device.

Once both sides are set up, Syncthing connects them automatically. First sync takes seconds. After that, it’s invisible — save a file, it appears on your friend’s computer.