# I Wrote 1,321 Journal Entries. Claude Code Read All of Them.

*A 7-level system for building an AI thought partner with Obsidian and Claude Code*

By [michaelcjoseph's musings](https://writing.michaelcjoseph.com) · 2026-01-12

---

I have 1,321 journal entries, 746 Readwise highlights across 161 entries, and 829 meeting transcripts sitting in an Obsidian vault. For years, they just sat there. Writing something meant forgetting it existed, occasionally stumbling across an old note and thinking "huh, I had that idea already."

Two weeks ago, I connected the vault to Claude Code.

Now I query my own life from my phone. Before a meeting, I ask who someone is and what we last talked about. Before investing, I ask what I have previously thought about the company or space. When planning outings, I ask for restaurant recommendations (my own, ranked by my own ratings).

But the queries are not even the valuable part.

At the end of every week, month, quarter, and year, Claude reads my notes and interviews me about it. Not summarizes. Interviews. It asks how I felt about a decision I made. Surfaces a note I wrote 2 weeks ago that I had already forgotten. Brings up patterns I am not seeing.

During one review, it surfaced tension in a relationship I had been avoiding. The conversation forced me to address something I would have glossed over for another month. That is not what I expected from a journaling system.

This guide shows you how to build the same thing.

Seven levels. Each adds value on its own. You can stop at Level 1 (Claude reads your notes) or go to Level 7 (query everything from your phone). Start simple. Build up as the habit takes hold.

What each level unlocks:

Level

What You Get

Setup Time

1\. Access

Claude can read your notes

15 min

2\. Capture

Consistent input Claude understands

Ongoing

3\. Structured Data

Queryable lists you care about (e.g. people, books, places)

30 min

4\. Living Documents

Evolving thinking with history

30 min

5\. Reflection

AI powered weekly/monthly/quarterly/yearly reviews

30 min

6\. Quick Access

Fast lookups across everything

5 min

7\. Mobile

Query your vault from your phone

2-3 hours

  

Let's build it.

* * *

What I Got Wrong First
----------------------

**I over-engineered the structure.** First I tried elaborate folder hierarchies. Then I swung the other way. No folders, just bidirectional links everywhere. Then separate buckets for inputs, outputs, and reviews. None of it stuck. I made note taking and searching more complicated than it needed to be. You just need a daily journal with timestamps for notes. Claude Code takes care of the rest.

**I built automation instead of just using Claude.** My first instinct was to write Python scripts to parse tags, update files, generate summaries. Unnecessary. Opus 4.5 is good enough to just read the files and do it in conversation. No middleware required.

**I outsourced thinking instead of doing it.** Early versions had Claude summarize my week. Convenient, but I was not reflecting. I was consuming a report. The shift was making Claude interview me rather than report to me. When it asks "how did you feel about that decision?" I have to actually think. That is where the value is.

* * *

Level 1: Give Claude Access to Your Notes
-----------------------------------------

**Time:** 15 minutes **What you get:** Claude can read your notes and answer questions about them

### Install Obsidian

Obsidian is a markdown-based notes app. Your files stay on your computer, no lock-in.

1.  Download from [obsidian.md](https://obsidian.md)
    
2.  Install and open
    
3.  Click "Create new vault"
    
4.  Choose a location that syncs across devices. If you use Mac/iPhone, I highly recommend using iCloud. Otherwise Dropbox and Google Drive work as well.
    
5.  Name it whatever you want
    

**Mobile:** Download Obsidian from App Store (iOS) or Play Store (Android). Open the same synced folder.

### Install Claude Code

Claude Code is a CLI tool that reads your filesystem.

    # Install Node.js if needed
    # Mac: brew install node
    # Or download from nodejs.org
    
    # Install Claude Code
    npm install -g @anthropic-ai/claude-code
    
    # Verify
    claude --version

### Create CLAUDE.md

The `CLAUDE.md` file tells Claude who you are and how your vault works. Without it, Claude is guessing.

    # Navigate to your vault
    cd ~/path/to/your/vault
    
    # Start Claude Code
    claude
    
    # Run init
    > /init

The command creates a starter file. Now improve it by asking Claude to interview you:

    I want to improve this CLAUDE.md file. Interview me about:
    1. Who I am and what I do
    2. What I want to use this journal for
    3. What matters most in my life that you should pay attention to
    4. How I want you to help me
    
    Ask me questions one at a time, then update CLAUDE.md based on my answers.

**Minimum CLAUDE.md structure:**

    # CLAUDE.md
    
    ## About Me
    [Your name, role, what you work on]
    
    ## What Matters Most
    [Family, health, projects — things Claude should pay attention to]
    
    ## Vault Structure
    [Description of your folders]
    
    ## How to Help Me
    [Be concise, cite sources, ask questions, etc.]

### Test It

Open Claude Code in your vault and ask:

    What do you know about me based on CLAUDE.md?

If Claude can describe who you are and what matters to you, Level 1 is complete.

* * *

Level 2: Build a Capture Habit Claude Can Parse
-----------------------------------------------

**Time:** Ongoing habit (not setup) **What you get:** Consistent capture that Claude understands

### Daily Interstitial Journaling

One file per day: `journals/YYYY_MM_DD.md`

Obsidian handles this for you. Go to Settings → Core plugins → Daily notes. Enable it, then configure:

*   **New file location:** `journals`
    
*   **Date format:** `YYYY_MM_DD`
    
*   **Open daily note on startup:** On
    

Now Obsidian creates today's file automatically when you open the app.

Write timestamps and stream of consciousness. No rigid structure. Capture what you do, think, and feel.

    10:15 - Call with sarah about the product launch. She wants to push timeline by two weeks.
    
    10:45 - Back to the authentication bug. Need to check if the token refresh is the issue.
    
    12:00 - Lunch at Tatsu-ya #place. Best ramen in town.
    
    14:00 - Finished "Four Thousand Weeks" #book - the chapter on time anxiety hit hard.
    
    15:30 - Random thought: what if we added a social feature to the app?

### Key Elements

**File references:** `[[double-brackets]]` link to other files (e.g. projects). Create files sparing, at least at first. Once they're created, link to them liberally.

**Tags:** Signal data for structured storage (you will set this up in Level 3). For example you can use:

*   `#book` — books you read or want to read
    
*   `#place` — restaurants, cafes, locations
    
*   `#people` — people to remember
    

**Timestamps:** Create natural structure without rigid templates.

### Tools to Speed Up Capture

*   **Voice recording:** Apps like [Wispr Flow](https://wisprflow.ai/) transcribe voice to text
    
*   **Meeting notes:** Tools like [Granola AI](https://www.granola.ai/) capture transcripts you can drop into your journal
    

### Test It

Write a journal entry with at least one `[[file-reference]]` and one `#tag`. Then ask Claude:

    What did I do today?

If Claude can summarize your day from the journal, Level 2 is working.

* * *

Level 3: Turn Tags Into Queryable Data
--------------------------------------

**Time:** 30 minutes **What you get:** Structured data that enables reliable queries

### How It Works

Some things are worth tracking in structured format. Books, restaurants, people, movies, music. Whatever you care about.

The pattern:

1.  **JSON file** stores the structured data (one file per category)
    
2.  **Tag in journal** signals new data (e.g., `#book`, `#movie`)
    
3.  **Daily command** syncs tagged mentions to the JSON files
    

You tag something in your journal. The `/daily` command finds it and adds it to the right JSON file. Now you can query it reliably.

### Pick Your Categories

Choose what matters to you. Common examples:

*   Books you read
    
*   Restaurants and places you visit
    
*   People worth remembering
    
*   Movies or TV shows
    
*   Music and albums
    
*   Recipes you try
    

For each category, create a JSON file with a consistent schema, pick a tag to use in your journal, and add instructions to your `/daily` command.

### Example Setup

Here is what I track. Use this as a starting point or design your own.

**pages/books.json:**

    [  {    "id": "four-thousand-weeks",    "title": "Four Thousand Weeks",    "author": "Oliver Burkeman",    "status": "read",    "rating": 5,    "summary": "A meditation on time management that argues against productivity culture.",    "journal_refs": ["2024_01_15"],
        "last_updated": "2024-01-15"
      }
    ]

**pages/places.json:**

    [  {    "id": "tatsu-ya",    "name": "Tatsu-ya",    "city": "Austin",    "country": "United States",    "type": "restaurant",    "rating": 5,    "notes": "Best ramen in Austin. Get the original with extra chashu.",    "journal_refs": ["2024_01_15"],
        "last_updated": "2024-01-15"
      }
    ]

**pages/people.json:**

    [  {    "id": "sarah-chen",    "name": "Sarah Chen",    "context": "Product manager at work. Leading the mobile launch.",    "birthday": "03-15",    "journal_refs": ["2024_01_15"],
        "last_updated": "2024-01-15"
      }
    ]

### Add the /daily Command

Create `.claude/commands/daily.md`. This command reads your journal, finds tagged mentions, and syncs them to the right JSON files.

Here is an example based on my setup:

    # JSON Updates
    Review today's journal entry and update JSON data stores based on tagged mentions.
    
    ## Process
    
    1. Read today's journal file (`journals/YYYY_MM_DD.md`)
    
    2. Find all tagged mentions:
       - `#book` → update `pages/books.json`
       - `#people` → update `pages/people.json`
       - `#place` → update `pages/places.json`
    
    3. For each mention, either:
       - **Add new entry** if first mention
       - **Update existing entry** if already in JSON
    
    4. Show me proposed changes before writing

Adapt the tag-to-file mappings for your categories. If you track movies instead of books, use `#movie` → `pages/movies.json`.

### Update CLAUDE.md

Add the JSON schemas and tag system to your CLAUDE.md so Claude knows how to handle them.

### Test It

Write a journal entry with one of your tags. Run `/daily`. Claude should propose adding or updating the relevant JSON file.

Then query it:

    What books have I read this year?

If Claude can pull from your JSON files and answer, Level 3 is working.

* * *

Level 4: Create Documents That Evolve With You
----------------------------------------------

**Time:** 30 minutes **What you get:** Living documents that capture your evolving thinking

### Create Long-Standing Markdown Files

These are different from daily journals. They represent your current thinking on important topics. You update them as that thinking evolves.

**Example: pages/worldview.md**

    # World View
    
    My perspective on how the world is evolving.
    
    ## Technology
    [Your current thinking on tech trends]
    
    ## Geopolitics
    [Your current thinking on global dynamics]
    
    ## Energy
    [Your current thinking on energy transition]
    
    ---
    
    ## Changelog
    
    ### [[2024_01_15]]
    **Changed:** Added section on AI and energy requirements
    **Why:** Reading about data center power consumption shifted my thinking

**Other examples:**

*   `projects/product-name.md` — Status, thesis, open questions for active projects
    

### The Changelog Pattern

Every long-standing file has a changelog at the bottom:

    ## Changelog
    
    ### [[YYYY_MM_DD]]
    **Changed:** What was added, modified, or removed
    **Why:** The reasoning (what prompted the change)

The changelog creates a history of how your thinking evolved. You can look back and see the progression.

### How Updates Happen

1.  You read something or have a realization (capture it in your daily journal)
    
2.  During a review (Level 5), Claude surfaces the connection to your existing documents
    
3.  Claude asks questions that help you refine your thinking
    
4.  If your thinking changed, update the document and add a changelog entry
    

### Test It

Create a worldview or project document with at least two sections. Then ask Claude:

    Compare this idea [paste an idea] against my worldview. Where does it align? Where does it challenge my current thinking?

If Claude can reference your document and identify tensions or alignments, Level 4 is working.

* * *

Level 5: Have Claude Interview You
----------------------------------

**Time:** Add commands (30 min setup), then 30-60 min per review **What you get:** Interview-based reflection that surfaces patterns

### Add the /weekly Command

Create `.claude/commands/weekly.md`:

    Run my end-of-week review.
    
    **Time:** ~30 minutes
    
    ## Step 1: Prep (Silent)
    
    Identify the most recent Friday. Read journals from the 7 days ending on that Friday. Note:
    - Mentions of family and friends
    - Project activity and decisions
    - Books, people, places tagged
    - Emotional highs and lows
    - Anything unresolved or worth probing
    
    Do not present a summary. Just gather context for the conversation.
    
    ## Step 2: Interview
    
    Have a conversation about the week. This is not a checklist — follow what comes up. But loosely cover:
    
    **Memories** — Start here. Ask about highlights, low points. Surface specific journal entries to jog memory. Probe what might be glossed over.
    
    **Work** — What happened? Not status updates — what mattered? Any big decisions?
    
    **Learning** — What was read or thought about? What ideas are sticking?
    
    **Reflection** — What is weighing on me? What am I not seeing?
    
    Throughout:
    - Surface specific journal quotes when relevant
    - Ask follow-up questions — do not accept surface answers
    - Name it if something seems off between what was written and what is being said
    
    ## Step 3: Outline
    
    Present a structured outline of what will be written. Wait for approval.
    
    ## Step 4: Write-Up
    
    Write the review and append to the Friday's journal with a `---` separator.

### Add the /think Command

Create `.claude/commands/think.md`:

    Help me think through this. Do not solve it. Help me clarify my own thinking.
    
    Rules:
    - Ask more than tell
    - Surface assumptions I might be making
    - Connect to relevant notes in my vault
    - Reference past thinking on related topics
    - No documents, just dialogue
    
    $ARGUMENTS

### What Reviews Feel Like

The weekly review is a conversation, not a summary. Claude reads your journals silently, then asks questions. It feels like talking to a friend. One who also happens to be your therapist and coach.

Claude asks how you felt about certain events. Probes your rationale for decisions. Brings up notes you wrote that are relevant. Surfaces things you captured but forgot.

> **In practice:** During one weekly review, Claude surfaced a note about tension in a relationship. The conversation brought up things to address, things I would have glossed over without the prompt.

### Test It

Run:

    /weekly

Have the conversation. See if Claude surfaces specific things you wrote and asks questions that make you think.

For thinking partnership, try:

    /think Should I take on this new project?

See if Claude asks clarifying questions and references relevant context from your vault.

* * *

Level 6: Query Your Life in Seconds
-----------------------------------

**Time:** 5 minutes **What you get:** Fast lookups across everything you have built

By now you have journals, JSON data stores, and long-standing documents. The `/q` command lets you query all of it.

### Add the /q Command

Create `.claude/commands/q.md`:

    Search my vault and answer this question.
    
    Guidance:
    - Be extremely concise — just the answer, no preamble
    - Cite the source note in parentheses
    - For lists, use markdown list syntax
    - For people, check `pages/people.json` and their journal references
    - For places, check `pages/places.json`
    - For books, check `pages/books.json`
    
    $ARGUMENTS
    

### Example Queries

    /q best restaurants in Nashville

→ Returns your top-rated places from places.json

    /q what books did I read this year

→ Returns books with status "read" from recent months

    /q who is Sarah Chen

→ Returns CRM context and recent interactions from journal refs

    /q what have I been thinking about regarding AI

→ Searches journals and long-standing docs for AI-related entries

### Test It

Ask a question that spans multiple sources:

    /q What are my open questions about [project name]?

If Claude can pull from your project doc, recent journals, and any relevant reading notes, Level 6 is working.

* * *

Level 7: Access Everything From Your Phone
------------------------------------------

**Time:** 2-3 hours **What you get:** Query your vault from your phone

This level is optional but powerful. Being able to ask questions while out (restaurant recommendations, book suggestions, who someone is) changes how valuable the system feels.

### What You Need

*   DigitalOcean account (~$6/month for the server)
    
*   Tailscale account (free tier works)
    
*   GitHub account with your vault in a private repo
    
*   iPhone with Termius app (free)
    

### How It Works

Claude Code runs on a small cloud server. Your vault syncs to that server via GitHub. Tailscale creates a secure private network between your phone and server (no exposing ports to the internet). Termius is the SSH app on your phone that connects to the server.

The flow: Phone → Tailscale → Server → Claude Code → Your Vault

### Step 1: Push Your Vault to GitHub

Skip this if your vault is already in a private GitHub repo.

**On your computer:**

    cd ~/path/to/your/vault
    
    # Initialize git if needed
    git init
    
    # Create .gitignore to exclude Obsidian cache
    echo ".obsidian/workspace.json" >> .gitignore
    echo ".obsidian/workspace-mobile.json" >> .gitignore
    echo ".trash/" >> .gitignore
    
    # Initial commit
    git add -A
    git commit -m "Initial commit"
    

**On GitHub:**

1.  Go to [github.com/new](https://github.com/new)
    
2.  Name it something like `vault` or `notes`
    
3.  Select **Private**
    
4.  Do not initialize with README
    
5.  Click Create repository
    
6.  Copy the SSH URL (looks like `git@github.com:username/vault.git`)
    

**Back on your computer:**

    # Add remote and push
    git remote add origin git@github.com:YOUR_USERNAME/YOUR_REPO.git
    git branch -M main
    git push -u origin main

### Step 2: Create SSH Key (If Needed)

You need an SSH key on your computer to connect to the server. Check if you have one:

    ls ~/.ssh/id_ed25519.pub

If you see "No such file or directory", create one:

    ssh-keygen -t ed25519 -C "your@email.com"

Press Enter to accept the default location. You can skip the passphrase (just press Enter twice) or add one for extra security.

Copy your public key (you will paste this into DigitalOcean):

    cat ~/.ssh/id_ed25519.pub

This outputs something like `ssh-ed25519 AAAAC3Nza... your@email.com`. Copy the whole line.

### Step 3: Create a DigitalOcean Droplet

1.  Sign up at [digitalocean.com](https://digitalocean.com) (they often have free credits for new accounts)
    
2.  Click **Create → Droplets**
    
3.  **Region:** Choose somewhere close to you
    
4.  **Image:** Ubuntu 24.04 (LTS) x64
    
5.  **Size:** Basic → Regular → **$6/mo** (1 GB RAM, 1 CPU) — this is enough
    
6.  **Authentication:** Select **SSH Key**
    
    *   Click "New SSH Key"
        
    *   Paste the public key you copied earlier
        
    *   Name it something like "laptop"
        
7.  **Hostname:** Something memorable like `claude-server`
    
8.  Click **Create Droplet**
    

Wait about 60 seconds. Copy the IP address shown (something like `143.198.xxx.xxx`).

### Step 4: Set Up the Server

Connect from your computer's terminal:

    ssh root@YOUR_DROPLET_IP

Type `yes` when asked about the fingerprint. You should see a welcome message and a `root@claude-server:~#` prompt.

Run these commands one section at a time:

**Update the system:**

    apt update && apt upgrade -y

This takes a minute or two. If prompted about restarting services, press Enter to accept defaults.

**Install Node.js:**

    curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
    apt-get install -y nodejs

**Install Claude Code:**

    npm install -g @anthropic-ai/claude-code

**Install tmux and git:**

    apt-get install -y tmux git

tmux lets you keep Claude running even when you disconnect.

**Install and configure Tailscale:**

    curl -fsSL https://tailscale.com/install.sh | sh
    tailscale up

This prints a URL. Open it in your browser to authenticate with Tailscale. Create a free account if you do not have one.

After authenticating, get your Tailscale IP:

This shows something like `100.x.x.x`. Save this. You will use it to connect from your phone.

### Step 5: Clone Your Vault to the Server

Still on the server, generate an SSH key for GitHub:

    ssh-keygen -t ed25519 -C "claude-server"

Press Enter three times to accept defaults.

Display the public key:

    cat ~/.ssh/id_ed25519.pub

Copy the output. Now add it to GitHub:

1.  Go to [github.com/settings/keys](https://github.com/settings/keys)
    
2.  Click **New SSH key**
    
3.  Title: `claude-server`
    
4.  Paste the key
    
5.  Click **Add SSH key**
    

Back on the server, clone your vault:

    cd ~
    git clone git@github.com:YOUR_USERNAME/YOUR_REPO.git vault

Type `yes` when asked about the GitHub fingerprint.

Set your git identity:

    git config --global user.email "your@email.com"
    git config --global user.name "Your Name"

Authenticate Claude Code:

    cd ~/vault
    claude

This opens a browser auth flow. Complete it, then type `/exit` to quit Claude.

### Step 6: Create Convenience Aliases

These shortcuts make daily use faster:

    cat << 'EOF' >> ~/.bashrc
    alias notes='cd ~/vault && git pull && claude'
    alias sync='cd ~/vault && git pull'
    alias push='cd ~/vault && git add -A && git commit -m "Update from mobile" && git push'
    alias t='tmux attach -t claude || tmux new -s claude'
    EOF
    
    source ~/.bashrc
    

What these do:

*   `notes` — Pulls latest changes and starts Claude
    
*   `sync` — Just pulls latest changes
    
*   `push` — Commits and pushes any changes made on the server
    
*   `t` — Attaches to tmux (or creates a new session)
    

### Step 7: Set Up Tailscale on iPhone

1.  Download **Tailscale** from the App Store
    
2.  Open it and sign in with the same account you used on the server
    
3.  Toggle the connection **ON**
    

Your phone is now on the same private network as your server.

### Step 8: Set Up Termius on iPhone

1.  Download **Termius** from the App Store
    
2.  Open it and tap **Get Started** (you can skip creating an account)
    

**Create an SSH key in Termius:**

1.  Tap **Keychain** (bottom nav)
    
2.  Tap **+** → **Generate Key**
    
3.  Name it `phone`
    
4.  Tap **Generate**
    
5.  Tap the key you just created
    
6.  Tap **Export to clipboard** → **Public key**
    

**Add the key to your server:**

From your computer (still connected to the server via SSH):

    nano ~/.ssh/authorized_keys

Paste the public key from Termius on a new line. Press `Ctrl+X`, then `Y`, then Enter to save.

**Create the host in Termius:**

1.  Tap **Hosts** (bottom nav)
    
2.  Tap **+** → **New Host**
    
3.  **Hostname:** Your Tailscale IP (the `100.x.x.x` from Step 4)
    
4.  **Username:** `root`
    
5.  Tap **Keys** and select the `phone` key you created
    
6.  Tap **Save**
    

**Test the connection:**

Tap the host. You should see the server's command prompt.

### Daily Mobile Usage

**Starting a session:**

1.  Open Termius
    
2.  Tap your server
    
3.  Type `t` and press Enter (attaches to tmux)
    
4.  Type `notes` and press Enter (pulls latest vault, starts Claude)
    

**Asking questions:**

    /q best restaurants in Nashville

    /q who is Sarah Chen

    /q what was I working on last Tuesday

**Ending a session:**

To keep Claude running in the background:

1.  Press the key labeled `Ctrl` in Termius
    
2.  Press `B`
    
3.  Press `D`
    

This detaches from tmux. Claude keeps running on the server. Next time you connect, type `t` to reattach right where you left off.

To fully quit Claude, type `/exit` before detaching.

### Keeping Your Vault in Sync

The vault lives in three places: your computer, GitHub, and the server.

**On your computer (after journaling):**

    cd ~/vault
    git add -A && git commit -m "Update" && git push

**On the server (the** `notes` **alias pulls automatically):**

If you make changes from mobile and want to push them:

    /exit
    push
    notes

**Tip:** Commit and push from your computer before using mobile. The `notes` alias pulls before starting Claude, so you always have the latest.

### Troubleshooting

**Cannot connect from Termius:**

*   Check Tailscale is connected on your phone (green toggle)
    
*   Verify the Tailscale IP is correct (`tailscale ip -4` on server)
    
*   Make sure you added the Termius public key to `~/.ssh/authorized_keys`
    

**Claude not starting:**

*   Run `claude` manually and check for errors
    
*   You may need to re-authenticate: `claude` then follow the auth flow
    

**Vault out of sync:**

*   On server: `cd ~/vault && git pull`
    
*   On computer: `git pull` then `git push`
    

**tmux session gone:**

*   Type `t` to create a new one
    
*   If Claude was running, it stopped when the session ended
    

### Test It

From your phone, connect and run:

    /q What did I work on this week?

If you get an answer based on your journals, Level 7 is complete.

* * *

The Only Way This Fails
-----------------------

The system only works if you capture.

Quality input leads to quality output. If you journal sporadically or superficially, Claude has less to work with.

But the feedback loop changes behavior. When your notes produce valuable output, you capture more. The insights and questions make the habit stick. The system rewards paying attention to your own life.

Skip a few days and nothing breaks. The system adapts to your rhythm.

* * *

What Comes Next
---------------

The system gives back more than you put in.

In two weeks I have already noticed:

1.  **I capture more** because I know it will not disappear. The friction of "where does this go?" is gone. Everything goes in the daily note. Claude sorts it out later.
    
2.  **I think more clearly** because weekly reviews force articulation. Saying "the week was fine" does not survive Claude's follow-up questions.
    
3.  **I remember my own life** in a way I did not before. Not just what happened, but what I thought about it, what I was worried about, what I was excited about.
    
4.  **I trust the system** to surface what matters. If something is important, it will come up in a review or a query. I do not need to hold everything in my head.
    

And this is just the foundation. Once it is working, you can extend it to be your:

*   **Accountability Partner**: Do not just reflect. Set goals and have Claude help keep you accountable.
    
*   **Health Coach:** Log workouts, use Claude as a trainer/nutritionist
    
*   **Research Assistant:** Create persistent research files that evolve like your worldview
    

Start with Level 1. Build up as the habit takes hold. Your notes will start talking back.

---

*Originally published on [michaelcjoseph's musings](https://writing.michaelcjoseph.com/claude-code-journal)*
