The problem
By autumn 2026 I was doing a large part of my job as Product & AI Lead through Claude Code: Jira, mail, Slack, meeting notes, calendar, my to-do list, research and code. It worked, but it ran on loose habits, and four problems kept coming back:
- Sessions forgot context.
- Advice drifted from decisions already taken.
- Scheduled assistants ran where nobody could see them.
- There was always a risk of something going out under my name without my OK.
None of these are model problems. They are operations problems, the same ones any team hits once AI stops being a chat window and starts doing real work.
The approach
I treated my own setup the way I'd treat a production system: one private repo that holds the context, memory, decisions, skills, scheduled routines and guardrails. All of it is versioned, tested and checked by itself. Every project repo sits beside it, and one setup script restores the whole thing on a new laptop.
Three principles shaped the build:
- Configuration over habit. If a behaviour matters, it lives in a file, not in my head.
- Guardrails as code, not as prompts. A prompt can be ignored; a hook that blocks the action cannot.
- Trust is earned by checks. Anything that runs on a schedule gets something that verifies it really ran.
Five weeks in (first commit 6 October, 917 commits by 13 November), the setup runs much of my week. It also has a few gaps, listed below, that I decided to live with rather than keep building.
Architecture
AI OS has six layers. Each one answers one of the problems above.
1. Context layer
Instruction files describe who I am, how I write, what the company does and what my priorities are. There is one status card per company system and a map of which tool reaches what. A session reads only what the task needs.
2. Memory with a hierarchy
About 285 short memory notes, one fact each, with a small index per project. On top sits a decision log: what was decided, the assumptions, the certainty, the source, the status and who confirmed it. It holds 153 decisions. Sessions must search it before advising, and when memory and the log disagree, the log wins.
Since 3 November, drafts that state a decision end with one confirm-or-correct question, and a routine records per person whether the answer came back.
3. Scheduled routines with safety built in
- 19 enabled cloud routines (17 on a schedule, 2 on demand), plus 3 scheduled tasks in the Claude desktop app and 2 Windows tasks. Among them the product discovery loop, the personal assistant layer, backlog hygiene and the self-checks below.
- Five scheduled routines and the app tasks are short stubs that read their prompt from a file in git. The other 12 scheduled routines embed their prompt in the routine itself.
- A kill switch I can flip from my phone stops the file-based routines, the app tasks, the probe task and the overnight data run at their next start. The 12 routines with an embedded prompt do not read it; those I switch off one by one.
- Cloud schedules are UTC-only, so fixed-hour routines fire at both possible hours and a time gate skips the wrong one. Tests check the hours.
4. Probes that test the context, with a canary
The design: 12 probes, scheduled for Mondays, are built to ask a fresh Claude session factual questions about my setup. Every probe carries known-wrong answers its checker must reject. One canary probe is built to fail: if it passes, the checker is broken, not the context.
5. Guardrails as hooks, not hopes
- Mail without my signature is blocked.
- Sends that carry the connector's mangled links are blocked.
- Calendar events at hours I keep free need my confirmation.
- A size hook makes Claude restructure any agent-loaded file that grows past about 5,000 tokens. The decision log is exempt by design.
- A pre-commit check validates the memory index and frontmatter, dead links, decision IDs and skill files, and scans staged files for secrets. It is the only gate for docs and memory, which go straight to
main.
6. Self-checks
- A daily knowledge scan (since 29 October) runs mechanical checks first, then judges contradictions, stale notes and misplaced knowledge. It fixes index and formatting itself and raises the rest as numbered findings.
- A watchdog (weekdays 09:15, since 31 October) checks that every routine, CI job, probe run and the overnight data run really ran, and messages me only when something is wrong.
- Graded audits score the setup on context engineering, orchestration, measurement and safety, with numbered fixes. Five audits so far, between 9 October and 11 November.
Results
| Commits, 6 October to 13 November | 917 (817 in the first month) |
| Cloud routines / skills | 19 / 22 |
| Memory notes / logged decisions | ~285 / 153 |
| Automated tests | 191 (up from 74 at the first audit) |
| Context probes designed | 12, one of them a canary |
Audit grades over one month (9 October to 11 November): safety from D to B-, measurement from C to B-, orchestration from B- to B+, context engineering from B- to B.
It caught real problems:
- The knowledge scan raised 60 findings in its first two weeks (29 October to 12 November) and applied 36 small corrections itself.
- The watchdog's first dry run found 9 real problems.
And changing laptop became a script, not a weekend.
What I learned
The kill-switch test found a gap a review never would. All 12 throwaway test runs stopped correctly. Then 4 live routines kept running with the switch off, because a resumed sandbox skipped the fresh fetch of the repo. Test the real thing, not the stand-in. I then decided not to extend the switch to the 12 routines with an embedded prompt: I can switch those off one by one if needed.
The environment can lie to you. The desktop app silently redirects application data folders, so a scheduled task wrote its logs somewhere nobody looked.
A checker can raise findings faster than you close them. The knowledge scan is useful, but on 12 November it had 36 open findings. Many are judgment calls only I can make. A scan that only adds work needs a weekly slot to clear it, or it becomes noise.
Know when to stop building. I wrote up ten improvements on 30 October and ran builds in parallel, with 168 commits on 3 November alone. That same day I stopped the build loop deliberately and froze five unfinished pieces as they were. One had failed its value gate (a Monday people briefing), and the meeting part of the decision log reached only 72% recall in replay. Six builds stayed live: the decision log, decision confirmation, quick capture from my phone, readable stakeholder profiles, a handover pack and the kill switch. The rule now: a frozen build comes back only when I miss it in daily use.
Not every idea survives a day, and the write-ups are the value. A cockpit pane and a voice briefing were each stopped within a day. Both have a write-up of what went wrong.
My role
Designer, builder and daily user, solo with Claude Code. Docs and memory go straight to main; scripts and tests go through pull requests and CI. Every finished experiment gets a learnings write-up, every decision a log entry, and every scheduled job a watchdog.
The point was never more automation for its own sake. The point was a setup I can trust to run while I'm not looking, and that tells me plainly when it isn't.