Pro Tip

Build a Personal Research OS

A simple setup that captures everything you read, processes it while you sleep, and pushes the useful bits back to your phone. Obsidian for storage, Claude Code as the engine, Telegram as the mobile layer.

Browse the Tooling on GitHub How it works

Vault skills and pipeline templates being extracted to standalone MIT-licensed repos — follow the GitHub profile for releases.

The Why

If you read a lot — papers, articles, tweets, YouTube — and you don't have a system, you're losing most of it. Three things tend to break:

  • Capture is rough. Bookmarks pile up. Read-later apps become read-never apps.
  • Processing doesn't happen. Even if you save things, you don't sit down later to integrate them into what you already know.
  • Mobile is locked out. Your notes live on your laptop. When you're walking the dog, you can't query them.

A Personal Research OS fixes all three. It's not glamorous — it's plumbing — but it changes how much of what you read actually compounds.

The Setup

Five small layers, each doing one thing, communicating only through the file system. The vault is the shared state.

From inbox to your phone, fully automated

Capture
Web Clipper
+ Telegram bot
Process
/ingest
(every 4h)
Connect
/graphify
Synthesise
/teach
/video-teach
Deliver
Telegram push
  • Capture — Obsidian Web Clipper drops articles into 00-Inbox/. A Telegram bot picks up anything you send from your phone.
  • Process — A Claude Code skill (/ingest) runs every 4 hours, classifies inbox items, writes structured source notes, and updates related topic hubs.
  • Connect — /graphify turns folders into knowledge graphs on demand — useful for new codebases, reading lists, research corpora.
  • Synthesise — /teach writes cross-source teaching digests; /video-teach turns YouTube links into NotebookLM briefing PDFs.
  • Deliver — macOS LaunchAgents push finished digests to Telegram via a small Python bot. File events trigger the push, so there's no wasted polling.

Why It Works

A handful of small design choices do most of the heavy lifting. Take or leave any of them — but these are the ones I'd put in any version of this.

1. Treat the file system as your API

The five layers don't know about each other. They communicate only through files in the vault. A failing Telegram push doesn't corrupt source notes; a flaky ingest doesn't lose digests already in the outbox. Every layer is independently replaceable.

2. The schema is the program

The vault has a clear schema in CLAUDE.md — frontmatter shape, folder structure, tag taxonomy. The skills don't hard-code logic; they apply the schema. Change the schema once, all skills follow. That's where Claude Code's headless mode (claude -p "Run /skill") becomes powerful — give the model a strong schema and it stays consistent.

3. File events beat polling for local automation

macOS LaunchAgent's WatchPaths mechanism fires the moment a file lands. No idle compute, no scheduled polling, instant trigger. Use it whenever the trigger is "a file appeared somewhere." For external sources you don't control (e.g. Telegram), long-polling with a 50-second timeout per request gives near-instant message delivery without hammering the API.

4. Pair scheduled cadence with immediate mode

Most pipelines have a default cadence (e.g. Mon/Wed/Fri at 08:00) and a manual override. Send a YouTube link via Telegram, get the briefing PDF back in 5-10 minutes. Routing on input pattern — URL host, message keyword — lets one bot handle both without a separate command surface.

5. Reversibility, not just speed

The weekly lint and synthesis skills don't auto-apply hub edits. They write proposals first; you have 24 hours to apply or discard. Letting the LLM autonomously rewrite the wiki is fast but lossy. The proposal pattern keeps the speed and preserves an undo window.

6. Bots are agents in disguise

A Telegram bot that detects intent (URL type, keyword) and routes to chained workflows is functionally an agent — message in, multi-step pipeline out, result delivered. No LLM-in-the-loop required for the routing layer. The LLM does the heavy thinking inside the skills; the bot just orchestrates.

What You Get

After running this for a few months, the value lands in two places that compound. Everything else (push reliability, file counts, automation cadence) is plumbing.

~3-5 hours/week saved

Manual ingestion and synthesis are automated. The time goes into applying what you learn, not filing it.

Cross-project compounding

Sources ingested while working on one project routinely surface in another's topic hub. The wiki connects them automatically, so insights from one body of work inform another without you having to remember.

What's Next

The setup is stable enough to extend rather than rebuild. Three things in flight.

  • Open-source templates

    Extracting the Telegram pipeline and the Claude Code skills pattern as MIT-licensed standalone repos. Aim: anyone with a Mac can stand up the same setup in an afternoon.

  • Cross-vault query agent

    Querying the wiki is still manual — open Obsidian, search. The next layer is a Telegram-triggered query agent: send a question, get a synthesised answer with wikilinks back to supporting sources.

  • Always-on hosting

    The current limitation is that the Mac has to be awake. Migrating the poller and the scheduled skills to a cheap VPS would lift that, with the vault synced via git. Not urgent, but the obvious next step when the laptop-closed gap starts biting.