Systems & tools

Build a life OS in plain text files

The most durable life OS you can own is a folder of text files and a Sunday half hour. The full build: the structure, the note types, the naming rules, how the pieces connect without a single plugin, and where this honestly stops.

Aleem O'BalogunBy Aleem O'Balogun|Updated |9 min read

The short answer

To build a life OS in plain files, make a small folder tree (an inbox, one note per life area, one page per week), write in plain markdown, and run a weekly rhythm: capture into the inbox all week, then spend a Sunday half hour turning what gathered into next week's page. The files are the memory; the weekly page is the part that makes it an operating system.

Steps

  1. 1

    Make the skeleton in five minutes

    One folder, three things inside: an inbox.md, an areas folder, a weeks folder. That is the whole starting structure, and it is deliberately smaller than feels serious. The minimum viable starter runs on exactly this; the grown version below adds folders only where real weight demands them.

  2. 2

    Give capture one file

    Everything lands in inbox.md: one line per thought, no sorting, no headings, no ceremony. The inbox is deliberately dumb because capture has to be frictionless or it stops happening. Filing is Sunday's job, and most lines will not deserve filing at all.

  3. 3

    Write a charter for each area that earns one

    When a part of life keeps turning up in your weeks (health, money, the people you are close to), give it one note: what this area is for, what good looks like this season, and its standing anchors. Not a dashboard, a charter. Most lives need four to six, and none on day one.

  4. 4

    Run the weekly page

    This is the operating system part. Every Sunday, half an hour: read the inbox, look four weeks ahead, and write one page for the coming week: what you noticed, the three to five things that matter, one line at the end of the week about what you learned. The full weekly method applies unchanged.

  5. 5

    Grow only under pressure

    Add a quarters folder when goals earn it, a reference folder when slow-changing lists pile up, an archive when finished things get in the way. Structure added before the pile exists is decoration, and decoration in a filing system is debt. The tree below is the grown shape most lives eventually reach, not the starting requirement.

Why plain files, of all things

Every other substrate you could build on will ask something of you eventually: a subscription, a migration, a proprietary format, a company still existing. A folder of text files asks nothing. It opens on any machine you will own for the rest of your life, in any editor, with no account, and it will open just as readily in thirty years, which is not a claim any app can honestly make. If owning your own data matters to you, plain text is not one option among several; it is the reference standard everything else is measured against.

There is also a quieter argument: plain files keep the system honest. With no views to configure and no widgets to arrange, the only thing left to build is the thing that actually works, which is a small structure and a weekly rhythm. The lineage here is real: Daniel Miessler's LifeOS runs on markdown files, Tiago Forte's PARA was designed to work in any folder system, and decades of plain-text planners quietly predate both. This guide assumes you know what a life OS is and whether building one is right for you; from here on, it is just the build.

The architecture: a tree that mirrors a life

The grown structure is six folders and a file, and every part has one job. The inbox catches things. The areas folder holds one charter per part of life that has earned one. The weeks folder holds one page per week, which is where the system actually lives. Quarters hold a goals sheet each, reference holds the slow-changing lists (the reading queue, the gift ideas, the policy numbers), and the archive holds everything finished, because nothing gets deleted, only moved.

Note types stay deliberately few: an inbox line, an area charter, a weekly page, a quarterly goals sheet, a reference list. Each has a template in the pack, and none needs more than plain markdown: headings, lists, and the occasional bold. The naming rules matter more than they look: ISO dates and week numbers (2026-W31, 2026-Q3), lowercase, hyphens instead of spaces. Sortable by name is findable by eye, and findable by eye is what replaces an app's search index.

The life OS folder structure, grownfolder-structure.md · free to copy, yours to keep
# The life OS folder structure

Grown from the minimum viable starter (inbox, areas, weeks). Add a
folder only when a real pile demands it; empty structure is debt.

    life/
      inbox.md            <- everything lands here, one line each
      areas/              <- one charter per area that has earned one
        work.md
        health.md
        money.md
        people.md
        joy.md
        growth.md
      weeks/              <- one page per week, named by ISO week
        2026-W31.md
      quarters/           <- one goals sheet per quarter
        2026-Q3.md
      reference/          <- slow-changing lists and documents
        reading-list.md
        gift-ideas.md
        insurance.md
      archive/            <- finished things, moved not deleted
        2025/

## The rules that keep it standing

    - Names: ISO dates (2026-W31, 2026-Q3), lowercase, hyphens,
      no spaces. Sortable by name is findable by eye.
    - New note? It goes in inbox.md first unless you already know
      its home. Filing is the weekly session's job.
    - Nothing is deleted; it is archived. Deleting takes a
      decision, archiving takes a keystroke, and the archive is
      where this year's review reads last year's evidence.
    - The structure serves the weekly page. If a folder has not
      been touched in a month and the weeks still run, it was
      decoration; fold it back in.

The starter's three folders, grown to the full working structure: areas with charters, weeks, quarters, reference, and an archive. Copy the tree and delete what your life does not need yet.

The weekly page is the operating system

A folder tree, however tidy, is storage. What turns storage into an operating system is a loop that runs on a schedule, and in this build the loop is one page and one half hour. All week, capture into the inbox. On Sunday, sit down with three inputs: the inbox, the calendar four weeks out, and last week's page. Read them, notice what actually needs attention (the deadline drifting closer, the friend not seen in a month, the area gone quiet), and write the week: three to five priorities, placed and sized honestly. At the end of the week, one line: what did this week teach you?

That is the notice loop run by hand, and the point of the structure above is to make the half hour easy: the inbox means nothing is lost, the charters mean each area's intentions are one file away, last week's page means you start from evidence. People who abandon plain-text systems almost never abandon the files; they abandon the Sunday. Protect the half hour the way you would protect any standing anchor, because it is the only moving part this machine has.

The ways plain-file systems fall apart

The substrate never fails; the failure modes are all human, and all designable-against:

  • The empty cathedral: a beautiful tree with no weekly page in it. Structure stores a life. Only the rhythm runs one. Build less, run more
  • The reorganising itch: redesigning folders instead of running weeks. If the weeks run, the structure is finished, whatever it looks like
  • The unemptied inbox: capture that nothing ever reads back. The Sunday read is the system. Miss it twice and restart there, not with new folders
  • The premature tooling: adopting plugins, scripts and sync machinery before the habit exists. The habit is portable. Eight weeks of weekly pages first, tooling after
  • The write-only archive: pages filed and never reread. Last week's page opens every Sunday, the year's pages open at the annual review. Files nobody rereads are storage, not memory

Where a built tool honestly beats this

Run well, this build does more than most software: it holds your whole life in files you own, costs nothing, and cannot be discontinued. What it cannot do is notice for you. The files hold the birthday, the drifting deadline and the quiet area, but nothing reads across them on a Wednesday; every act of noticing spends your attention, which is exactly the resource a full week has least of. That is the honest line between a system you run and software that runs one with you: asambl is one implementation of the same loop, where the noticing across areas is done deterministically and a drafted week is proposed for you to judge, with your data still in files on your machine.

If your Sunday half hour reliably happens, you may want nothing more than this folder, and that is a fine place to land. The point of the library is the loop, not the licence.

Sources

checked 26 July 2026

Framework credits verified against their authors' own sites, accessed 26 July 2026.

  • Daniel Miessler, LifeOS: the best-known plain-markdown life OS, and the source of the term's current usage.
  • Tiago Forte, The PARA Method: the filing lineage behind areas-based folder structures.
  • The weekly page's ancestry runs through Ryder Carroll's Bullet Journal migration, the monthly reread that inspired weekly noticing by hand.
← All guides