The System — how it actually works

The components that make it work

Everything below is a piece I actually run. It starts with the spine that ties them all together — the daily note.

The document vault

Underneath every intelligent system is a boring, beautiful thing: a well-structured document vault — plain files, in a deliberate shape, that both you and AI can navigate. Structure isn't bureaucracy; it's what makes the data findable, linkable, and trustworthy.

calendar/
└─ 2026/ └─ Q2/ └─ 06 - Jun/
   └─ 2026-W26/ └─ 2026-06-29 Mon/
      # daily note = index of the day
      transaction_…  scan_…  debrief_…

personal/  # career, health, finances, travel…
business/  # the companies
family/    # shared
   ├─ 1-plan/      # thinking
   ├─ 2-active/    # current
   ├─ 3-history/   # archived
   └─ 4-insights/  # analysis

A small vocabulary of capture types

Most notes apps give you one bucket: "a note." But a fleeting idea, a decision, a task, and a reflection are different things that deserve different handling. So every capture has a type — and that one label is what makes the pile sortable, queryable, and promotable later. AI (or you) tags it at the moment of capture.

Why bother? Because a typed capture is data, not just text: you can pull "every open question_", "all decision_ records this year", "unresolved action_s" — instantly. The type is a tiny act of structure at capture time that pays off forever after.

Why metadata matters — even for a personal system

"Metadata" sounds like enterprise jargon. It just means the facts about a thing — when a photo was taken, where, by which camera; who a note is about; what a document is for. You don't need a data platform to benefit. The moment your own stuff carries a little structured data, it stops being a pile and becomes searchable, sortable, answerable.

Reading the vault with Obsidian

A pile of markdown files becomes a navigable knowledge base in Obsidian — links between notes, a graph of how everything connects, and live views built from the data itself. The same plain files an AI reads, you read as a connected web.

---
type: agreement
vendor: Hetzner
amount_eur: 4.20
cycle: monthly
status: active
tags: [backup, eu, infra]
---

```dataview
TABLE vendor, amount_eur, cycle
FROM #agreement
WHERE status = "active"
SORT amount_eur DESC
```

Frontmatter makes notes data; Dataview makes that data visible; the AI layer makes it actionable. Three views of the same structured files — for the eye, for the query, and for the assistant.

# in a trip note
Dinner at [[Don Camillo]] with [[Annemarie]],
booked via [[Ortigia 2022]] — see [[hotel-quality]].

A graph is just structure made visible — and structure is what lets an AI navigate your knowledge instead of hallucinating around it. Every link you make is a hint you leave for your future assistant.

Plain files, versioned, reachable anywhere

The whole system rests on a deceptively simple choice: store everything as markdown. From there, version it like code, and reach it from every device through one AI layer.

Trust comes from checking, not hoping

AI generates; it also gets things wrong. The difference between a toy and a system is that a system validates its own output — continuously — and keeps improving. This is the discipline most "AI productivity" never mentions.

It's a double loop: rules check the output, and the checks themselves get reviewed and improved. Borrowed straight from data-quality engineering — and the reason the output stays reliable as the system grows. You must check the auto-generated results. Continuously.

If input is the price, make input cheap

Training the system takes a lot of input — so the friction of getting it in matters enormously. Typing is the slow path. The trick is to capture by the fastest means available and let the structure absorb it.

Freedom at the input, discipline in the structure. The easier it is to feed the system, the more it knows — and the smarter the assistant gets.

Your voice, your no-list, your lessons — as files

The hardest things to get from AI — sounding like you, avoiding your pet hates, not repeating yesterday's mistake — aren't prompting tricks. They're files. Once captured, they apply every time, automatically.

Voice, anti-style, mistakes — three files that turn the most human, hardest-to-pin-down parts of working with AI into durable structure. Write it once; it applies forever.

Applications, already in the vault

Not a roadmap — what's running today. Dozens of small, connected applications on one foundation, each turning a source into something useful.

Enterprise-grade data tools, for the rest of us

The same class of technology that powers large data platforms now runs on a laptop — for almost nothing. This is what makes governed, powerful systems possible beyond the enterprise.

The point isn't the tools — it's that the gap between "enterprise data platform" and "what one person can run" has collapsed. Structure is now affordable for everyone willing to build it.

Everyday tools, wired into one system

You already use the right tools — calendar, drive, CRM, photo and book libraries. The leverage comes from making them talk: each is a source or a surface feeding one connected brain, instead of a silo.

A calendar entry, a photo's location, a CRM contact and a book highlight stop being four separate apps — and become one fact the system can reason over.

Exchange: how data comes in, and how you share it out

A private system still has to meet the world. The trick is a clean, deliberate boundary — a controlled inbound for what comes in, and a publication layer for what goes out — so your private core stays private and only what you choose is shared.

Inbound and outbound are the same idea from two sides: a deliberate boundary that lets a sovereign personal system still collaborate — without surrendering control of the whole.

Curated Sources

Not all inputs are equal. A Curated Source is a person, publication or collection you've deliberately judged worth trusting — scored for relevance and quality — and fed to the system as a filter. The opposite of drinking from the firehose: a chosen, structured layer of inputs the AI can lean on.

Because you chose them, they're a signal of your taste — exactly what an AI needs to recommend like you would. Curated Sources turn "what I trust" into structured input. Generic AI averages the internet; this points it at the few sources that actually match you.

Personas — one engine, many selves

An architectural idea that falls out naturally once structure is clean: separate the data from the preferences, rules and history. The vault engine stays the same; the persona loaded on top is swappable.

Copy the vault, load a different persona — different interests, history, anti-preferences — and the same machine reasons as a different person. You can build the architecture once and serve many people, import sensible starter rule-sets for a life-stage, or simply see the world through another lens. The cleanest proof that data and judgement are separate things. (A direction I'm designing — vision, not yet built.)

Building blocks: where your data lives, and who controls it

A powerful personal system is worthless if you don't own and protect what's in it. Sovereignty, privacy, and backup aren't an afterthought — they're the foundation everything else sits on. The governance discipline, applied to your own life.

Each is a building block. Stack them and you get something rare: a powerful, AI-ready personal system you actually own — private, portable, and resilient by design.

One method, every corner of life

The same structure-first approach turns each area of life from a pile of stuff into a system that knows your taste — and your favourites.