What this is
The core idea
A structured journal that stores everything you write—reflections, observations, insights across your work and life—and a conversational agent that lets you query that journal across time. Not a chatbot. Not an automation. A thinking tool that makes your own development visible and searchable.
What it is NOT
It does not schedule tasks, send emails, or execute actions. It does not give advice from the internet. It only works with what you put into it. The quality of its reflection is entirely a function of the quality of your journal entries.
Architecture — three layers
Layer 1
The Journal
Timestamped markdown files. One entry per reflection. Lightly tagged by domain. Freeform prose—you write naturally. This is the source of truth everything else depends on.
leadershiptrainingbusinessrelationshipscontemplative
Layer 2
The Search Layer
Each entry is converted to a vector embedding. When you ask a question, the system finds semantically relevant entries—not just recent ones. The difference between search and recall.
embeddingsLanceDBsemantic search
Layer 3
The Agent
Claude + retrieved entries. When you ask a question, it finds relevant journal passages, passes them to Claude, and returns a reflection grounded in what you've actually written—not generic coaching.
Claude APIretrievalreflection
What you can do with it
Query across time
"How has my thinking about delegation changed over the past six months?" — The agent finds every entry tagged leadership where delegation appears and reflects back the arc of change.
Surface patterns across domains
"I notice you've framed this relational dynamic the same way you framed a negotiation last March — is there a connection?" — The agent connects what you consciously keep separate.
Identify what you're integrating away
"You've mentioned feeling stuck on this three times. What's the common thread in how you frame it?" — The system notices persistence better than you can in the moment.
Weekly synthesis
A scheduled digest: what shifted this week, what recurred, one question to sit with. Auto-generated from recent entries. Delivered to your inbox or Telegram.
Technical stack
Design principle
Every component is chosen for simplicity and longevity. No vendor lock-in. No cloud infrastructure that breaks when someone changes their pricing. Your journal is markdown files. You own them forever.
Journal storage
Markdown files in a local directory, named by date.
2026-05-11-leadership.md. You can read, edit, and back up your journal with any text editor, forever.€0
Vector database
LanceDB — local, serverless, no setup. Stores embeddings of your journal entries so semantic search works. Lives on your machine alongside the journal.
€0
Embeddings
Anthropic embeddings API. Each new journal entry is converted to a vector when you add it. Tiny cost per entry.
~€2/month
Agent / reasoning
Claude Sonnet via API. Receives your question + retrieved journal entries. Returns a reflection grounded in what you've written. Sonnet is the right balance of quality and cost for this use case.
~€20–40/month
Interface
Phase 1: CLI (terminal). Phase 2: Telegram bot so you can journal and ask questions from your phone. Phase 3 (optional): simple web UI.
€0
Weekly digest
Cron job (scheduled Python script) that runs every Sunday, generates a synthesis of the week's entries, and sends it to your email via SendGrid — the same integration you learn in Phase 4.
~€3/month
The agent's system prompt — design intent
This is the most important part of the build. The prompt defines whether the agent reflects or validates, challenges or flatters. It needs to be specific to how you work.
System prompt — draft
# Who you are
You are a reflective agent working with Jakob's
personal development journal. Your role is to help
him see patterns, connections, and shifts in his
thinking across different areas of his work and life.
# What you work with
You have access to relevant excerpts from Jakob's
journal, retrieved based on semantic similarity to
his question. Every reflection you offer must be
grounded in what he has actually written — not in
general coaching frameworks or external advice.
# How you work
When asked a question:
1. Surface what you notice — patterns, contradictions,
evolution in how he frames things
2. Ask what he may be integrating away or avoiding
3. Connect domains when relevant — leadership work
and personal development often mirror each other
4. Name what has shifted since earlier entries
# Red lines
Never validate for the sake of validation.
Never offer advice not grounded in his entries.
When he seems stuck, push — do not comfort.
If you notice a pattern across three or more
entries, name it directly: "You've framed this
the same way three times."
Note to self: This prompt is a starting point. The right prompt will only emerge after you've used the tool for 4–6 weeks and noticed where it flatters instead of reflects. Add rules when it repeats mistakes — the same discipline you apply to CLAUDE.md.
Build sequence — how to get there
Wk 20–21
MVP — journal + basic retrieval
No embeddings yet. Just reading and reflecting.
You have one tool: a Python script that reads your journal directory, passes recent entries to Claude, and returns a reflection.
- Create a
journal/directory — one markdown file per entry - Write a Python script: read all files → sort by date → pass last 20 entries to Claude API → print reflection
- Add a simple tagging system: first line of each entry is a tag (
#leadership,#training) - Add basic filtering:
python journal.py --tag leadershipreturns only leadership entries
You already know all the pieces: file I/O (Phase 1), Claude API calls (Phase 3b). This is recombination, not new learning.
✓ Milestone: Ask one real question and get a useful answer
Wk 22–23
Add semantic search
The journal becomes queryable across time, not just recent.
Replace recency-based retrieval with embedding-based retrieval. This is the step that makes the tool genuinely useful after 3+ months of entries.
- Install LanceDB (
pip install lancedb) - Write a script that reads all journal entries and stores their embeddings in LanceDB
- Replace the "last 20 entries" logic with "most semantically similar entries to your question"
- Add a script that re-embeds any new entries since last run — run this whenever you add something new
New concept: what an embedding is, and why vector similarity finds meaning rather than keywords. This is your first hands-on encounter with how LLMs "understand" text.
✓ Milestone: Ask about something from 3+ months ago and have it surface correctly
Wk 24–25
Add Telegram interface
Use it from your phone. Journal anywhere.
Wrapping the Python script in a Telegram bot. You already know the Claude API and file I/O. A Telegram bot is just another API call.
- Create a bot via @BotFather on Telegram — takes 5 minutes
- Install
python-telegram-bot - Two commands:
/journal [your entry]to add a new entry,/ask [your question]to query - Run the bot on a simple server (Railway, €5/month) so it runs while your iMac is closed
This is where the tool becomes a daily habit rather than a desk-only tool. The friction of opening your laptop to journal is the thing that kills journaling habits.
✓ Milestone: Journal from your phone during a commute or between meetings
Wk 26–28
Weekly digest + refinement
The tool earns its keep over time.
Add the weekly synthesis. This is a cron job — the same mechanism you learned in Phase 4 (client intake form scheduler), applied here.
- Write a prompt that asks Claude to synthesise the week's entries: what shifted, what recurred, one question to sit with
- Schedule it as a cron job on Railway: runs every Sunday at 8:00
- Delivers via email (SendGrid, same as client intake form) or Telegram
- Spend the remaining time refining the system prompt based on actual use — where it flatters, where it pushes too hard, what it misses
By this point you will have ~6 weeks of entries. The digest will start finding things you've forgotten. That's when it becomes genuinely useful rather than interesting.
✓ Milestone: Receive a weekly digest that surfaces something you'd forgotten
What you learn by building this
Technical
Embeddings + vector search
You understand what an embedding is and why it works — the same concept that powers every modern AI search product. This is hands-on, not theoretical.
Technical
Production Python
File I/O, database writes, API calls, scheduling, error handling — all working together. This is the full stack of a real solo-operator tool.
Conceptual
Prompting as product design
The system prompt is the product. Iterating it based on real use teaches you more about AI product design than any course.
For clients
A real case study
"Here is a tool I built for my own development work. Here is what it taught me about how AI tools work in practice, and where they don't." That's worth more than abstract advisory.
Honest constraints
The tool only works if you journal
If you don't already journal regularly, start the habit before building this. Build it once there is signal to work with — otherwise you're maintaining infrastructure for an empty database.
It reflects your biases back
The agent is trained on your language, your frames, your patterns. It may miss what you systematically avoid — because you've never written about it. A human coach who knows you will catch things this won't. They are not substitutes.
Validation is the default failure mode
Claude defaults toward helpful and affirming. Without strong red lines in the system prompt, the agent will validate your existing frames rather than challenge them. The prompt is the primary safeguard — not the technology.
Where this fits in the learning plan
Prerequisite: Phases 1–4 complete
This project requires: file I/O (Phase 1), Claude API calls (Phase 3b), deployment and scheduling (Phase 4). It is the Phase 4 capstone — built after the client intake form is live, using everything learned across the plan.
Placement: Weeks 20–28 (Phase 4+)
Begins after the client intake form is shipped and deployed. Runs in parallel with the Mac mini evaluation and the start of the automation layer. This is the first project built for Jakob, not for MøllerBeck — which makes it a different kind of learning.
The question to check in with at Week 20
Am I writing in a journal regularly — even informally — right now? If yes: build this. If not: start writing first. The tool is only as good as what you put into it, and building infrastructure for a habit you haven't formed yet is sharpening an axe for wood you haven't cut.