The argument in one line.
Building an AI operating system is not about choosing the right model - it starts with one default habit and compounds through four ordered layers that together turn a chat tool into a second brain that acts on your behalf.
Read if. Skip if.
- You use Claude Code or a similar agentic IDE daily but still open separate AI tools for different tasks.
- You want a reusable knowledge and skills architecture that survives model switches and subscription changes.
- You manage a small team and are thinking about how to extend a personal AI OS to colleagues.
- You are already experimenting with custom slash commands and want a principled framework for organizing them.
- You want a step-by-step setup guide - the actual hands-on course lives in a free external community, not this video.
- You are not using an agentic harness like Claude Code, Codex, or equivalent - the architecture advice assumes one.
The full version, fast.
An AI operating system begins with one decision: defaulting to your agentic harness instead of scattered tabs. The four-Cs framework - Context (your CLAUDE.md as a routing tree), Connections (live vs. static data via APIs and CLIs), Capabilities (skills encoding repeated prompts), and Cadence (automated triggers) - describes the build order and explains why skipping layers creates brittle systems. The creator walks through his actual HERC 2 project structure live, including a permission-layer principle that no prompt is a security boundary: only scoped API keys are.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Intro: Claude Fable and My Second Brain
Obsidian graph and Claude Fable benchmark table. Frames the video as a live system walkthrough, not a getting-started guide.

02 · The Mindset Shift
Close the tabs. Default to one harness. Before/After slide: scattered tools vs. single compounding context.

03 · The Four Cs Framework
Diagram: Context to Connections to Capabilities to Cadence. Second brain equals first two layers; OS equals last two.

04 · Context: Your Routing Tree
CLAUDE.md as a router pointing to rules, skills, wikis, other projects. Live VS Code walkthrough of HERC 2 folder structure and OtherWorlds pattern.

05 · Connections: Static vs Live Data
Tier-1 map of weekly apps by category (Revenue, Calendar, Comms, Tasks, Meetings, Knowledge). APIs and CLIs preferred over MCP servers for control and cost.

06 · What Fable Already Knows About Me
Live demo of /goal slash command generating a who-I-am video from transcripts. One-shot relationship-map app. Explains why static data goes stale and how live connections fix it.

07 · Capabilities: Skills and Workflows
Repetition is the signal for a skill. Assembly-line sessions: one clean job, then pass output. 20+ skills shown live. Update every skill after each use.

08 · Cadence: Automating While You Sleep
Three trigger types: manual, event, schedule. Autonomy is earned through battle-testing. Cautionary story: agent sent a discount code to 150-200K people unintentionally.

09 · Usage Tips
Thought partner with devil's advocate framing; grill-me skill for knowledge extraction; have agent verify its own work visually or with Playwright.

10 · Lightning Round Q&A
Cost, data privacy, no-code entry via GitHub starter repo, handling confident mistakes, live connections via APIs, team rollout.

11 · Final Thoughts
You are building your own personal OS, not a Claude Code OS. Folders, markdown, skills, routing logic - that is the IP that survives every model switch.
Lines worth screenshotting.
- An AI OS does not start with architecture - it starts with a default; closing tabs and opening your harness first is the entire first step.
- The second brain and the AI OS are two distinct layers; conflating them is why most setups feel like they never quite work.
- CLAUDE.md is a router, not a knowledge base - it holds pointers to where content lives, not the content itself.
- Static context and live connections require different handling; mixing them into one file creates staleness bugs you will spend weeks debugging.
- Any prompt you type three times is waiting to become a skill - repetition is the signal, not complexity.
- Skills are never finished - every use is data; updating the skill after each run is how the system compounds instead of plateauing.
- The assembly-line mental model applies to sessions: one clean job per session, then pass the output forward, rather than doing everything in a single context window.
- A prompt is never a permission layer - if the agent has a credential, assume it will use it; security is scoped API keys, not instructions.
- More autonomy in an automation means more monitoring, not less - the maintenance burden scales with the capability.
- The model is just the engine - folders, markdown files, skills, and routing logic survive every model switch; that is what you are actually building.
- Context rot is real: too much work in one session blurs outputs; phasing tasks with a clear between them keeps outputs sharp.
- Having the agent verify its own work is a concrete instruction, not a metaphor - give it a browser, have it click through, require it to show sources.
The model is the least interesting variable in your AI setup.
Every capability gap you feel with AI tools is almost always an architecture gap, not a model gap - and fixing it follows a specific order.
- Default first: close every other AI tab and commit to one agentic harness before building anything else; context compounds only when it accumulates in one place.
- The second brain and the AI OS are two distinct layers - Context and Connections build the brain, Capabilities and Cadence make it an OS; skipping layers produces systems that feel fragile.
- Treat your system prompt as a router of pointers, not a knowledge dump - it should say where things live, not contain everything itself.
- Separate your static knowledge from your live connections - they go stale at different rates and need different refresh strategies.
- The signal for a skill is repetition: any prompt you type three times should become a reusable slash command, and you should update it after every run.
- Run one clean job per AI session, then pass the output to a fresh context for the next phase - mixing research, drafting, and publishing in one session degrades all three.
- Automate only what is battle-tested: the cost, risk, and maintenance burden of an automation all increase together, and set-it-and-forget-it is how agents send wrong emails to 200,000 people.
- A prompt is never a permission boundary - if your agent has a credential, architect around the assumption it will use it; scoped API keys are the real guardrail.
- Having the agent verify its own work is a concrete instruction you give inside the prompt - specify how (open a browser, click through, check accuracy) the same way you would with a new employee.
Terms worth knowing.
- AIOS (AI Operating System)
- A personal computing layer built on top of an agentic AI harness, combining a knowledge base, live data connections, reusable skill automations, and scheduled tasks - as distinct from a simple chat interface.
- Second Brain
- The knowledge layer of an AIOS - all the static and semi-static information the agent knows about your business, life, and context, stored as markdown files rather than a database.
- CLAUDE.md (as router)
- The primary instruction file in a Claude Code project, used here not as a knowledge store but as a routing tree of pointers that tells the agent where rules, skills, wikis, and other projects live.
- OtherWorlds folder
- A convention for nesting multiple distinct code projects inside one Claude Code workspace so a single session can reach across repos without switching projects.
- Context rot
- The degradation in output quality that occurs when a single AI session handles too many distinct tasks, causing earlier context to dilute or confuse later responses.
- Grill Me skill
- A custom slash command that instructs the agent to ask the user an extended series of questions to extract knowledge from the human into the second brain markdown files.
- Cadence
- The fourth layer of the four-Cs framework - automations that trigger on a manual call, an event, or a schedule, running without the user being present.
- Scoped API key
- An API credential with explicit read/write/delete permissions restricted to specific endpoints, used as an actual permission boundary rather than relying on prompt instructions to prevent unwanted agent actions.
Things they pointed at.
Lines you could clip.
“An OS doesn't start with architecture. It starts with a default.”
“I think of my CLAUDE.md file as my router. It's like, okay, this is where the files live.”
“Your skill will almost never be perfect on the first try. Every time you use your skill, that's data.”
“A prompt is never a permission layer. If it can, it will.”
“You're not building a Claude Code AIOS. You're building your own personal operating system.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
An Obsidian knowledge graph fills the screen - hundreds of nodes, each one a piece of a creator's business. The claim is audacious: a single AI agent understands this better than its owner does. What follows is not a product demo but an architecture tour, and the lesson is that the model is the least interesting variable.
Named ideas worth stealing.
The Four Cs
- Context
- Connections
- Capabilities
- Cadence
A build-order framework for an AI operating system. Context = who you are and your routing tree. Connections = live data access. Capabilities = skills and automations. Cadence = scheduled/event-triggered runs. The order is not optional - each layer depends on the previous.
The Routing Tree
CLAUDE.md acts as a router, not a knowledge store. It holds pointers to where content lives. Pulse check: if you cannot manually drill to any file, the agent cannot either.
Assembly-Line Sessions
Each Claude Code session should do one thing well and hand a clean output to the next session. Parallel tasks delegate to cheaper sub-agents with one summary returned to the orchestrator. Prevents context rot.
Keys Not Prompts
A prompt is never a permission layer. If an agent has a credential, assume it will use it. Real permission layers are scoped API keys that limit physical capability: archive instead of delete, draft instead of send, read instead of edit.





































































