Compound Journaling with Claude Code
Structured Reflection for the Over-Engineered Brain
An open-source journaling system built on Claude Code: daily rituals, searchable history, and “lenses” for reflection, all in AI-organized files you control. Built to compound and evolve with you over time. Fork it and make it yours with /onboarding
Have you ever wanted to panic-Google your own brain? Please tell me it’s not just me.
After a year of asking AI to remind me what we’d talked about, I realized I wanted something more rigorous than chat logs.
I have tried journaling before: apps, morning pages, sporadic notebooks, random bursts of adherence across too many mediums. The problem wasn’t just consistency. It was that the good stuff didn’t resurface. Context got lost, with motivation close behind it.
I wasn’t looking for “perfect memory.” Rather, I wanted journaling to compound: a facilitated habit that builds an index of my own context, pulls in history when it matters, and lets me choose a useful lens in the moment - so when Future Me goes, “...what was I thinking?”, there’s something real to resurface.
I wanted a well-read thinking partner and a filing system with low friction and high returns - an interactive place where thoughts become structured, decisions stay traceable, old clarity connects to new dilemmas, and usefulness and insight grows over time. So I used the same toolkit I do for engineering and started building one!
Turning the toolkit inward
Over the past year, I’ve been leveraging AI to make data science systems more powerful and rigorous. This repo was an experiment in taking the same toolkit and pointing it at my own thoughts.
What it enables:
Capture thoughts quickly (often by dictation)
Ingest and organize historical snippets (old journals, notes, half-finished thoughts) into a consistent, searchable structure
Structure new reflection into repeatable, low friction habits (daily + weekly)
Resurface what I’ve already worked through when I’m stuck
Connect old context to new decisions
Learn patterns over time, constantly adapting and improving.
How it works
Commands as habits
Low-friction, consistent entry points to start a reflection session without negotiating with a blank page.
Lower activation energy. A single, familiar trigger to begin (especially when I’m tired or overwhelmed).
Routing into structure. Whatever happens next lands in the right weekly/day/decision place automatically, instead of becoming another stray note.
Continuous personalization. As you teach the system you preferences, it adapts and remembers
Mix-and-match. You can interact with the system however you want—quick guided check-ins, long freeform rambles, or focused deep dives—and it all still lands in the same structure (so summaries/indexes/search keep working).
Files + structure over chat logs
Chat is great for thinking in the moment. But generic chats didn’t have the storage format for the targeted task that I wanted journaling to serve.
This system makes the output land as durable artifacts inside an intentional structure: predictable folders + lightweight templates (weekly journals, decision threads, dashboards, self‑map). That structure is what enables everything downstream—summaries, indexes, and the search agent—because the system has a map of where things live.
How it becomes durable and searchable
“Searchable” isn’t a single feature. It’s an outcome of a few pieces working together.
Commands create predictable structure. When I run
/start-dayor/end-day, the output lands in a consistent place and format (weekly files, decision files, dashboards), instead of another one-off chat.Claude shapes messy input into clean artifacts. Dictation and brain-dumps go in; Claude turns them into something I can actually come back to: headings, bullets, a next step, a short summary.
Weekly review generates the index layer.
/weekly-reviewcreates small summaries/rollups that describe what happened without me re-reading everything.Import builds a real archive. If I have old journals or notes,
/import-historyprocesses them into organized files (themes, key relationships, a quotes index) so the past isn’t just “stored,” it’s navigable.Search is index-first. When I ask “what was I thinking?”, the search agent reads index files and summaries first, then dives into raw entries when useful.
History that surfaces
/import-history is the part that turns this from “a fresh journaling habit” into an actual archive.
You just dump in whatever data you have (text, images, etc), it processes them into a structure that’s easier to navigate later—things like:
a full-text archive (so nothing is lost)
a quotes index (useful lines you can actually resurface)
theme files (recurring topics/patterns)
relationship files (people as entities, over time)
Import doesn’t just archive the past—it creates the navigation layer (index files + consistent structure) that tells the search agent what exists. When I ask a question later, search reads indexes first, scans summaries to find the right timeframes, and only then dives into raw entries—so it feels like structured recall, not grep.
That’s also why I didn’t build an “embed everything + vector database” setup. Recall is powered by simple human-readable summaries and index files—thin enough to maintain, flexible enough to evolve, strong enough to resurface what matters.
That means I can ask questions that are hard to answer from scattered notebooks, like:
“Pull the most relevant quotes I’ve written about burnout”
“What themes keep showing up when I’m making big decisions?”
“How has my thinking about X changed across the years?”
“When did I first start circling this decision—and what else was going on around then?”
Frameworks: Lenses for Reflection
The repo ships with a few starting lenses (Stoicism, Atomic Habits, Brené Brown), but the real idea is that you build a reference library over time based on what actually resonates.
When something clicks—a book, an author, a concept—you can run /add-framework and Claude researches, builds, and routes it into the right reference folder (frameworks/, practices/, or personality/). The reference files stay generic (the “lens” itself). My personal application lives separately in private/—especially assessments/, other archive files, and the self-map.
The point is flexibility: I’m not declaring “I’m a Stoic.” I’m asking, “What questions would a Stoic lens ask right now?”
Shareable System, Private Lessons
Journaling is a very private practice! But I also wanted the compounding of something I could share. Here’s how I split the difference:
The system is open source. You can fork it, customize it, and still pull updates. But the content of what you learn stays yours. The public component is shared structure, training, and broad expertise - your personalization stays private (see Privacy Notes for more).
Universal scaffolding, individual learning: Benefit from an evolving architecture, while evolving with your individual patterns, learnings, and preferences.
Dictation for Maximum Ramble Power
On macOS, I set dictation to Press Globe Key Twice (System Settings → Keyboard → Dictation). Then I just talk. There are other great dictation options out there but I find this both sufficient and easy to use.
Typos, garbled transcription, stream-of-consciousness rambling: Claude can still shape it into something coherent. I dictate more than I type now.
What this is (and isn’t)
This is a space for reflection, not therapy.
Writing things down, noticing patterns, and having a thinking partner can be valuable—but it isn’t treatment, and it’s not a replacement for human connection.
If you’re working through something heavy, a good therapist offers things this can’t.
Privacy Notes
The journal lives locally in gitignored Markdown, and the repo adds guardrails to reduce the chance you accidentally publish personal content:
private/is gitignoreda hook blocks any attempt to commit
private/orCLAUDE.mdanother hook scans committed content for likely personal/sensitive text
Using Claude Code also means the text you work with is sent to Anthropic’s servers for processing. Data retention and model-improvement use depends on your Claude account privacy settings. See the project README for more information.
What I don’t know yet
Will this stick? It’s week one. Ask me in six months.
Is this useful for anyone else? I open-sourced it to find out.
Am I over-engineering my feelings? Possibly. But other emotional strategies I’ve tried include suppressing, forgetting, and avoiding. Sooo, hard to do worse, tbh.
Try it
Repo: github.com/Wrendered/journaling-with-claude
Fork it, open Claude Code in the repo, run /onboarding.