I wanted to summarize the experience of building lifelab from scratch. I asked claude to put a story-arc based on my (it's) git history. I thought it's interesting to put the commits on a timeline and find distinct patterns (eras) of development. It actually weaved a fun story. Since Claude actually writes proper commit messages and PR you can backtrace the entire system and most decisions. I definitely wish I had the discipline to do that manually and I wonder how many production systems do.

[slop disclaimer]

The content after block this is fully claude generated. I am not sure about the etiquette of exposing readers to slop so I decided to put a warning . I left some human comments, but I was entertained by what claude wrote enough to share it without major editing. Maybe the quality went up compared to my human writing?

LifeLab's git history reads like a speedrun of software philosophy. It starts as a clone ("what if Deepnote but mine?"), immediately rebels against its parent ("not notebooks — pages"), discovers its spiritual ancestor ("org-mode had it right"), goes through an infrastructure gauntlet ("Docker on Hetzner, fight me"), tries four different scripting runtimes before settling on one, builds its own extensibility model from scratch, and ends up as something genuinely novel — a malleable, org-mode-inspired personal knowledge OS that runs as a desktop app, PWA, or self-hosted server, with AI woven into the fabric.

The claude/ branch prefixes tell their own story: this was built through relentless human-AI pair programming, with the human driving the vision and the AI executing at a pace that produced 15 commits a day for over four months straight.

The first commit: Add notebook-app package

The repo starts as a fork/clone of Deepnote — a computational notebook platform. The very first PR is already from claude/ — AI-assisted from day zero. Within hours, it's already being pulled apart: cell buttons move, the Deepnote Toolkit gets integrated, then immediately reverted and removed. The codebase is being interrogated: what are you, and what should you become?

Human note

I saw deepnote being open sourced on hackernews and instantly thought I can reuse it for note taking. I have been working on a jupyterlab-task-management solution but the interface was ugly, and deepnote was pretty. I quickly realized not all parts were shared and the parts I wanted were proprietary.

Key commit: Refactor: Convert to standalone meta-programmable notebook app

This is the fever-dream opening. 100 commits on November 6 alone. The project explores:

• Malleability system — hooks, self-documentation, "the blocks should modify themselves"
• Schema blocks — JSON editors for structured data
• CSS variables unification — full theming system
• WebSocket race conditions — the inevitable async debugging
• A Rust backend investigation alongside the Python one (Axum + DashMap)
• A ratatui TUI (terminal interface!) gets built in parallel
• Vim-style command mode with autocomplete in the TUI
• The commit messages capture the energy: yeeeee, push all, run. Someone is building very fast and seeing what sticks.

Human note

The first system was a crystalization from blog/pkm/PKM concept exploration]. I had an idea of everything being a block, including code blocks that can query the database. The most unique thing is I went with rust for rest backend instead of python fastapi. I was familiar with fastapi, so I could fix it myself. I decided I don't want to fix things myself. Rust Axum ended up being fantastic, it was performant, snappy and once claude got the code to compile it was basically bug free

Key commit: Refactor: Rename notebooks to pages throughout codebase

A philosophical pivot: the atomic unit isn't a "notebook" — it's a page. Notebooks are linear; pages are a graph. This era introduces:

• Hierarchical page titles (folders removed — just use / in names)
• Tags as links between concepts
• Fractional indexing for block reordering
• pgvector embedding storage for semantic search
• Fulltext search with configurable filters
• Task blocks with dedicated UI
• The naming is still "Deepnote" in the repo URL, but the soul has changed.

Human note

I hate folders and wanted to enforce purity. I messed up by naming tags "links" just to be unique, no one including me could get it.

Key commit : Complete rebrand from Deepnote to LifeLab

The project gets its real name. This isn't just cosmetic — it marks the shift from "a notebook tool I'm hacking on" to "a personal knowledge operating system." The features that follow confirm the ambition:

• Pinned blocks and wiki-style auto-page-creation
• Publishing infrastructure — static HTML blog export
• Task management with due dates, collapsible descriptions, metadata panels
• Image upload with drag-and-drop

Human note

5 days since starting it, it become a fairly usable wiki web app. The name was stupid but it stuck.

Key commits: Add complete Docker deployment setup for Hetzner with Watchtower CD, Re-implement PWA features with service worker and offline support

The build-it-and-they-will-come phase. Massive infrastructure work:

• Docker deployment on Hetzner with Watchtower continuous delivery
• PWA with iOS support, service worker, offline IndexedDB
• Telegram bot for mobile ingestion ("send a thought from your phone")
• Mobile-responsive UI with hamburger menu
• Calendar sidebar replacing the journal list
• Passkey authentication (WebAuthn) — no passwords

This era has the most Docker debugging commits you'll ever see. GLIBC mismatches, nginx regex bugs, kernel bridge paths. The classic "it works on my machine" gauntlet.

Human note

I can't believe I did all of this in two weeks this was insane. Claude code quota was very generous and I basically worked on this every night after work.

Key commits: Add smart title bar with org-mode inspired syntax, Implement single timer mode (org-mode style), Add TODO/DONE keyword-based tasks (org-mode style)

A design revelation: Emacs org-mode had figured out personal knowledge management decades ago. LifeLab starts absorbing its ideas wholesale:

• Smart title bar with org-mode headline syntax
• Property drawers — collapsible metadata panels
• TODO/DONE keywords for task management
• Tag syntax with : trigger (:project:urgent:)
• Logbook for time tracking (clock in/out)
• Org-mode export format
• Collapsible headlines with fold indicators

The CSS restyling commits (Restyle metadata and logbook as org-mode property drawers) show the UI being pulled toward org-mode's information density.

Human note

What started as "jupyter but with tasks" slowly became "org mode, but without the yucky Emacs" I really liked the information density of org mode styling blog/pkm/Beauty of orgmode syntax] and started leaning into it more. I initially left both jupyter styling and orgmode styling as an option. This is when I used lifelab every day.

Key commit: feat: add Tauri desktop app scaffolding and backend mode toggle

LifeLab goes native. A Tauri (Rust + WebView) desktop app gets scaffolded with:

• Native SQLite repository (rusqlite, not sqlx)
• FTS5 search for local full-text search
• Sync JavaScript runtime via rquickjs embedded in Rust
• Hooks and slash commands ported to Tauri mode
• GitHub Actions CI for building desktop binaries on release
• Bundled tutorials seeded on first run

The repository pattern (from CLAUDE.md) makes sense now — the frontend needs to work against REST or Tauri or PWA/IndexedDB backends interchangeably.

Human note

Multibackend era, where there are 3 implementations of database with 1 frontend

The runtime roulette: Python (Jupyter) → Rhai → JavaScript (QuickJS/rquickjs) → Lua

This is the most fascinating thread in the entire history:

• Python/Jupyter was the original runtime — full notebook execution
• Rhai (Rust scripting language) was tried, got syntax highlighting, then was removed entirely (PR #552)
• JavaScript via QuickJS was embedded in Rust via rquickjs — then also removed (PR #553: "Remove JavaScript runtime support, keep Python-only")
• Lua arrived and stuck — the nb.* API was ported, tutorials rewritten, all JS references replaced with Lua (PR #736)

The final commit in this saga: Remove jupyter view mode, commit fully to org mode (#772) — the Jupyter notebook heritage is finally, fully shed.

Human note

Claude says it is interesting but this was the most slop heavy time. I did not find a proper way for users to extend lifelab using existing code. I wanted to be hipster by adding rhai (basically scriptable rust), but lua ended up faster. Embedding quickJS and nodeJS was a complete disaster. I thought it would be easy since I have to ship javascript anyway, but serverside executed javascript was async and basically broke everything constantly.

Key commits: Add ultrathink toggle to AI blocks, Add inline diff overlay for AI suggestions, Add transcription block type with Soniox real-time audio

The latest era weaves AI throughout:

• AI blocks with model selection, prompt pages, inline diff overlays
• Inline AI edit — /ai command for quick block modifications
• Transcription blocks with real-time Soniox audio input
• PDF viewer with annotation drawer, highlights, touch support, zen-mode fullscreen
• Pinyin ruby annotations for CJK characters
• UI form inputs with nb_ctx context injection
• Zero-downtime deployments with Caddy

And the human moments: 618a9b90 I broke things and blamed claude, 01ab449f add npm, this one is on claude

• 2,053 commits in 137 days (~15/day average)
• 509 merged pull requests (778 total PRs opened)
• 1,003 commits in November 2025 alone (the founding month)
• 100 commits on November 6 — the single highest day
• 4 scripting runtimes tried (Python, Rhai, JS, Lua)
• 3 major UI paradigms (notebook → pages → org-mode)
• 3 deployment targets (Docker/cloud, PWA, Tauri desktop)