Home / Work / AI OS: My Job, Run as Tested Configuration

AI OS: My Job, Run as Tested Configuration

Personal Project ยท 2026

Much of my work as Product & AI Lead runs through Claude Code. AI OS turns it into one repo with context, memory, 153 logged decisions, 19 cloud routines and guardrails, versioned and tested.

  • 917Commits
  • 19Cloud routines
  • 191Automated tests
  • 153Logged decisions
  • Claude Code
  • AI Operations
  • Context Engineering
  • Agentic Automation
  • Guardrails
  • Testing
  • Personal Infrastructure
AI OS: My Job, Run as Tested Configuration

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:

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:

  1. Configuration over habit. If a behaviour matters, it lives in a file, not in my head.
  2. Guardrails as code, not as prompts. A prompt can be ignored; a hook that blocks the action cannot.
  3. 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

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

6. Self-checks

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:

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.