How I Built My AI Chief of Staff

A step-by-step guide to build this yourself: folder structure, templates, extraction prompt, and the bootstrap that wires it all together.

I Don’t Write Code. I Turned Claude Code Into My Personal Operating System Anyway.

I’m a product leader. I run a large creative platform. My background before tech was playing music professionally for seven years. I have never written a line of production code in my life.

When I first heard about Claude Code, I assumed it wasn’t for me. Command-line tool. Lives in a terminal. Marketing aimed at engineers. Everything about it signals “this is for developers.”

I was wrong. It turns out Claude Code runs inside a desktop app that looks like any other chat window. No terminal required. And the gap between what I assumed it was and what it’s actually capable of might be the most interesting misread in the current AI landscape.

Over the past few months, I’ve configured Claude Code into a personal operating system. Not a chatbot. A persistent, context-aware system that knows who I am, reasons through problems the way I do, writes in my voice, carries decisions across sessions, and gets sharper every week. I built the whole thing with text files and folder structure. The same skills you’d use to organize a shared drive.

The Problem

If you’re a product or marketing leader, you know this cycle: open a new AI chat, spend three messages explaining your role and context, get a competent but generic response, iterate until it’s close enough, close the window. Tomorrow, start over.

Your best human thinking partner didn’t become useful from a single conversation. They got there from months of shared context. They know your role, your products, what you’ve decided and why, how you talk. That accumulated context is the difference between a tool and a collaborator.

This setup answers one question: what if your AI had that context from the first message of every session?

What I Built

Identity context. A document describing who I am, what I lead, my strategic themes, my mental models, and critically: what I value in analysis and what makes me stop reading. Claude reads it at the start of every session. When I ask it to evaluate a pricing strategy, it doesn’t produce a generic pros-and-cons list. It evaluates through marketplace economics and behavioral incentives. Because those are my lenses now.

Thinking models. I externalized my actual decision frameworks. Not textbook models. The real filters I apply: does this scale? Does it compound? Does it change behavior or just enable it? Does it create structural advantage? Writing these down forced an unexpected reckoning. I’d been running on some of these for years without examining them. A few turned out to be habits, not frameworks. That clarity alone was worth the exercise.

Voice calibration. The most detailed piece, and the one that took longest to get right. My voice characteristics, sentence style, argument structure, vocabulary I reach for vs. words I never want to see. Real writing samples for calibration. And the section that changed everything: what reads as “off” to me. Defining what you reject is more useful than defining what you want. That negative space is where your actual voice lives.

An operating protocol. The behavioral contract: what Claude reads before every task, which folders are protected, communication rules (direct, concise, no jargon), and guardrails (show your plan before multi-step tasks, flag assumptions, never delete without confirmation). Plus a folder architecture with naming conventions so every output has a home. Mundane, essential infrastructure.

Persistent memory. This is the layer that makes the system compound. A routing file acts as a table of contents for Claude’s brain, loading only what’s relevant for the current task. Topic files cover professional context, thinking models, voice rules, and workflow protocol. I documented five modes I actually operate in: extraction (help me find words for an intuition I already have), distillation (raw inputs in, decision-ready output out), translation (same insight across audiences), pressure-testing (”this feels off” means push back, not agree), and sharpening (iterative tightening). Naming these modes changed how Claude responds to me.

A knowledge graph. Atomic notes titled as claims, not categories: “Feature speed is becoming a weak moat.” “Shipped features are not delivered value.” “Shallow adoption masquerades as product market fit.” When Claude searches for context on a new problem, it finds positions I’ve already taken. My past thinking shapes future analysis. Decisions have preserved rationale. Insights compound instead of disappearing between offsites.

Meeting notes. A structured archive with an index, monthly files, and a standard template. I paste transcripts from my meeting recorder. Two steps. Then I can ask: “What did we decide about pricing last quarter?” or “What action items am I behind on?” 23 hours of weekly meetings, made searchable.

Tool integrations. Semantic search over my knowledge graph, browser automation, cloud storage access, scheduled tasks (weekly competitive briefings run automatically), and design tools for quick social graphics and presentation visuals.

What Actually Changed

The shift is categorical, not incremental. Before: prompting a model, explaining context, starting over. After: working with a system that knows my role, reasons through my frameworks, writes in my voice, and improves with every session.

The architecture section above explains what the system is. Here’s what it actually does on a typical day.

Morning: meeting prep. A scheduled task ingests my calendar and produces a one-page brief before each meeting. What we decided last time. What action items are open. What each person committed to. Whether I’m walking into an information share or a decision that needs me. I used to either spend ten minutes re-reading old notes or show up cold. Now I show up prepared without doing the prep.

Between meetings: the leverage question. Thirty minutes between calls. Instead of opening Slack, I ask: what’s the highest-leverage thing I should focus on right now? The system cross-references my calendar, open action items, and project priorities. The first time it worked, it flagged something I’d completely forgotten that was blocking two other people. That single moment, where the system reduced the cognitive overhead of deciding what to do so I could just do it, was when it stopped feeling like a tool and started feeling like a thought partner.

End of day: metabolization. A scheduled task runs every evening. It consumes every meeting transcript from the day, produces a summary, extracts action items, and triages them into three buckets: what Claude can draft without me, what needs my partial input, and what only I can do. I wake up to a prioritized list with first drafts already started on the things that didn’t require my judgment. The Earmark integration described below is what feeds the transcripts in. The scheduled task is what turns them into next-day momentum.

People context: auto-updating. The metabolization also feeds a people file. Every person I meet with gets an entry that builds over time: who they are, what they do, how they connect to my work, what we’ve discussed. A CRM I never maintain. The surprise was what emerged from it. A direct report mentioned upcoming parental leave in a 1:1. Weeks later, when I was staffing a project, Claude flagged that this person would be out and listed the workstreams that needed transition plans. I hadn’t asked for that. The accumulated context made it possible.

Weekly: market intel. An automated digest runs each week, pulling market and customer signals filtered through the strategic priorities I’ve defined for the businesses I run. Not a generic news roundup. What surfaces is what actually matters to my decisions.

Three things I didn’t expect. Externalizing your thinking forces you to examine it in a way that makes you sharper independent of the AI. Naming beliefs as claims (”shipped features are not delivered value”) changes your relationship to knowledge because you can’t hide behind categories. And the people who’ll get the most from this aren’t the ones who can write Python. They’re the ones who can articulate how they think. That’s a product and marketing skill, not an engineering one.

I’m curious how others are approaching this. What layers have you built? What’s compounding? What’s not worth the effort?

The tools are here. The question is whether we treat them like search engines or like operating systems.

---

The Setup: Copy, Paste, Build

Everything below is designed to be handed directly to Claude Code. Copy the bootstrap prompt at the end into a Claude Code session and it will help you build the entire system interactively, filling in your specific context as you go.

What You Need (Three Tools)

The full stack is three tools. One is the engine, one is the viewer, one is optional but high-leverage.

1. Claude Code via the Claude Desktop App

This is not a terminal tool. The Claude Desktop App gives you Claude Code in a clean chat interface. Once installed, you’re working in a window that can read, write, and organize files on your machine. You chat with it. It builds things. That’s the whole interaction model. Claude Code requires a Claude Pro or Max subscription.

2. Obsidian

Obsidian is a free markdown editor that turns a folder of text files into a navigable, searchable knowledge base. Download it and point it at your ~/Claude/ directory. It becomes the viewer for everything Claude builds: your context files, knowledge graph, meeting notes, all of it. Graph view shows connections between notes. Search finds anything instantly. Not strictly required (the files are just markdown; any editor works), but it makes the knowledge graph and meeting archive genuinely usable.

3. Earmark (for meeting notes)

Earmark is a meeting transcription tool that runs locally on your machine and no bots join the call. After each meeting, it automatically drops a .md transcript file into a folder. Then I have a Claude scheduled task that runs at the end of each day, consumes all the day’s transcripts, and synthesizes them into structured meeting notes. I go from a full day of back-to-back meetings to a searchable, indexed archive without lifting a finger.

Folder Structure

Create this in your chosen working directory (e.g., ~/Claude/):

Claude/
├── Context/              ← Read-only: your identity and rules
│   ├── ABOUT_ME.md
│   ├── THINKING_MODELS.md
│   ├── VOICE_CALIBRATION.md
│   └── WORKING_PREFERENCES.md
├── outputs/              ← Claude writes here: all generated work
├── knowledge/            ← Your thinking archive
│   ├── graph/            ← Strategic insights (claims)
│   ├── decisions/        ← Key decisions with rationale
│   └── domain/           ← Market and user knowledge
├── Meeting Notes/        ← Searchable meeting archive
├── inbox/                ← Raw captures and drops
└── GLOBAL_INSTRUCTIONS.md

GLOBAL_INSTRUCTIONS.md

This is the behavioral contract. Save it at the root of your working directory.

# Global Instructions

I’m [YOUR ROLE] at [YOUR COMPANY]. I lead [WHAT YOU LEAD].
I think in [YOUR FRAMEWORKS -- e.g., systems, loops, incentives].

## BEFORE EVERY TASK
1. Read all files in Context/. No task starts without these.
2. If the task relates to an active project, check the relevant folder first.

## FOLDER PROTOCOL

### Read-only -- never create, edit, or delete:
- Context/ -- My identity, thinking models, voice, preferences

### Write folders:
- outputs/ -- Generated artifacts, organized by project
- knowledge/ -- Graph notes, decisions, domain knowledge
- inbox/ -- Unprocessed captures
- Meeting Notes/ -- Structured archive

### Naming conventions:
- outputs/: project_content-type_v1.md (e.g., q2_pricing-analysis_v1.md)
- knowledge/: prose-as-title (claims, not categories)
- Increment version number if file already exists

## HOW TO WORK WITH ME
- Lead with insight, not summary
- Challenge weak assumptions directly
- Use structured analysis: Problem > Why > Options > Recommendation > Risks
- System-level thinking, not feature-level

## COMMUNICATION STYLE
- Direct, concise, no filler
- Bullet points over paragraphs
- No corporate jargon or buzzwords

## OPERATING RULES
- Show your plan before executing multi-step tasks
- Flag assumptions explicitly before acting on them
- If instructions are ambiguous, ask -- don’t guess
- Never delete files without my explicit confirmation
- If task scope expands beyond what I asked, stop and check in

Context/ABOUT_ME.md (Template)

# About Me

## Role
[Your title, company, what you’re responsible for]

## Products / Business Areas
[List the products, teams, or business areas you own]

## Strategic Themes
[The problems and opportunities you keep returning to -- e.g.,
marketplace liquidity, retention systems, brand positioning,
demand generation, pricing strategy]

## Core Expertise
[What people come to you for -- e.g., product-led growth,
go-to-market strategy, competitive positioning, monetization]

## What I Value in Analysis
- [e.g., Structural thinking over surface observations]
- [e.g., Second-order effects, not just first-order]
- [e.g., Behavioral reality -- what people actually do, not what they say]

## What I Reject
- [e.g., Generic advice that could apply to any company]
- [e.g., Motivational fluff or hype language]
- [e.g., Repeating my question back as the opening line]
- [e.g., Vague frameworks without substance]

Context/THINKING_MODELS.md (Template)

# Thinking Models

## How I Break Down Problems
1. [e.g., Clarify the system: actors, incentives, constraints, loops]
2. [e.g., Identify the core dynamic: is this a growth, distribution,
   or monetization problem?]
3. [e.g., Find leverage points: what one change strengthens the system?]
4. [e.g., Evaluate options: benefits, risks, complexity]
5. [e.g., Recommend: take a position, don’t stay neutral]

## Decision Filters
When evaluating any initiative, ask:
- [e.g., Does it scale without proportional cost?]
- [e.g., Does it compound over time?]
- [e.g., Does it change behavior, not just enable it?]
- [e.g., Does it create defensible advantage?]

## How I Want Reasoning Presented
- [e.g., Show the thinking, not just the conclusion]
- [e.g., Build from observations upward]
- [e.g., Question assumptions along the way]
- [e.g., If uncertain, say so -- don’t project false confidence]

Context/VOICE_CALIBRATION.md (Template)

# Voice Calibration

## Core Voice
[e.g., Clear, analytical, confident, conversational. Calm authority
with thoughtful curiosity. Not corporate, not academic, not hype.]

## Sentence Style
[e.g., Medium-length baseline. Short declarative sentences at key
pivots for impact, not as default. Clear transitions. Natural rhythm.]

## Argument Structure
[e.g., Observation > Tension > Insight > Implication > Takeaway]

## Words I Use
[List 10-15 words/phrases you naturally reach for in your best work]

## Words to Never Use
[List words that make you cringe -- e.g., synergy, best-in-class,
innovative solutions, game-changing, holistic, robust]

## What Reads as “Off”
- [e.g., Motivational openers: “In today’s fast-paced world...”]
- [e.g., Lists without insight: “Here are 5 things...”]
- [e.g., Hedging: “It could be argued that...”]
- [e.g., Anything that feels assembled from a template]

## Writing Samples
[Paste 2-3 real examples of your writing -- LinkedIn posts, strategy
excerpts, internal memos. These are the calibration target.]

Context/WORKING_PREFERENCES.md (Template)

# Working Preferences

## How I Want to Be Challenged
- [e.g., Push back on weak logic directly -- don’t soften it]
- [e.g., If my framing is wrong, say so before answering the question I asked]
- [e.g., Don’t agree with me to be agreeable -- I’d rather be wrong and know it]

## My Five AI Modes
These are the types of help I actually need. I’ll invoke them by name.

- Extraction -- Help me find words for an intuition I already have.
  I know what I think; I can’t articulate it yet.
- Distillation -- Raw inputs in, decision-ready output out.
  Condense complexity into something I can act on.
- Translation -- Take the same insight and reframe it for a different
  audience (e.g., board vs. team vs. customer).
- Pressure-testing -- Push back. If something feels off, say so.
  Don’t agree. Find the weakest point and name it.
- Sharpening -- Iterative tightening. The draft is close.
  Make it better without changing the substance.

## Output Format Preferences
- [e.g., Bullet points over paragraphs for analysis]
- [e.g., Prose for drafts and narrative work]
- [e.g., Lead with the recommendation, then the reasoning]
- [e.g., Never bury the insight in the middle]

## What I Hate in AI Outputs
- [e.g., Restating my question back to me as the first line]
- [e.g., “Great question!” or any variation]
- [e.g., Hedging where a position is clearly warranted]
- [e.g., Lists of options when I asked for a recommendation]
- [e.g., Summaries at the end of a response I just read]

Meeting Notes Template

Save this as Meeting Notes/README.md:

# Meeting Notes

## Structure
- INDEX.md -- Master log of every meeting
- PEOPLE.md -- Key recurring people with context
- YYYY-MM.md -- Monthly files (e.g., 2026-03.md)

## Entry Template

---
## YYYY-MM-DD | Meeting Title | Duration

Attendees: Names
Type: standup | 1:1 | review | strategy | external
Tags: #topic1 #topic2

### Summary
[2-3 sentences: what was discussed and decided]

### Key Decisions
- Decision 1
- Decision 2

### Action Items
- [ ] @Person -- Task -- due YYYY-MM-DD

### Notes
[Paste transcript or raw notes here]

Persistent Memory (MEMORY.md)

Claude Code has an auto-memory directory that loads files automatically at the start of every session. You don’t need to find or create this folder manually. The bootstrap prompt will handle it.

For reference, the directory lives at:

~/.claude/projects/[encoded-working-directory-path]/memory/

The key file is MEMORY.md. It acts as a routing table: it tells Claude which context files to load based on the type of task. Writing a post? Load voice calibration. Running a strategy session? Load thinking models and business context. Processing meeting notes? Load the workflow protocol.

The bootstrap prompt creates this file automatically after your context files are built. Once it exists, every session starts with exactly the right context for what you’re doing.

Tool Integrations (Optional)

These are not required to get value from the system. The core setup, identity, thinking models, voice, memory, and knowledge graph, works without any of them. Add integrations once the base is working.

Claude Code connects to external tools via MCP (Model Context Protocol). Four worth knowing about:

• smart-connections -- Semantic search over your entire working directory. Ask “what have I written about X?” and it finds relevant notes by meaning, not just keywords. Install via the Obsidian plugin library.

• qmd -- Structured keyword and vector search over your markdown files. Faster for exact lookups.

• Claude in Chrome -- Browser automation. Claude can read and interact with web pages directly.

• Scheduled Tasks -- Run automations on a schedule. Weekly competitive briefings, daily meeting reviews, anything that should run without prompting.

Setup instructions vary by tool. Search for each by name in the MCP registry or Claude Code documentation. Start with smart-connections if you add anything. That alone is worth the effort.

Starting with Minimum Viable Context

Before you build from scratch, there’s a shortcut. If you’ve been using ChatGPT, Claude, or any AI tool for more than a few weeks, it already has a rough model of who you are, what you work on, and how you think. That accumulated context is sitting there. Extract it.

Open your most-used AI tool and paste this:

I’m migrating my knowledge base to a new system. I need you to export everything you know about me -- explicit and implicit -- organized into these categories:

Identity & Role: Who I am, what I do, my scope of responsibility, key products/teams

Strategic Beliefs: How I think about problems, mental models I favor, frameworks I return to, positions I’ve taken repeatedly

Decisions & Rationale: Key decisions you’ve seen me make or reference, and the reasoning behind them

Preferences & Boundaries: Communication style, what I like/dislike in outputs, tools I use, workflows I follow, things I’ve explicitly told you to never do

Domain Knowledge: Recurring topics, industry dynamics I’ve explained, competitive landscape I’ve referenced, market assumptions I operate from

Active Projects & Context: What I’m currently working on, what’s been top of mind recently

People & Relationships: Key people I’ve mentioned, their roles, how they relate to my work

Patterns You’ve Noticed: Anything I haven’t explicitly stated but that’s clearly true based on how I interact with you -- recurring concerns, blind spots I’ve flagged, questions I keep coming back to

Be exhaustive. Include things even if you’re not 100% certain -- flag confidence level. I’d rather filter down than miss something.

This will give you two to four pages of raw material. Some of it will be surprisingly accurate. Some will be wrong or shallow. That’s fine. You’re not using it as-is. You’re using it as a head start for the bootstrap interview below.

When I did this with ChatGPT, I got about three pages back in under ten minutes. The categories in the prompt map roughly to the context files you’ll build: Identity & Role becomes ABOUT_ME.md. Strategic Beliefs becomes THINKING_MODELS.md. Preferences & Boundaries becomes VOICE_CALIBRATION.md and WORKING_PREFERENCES.md. The rest feeds your knowledge graph and meeting notes over time.

Take that output and paste it into the bootstrap prompt session below. When Claude interviews you for each context file, you’ll already have your answers half-formed. What took me three hours to build from scratch could take you 90 minutes with this shortcut.

The Bootstrap Prompt

Copy everything below into a Claude Code session. It will walk you through building the full system interactively.

I want to set up Claude Code as my personal operating system using a
layered context architecture. Here’s the system I want to build:

FOLDER STRUCTURE:
Create this directory structure in ~/Claude/:
- Context/ (read-only identity files)
- outputs/ (generated artifacts)
- knowledge/graph/ (strategic insights as atomic claim-titled notes)
- knowledge/decisions/ (key decisions with rationale)
- knowledge/domain/ (market and user knowledge)
- Meeting Notes/ (structured archive)
- inbox/ (raw captures)

THEN, interview me to create these files:

1. GLOBAL_INSTRUCTIONS.md at the root -- Ask me about my role, what I
   lead, my communication preferences, and how I want you to operate.
   Write the behavioral contract.

2. Context/ABOUT_ME.md -- Interview me about my role, products, business
   areas, strategic themes, expertise, what I value in analysis, and
   what I reject. Go deep. This should read like a thorough briefing
   document, not a bio.

3. Context/THINKING_MODELS.md -- Ask me how I actually break down
   problems. What questions do I ask? What filters do I apply before
   recommending anything? How do I want reasoning presented? Push me
   to be honest about my real frameworks, not aspirational ones.

4. Context/VOICE_CALIBRATION.md -- Ask me about my writing voice, tone,
   sentence style, argument structure. Ask for words I use and words I
   hate. Ask me to paste 2-3 real writing samples. Then ask what
   “reads as off” to me -- the patterns that make me stop reading.

5. Context/WORKING_PREFERENCES.md -- Ask about collaboration style,
   output format preferences, how I want to be challenged, and what
   modes I operate in (do I sometimes need help finding words for an
   intuition? distilling complexity? translating across audiences?
   pressure-testing ideas? iterating drafts?)

Take these one at a time. Interview me thoroughly for each file before
writing it. Don’t accept surface-level answers -- push for specifics.

After all context files are created, create a MEMORY.md file in Claude
Code’s auto-memory directory that routes to these files based on task
type, so future sessions load the right context automatically.

Start with step 1.

---

That’s the full system. Text files and folder structure. Start with the bootstrap prompt and let Claude interview you. The hard part isn’t technical. It’s articulating how you actually think, write, and work. But that’s the part that makes it yours.

---

I recently went on the Supra Insider podcast to walk through this entire system live, including how the layers connect, what the daily workflow actually looks like, and the parts that surprised me most. If you want the full story behind the setup, this is it.