A Personal AI Operating System: Six Months of Practice, by the Numbers

Andrew Maryasov, AI consultant. I deploy AI agents for businesses, and for the past six months I’ve been living inside my own AI operating system — an ordinary Markdown folder that an agent reads. This isn’t a “how I automated everything in one evening” post. It’s an honest report: what worked, what didn’t, and where I caught myself doing something dumb.

TL;DR (in 30 seconds)

• 90% of the result is encoded context, not prompt cleverness. The accumulated context about me, my work, and my goals matters more than any phrasing of the request.
• The whole system is one Markdown folder. No custom data layer: git-native, grep-debuggable, and moving to a new tool is a single cp -R.
• You can’t trust your own perception. METR 2026: developers estimated AI made them +24% faster, while measurement showed −19%. Forty-three percentage points of difference.
• You can start in 30 days, not half a year. A week of logging, a week of encoding, one encoded judgment call — and everything measured in numbers.

The gist that got 5,000 stars in a week

In April, Andrej Karpathy published a GitHub gist about his daily work with AI. Five thousand stars in the first week, 16 million views on X. His one-line summary: “Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.”

I’ve been living in exactly this kind of thing for six months. A personal AI operating system isn’t a metaphor — it’s literally a folder of Markdown files where an agent has full context about me, my projects, and my goals. And I’m not here to “inspire” — I want to show numbers: what works, what doesn’t, and where I got in my own way.

Karpathy calls this approach “files are the API.” No custom data layer, no clever runtime: files that a human and an agent see identically — git-native and grep-debuggable. If Claude 5 or a new Cursor ships tomorrow, I move with a single cp -R.

Four calibrations you can’t delegate

The main thing I’ve understood over these six months: you can’t build an AI system for a team unless you’ve lived inside one yourself. That’s not grandstanding — it’s four calibrations that only form firsthand.

Taste. Out of a hundred drafts, picking not the “nice” one but the one that solves the problem.

Cost intuition. What a task really costs in tokens: where paying extra for a frontier model is justified, and where Haiku is enough.

Blast-radius intuition. Where you can let the agent run on its own, and where you need eyes on every step, because one mistake will do real damage.

The context-to-prompt ratio. The most painful of the four: 90% of the result comes from encoded context about me, my work, and my goals — not from prompt cleverness. This can’t be delegated to anyone and doesn’t show up on any dashboard. It only accumulates through reps — repetition on real work.

That same conviction grew into my client work at Grow2.ai: before bringing an approach into someone else’s team, I live it myself.

What’s on my disk

Here’s my system — no screenshots, in plain words:

my2brain/
├── .claude/
│   ├── CLAUDE.md           — the agent's operating manual
│   ├── TELOS/              — mission, goals, beliefs, strategies
│   ├── MEMORY/State/       — active task, open loops
│   ├── skills/             — 60+ skills
│   └── rules/, references/ — conventions loaded on trigger
├── 00_Inbox/               — temporary capture
├── 01_Projects/            — active projects with deadlines
├── 02_Areas/               — areas of responsibility
├── 03_Resources/           — references, concepts
├── Goals/                  — cascading goals
└── Daily Notes/            — daily notes

This isn’t Obsidian versus Claude Code — it’s one Markdown folder that both see identically. The full list of tools around it, with prices, I broke down separately: my AI stack 2026.

Four files do all the heavy lifting.

CLAUDE.md — 40-60 lines on who I am and how the workspace is organized. Not marketing — operating constraints. Essentially a specification of my working environment, written as text: the same principle I described in “Software Is Now Text, Not Code,” applied to my own work.

TELOS: mission + goals. So the agent knows which tasks pull toward my goals and which are merely urgent.

A GTD list with five sections — Now, Next, Waiting, Someday, Done. The agent reads it before planning and appends to it after execution.

who-am-i + personal-voice. Without these two, the agent writes generic. With them — it writes the way I would. This post, by the way, is 80% my draft and 20% the agent’s edits. Not the other way around.

What actually changed in six months

No “10x productivity” promises. Three things I can show.

I stopped repeating myself. A correction I gave the agent a month ago works automatically today — through the memory system (Graphiti + MemPalace). This is the hardest thing to explain in words: you feel it around week three, when you watch the agent avoid a mistake you’d forgotten you ever told it about.

Context at hand, not in my head. A client asks about something we discussed two months ago — I have the verbatim of that conversation plus structured facts from the graph. No “I think we decided back then…”.

Connections I would never have built deliberately. LightRAG surfaces overlaps between notes. You’re writing a proposal for a new client — and suddenly see a note from a 2024 webinar that fits the case exactly. It’s long gone from my head. It’s still on disk.

Five failure modes I caught myself in

1. Editing AI below your own expert level means making it worse. The field study by Dell’Acqua and Mollick with 758 BCG consultants showed: the bottom of the output distribution drops to the 8th percentile when a person edits AI without expertise in the topic. I saw it in my email drafts: for the first few months I rewrote everything — and quality dropped. Now I accept email almost as-is, and in legal documents I rewrite every line, because there I know exactly what I want.

2. After the third failure — don’t re-prompt, add context. The failure is almost always missing context, not the model. A third failure is a signal to step back, not to try again with slightly better phrasing.

3. A prompt that grows quarter after quarter is a signal of missing context. Went from 50 lines to 500 — move the content into context files. Prompts should get shorter; files should grow.

4. Cost drifts quietly. $5 one day, $15 the next, $80 a month later. In the moment it always feels “cheap” — and that’s the worst part. A hard daily limit plus a weekly review is the bare minimum that saves you. Mine is $15 a day right now, and I don’t let myself cross it.

5. Marketplace skills execute with your access rights. A skill is code that runs with your permissions, not a passive instruction. In early 2026, several public reports surfaced about popular skills that steal keys or quietly trigger external requests. The rule is simple: read the code of every skill before you install it.

And the most painful discovery isn’t mine. The 2026 METR study: experienced open-source developers using AI self-reported +24% speed, while measurement showed −19% — slower. Forty-three percentage points between “feels like” and “is.” In your first month, you can’t trust your felt sense. You need measurement.

30 days instead of six months

It took me half a year of trial and error. You can start faster — here’s the arc that actually works, minus the wasted experiments.

Week	What to do	Why
1	Run everything through the agent	Not to save time, but for the log: what actually saves time versus what merely feels productive
2	Encode only what you’ve done twice	Once isn’t worth it: the skill will rot and become clutter
3	Encode one recurring decision (deal scoring, prospect screening, support triage) as a skill	Writing the rubric reveals which decisions were consistent and which were “whatever felt right that day”
4	Measure: time, quality, cost, debugging overhead	Kill everything that looks good by feel but fails on the numbers

Three day-30 markers that separate compounding from a plateau: three to five daily workflows at adequate quality; an acceptance rate above 70% — the share of AI output you accept with minimal edits; and one encoded judgment call — the first artifact you can share with a team.

And here’s the surprise: you don’t consciously choose that first team artifact. The daily brief I built for myself becomes the template for the team standup. A style guide becomes the communication standard. A deal-scoring rubric becomes the team’s due diligence. I don’t pick what to share — the team pulls out whatever scales. It took me until month four to understand that.

Six months is too short to make loud claims. It’s enough for a calibration of “this works” / “this is theater” to emerge. Next I’ll break down specific files and skills one at a time — starting with GTD.md, because that file pays back the time you put into it fastest.

Meanwhile, a question worth more than this entire post. If AI really makes you faster: how exactly did you measure it?