It schedules your attention. Allocates your energy. Caches your beliefs. Drops packets called “sleep.”
It has background processes (anxiety), memory leaks (doomscroll), and a perfectly functional kernel… that nobody bothered to document.

So I’m building self.md: a markdown-first Personal Operating System for the AI age — in public.

Not a productivity blog. Not a Notion template zoo.
More like: patch notes, protocols, crash reports, and a growing folder of systems that actually run.

What is self.md?

self.md is a set of plain-text primitives (files, folders, rules) + automation hooks + AI workflows that treat your life like infrastructure.

Think:

• Markdown as your filesystem

• AI as your operator (not your replacement)

• Protocols as reusable functions

• Review loops as cron jobs

• Decisions as commits

• Reality as an unreliable API

The goal isn’t to “be more productive.”
The goal is to be more sovereign: less brittle, less dependent, more executable.

Why now?

Because the old stack is collapsing into two extremes:

1. SaaS productivity theater
   Pretty dashboards. Broken cognition.

2. AI everywhere, context nowhere
   You can’t delegate your life to a chatbot that forgets you every session.

We need something in between:
A local-first personal system where AI can help—without owning your memory.

What you’ll get here (the menu)

This publication will ship in a few repeating formats:

1) Patch Notes

Short, frequent updates like:

• v0.1.1: inbox capture simplified

• v0.1.2: daily review now outputs 3 files + 1 action list

• v0.1.3: removed ritual, kept the function

2) Protocols

Copyable workflows: minimal, testable, versioned.
If it can’t be explained as a procedure, it’s probably vibes.

3) Crash Reports

Monthly post-mortems:

• what broke

• why it broke

• what I changed

• what I reverted

4) Field Tests

Experiments with:

• markdown-native task systems

• “life as code” automation

• local AI agents that operate on files

• decision logs and memory scaffolding

Who this is for

If any of these sentences feel uncomfortably true:

• “My tools are organized. My brain isn’t.”

• “I have systems. I don’t have an OS.”

• “I want AI help, but I don’t want my life in someone else’s cloud.”

• “I want simple, hackable primitives — not a ‘second brain’ lifestyle brand.”

Welcome.

The minimal philosophy (so we don’t drift)

A Personal OS should be:

• Plaintext-first (portable, durable, grep-able)

• Composable (small parts that combine)

• Local-first (your data lives with you)

• Versioned (you can rollback bad ideas)

• Observable (logs > feelings)

• Boring enough to run daily (and weird enough to stay alive)

What ships next

Over the next posts, I’ll publish:

1. The folder structure (the filesystem of self.md)

2. The capture pipeline (how raw inputs become actions)

3. The weekly review as a compiler (turning chaos into output)

4. The AI operator rules (what it’s allowed to touch, and what it never touches)

Join the experiment

If you want to participate, hit reply (or comment) with:

1. Your current “life stack” (Obsidian? plain .md? Cursor? paper?)

2. Your biggest failure mode (memory, follow-through, context-switching, etc.)

3. One thing you’d like an OS to do for you automatically

I’ll use that to prioritize what to build + document first.

Until then:
keep your logs, respect your bandwidth, and never trust an unversioned belief.

— Ray / shmlkv / self.md

Subscribe now