Most mornings start the same way. Emails I haven’t read, a task list that grew while I slept, a trade that might need attention before the market opens, and somewhere a thread from yesterday I never closed. Not a crisis. Just the weight of everything that kept moving while I was doing something else.
For a long time my answer was to get better at catching up. Start earlier. Review the night before. Keep the list cleaner. There’s no version of that where you actually win. The inbox refills. The list grows back. You’re not falling behind because you’re disorganized. You’re falling behind because the volume of a normal life is more than one person can sort through alone.
So I started building. What I ended up with was two systems, not one. I named them Sunday and Monday, one for my personal life and one for work, and both began as plain automation: a script to file newsletters, a nudge when a bill was coming due, a morning brief that assembled itself while I slept. It helped. Then, a few months in, the automation turned into something else. It stopped waiting for instructions and started having a view on what mattered, and I found myself trusting it with judgment I used to keep for myself. This is the story of how that happened, and why the part that made it work was never the automation.
The First Version Just Ran Errands
When people hear “I automated my morning,” they picture a stack of shortcuts: filters, reminders, canned replies. That’s a checklist that runs itself, and it fails in a specific way. It cares about finishing the steps, not about the result you actually wanted.
A checklist doesn’t know why it exists. It flags the email marked “urgent” because the rule says to, whether or not that email changes anything in your day. An assistant is happy to do that faster. I didn’t want a faster assistant. I wanted something that knew what I was aiming at, so it could tell the difference between busy and important.
What was missing wasn’t more automation. It was a way for the system to know what I was actually trying to do, so it could weigh everything against that and hand me only what mattered. I sat down and wrote that part out, once for each of the two systems. What I wrote turned out to have a shape I recognized: six parts that fit together. I’ve come to think of them as the system’s charter.
Each OS Has a Charter
It’s not a metaphor for good intentions. It’s an actual set of files each system reads before it does anything. If “charter” sounds grand, read it as “the things it has to agree with first.” Here are the six, and what each one holds for me.
Principles: how I try to operate, whatever I’m chasing. These sit above everything else. I took the habit from Ray Dalio’s Principles: write down the rules you actually live by, so you’re not re-arguing the same decision every week. Mine are plain. What I believe about the world is always a little out of date, so update it faster than it goes stale. Time with the people I love compounds, so hand the machine everything that isn’t presence or judgment. A goal can change next year. A principle is what decides which goals I’m even allowed to chase.
Mental models: how it understands the way the world fits together. If principles are how I operate, models are how I see. They’re the relationships I’ve learned, the way one thing depends on another. How you should trade is a function of how volatile the market is, so the system shifts its posture when conditions change instead of running the same play every time. People grow by moving from owning tasks to owning outcomes, so how much of a problem someone should own, not just the solution handed to them, depends on where they sit on that path. Models like these let the system reason about something new instead of matching it to a pattern it has seen before. Principles rarely move. Models are supposed to. They’re the part of the charter most often wrong, and most worth updating.
The goal: one line, straight out of the principles. A single sentence I can hold the whole system against. Mine right now: solve hard problems while actually enjoying my life. The hard problems are the ones I get to work on in AI. Enjoying my life means being there for my family and helping my son grow up curious. It reads soft until you notice it has two halves that pull against each other, work and home, and the job is to keep either one from eating the other.
Success criteria: how I know the goal is being met. Some of it is countable, and the numbers keep me honest: hours of real, phone-down time with my son; whether a piece of work cleared a bar I set before I started, not one I moved afterward to feel better. But not everything that matters is a number. Some of the criteria are felt. Whether I walk into the week calm instead of braced. Whether I’m present in a conversation or just physically in the room. Those never show up on a dashboard, and pretending they do is its own kind of lie. The system tracks what it can count, and asks me about the rest.
Priorities and sequencing: what wins when things collide, and what I’m on right now. The order is settled in advance so I’m not renegotiating it at 7am. Health first, physical and mental both, because if my health goes I’m no use to anyone else. Then family, then work, then money, then everything after that. Sequencing is the live layer on top: the two or three things actually in focus this season. One of mine right now is unglamorous. I’m working out how to store my own context in the leanest form possible, so the system stays cheap and sharp as it grows. Another runs on its own: when something lands from a newsletter I follow, the system goes and reads it for me, without being asked.
Guardrails: what it’s allowed to do on its own, and what it isn’t. These are deliberately cautious for now. When a message comes in on WhatsApp or Slack, the system writes the reply I’d send, in my voice, with the context filled in, and then it stops and waits for me to hit send. Same with email. Same with a trade: it can line the whole thing up, but the last click is mine. It also learns by watching before it’s allowed to act. For weeks it shadowed my trading, logging what it would have done beside what I actually did, so I could judge whether to trust it before handing over the button. Guardrails are what let me leave it running without hovering. I’ve told it exactly where the line is, so I don’t have to watch it.
Principles, mental models, goal, success criteria, priorities, guardrails. Together, that’s the charter: the files the system reads before it lifts a finger. Everything else it does runs downstream of them.
I’ve written before about running Claude as a system instead of a chatbot, and about the runtime that lets parts of it work while I’m asleep. Those are about how the machine is built. The charter is the layer above the machine: what it’s for, and what it’s not allowed to do.
Fig. 1 — The charter the system reads before it runs. The automations sit at the bottom, and what happens in the real world flows back up to revise the parts that are meant to move.
What It Looks Like on Disk
The charter isn’t just an idea. It’s files. The personal system is a folder, and the order of the folder is the argument: the charter comes first, the automations come last.
sunday/
├── context/ the charter in prose — principles, goal, success criteria, priorities, guardrails
├── mental-models/ how the world works and how it connects — kept, tested, revised
├── finance/ positions, the long-term plan, the money model
├── people/ family and the relationships that matter
├── health/ energy, exercise, sleep
├── learning/ insights worth keeping, notes on improving the system itself
├── projects/ everything with a finish line
└── .claude/skills/ the automations — they read everything above first
The charter lives in the top two folders. context/ holds the principles, the goal, the success criteria, the priorities and the guardrails, written out in plain language. mental-models/ holds the models. Everything below them — finance, people, health, learning, projects — is the material the system works on, and .claude/skills/ is the automation that does the working. A skill that drafts my morning brief doesn’t start from a blank page. It reads the charter first, then decides what’s worth putting in front of me. The automation itself is small. Almost all the work went into what sits above it, and that’s on purpose.
Not that it’s as tidy as a six-item list makes it sound. The principles are written down cleanly. The success criteria and priorities are still spread across a handful of files, getting consolidated as I go. And the charter mostly grows by being wrong first. When the system does something I didn’t want, I don’t just bolt on a rule. I ask it why it did what it did, and the answer tells me which layer was actually off. A misfire in how it communicated, the who and what and why of a message, belongs up in the principles. A goal it optimized that I don’t actually care about is a success-criteria problem, or a leading indicator I forgot to give it. Each miss updates a different part, and knowing which part is half the work.
The work system is a separate folder with the same six-part shape. The two aren’t sealed off from each other. Each can read the other as context when it helps: the work system knows I have a family, the personal one knows I have a job. What stays separate is the doing. My personal automations run on my personal accounts, work stays on work, and the wall between them is what keeps one side from slowly taking over the other. I think of that as the two-OS rule: shared context when it’s useful, separate hands always, so the balance between the two halves of my life is something the setup protects instead of erodes.
How It Actually Runs
So far this has been the idea. Here’s the plumbing, because the idea only matters if it survives a real week.
All of it lives in a git repository, the same version control software developers use for code. The charter files, the skills, the notes the system writes back to itself: every one is a plain text file with a full history. That sounds like a technical detail, but it’s what makes the whole setup trustworthy. Nothing changes silently. If the system updates a belief or rewrites a priority, that’s a recorded change I can read and undo. Git keeps the paper trail.
The skills run in three ways. Some are Claude routines on a schedule in the cloud: a Sunday routine that preps my week, a midweek one that clears the queue. Some run on my own machine at a set time, like the morning brief or a market digest before the open. And some I just ask for, in the moment. However a run starts, it reads the charter first, does its work, and leaves the result as a draft for me or a saved change in the repo. The cloud runs report back over Telegram, and for now I stay in that loop: a message lands, and I decide whether to nudge the automation or let it carry on. The local and on-demand runs I’m already sitting with, so I steer those as they go. The goal is for a quiet day to mean everything was handled. I’m not there yet. Today the system still talks to me more than it will once I’ve learned to trust it further.
Fig. 2 — The same system as plumbing: version-controlled files, a few scheduled routines, and the runs that read the charter and act.
It Amends Its Own Charter
Even a system with a charter behind it would go stale if that grounding never moved. The part I didn’t expect is how much of the value lives in the opposite: the system keeps rewriting its own charter, and sometimes argues with me about mine.
It’s the mental models that move most, but not only them. A success criterion turns out to measure the wrong thing and gets swapped. A leading indicator I was missing gets added. The files carry dated updates, and the updates overturn what came before. Something I believed with confidence one month gets contradicted by the evidence the next, and the file records the reversal instead of pretending the old view was never there.
MENTAL MODEL — UPDATED
What I used to think: a better AI model makes a better system. Reach for the smartest one and you’re ahead.
What changed: swapping in a smarter one barely moved my results. What moved them was the harness around it: the skills, the context, and a running log of every decision it made and why. That log is what lets each run learn from the last instead of starting cold.
So: the AI model is the most replaceable part. The edge is the harness, and the feedback loop I build on top of it. I log the decisions, turn the misses back into better skills, and the system compounds instead of resetting every morning. That’s what I’m wiring into my own Claude sessions right now.
That’s one half. The other half is that the system pushes back on me. When I commit to something for the week that falls outside what I said I’m focused on, it doesn’t just go along with it. It flags the mismatch once, asking whether this is deliberate or whether I’m drifting, and then it accepts my answer. A tool that always agrees with you just helps you fool yourself. The useful version has enough backbone to point at the contradiction, and enough sense to then get out of the way.
This is the real difference between a checklist and a system with a charter. A checklist runs the same steps until you rewrite it. A grounded system keeps its picture of the world current, and holds you to the goals you set on a clear day, on the mornings when your head isn’t.
What the Morning Looks Like Now
With all of that underneath it, the surface goes quiet. The morning brief runs before I’m even at my desk: what’s on the calendar, whether anything needs attention before the market opens, whether anything in the inbox truly needs me today. Not a summary of everything. A short list, sorted by what matters instead of by what arrived most recently.
Triage runs next and mostly disappears. It flags what matters, clears what doesn’t, and pulls the one useful idea out of the reading I’d otherwise skim in a dozen scattered minutes. Once a week, a check-in surfaces the things that rot in silence and asks the questions I’d skip on my own.
Most of what the system absorbs is low-value work that still has to happen: sorting, the reading I subscribed to and mostly won’t act on, scanning a list to find the one thing that matters. None of it is what I want to spend attention on. The system carries that load so the part I care about gets a bigger share of the day: a clear head for the decisions that need one, and real presence for a son who’s learning to walk. Owning my time was never the goal by itself. It’s what clears the way back to the life that’s already happening.
The Part I Haven’t Solved
The system gives back a few hours a week of time I used to lose to sorting. The number is real but rough, and the exact figure matters less than the direction. I start fewer days in reactive mode. The inbox isn’t a source of dread. The things that used to quietly rot get surfaced in time.
It works on good weeks. On the bad ones, when I’m stretched and tired and running on empty, the system keeps running but I stop meeting it. The briefs arrive and I skim past them. The check-in gets skipped.
What the system can still do, even then, is make the case. It knows the goal, the priorities, the guardrails I set back when I was thinking straight, so it can point at the drift and name the next right step: this is what you said mattered. What it can’t do is take that step for me. Between the recommendation and the action there’s still a person, and on the hard weeks that gap is where everything stalls.
That’s the part still open. The grounding is good at cutting friction, and better than I expected at naming the right thing to do. It still needs me to show up and take the call it hands me.