A talk on personal AI systems

Principles of a personal operating system.

The tools are the least interesting layer. Eight principles from seven months of building a personal AI system, and a look inside mine.
Isabella Isotta
Principles of a personal operating system.
Before anything else

Claude is my ______.

Finish the sentence. One word only.
Why the word matters

A tracker is not a butler, and a butler is not a thought partner. The word you pick says a lot about what you have actually built - and what you haven't.

Collect five or six words from the room.
The one thing I want to shift

Where the leverage actually lives.

What I thought when I started
  • Using AI well means picking the right tools
  • and writing good prompts
  • so the skill to learn is prompting, and the decision to make is which subscription to buy
What I think now
  • The tools are the least interesting layer - the leverage is in the system you design around how you think
  • This year's word for it is the harness - and everyone's building them for companies. This talk is about building your own
  • A personal harness is made, not picked - and the design principles are learnable
Everything that follows is evidence for the right-hand side.
Three relationships, three costs

Extend, replace, or gap-fill?

Every piece of a setup does one of three things to a faculty you already have. Only one of them costs you anything.
Extend
The thinking still runs through your head - you just get further with it. An essay draft comes back with the three notes in my own vault that argue against it. The argument is still mine to make.
Gap-fill
It does something you never could. Pure gain. A morning briefing that has read forty sources before I'm awake. No version of me was doing that.
Replace
It does the thinking and you collect the output. The faculty atrophies. Summarising: hand every long read to a model and the muscle for reading a hard argument start to finish goes quietly.
Which losses actually matter

Retiring a faculty on purpose is legitimate. The test - is it still owed of you unassisted, in rooms the system cannot enter, and was it strong before? Both yes, protect it. Otherwise delegate without guilt.

Ask it of a faculty, not an activity - and make retention a decision, not an accident.
A 20-second detour into philosophy

A thought experiment.

Clark and Chalmers, 1998. Inga hears about an exhibition, remembers the museum is on 53rd Street, and sets off. Otto has Alzheimer's, keeps every address in a notebook he carries everywhere and trusts completely, looks up the same street, and sets off.
The question

Inga's belief lived in her head. Otto's lived in the notebook. Both walked to the same door for the same reason - so what, exactly, is the difference between where their minds stop?

Tools have always extended thinking. This is the first one general enough to extend almost any faculty you point it at.
One picture before the principles

The whole thing, in four layers.

The substrate
Plain markdown files in flat numbered folders, in a git repository on my machine - every note, essay, lecture, person and task. Pushed to a private mirror every 15 minutes, without my touching it.
The machinery
Scripts and scheduled jobs that move things deterministically - transcription, filing, syncing, backup. No model involved, because none is needed.
The intelligence
Claude Code reading the same files: skills for repeat jobs, agents for the judgment calls, and hooks that check its work on every write.
The connections
MCP servers into mail, calendar and files, plus a browser for anything behind a login. All swappable, and deliberately the easiest part to tear out.
Live: the vault open in Obsidian, and the same folder in Terminal - no database anywhere.
Principle 1 of 8

1 · Own the memory, rent the reasoning.

The principle

The durable half of the system is memory - notes, history, corrections, structure - and it lives in plain text on your machine. The reasoning is compute you rent by the month, and it should be swappable without touching a single file. Never let the thing that thinks own the thing that remembers.

  • Markdown, folders and git are fully portable. The record itself has no lock-in at all.
  • MCP is an open standard, so the integrations mostly travel between tools too.
  • The tool-specific glue - hooks, permissions, skills - took real time to build, and I won't pretend it rebuilds itself. But it is mine, it is readable, and nobody else holds it over me.
Live: the vault in Finder is just files; git log shows a backup every 15 minutes.
Principle 2 of 8

2 · Hard structure, fluid meaning.

Be rigid about
  • The folder skeleton - flat, numbered, boring
  • One metadata schema for every note
  • Naming rules that never bend
Be loose about
  • The areas of your life - they change, and the system should let them
  • What connects to what - links and metadata do this, so meaning can move without files moving
  • What anything means this month versus last
Live: flat folders that look like chaos, then the map page that assembles them into a life.
Principle 3 of 8

3 · Every step is deterministic or judgment - on purpose.

  • Every step in a pipeline is either a script (transcription, filing, linting - things that must never vary) or a judgment call (summarising, deciding - where the right answer depends on context). Knowing which is the whole discipline.
  • Instructions in a context file are advisory - the model will eventually ignore one. A rule you care about becomes a check that runs on every write and fails loudly.
Some of mine

A metadata check that runs on every single write and fails loudly. A voice gate that runs before anything can leave in my name, checking it against my own writing. A check that fires the moment a new person note appears. None of them asks permission, and none of them depends on anyone remembering.

A captured moment: a hook catching a malformed note and making Claude fix its own work.
Principle 4 of 8

4 · Tell it your goals, not your spec.

The principle

"Make me a study plan" gets you a study plan. "I want to stay on top of coursework without giving up my evenings" gets you a much better one. Both are instructions - the difference is altitude. Say what you are optimising for, and let it choose the artefact.

Standing missions
The handful of things the system always holds - what this year is actually for. Loaded every session, never restated.
The goals of this block
What I'm optimising for right now, this term. Changes a few times a year.
The goal of this session
Stated at the top of the hour. This is the one people skip, and it's the one that stops a session drifting.
Because all three are explicit, it can trade them off - and push back when a request works against something bigger.
Live: the goals file loading at session start, and the model pushing back on a request because of it. The one idea I properly copied - Daniel Miessler's PAI.
Principle 5 of 8

5 · Build for how you think.

The principle

If the system is part of your mind at all, it has to be shaped like yours. The bottom of the stack is engineering and is the same for everyone - but the interface, how it surfaces things to you and how you feed it, is the part nobody else can design for you.

  • Build it flexible enough to bend to how you already work, not rigid enough that you have to bend to it. That flexibility is where the leverage is - a system fighting your habits loses.
  • I killed urgency scoring in my own task system because I need the full map in my head in advance - a friend of mine runs the exact opposite, and both of us are right.
  • Then the test from slide three, unchanged: is the faculty it touches still owed of me unassisted, in a room this system cannot enter? If it is, build it to extend rather than replace.
Live: the task system, a surface I type brain dumps into, and a note pulling its related ideas alongside it.
Principle 6 of 8

6 · Close the loop - never give the same feedback twice.

The principle

Every correction should become either a permanent memory or a mechanical check. The test is whether you have ever told it the same thing twice.

  • When I flag a phrase I hate in a draft, it goes onto a banned list that a script checks every outgoing email against - I see it once, and never again.
  • 149 memories so far: how I work, what a project is for, rulings I've made once and never repeated.
  • Writing everything into memory isn't the answer either - an unbounded list is just a longer thing to read. Knowing which corrections deserve to be permanent is the craft.
Live: the memory index - seven months of corrections as one-line facts it never needs telling again.
Principle 7 of 8

7 · Scale autonomy with verifiability.

The principle

Generation is cheap - your attention is the scarce resource in the loop. So every delegated surface gets a permission boundary (what it structurally cannot do) and a verification surface sized to the blast radius (what you check, and how fast).

  • Mine is scoped to a draft-only mail surface, so there is no send button to misfire. It never bulk-edits without piloting one file first, and it proposes changes to anything important and waits.
  • None of that is distrust - it's what lets me hand over more each month, because checking stays fast.
The dial goes up exactly as fast as checking gets cheap - the same variable as slide three.
Principle 8 of 8 - the one to leave with

8 · Separate what appreciates from what depreciates.

Appreciates as models improve
  • Your data - notes, history, everything captured
  • Your goals and feedback - every correction you have ever given it
  • Your structure and taste
  • Same model, richer record, better answers
Depreciates as models improve
  • Prompts - useful, but built to be rewritten
  • Scaffolds and glue code
  • Keep this layer thin, separate and cheap to replace
  • When the next model lands, you should already know which files you'd touch
The models changed underneath it more than once. The vault never noticed.
The part people actually ask about

It doesn't just serve you - it extends you.

A bench of advisors
Seven agents, each grounded in a corpus I built - every essay Paul Graham has published, the LessWrong Sequences, my negotiation course - which answer by quoting the source verbatim, never by impersonating its author.
A voice gate
Every piece of outgoing writing is checked against my own unassisted writing, including a growing banned-phrases list of things I've caught AI saying in my name.
A relationship record
264 people and 17 companies, where every meeting note, email and task involving someone assembles itself on their page without my touching it.
A taste record
The one I use most, which probably tells you something. I have always been a massive lister. Now the lists make themselves. I speak a verdict on whatever I have read or watched into my phone, and it files itself.
Live: a pre-run consultation, and the list of my own banned phrases.
The worked example - what it took to add Wharton

A good system makes new areas of life cheap.

The test I'd give any setup

What is the marginal cost of adding a whole new area of your life? When Wharton arrived - new courses, a new platform, new readings and deadlines - I didn't build a Wharton system. I asked what the existing design already handled, and the answer was almost everything.

Already there
  • Lectures, readings and deadlines flow through the existing pipelines
  • The same schema organises all of it
Actually new
  • One Canvas sync - a new source
  • One map page - a new view over existing structure
  • That's the whole build
Live: a synced course folder, a processed lecture note, a course map page.
For the way home

Where the ideas came from.

Andrej Karpathy
The llm-wiki idea - raw sources, a persistent markdown wiki the model maintains, Obsidian as the human's window onto it.
Daniel Miessler
Personal AI Infrastructure (PAI) - the most complete open framework, and where my goals-files idea comes from.
Simon Willison
The clearest writing on what agents can and can't be trusted with - read him before you connect anything to your email.
Steph Ango
"File over app" - the case for owning your data as plain files. The whole substrate argument in about a page.
Ethan Mollick
Co-Intelligence - the book on working with AI day to day.
And I write about self and system at I Heart My Strange Loop.
← → move · O overview