The Personal Stack
Inside the operating system that changed how I work — and how to build yours
In Part 1, I described a problem: too many ideas, not enough structure, and the quiet shame of failing at every productivity system I'd tried. I described what happened when I stopped trying to become organized and built something that compensated for what I'm missing.
People had two reactions. Half said "I feel that." The other half said "OK, but what did you actually build?"
This is the answer.
The Insight That Changed Everything
Every note-taking system I've used makes the same assumption: the hard problem is where to put things. Notion gives you databases. Obsidian gives you links. Roam gives you blocks. They're all answering the question "how do I organize my stuff?" — as if organization is the point.
It isn't. The hard problem isn't where to put things. It's knowing what to do with things.
My system doesn't organize by topic. It organizes by actionability — what I need to do with the content right now. Is this something I need to ship? It goes in Actions. Something I need to maintain over time? Contexts. Something I need to reference and build on? Knowledge. Something about who I am and how I work? Self. Something I need to capture quick and route later? Inbox.
This sounds like a filing system with different labels. It isn't. The difference shows up when you look at a single topic across the system.
Take teaching. Right now, "teaching" exists in five different places:
- An active course with a deadline and session plans (Actions — ships in April)
- An ongoing professional role with relationships and standing commitments (Contexts — never "done")
- A canon of reusable methodology, frameworks, and templates (Knowledge — compounds over semesters)
- A set of identity patterns about how I teach and what kind of teacher I am (Self — evolves slowly)
- Meeting transcripts and student feedback I haven't processed yet (Streams — raw inputs waiting to be harvested)
These aren't duplicates. They're the same domain at different speeds. The course ends; the role continues; the methodology compounds; the identity evolves. A topic-based system would put all of this in one "Teaching" folder. Mine separates it by what I need from each piece — and that separation is what makes the system useful instead of just organized.
There's a deeper point here. Most productivity systems draw a hard line: work over here, personal over there. But that's not how a life actually works. My teaching informs my methodology. My methodology draws from my identity work. My identity work connects to how I've navigated my career. The system holds all of it because the connections between domains are where the most useful insights live. An AI that only sees your work tasks can't help you notice that you keep avoiding the same kind of decision across three different parts of your life.
The Eight Layers
The system has eight layers. Each one handles a different kind of content at a different speed.
Inbox is frictionless capture with a 48-hour expiration. Anything can go here — an idea, a link, a half-formed thought. The rule is simple: process it within two days or delete it. Inbox is a landing pad, not a home.
Streams is where durable source material lives — meeting transcripts, article highlights, conversation notes. The key distinction from Inbox: Streams content is worth keeping. You harvest from it over time.
Operations is how the system itself works. Protocols, rules, templates. This is the layer that tells the AI how to behave.
Actions is where projects live. Everything with a deadline and a deliverable. Projects move through four tiers: Focus (max three, actively shipping this week), Background (touch when time allows), Paused (on hold with an explicit resume trigger), and Planning (not started, backlog). The tier system is enforced, not aspirational.
Contexts is for ongoing roles and responsibilities that never "complete." Teaching. Consulting. Client relationships. The test: can it be "done"? If yes, it's an Action. If no, it's a Context.
Knowledge is reference material that compounds. This is where canons live — domain-specific knowledge bases I've built over time. Each canon gets smarter as I use it across projects and semesters. I don't rebuild course materials from scratch anymore.
Self is the identity layer. Values, personality assessments, working style, shadow patterns, direction. Most systems ignore identity entirely. Mine makes it operational.
Archive is cold storage. Completed projects, deprecated content, old semesters.
You Already Understand This
At some point I stopped thinking of this as a note-taking system and started thinking of it as a computer.
Not metaphorically. Structurally.
If you've ever used a laptop, you already understand the architecture. The vault — my files — is storage. Like a hard drive: persistent, organized, survives restarts. The AI's context window is memory — volatile, limited, what's loaded right now. The AI itself is the processor. The rules and configuration files are the operating system. The knowledge bases and workflows are applications.
Once I saw it this way, design decisions started making themselves.
Why does my system have a "light mode" that loads minimal context for quick sessions? Memory management. Why does every session end with a commit to version control? Flushing buffers to disk. Why is there a hard limit of three Focus projects? You can't run more concurrent processes than you have capacity for without everything slowing down. The constraint is the feature.
Most people treat their tools like appliances — "I use Notion" or "I use Obsidian." That's like saying "I use a hard drive." A hard drive is one component. To do real work, you need the whole machine.
Five Things That Keep It Alive
The eight layers are the structure. These five behaviors are why this system didn't rot like every other one I've tried.
Anti-clutter rules prevent decay. Three rules do most of the work. The 48-hour Inbox rule means capture is temporary. Just-in-time folders means I never create structure I don't need yet. The Rule of Three means topic folders only exist when three or more items accumulate. These sound minor. They're not. They're why the system is still clean after a year.
Knowledge has status gates. My teaching framework exists separately from any specific course that uses it. The framework compounds across semesters. The course ends and archives. Separating foundational methodology from its delivery means I never rebuild from scratch.
The AI reads your context before you ask. Every file has structured metadata. Context loads in three layers: a global identity file, project-level rules, and domain-specific constraints that load automatically. I'm not starting from zero every conversation.
Accountability is structural, not aspirational. The system compensates for what I can't do on willpower alone. The Focus limit prevents spreading thin. Escalation tiers surface things I'm avoiding. Session rituals mean I don't rely on memory for continuity.
The system extends itself. Any workflow I repeat more than twice becomes a command. I started with five commands. I now have nearly fifty. A meta-command helps me build new ones — the system compiles its own extensions.
That last point is the one that matters most. Every system I'd abandoned failed because maintenance required the discipline I don't have. This one automates the maintenance. The AI processes. The rules enforce. The rhythms trigger. I stay on the thinking side.
What a Day Actually Feels Like
Monday morning. I open a terminal and type /start-session. In about ten seconds, the system loads my objectives, surfaces my three Focus projects with their next actions, shows yesterday's commits, and checks the calendar.
The output is short. Three projects, each with one thing to do next. Recent commits for continuity. Any alerts. I read it, pick one, and start working. Total time from cold start to flow state: under a minute.
Before I built this, I'd spend ten to fifteen minutes at the start of every session opening files, scanning project lists, trying to remember what I was doing.
Once I'm working, the AI knows what I'm working on. When I ask it to design a course session, it already knows my pedagogical framework, my slide conventions, and my students' team structure. I don't explain any of that. I just say "design Session 8 on customer discovery" and it loads the right constraints.
End of day, I type /end-session. The system documents what was accomplished, commits everything to version control, and writes a handoff note for tomorrow. Tomorrow's session will know what today's session did.
The honest description of how this feels is a word I wouldn't have predicted: calm.
How to Start
You don't need eight layers, fifty commands, and four knowledge bases. You need three things.
One project with a file that has a next-action field. That's it. One folder, one file, one field that says what to do next. The AI reads that field when you start your day and tells you what to work on.
One command that reads it. A start-session command that loads your objectives and project files. This takes about fifteen minutes to set up.
Version control, so nothing is lost. Every session ends with a commit. Every change is tracked.
Start there. Use it for a week. Notice what's still friction. Automate that. Repeat.
Build the minimum. Let friction teach you. The system will tell you what it needs to become.