How I Built a Personal LifeOS with AI

TL;DR

• Your life generates too much information to organize by hand. Mine does too.

• I built a three-layer system: raw documents (Google Drive), a living wiki (Notion), and an AI agent that maintains both.

• The agent isn't smart. The system is predictable. That's why it works.

• This post covers the architecture, the schema, and the file tree.

---

I'm a product counsel by day. Outside of work, I'm an IVF patient tracking insurance, appointments, and claims; an investor managing accounts across multiple brokerages; a general counsel advising a healthcare AI startup; and a person trying to stay on top of my own health. Each of those roles generates documents — medical records, insurance claims, tax forms, investor updates, NDAs, meeting notes. It all adds up fast.

As a result, for years, my life's information lived in parallel fragments: a contract scan in my email inbox. A voice memo in an app. Meeting notes in a physical notebook. An article saved to a read-later folder I never read later.

I'd have to sit down for an hour — sometimes two — every week to gather all of these scraps and process them. This required sorting things into the right folders, pulling out actionable todos, updating my project lists, and tracking progress. This was just pure overhead. I wasn’t thinking, definitely not creating.

The problem wasn't that I lacked an organizational structure. I had folders, databases, notebooks. The problem was that nothing connected them. No system could look at a 1095-B in my email, know it belonged in both my health insurance folder and my tax prep folder, update the document inventory in Notion, and check off the TODO — because no system understood how all the pieces connected.

Now one does. The fix was a routing schema — a simple table that maps every type of content in my life to where it gets filed and where it gets tracked. I've built a system where the organizing, filing, summarizing, and transcribing is handled by an AI agent — not because the agent is smart, but because the system is predictable. The agent follows a schema that encodes how I think about my life's information.

The result: when I sit down to work on something, everything I need is already where it should be.

Why I think this system will stick:

• Not handcuffed to any specific app: When I switched from Trello to Notion to Obsidian, each migration was an obsessive scramble to ensure I comprehensively gathered all historic material + perfected a new organizational structure. Here, the three layers — raw storage, structured wiki, agent — don't depend on any single app. Google Drive could be Dropbox. Notion could be Obsidian. Claude could be another model. What holds it together isn't the tool; it's the schema — the set of rules that says "this type of document goes here, gets routed there, and updates this." As MCP access expands and agents can connect to more systems natively, the schema only gets more powerful.

• Wholesale handling information. Instead of "where does this PDF go?", I'm writing SOPs — standard operating procedures that apply regardless of the content. File a tax form, file an insurance document, file a contract — they all flow through the same routing logic. The work shifts from processing to designing processes. You do that once, and it compounds.

The Three Layers

The architecture is three layers, but they're not equal. Two of them are data layers — static and derived — and the third is a labor layer that moves information between them.

(1) Raw is static. Tax forms, contracts, medical records, news articles — primary source documents that don't change after they're created. They're evidence. You file them and leave them alone. I keep raw material in two places: Google Drive for anything document-shaped (PDFs, spreadsheets, signed contracts), and a Notion database for web-native content (articles clipped with Notion Web Clipper, short text notes that don't need to live as files). Both are raw in the same sense: captured, not synthesized.

(2) Wiki is derived. It's built from the raw material — summarized, synthesized, structured, cross-referenced, and continuously updated. The raw layer has a 1095-B PDF from my health insurance, which is never edited. The wiki has a Health Insurance page that tracks what the policy covers, what I've filed, and what's still outstanding. The wiki page evolves every time I trigger the agent. Importantly, the wiki survives on its own — even if the agent went away tomorrow, the Notion pages would still be useful standalone documents.

(3) Agent is the labor. It reads raw documents, updates the wiki, files things in the right place, checks off TODOs. I don't move boxes — I design the process. The agent runs it.

If the raw layer is the archive and the wiki is the living knowledge base, the agent is the associate who maintains both. I set the standards. The agent does the work. The agent isn't smart. The system is predictable. That's why it works.

In code:

Layer 1: Raw Sources (Google Drive + Notion) 
	- Where documents and web content live. Nothing synthesized. 
	- GDrive for files; Notion databases for web clips and notes. 
	- Files renamed w/ uniform convention: YYYY_Type_Source.ext.

Layer 2: The Wiki (Notion) 
	- Where knowledge lives. Structured notes, decisions, actions. 
	- Two databases: Projects (actionable) and Notes (reference). 
	- Every page same format: Tabs at the top, toggles everywhere. 

Layer 3: The Agent (Claude Code + Skills) 
	- The bridge between layers 1 and 2. 
	- Classifies documents, routes content, maintains the wiki. 
	- Has memory, skills, and a schema that encodes how I think.

The File Tree

A quick primer before the file tree: Claude Code is Anthropic's CLI for running Claude as a file-system-aware agent — it reads and writes files on your machine. Its configuration and memory live in a dot-folder at ~/.claude/. Skills are reusable sets of instructions the agent can invoke like scripts. CLAUDE.md is a plain-text file the agent reads on startup (and whenever its context changes) — think of it as standing orders or a briefing memo.

If you're not technical, skim the next two code blocks. The syntax doesn't matter; the point is that the entry point is small and the modules are deep — a few top-level files that point to deeper skills, memory, and folder-specific context.

Here's what the agent's brain looks like:

~/.claude/
├── CLAUDE.md                    <- The north star (15 lines)
│                                   Why, Map, Rules, Workflows.
│                                   Loaded every session.
│
├── memory/                      <- What the agent remembers about me
│   ├── MEMORY.md                   Index file
│   ├── user_amy_profile.md         Who I am, what I do
│   ├── feedback_*.md               How I like to work
│   └── reference_*.md              Where things live in Notion
│
└── skills/                      <- Reusable workflows
    ├── organize-inbox/SKILL.md     Triage both inboxes
    ├── push-to-notion/SKILL.md     Route content to the right page
    ├── file-document/SKILL.md      Rename + file + update wiki
    ├── tend-the-vault/SKILL.md     Weekly review (Knowledge PRs)
    └── process-granola/SKILL.md    Meeting transcripts -> notes

And in Google Drive, local context files sit at "sharp edges" — the folders where mistakes are expensive:

Google Drive/
├── Life_Google Drive/
│   ├── Finances/Taxes/2025-2026/
│   │   └── CLAUDE.md    <- "RSUs are double-trigger.
│   │                       Don't include in income."
│   ├── Health/
│   │   └── CLAUDE.md    <- "Insurance covers N cycles.
│   │                       Confirm what counts toward cap."
│   └── Housing/
│       └── CLAUDE.md    <- "50/50 ownership with co-owner.
│                           Nominee reporting needed on 1098."
└── Work_Google Drive/
    └── Projects/2026/Startup/
        └── CLAUDE.md    <- "No PHI in training data.
                                Flag any de-ID issues before release."

Local context at the folder level. The top-level CLAUDE.md tells the agent how the system works upon engagement. But each project or category has its own nuances that the agent can't infer from the file name alone.

When a document arrives, the agent first classifies it and routes it to the right folder. Then it reads the CLAUDE.md in that folder for local rules before doing anything else. Without these local rules, the agent would process every tax document the same way. With them, it knows that this folder has specific rules — the way an associate would read a matter memo before touching a file.

This is also the same principle as good code architecture: the entry point is small, but the modules are deep.

The Wiki

Why Notion. I won't belabor the tool choice — this architecture works with whatever wiki layer you prefer. I use Notion because I love using it. The keyboard shortcuts are in my muscle memory. The page layouts are flexible enough to handle everything from a tax prep checklist to a multi-year project tracker. The design is clean. And critically, agents can push content into Notion natively through MCP, which means my wiki updates itself without me opening the app.

As a template-lover, I also use a consistent project-page template across every active project — the same tab layout, the same toggle structure, the same place for TODOs. Both I and the agent always know where to look.

The Schema: How the Agent Thinks

The agent doesn't just have instructions. It has a schema — a mapping table that encodes how content flows through the system.

| If the content is about...          | File to (GDrive)        | Route to (Notion)              |
|-------------------------------------|-------------------------|--------------------------------|
| Taxes, insurance, benefits, comp    | Life_/Finances/         | Project - Finances             |
| Medical, health, fitness            | Life_/Health/           | Project - Health               |
| Fertility, IVF, clinic visits       | Life_/Health/           | Project - Health - Fertility   |
| Housing, mortgage, utilities        | Life_/Housing/          | Project - Home                 |
| Day-job legal work                  | Work_/Projects/         | Project - Day Job              |
| Healthcare AI startup, compliance   | Work_/Projects/Startup/ | Project - Startup              |
| Blog, speaking, networking          | Work_/Projects/Blog/    | Project - Career Growth        |

This table is the core of the system. When I drop a 1095-B health insurance form into my inbox, the agent reads it, classifies it as "health insurance / tax document," and knows to:

1. Rename it: 2025_1095-B_health.pdf

2. Copy to Health/Insurance/ AND Taxes/Income & Employment/

3. Update the Notion tax page document inventory

4. Check off the 1095-B TODO

What happens when the schema doesn't cover something? The agent has a standing rule: if it’s not confident about the classification or routing, ask me before acting. I can tune how aggressive this is — ask me for every change, or only when the stakes are high (moving a privileged document, updating a tax number, deleting anything). In practice, I leave it loose.

The schema covers 90% of what comes through my inbox, and the agent's judgment on the remaining 10% has been good enough that I rarely get asked. When I do, it's usually a signal that the schema needs a new row — which is how the system gets better over time.

How Long This Took

Honestly — it’s taken me months to perfect. But the reason is because each system is always iterating. My dashboard, the schema, the skills, the folder structure — all of it evolved through trial and error. I didn't sit down one weekend and build; I started with the three layers and a rough schema, and iterated. Each time something didn't file correctly or I couldn't find what I needed, I refined a rule.

You don't need months to start getting value. The three-layer structure takes an afternoon. A basic routing schema takes an hour. From there, let the system tell you what's missing — every time the agent asks you "where should this go?", that's a new row in your schema. Prompt the agent to suggest improvements to the structure as you work. The system builds itself if you let it.

What Makes This Different

I used to spend hours each week just filing — sorting inbox scraps into folders, renaming documents, updating project lists, figuring out what was actionable. That time is gone. But the bigger shift isn't about filing.

It's about preparation. When I sit down to read an article, review a contract, or prep for a meeting, I'm no longer starting cold. The agent has already summarized it, connected it to the projects and documents I'm already tracking, and filed it where I'll need it. It's like having someone who sets the table before every meal. The ingredients are prepped. The context is laid out. I just sit down and think.

That's what I mean when I say this isn't a note-taking system. It's infrastructure for a complex life. The agent doesn't think for me — it ensures I spend my time learning, creating, and thinking instead of preparing to think.

The agent isn't smart. The system is predictable. That's why it works.

---

Amy Aixi Zhang is a product counsel at a fintech company and general counsel at a healthcare AI startup. She writes about the intersection of legal practice, AI, and building systems that scale. Find her at amyaixizhang.com or on LinkedIn.