Obsidian as a Personal OS for AI Coding Agents

Last month three developers asked me the same question, independently. A data engineer in Lima, a PM in Bogota, a founder building from Italy.

“How does your AI workflow actually work?”

They all described the same frustration: AI tools that forget everything between sessions. I’ve been running a system that solves this for 4+ months.

Not a note-taking app. Not an AI config file. A personal OS where the AI already knows your stack, your repos, your goals, your recurring failures, and your entire work history before you type a single prompt. The result: I ship production code across 10+ projects in parallel, each terminal session starting from the same vault, each one able to cross-reference any other project, and the AI gets better at helping me every day because it remembers everything.

I open-sourced it: github.com/Railly/agent-brain .

The Problem

Every AI coding tool starts from zero. You open Claude Code, Codex, Cursor, and the first thing you do is explain context. “I’m building a Next.js app with Clerk auth, Bun, Biome, deployed on Vercel.” Every. Single. Session.

That’s the real problem. Not that AI can’t code, it absolutely can. The problem is that AI doesn’t know you. It doesn’t know your stack preferences, your repo layout, your past decisions, or why you chose Biome over ESLint. So it gives you generic answers, and you spend half the session correcting it.

What if the AI already knew all of that?

Not “AI-assisted note-taking” where you paste text and get a summary. A personal operating system where the AI knows your goals, your recurring failures, your vault structure, and the context of every project you’ve ever worked on, and it uses all of that to write better code, faster.

That’s what I built.

The Architecture

The system has three layers:

Obsidian is the persistence layer. A vault with 7 folders following a Zettelkasten German for “slip box.” Each note captures one atomic idea and links to others, building a web of knowledge over time. Invented by sociologist Niklas Luhmann, who published 70 books using this method. + PARA Projects, Areas, Resources, Archives. Tiago Forte’s organizational method that sorts information by how actionable it is, not by topic. hybrid:

01_Inbox/        -> Raw captures from Web Clipper
02_Journal/      -> Daily logs, weekly plans, reflections
03_Garden/       -> Evergreen atomic notes (concepts, people, meetings)
04_Projects/     -> Active project work
05_Areas/        -> Ongoing life contexts (work, content, health)
06_Content/      -> Ready-to-publish drafts
07_System/       -> Context files and configuration

Claude Code / Codex is the execution layer. 14 slash commands (Claude Code) or skills (Codex) that process, connect, analyze, and create. Each one reads from the vault, makes decisions, and writes back.

CLAUDE.md / AGENTS.md is the personality layer. It contains your identity, goals, stack preferences, anti-patterns, and communication style. Claude Code reads CLAUDE.md, Codex reads AGENTS.md, same content, native format for each tool. Every session starts knowing who you are.

The vault also includes system-level files at the root that give any AI agent (Claude Code, Codex, or anything that reads markdown) full context:

File	Purpose
CLAUDE.md / AGENTS.md	Identity, stack, goals, anti-patterns, commands (same content, native format per tool)
PURPOSE.md	Why this vault exists, architecture decisions, for any LLM that needs orientation
HOME.md	Vault stats, quick start, entry points
HUMAN.md	How-to guide for the human: daily workflow, folder guide, tips

This means any AI tool you point at the vault immediately understands what it is, how it works, and what you expect.

The Leverage: Programming With Persistent Memory

Here’s what nobody expects when I show this system. The vault isn’t just for notes. Every programming session I open starts here.

Not in the project repo. In the vault. Because CLAUDE.md (or AGENTS.md for Codex) loads on startup, the AI already knows my stack preferences (Bun, not npm. Biome, not ESLint. Clerk for auth. Tailwind. Server Components first.), where every repo lives on my machine, and the context of what I’ve been working on across all projects.

The 07_System/context-files/ folder is the secret weapon, deep context files for each project, loaded at session start with the @ reference syntax:

@07_System/context-files/clerk-context.md
@07_System/context-files/crafter-station-context.md
@07_System/context-files/repos-map.md

My repos-map.md lists every repo I work on, the stack, the local path. My clerk-context.md has my team, my ownership areas, active Linear issues, common patterns across 16 repos. When I say “fix the flaky test in clerk-evals”, the AI already knows the repo is at ~/Clerk/clerk-evals, it uses Bun and Biome, and the eval system uses AI SDK with MCP server support. Zero preamble. It just goes.

This means every terminal I open starts from the vault, and any session can reach into any project. I run 10+ sessions in parallel, each one cross-referencing repos as needed. “Fix the auth bug in the dashboard, then update the docs site, then push both”, zero re-explaining, because every session inherits the same context. The AI knows where everything is and how each project works.

And it compounds. The auto-memory system File-based memory in ~/.claude/projects/memory/. Claude Code automatically saves user preferences, feedback, project context, and reference pointers. Each memory is a markdown file with frontmatter. A MEMORY.md index keeps everything discoverable across sessions. means every correction I make (“don’t use npm”, “always use Server Components first”, “Biome not ESLint”) gets saved and applied in every future session. I never repeat myself. The AI learns my taste.

Zero to Production in 2 Minutes

The compound effect is most visible with skills Reusable agent capabilities. Skills are installed globally (~/.claude/skills/ for Claude Code, ~/.agents/skills/ for Codex) and available in every session. Unlike commands (per-project), skills carry specialized knowledge across all your work. , global capabilities that work across every project.

/scaffold creates a full production app from a single command:

/scaffold cook with nextjs "A cooking recipe app"

That one line:

1. Creates a Next.js 15 app with TypeScript, Tailwind, and shadcn
2. Replaces ESLint with Biome (my linting standard)
3. Generates a branded README
4. Creates a GitHub repo and pushes
5. Deploys to Vercel
6. Sets up a custom subdomain

Two minutes. From nothing to a live URL. The skill knows my org, my deploy target, my tooling preferences, because it reads from the same config that powers everything else.

I have skills for deploying to Vercel, generating OG images, creating Clerk auth flows, building UI components, and dozens more. Each one carries specialized knowledge that would otherwise live in my head or in a bookmark I’d never find again.

The Daily System

The vault maintains itself through a daily loop. This isn’t busywork, it’s what keeps the persistent memory accurate and the AI context fresh.

1. Morning: /morning pulls my calendar, pending tasks, carry-over from yesterday, open PRs, and Linear issues. Three MITs Most Important Things. The 3 tasks that, if completed, make the day a success regardless of everything else. Set each morning, reviewed each night. for the day. I know what to focus on before opening any editor.

2. During the day: /ship commits code and auto-logs to the daily journal. /log "idea" timestamps quick thoughts. No context switching, everything flows into 02_Journal/.

3. Processing: /inbox reads Web Clipper Browser extension that saves web pages directly into your vault as markdown files. Articles, tweets, documentation, anything. It becomes the entry point for all external knowledge. captures, extracts core ideas, creates atomic notes in 03_Garden/ with backlinks, and marks clips as processed. 10 articles in under 3 minutes.

4. End of day: /today audits planned vs actual, checks MIT progress, asks for a day rating. Carry-over items become tomorrow’s tasks.

5. Weekly: /pulse runs a Pareto analysis The 80/20 rule applied to your work. Finds the 20% of activities producing 80% of your results. /pulse ranks your interests by engagement weight and flags the vital few. , reads daily logs, notes created, and projects touched, then compares against stated goals. More on this next.

This loop is what keeps the system alive. Skip it for a month and your vault becomes stale. Run it daily and your AI gets smarter every week.

The Anti-Pattern Engine

This is the feature that surprises people the most.

Every year I answer 40 questions Annual self-reflection exercise by Steph Ango, CEO of Obsidian. Questions like “What was your biggest failure?” and “What did you waste time on?” force honest pattern recognition across years. . “What was your biggest failure?”, “What did you waste time on?”, “What habit do you keep failing to build?” After a few years, the patterns become obvious. Same failures, different year.

So I formalized them. In your CLAUDE.md / AGENTS.md, you write your recurring failures. Honestly:

### Sleep Schedule (x2)
**Pattern**: Going to bed late, waking up tired
**Signal**: Average sleep < 7h, commits after midnight
**Intervention**: "Average sleep this week: {X}h. Target is 7+."

### Tutorial Hell (x4)
**Pattern**: Watching tutorials instead of building
**Signal**: 5+ bookmarked courses, 0 new projects started
**Intervention**: "Close the tutorial. Open your editor. Build the thing."

The (xN) is how many times this pattern has appeared in yearly reviews. When /pulse runs, it checks these against your actual data:

VITAL 20%
1. Auth/Clerk    ████████████ 45%
2. AI Agents     ██████░░░░░░ 25%
3. Community     ████░░░░░░░░ 15%

BLIND SPOTS
- "Math for ML" - No engagement in 14 days

PATTERN ALERT: No exercise logs in 10 days (recurring x2)

This feeds back into the programming workflow. When /morning runs, it includes anti-pattern checks. If I’ve been coding past midnight for a week, it flags it before I start another late session. The system doesn’t just make me a faster programmer, it makes me a more sustainable one.

The /ship Command

This is the command I run most. Multiple times a day.

/ship

It commits your code, pushes to GitHub, and auto-logs the commit to your daily journal, all in one command. But the logging is what matters. Every /ship adds a timestamped entry to 02_Journal/daily/:

- [14:32] *shipped*: fix(auth): preserve return URL through OAuth callback
- [16:10] *shipped*: feat(settings): add dark mode toggle
- [17:45] *shipped*: refactor(settings): extract SettingsSection components

This is how the system builds memory without effort. I never manually write “today I worked on auth”, /ship captures it automatically. When /morning runs tomorrow, it sees what I shipped yesterday. When /pulse runs on Sunday, it knows exactly which projects got attention and which didn’t. When I ask “what did I work on last week?”, the data is already there.

Every /ship is a data point. Over months, those data points become a complete record of what you actually do (vs what you think you do). That’s the raw material that makes /pulse accurate and the anti-pattern engine honest.

The other commands that round out the system: /challenge argues against your own beliefs using vault evidence (anti-sycophancy engine with six analytical lenses), /relink finds missing connections between notes, and /de-ai strips AI-generated jargon from your writing. They’re all in the repo.

Going Further

What I open-sourced is the core system. 15 commands, the vault template, the CLAUDE.md / AGENTS.md template, and full documentation.

But I run 40+ commands privately. The advanced version includes:

• Kai, an always-on WhatsApp assistant that responds to messages via webhook, runs cron jobs, and proactively nudges me based on events
• Multi-agent orchestration where 9 specialized AI agents (Bolt for code, Sage for review, Nova for research, Orion for planning) work on Linear Project management tool built for software teams. Issues, cycles, roadmaps. Each agent gets assigned issues and works them autonomously through the API. issues autonomously, each with their own GitHub App and Linear OAuth identity
• QMD, a local search engine over 2,900+ vault documents. Keyword search in ~30ms, semantic search in ~2s, deep search (auto-expands queries, reranks) in ~10s. This is the backbone that makes every command fast
• Autopilot daemon that queues tasks for Codex OpenAI’s cloud coding agent. Runs autonomously in a sandbox. I queue tasks before sleeping and wake up to PRs. The autopilot daemon dispatches them with concurrency control. and dispatches them while I sleep. I queue 5-10 tasks at night and wake up to PRs
• /autobiography, a language learning wizard where you write your life story, translate it, analyze grammar errors, generate Anki cards, and do daily speaking practice. Built from a method by Jovanna Reyes Language teacher whose autobiography method replaces textbook exercises with personal storytelling. You learn vocabulary you’ll actually use because it’s about your own life.
• /workout, a full fitness system: program generation, session logging, and recovery-aware coaching based on Apple Health data
• /grill-me, inspired by Matt Pocock’s viral skill Structured interrogation. The AI asks you question after question about a plan or design until reaching shared understanding, resolving each branch of the decision tree. ~45 min sessions that surface assumptions you didn’t know you had. . Rubber ducking where the duck fights back, interviewing you relentlessly about a plan until every branch of the decision tree is resolved
• trx , an open-source agent-first CLI for transcription. Feed it a YouTube URL, a Google Meet recording, or a local file, and it outputs clean text via Whisper. The /meeting command uses it to transcribe recordings before extracting decisions and action items
• Health tracking synced with Apple Health data, 724+ daily files automatically ingested into Obsidian, queried by AI agents
• Content pipeline that turns daily work into tweets, blog posts, and videos

That’s not in the open source repo because it requires infrastructure (Cloudflare tunnels, WhatsApp API, custom webhooks, Codex access). But the foundation is the same vault + commands system.

What’s Next

This is the first post in a series. The personal OS is the foundation, but the real power is in the verticals built on top of it.

Domain series, one post per life area, each with its own commands and config patterns:

• AI Agents for Language Learning: How /autobiography replaced my TOEFL prep with a system that actually sticks. Writing your life story in a target language, getting grammar analysis, generating Anki cards, and doing daily timed speaking practice.
• AI Agents for Fitness: How /workout and /health read your Apple Health data and build programs that adapt. Commands that query your body like they query your codebase.
• AI Agents for Content Creation: How /draft, /ship-in-public, and the content pipeline turn daily engineering work into tweets, threads, and blog posts without extra effort.
• AI Agents for Research: How /lab and the Hunter Research Lab run 50-100 iteration loops overnight, with Claude and Codex agents working in parallel.

Skills series, deep dives into the global skills that make the whole system compound:

• The Scaffold Skill: Zero to production in 2 minutes. How /scaffold creates, deploys, and configures a full app from a single sentence.
• The Agent Browser Skill: Visual verification, screenshot comparison, and pixel-perfect iteration loops.
• The Clerk Skill: One-shot authentication setup for any project.
• Building Your Own Skills: How to create, test, and share agent skills that work across tools.

Each post will include the commands, the config patterns, and real examples.

Get Started

Three commands:

git clone https://github.com/Railly/agent-brain.git
cd agent-brain && claude
/init

/init is a guided wizard. It asks your name, your stack, your goals, and one recurring failure you keep repeating. Then it creates your vault, generates a personalized CLAUDE.md and AGENTS.md, copies all 15 commands, scans your machine for git repos, and creates your first daily log. Two minutes, zero manual setup.

After that, open the vault in Obsidian and try /morning from a new terminal.

The repo also includes:

• Vault template with example notes across all 7 folders
• CLAUDE.md + AGENTS.md templates with placeholder sections for identity, goals, and anti-patterns
• Two example configs (indie developer and employed engineer)
• Full documentation: setup guide, command reference, philosophy, customization

The repo is at github.com/Railly/agent-brain . Star it if it’s useful. Open an issue if something’s broken. And if you set it up and it changes how you work, I want to hear about it.

This is not a dotfiles repo. It’s a system. The commands reference each other. /today feeds /pulse. /inbox feeds the garden. /relink connects the dots. /draft turns insights into content. The flow is the product.

Shoutout to Luis Fernando Yupanqui whose symbiotic-ai (690+ stars) inspired me to finally share my own system publicly. Different approach, same philosophy: your AI should remember who you are.

Your AI should know your failures better than you do. That’s the point.

---

I’m also building The Last 30% , a course series on the software engineering fundamentals that AI skips. The first mini-course, Debugging AI-Generated Code (14 lessons), is completely free. Everyone who completes it gets perks for the rest of the series.