John Saad

Play · The Machine Behind It

PlainTextOS

A personal, terminal-native AI operating system: one assistant, a whole life’s context, plain files owned forever.

Every AI chat starts from zero. It does not know what you decided last Tuesday, which project is quietly on fire, or what your rules are; so you re-explain your life every session, and it hands back generic answers to specific problems. I got tired of employing a brilliant amnesiac.

So I built it an operating system. Not a kernel in the classical sense, but a life layer: a git-tracked vault of markdown where every fact and decision has one home, a rules file the assistant loads before it acts, small command-line helpers that let it read my real inbox and real calendar and real bank ledger, and a set of rituals that keep the whole thing honest. It lives in the terminal, because the terminal is where tools compose.

The result reads like science fiction and runs like plumbing. My mornings open with a briefing that already knows the day; my captures file themselves under the right project from whatever device is nearest; my sessions end with the record updated, the work committed, and tomorrow’s first move named. The machine serves the life, and the life is mine.

Not a mockup. This is the whole loop: boot, capture, one confident next, wind-down. The assistant already knows the day.

The parts

✦ THE VAULT memory one folder of files THE KERNEL boot, already briefed SENSES eyes on real surfaces THE BAR the OS at a glance RITUALS boot briefing · wind-down VERBS named routines as playbooks TASKS one confident next
The seven parts. Arrows show which way the facts flow: senses, verbs, and rituals write into the vault; the kernel, tasks, and the bar read out of it.
1

The kernel

one rules file, auto-loaded

A single file of house rules the assistant reads before it touches anything: how I write, what it may never delete, what “wrap up” means. When it gets something wrong, the correction becomes a rule with a date; the kernel is a constitution that grows one amendment at a time.

2

The vault

plain markdown, git-tracked

Every fact, decision, and open thread lives in one canonical markdown file among a few hundred, indexed and cross-linked; git gives it history, sync, and an audit trail. Ask what we decided in March and it quotes the file, with the date.

3

Tasks

a file, not an app

The task store is a local JSONL file with an auto-ranked queue; urgency, impact, and staleness are computed, not curated. “What’s next” returns one confident answer. Capture works from the terminal, the phone, or the watch, and everything lands under a project.

4

Senses

small CLIs for real surfaces

Email, texts, calendar, contacts, finances, deploys; each is a small command-line helper the assistant can read, so triage becomes a conversation. Reads are free; anything that sends or deletes is gated behind an explicit confirmation.

5

Verbs

skills as playbooks

Named routines written down as playbooks: walk the inbox, rank the queue, wind down the session. Say the phrase and the whole procedure runs; refine the playbook and the OS gets permanently better at that verb.

6

Rituals

the habits that keep it honest

A briefing at boot with the day’s state; a wind-down at close that updates the docs, commits, journals the session, and names tomorrow’s first move. The journal even classifies the misses: detour, rest, or avoidance.

7

The bar

ambient awareness

A one-line status bar under the terminal: project, focus, unread mail, texts, next meeting. Every segment reads a local cache and never blocks; the whole OS is visible at a glance without opening a single app.

The principles

  1. 01Files over apps; plain text you own outlives every platform.
  2. 02One context; a life is one system with one index, not silos.
  3. 03Terminal-native; what lives in the shell composes.
  4. 04Read before act; written rules beat remembered preferences.
  5. 05Rituals over discipline; the system survives on habits, not willpower.

Build your own

PlainTextOS is not a product; you cannot install someone else’s life. It is a method, and the method is teachable: the vault, the kernel, the task store, the senses, the verbs, the rituals, built in a weekend and grown for a lifetime.

I turned that method into a course, and then I did the thing no course does: I made it install itself. Every module ships a setup file you hand to your own AI assistant. It interviews you, builds that piece on your machine, and proves it works before you move on. You are not reading about an OS. You are assembling yours, with the same assistant that will run it.

The first builders get more than the modules: lifetime updates as the OS grows, a direct line to me, and their setup reviewed by hand. Leave your email and you will be first through the door.

And a promise only this course can make: every module ends in a check you run with your own eyes. Do the Assembly Weekend, and if by Sunday night your assistant is not briefing you on your own day and closing your loops, email me inside thirty days for a full refund. You keep the Starter Kit either way. And if you would rather have it built with you, hands-on, there is a tier for that too.

Or start for free, right now: the first piece needs nothing but a terminal and twenty minutes, and at the end your assistant will tell you something true about your own life from memory. Install your first piece.