Fabio Luiz

How I built a blog that writes itself

3 min read

My blog writes itself. Every Claude Code session gets captured automatically. When I’m ready, a command synthesizes those captures into polished journal entries. I just review and publish.

The Problem

I wanted to journal my learnings from Claude Code sessions without manual copy-paste drudgery. The challenge was designing a system that:

  1. Captures sessions automatically without slowing down exit
  2. Preserves raw content for flexible reprocessing later
  3. Generates polished entries with consistent voice and style
  4. Keeps the drafts directory organized as entries accumulate

The Solution

The key insight was preserving raw content instead of summarizing early. I wanted captures that could be processed with different prompts for different purposes: a journal entry, an end-of-day report, or a LinkedIn post. This gives me:

  • Source preservation: reprocess with different prompts later
  • Resilience: if synthesis fails, nothing is lost
  • Separation of concerns: capture is simple, synthesis uses the skill’s voice
  • Flexibility: batch multiple sessions or split one into multiple entries

Two-stage pipeline

Stage 1 (automatic):  session end → hook captures transcript → drafts/
Stage 2 (on demand):  /drafts + /journal N → journal/

Stage 1 runs invisibly on every session exit. A Claude Code hook extracts the full conversation and saves it to ~/garden/drafts/. No thinking, no summarizing—just capture.

Stage 2 happens when I’m ready. The /drafts command groups captures by theme and suggests journal entries. Then /journal N synthesizes entry N using a skill that defines my writing voice.

Progressive file organization

Drafts flow through three stages:

drafts/               # Fresh captures (analyzed by /drafts)
  ↓
drafts/gardening/     # Grouped into entries (waiting for /journal N)
  ↓
drafts/archive/       # Processed into entries (done)

This keeps the root directory clean while preserving history for reprocessing.

The daily workflow

  1. Work normally: Claude Code sessions get captured automatically
  2. Run /drafts: Groups captures, suggests entries, creates a plan
  3. Run /journal 1: Generates the first entry from the plan
  4. Review and publish: Light edits, then push to deploy

For the implementation details—how to build hooks, commands, and skills—see Putting Claude Code minions to work.

Key Takeaways

  • JIT processing beats eager summarization: preserve raw data, synthesize later
  • Separate capture from synthesis: hooks should be fast, skills handle creative work
  • Keep captures reusable: the same session can become a journal entry, a report, or a post
  • Automate the boring parts: capture and organization are invisible, writing gets my attention

The result is a pipeline I don’t think about. Sessions get captured while I work, and when I’m ready to write, the raw material is waiting.

See also: Claude Code, Digital Gardens, Quartz, Automation