Jonathon's AI Wiki

Build Your Own Jarvis with Claude Cowork — Three-Level Rule-Stacking AIOS (Jeff)

13 min read

Source: “Claude Cowork — Build Your Own Jarvis” YouTube tutorial by Jeff, 20-min video, youtube.com/watch?v=0_dSWLOHKng, fetched 2026-05-03. Auto-captions normalized via perl -0777 for “Cowork” (caption: “Coowwork” / “Co-work” / “Coor”), “CLAUDE.md” (caption: “claw.md” / “cloudmd” / “cloud MD” / “clawed MD”), “memory.md” (caption: “memory.mmd” / “memory MD”), “voice-principles.md” (caption: “voice principles.mmd”), “Coursera” (caption: “Corsera”), “Sonnet”/“Opus” (preserved). The “iClaude OS” parent folder name is the speaker’s intentional pun on “iCloud” (transcript line 41–46).

A non-developer-friendly tutorial that takes a Cowork user from empty desktop to a functioning personal “Jarvis” — a workspace where Cowork knows the user’s writing voice, active projects, finances, email conventions, and Notion structure. The setup uses three nested levels of CLAUDE.md files (root → workstation → project) plus per-level memory.md and on-demand resources/ folders. Operator counterpart to Simon Scrapes’ developer-track nine-component AIOS — same architectural pattern (rule stacking + persistent memory + skills), different surface (Cowork desktop vs Claude Code terminal). Sister tutorial to the Cowork Getting Started Notion walkthrough which covers Cowork basics; this one is the deep follow-on for users who already understand Cowork and want a personal command center.

Key Takeaways

  • The whole system is plain text files. Source’s most-emphasized point (“the single most important takeaway” — line 56–58): CLAUDE.md and memory.md look like code but they aren’t. Open them, copy-paste into any notes app, and you’ll see Header 1 + bullet points. The intimidation factor is purely visual; the actual files are human-readable lists of preferences and rules. This is the operator-track unlock that a lot of people miss when they hear “AIOS.”
  • Three-level rule stacking — US Constitution analogy. Root CLAUDE.md = countrywide constitution (every session reads it first). Workstation CLAUDE.md (e.g., Email HQ, Personal Finances) = state law (loaded only when working on that area). Project CLAUDE.md (e.g., Boston Wedding Trip under Travel) = city ordinance (loaded only for that project). Rules stack — a workstation rule layers ON TOP of root rules, doesn’t replace them. Writing an email reads both root voice principles AND email-specific conventions (greeting, signoff). This is the same parent-folder-inheritance pattern that Simon Scrapes documented for multi-client Claude Code architectures.
  • Persistent memory comes from two specific lines in root CLAUDE.md. Quote (line 168–172): “At the start of every session, read memory.md before responding” + “When I say remember this, write the information to memory.md.” That’s the entire memory system — two sentences. Cowork follows them automatically. The memory.md file has two top-level sections: Active Projects (auto-populated when you tell Cowork what you’re working on) and Memory (auto-populated when you say “remember this”). To verify it’s working, start a new session and ask “What did I say about X recently?” — Cowork retrieves from memory.md.
  • Routing map points to resources, doesn’t include them. Root CLAUDE.md has a “References” section listing pointers to files in 00-resources/ that Cowork ONLY loads when needed. Example: voice-principles.md (~150 lines in Jeff’s actual setup) is referenced — not inlined — so it doesn’t burn tokens on every session. The “Routing Map” subsection is a table mapping task types to which workstation folder to load. This is progressive-disclosure pattern applied to personal context, not just to skills.
  • Voice profile auto-generated from your last 30 sent emails. Jeff ships two prompt templates (option 1: Gmail connector reads last 30 sent emails; option 2: paste five writing samples). Either runs once and writes the result to voice-principles.md — warm/direct/professional, lead with transparency, etc. From then on every workstation that drafts text reads voice-principles first. Adds entries over time as Cowork learns more preferences. Foundation for the voice-first content systems pattern but applied at the OS level rather than per-skill.
  • Workstation auto-creation rule is the meta-trick. Inside root CLAUDE.md: “Whenever I ask for a new workstation, create a subfolder with that name and add a CLAUDE.md, memory.md, and empty resources/ folder inside.” So building Email HQ is just “make me an email-hq workstation” + one prompt template that scrapes Gmail send folder for last 4 weeks of patterns and writes editorial-rules section to email-hq/CLAUDE.md. Cowork builds its own scaffolding. Same trick works for any workstation — Personal Finances, Travel, Speaking Engagements, Housing, Newsletter HQ.
  • Universal vs Dedicated workstations. Universal = things you do across every life area (email is the canonical example — you email your team, your accountant, your sponsors). Dedicated = one specific area (Personal Finances, Travel). Project subfolders only live inside dedicated workstations (e.g., Travel/2026-Boston-Wedding/, Speaking-Engagements/2026-Q3-Corporate-Workshop/). Each project gets its own CLAUDE.md + memory.md + resources/.
  • Cost discipline — three rules to control token spend. (1) Keep root CLAUDE.md under 300 lines because it loads on every session — point to resource files instead of inlining content. (2) Don’t repeat the same rule in multiple files — root voice-principles handles “no corporate jargon, never bury the lead”; email-hq only adds email-specific rules like thread-first drafting, default greeting, default signoff. (3) Default to Sonnet — “80% of the time Sonnet is more than enough and it’s a fifth of the cost of Opus. Switch to Opus only when the task has 3+ steps that all depend on each other.” Aligns with Opus 4.7 best practices (W16 made Opus 4.7 default on Max/Team Premium; this video predates that change).
  • Session-audit skill captures principles between sessions. Jeff ships a starter /session-audit skill (linked from his free Cowork toolkit). At end of a session: type /session-audit (or “before we wrap audit this session”) and Cowork scans the conversation for unsaved principles/preferences and writes them to memory.md so the next session inherits them. This closes the Simon Scrapes wrap-up gap — same pattern, packaged as a Skill in Cowork instead of a Hooks pattern in Code.
  • Concrete use cases shown. (a) Screenshot-a-copywriting-framework + “save it somewhere, figure it out” → routing map sends it to existing copywriting-frameworks.md. (b) Email HQ rule “before drafting any email, search Gmail for existing threads with the recipient on the same topic” — kills the multiple-thread anti-pattern. (c) Post-meeting follow-up: pull latest event from calendar → fetch transcript → identify it’s tied to a corporate-training project under Speaking Engagements → load that workstation → draft follow-up email per Email HQ rules. All chained automatically. (d) Travel project creation: “I’m going to Boston July 17–24 for a wedding, set up a project in Notion” — Cowork knows your Notion conventions from command-center/CLAUDE.md and builds the Notion page with all properties + sections + a notes thread. (e) 12 months of credit card statements → Personal Finances workstation builds a master spending tracker spreadsheet with Transactions / Yearly Summary / Monthly Summary / Category Taxonomy tabs; corrections (e.g., “Canva is software/subscription, not freelancer”) get persisted so future months categorize correctly.
  • Build slowly. ~30 workstations is the eventual ceiling. Direct quote (line 430–435): “After building almost 30 workstations, I can tell you it’s best to start slow. Build two or three workstations out. Get used to how the CLAUDE.md and memory.md files all interact to work together and only build new workstations when the need comes up.” Don’t try to scaffold the full operating system day one — wait for the friction signal.
  • Obsidian for reading-only, not authoring. Jeff suggests installing Obsidian and pointing it at the Cowork-OS/ folder as a vault — purely to read the markdown files in a friendlier format. Explicit caveat: “I don’t know how to use Obsidian — we’re just using it to read the markdown files.” Also: Obsidian only indexes markdown, so Excel files (e.g., the spending tracker) are invisible in the sidebar even though they exist on disk. The Cowork-OS/ folder is the single source of truth, not Obsidian. Mirrors how the Karpathy LLM-wiki pattern uses Obsidian as a viewer for an LLM-maintained file tree.
  • Why the strategic ending matters — “start today.” Jeff’s closing argument: “It doesn’t have to be on Claude — Google and OpenAI will definitely come up with Cowork equivalents. You don’t even have to use my templates or take my course. But you do need to start building this personal context system as soon as possible because the rules, the memory, the patterns compound every single session and you will always be ahead of someone who starts even a day after you.” This is the operator-track justification for the 2026 Claude Code AIOS Pattern — accumulated context becomes a moat.

Architecture at a glance

Cowork-OS/                              ← star this folder in Cowork; loaded by default
├── CLAUDE.md                           ← root: instructions + routing map + references (≤300 lines)
├── memory.md                           ← root memory: Active Projects + Memory sections
└── 00-resources/                       ← detailed knowledge, loaded on-demand
    ├── voice-principles.md             ← generated from last 30 sent emails (~150 lines)
    ├── copywriting-frameworks.md       ← reference library, auto-routed to from chat
    └── notion-conventions.md           ← Notion property/section conventions
│
├── email-hq/                           ← UNIVERSAL workstation
│   ├── CLAUDE.md                       ← editorial rules (greeting/signoff, thread search rule)
│   ├── memory.md                       ← email-specific memory
│   └── resources/                      ← (empty until needed)
│
├── personal-finances/                  ← DEDICATED workstation
│   ├── CLAUDE.md                       ← finance rules + categorization conventions
│   ├── memory.md                       ← spending decisions, ongoing categorization corrections
│   └── resources/
│       ├── master-spending-tracker.xlsx ← invisible in Obsidian sidebar (markdown-only index)
│       └── statements/                  ← 12 mo of credit card PDFs
│
└── travel/                             ← DEDICATED workstation
    ├── CLAUDE.md                       ← travel preferences (airlines, lodging tier, packing rules)
    ├── memory.md
    └── 2026-boston-wedding/            ← PROJECT subfolder
        ├── CLAUDE.md                   ← project-specific rules
        ├── memory.md
        └── resources/

Implementation

Tool/Service: Claude Cowork (desktop, Pro/Max/Team) + plain-text Markdown files. No code or scripts required. Optional: Obsidian (free) for friendlier reading. Optional: Gmail connector inside Cowork for the voice-profile generation step.

Setup (~30 min for the root + 1 workstation):

  1. Create Cowork-OS/ folder in Documents. Drop Jeff’s three starter templates inside: CLAUDE.md, memory.md, and 00-resources/voice-principles.md (linked from his free Cowork toolkit). Pro tip from source: when downloading the templates, use File → Download → Markdown to ensure correct format (not HTML/PDF).
  2. Open Cowork → select Cowork-OS/ as parent folder → click “Always Allow” → star it so Cowork defaults to this folder every new session.
  3. Generate voice profile by pasting the appropriate prompt template into a fresh Cowork session. Option 1: Gmail-connected (scrapes last 30 sent emails). Option 2: no-Gmail (paste five writing samples). Cowork writes/updates voice-principles.md.
  4. Build first universal workstation — Email HQ by pasting the email-hq prompt template. Cowork’s auto-creation rule (in root CLAUDE.md) creates the subfolder, and the prompt’s own instructions extract email-specific patterns from the last 4 weeks of Gmail send folder, write them to email-hq/CLAUDE.md’s editorial-rules section.
  5. Build first dedicated workstation — Personal Finances by mounting 12 months of credit card statements and pasting the personal-finances prompt template. Cowork builds the master spending tracker spreadsheet inside personal-finances/resources/ with four tabs (Transactions / Yearly Summary / Monthly Summary / Category Taxonomy).
  6. Install the /session-audit starter skill via Cowork → customize skills → upload skill (.skill file from Jeff’s toolkit). Use /session-audit (or “before we wrap, audit this session”) at the end of significant sessions.

Cost:

  • Cowork access: requires Claude Pro (100–200), Team ($20/seat), or Enterprise (custom).
  • Default model — Sonnet (free under existing tier; $/1M tokens internally allocated). Reserve Opus for tasks with 3+ dependent steps. Pre-W16 the source assumes Opus 4.6; post-W16 Max/Team Premium defaults to Opus 4.7 (see W16 release notes).

Integration notes:

  • Gmail connector required for voice-profile generation Option 1. Set up via Cowork → Connectors → Google → Gmail.
  • Notion conventions captured in a separate command-center/CLAUDE.md (not shown in detail in the transcript) is what powers the “create a Notion travel project” example. Pattern: any external system you want Cowork to write to needs its own conventions file in 00-resources/ or a dedicated workstation.
  • Excel files invisible in Obsidian sidebar because Obsidian only indexes markdown. Pin the Cowork-OS/ folder as the source of truth, not the Obsidian vault view.
  • Cowork desktop must stay awake when running multi-step workflows (per Dispatch tutorial — same constraint applies here).

Try It

  • Build a minimal version: just Cowork-OS/CLAUDE.md + memory.md + one workstation (email-hq/). See if persistence works across sessions before scaffolding more.
  • Compare with Simon Scrapes’ developer-track nine-component framework — same architectural primitives applied to Claude Code skills/hooks/projects rather than Cowork workstations. Pick whichever surface matches the team’s daily driver.
  • Run a /session-audit after the next 5+ significant sessions to see how memory.md evolves; expect “remember this” prompts to be the most common trigger.
  • Replace the Cowork Getting Started one-folder setup with a Cowork-OS/ parent folder + 1 workstation if your daily Cowork use is starting to feel chaotic. The 7-step intro walkthrough is the prerequisite.
  • Compare the cost discipline rules (root ≤300 lines, no rule duplication, Sonnet default) against the prompt-caching agency economics article — same theme: stable prefixes + lean per-session context.
  • For WEO Council audiences: this is operator-track territory and complements the Intermediate Course Module 3 coverage of Cowork as the Intermediate course’s no-code path.

Open Questions

  • Creator’s full identity unconfirmed. Transcript names “Jeff” (line 65: “Jeff’s Cowork”) with style cues consistent with productivity YouTuber Jeff Su (Coursera promo, 6+ years making videos, “Cowork toolkit” + paid “Cowork Academy” wait list, ~30 workstations built personally). Source doesn’t include a last name; treat as anonymous-Jeff until verified via channel page.
  • Cowork Academy course referenced but not yet shipped. Source line 365–370: “I’m putting together a Cowork Academy course, and you can sign up for the wait list down below.” Worth tracking if it materializes — would be a candidate ingest for a more production-grade WEO Marketly operator-track recommendation.
  • Free Cowork toolkit URL not in transcript. Three starter templates (CLAUDE.md, memory.md, voice-principles.md) + email-hq prompt + personal-finances prompt + /session-audit skill are all gated behind a sign-up. Could be retrieved via the YouTube description if the operator is willing to subscribe.
  • /session-audit skill internals not detailed. Source line 510–516: install via “customize skills → upload skill”. The internal logic of the skill — what it scans, how it decides what to write to memory.md — isn’t shown. Would be useful for skill-design comparison if the source code becomes available.

Graph View

Backlinks