Session: gentle-planning-hopper — 2026-04-03

Project: demo-beta · Branch: main · Mode: plan · Model: claude-opus-4-6

Stats: 5 user messages, 3 tool calls, tools used: WebSearch, Read, Write.

Conversation¶

Turn 1 — User¶

I want to build a small static blog generator in Go. Just markdown → HTML, no fancy features. What's the simplest approach?

Turn 1 — Assistant¶

A Go static blog generator with only markdown → HTML can be done in under 200 lines. The minimum ingredients are:

1. Markdown parser — github.com/gomarkdown/markdown is the standard choice. Actively maintained, no cgo, GoldMark is an alternative if you want CommonMark strictness.
2. Frontmatter parser — either parse YAML yourself from the --- delimited header, or use github.com/adrg/frontmatter.
3. Template rendering — html/template from stdlib handles safe HTML rendering with zero dependencies.
4. File walker — filepath.WalkDir from stdlib for reading a content/ directory.

The overall flow is: walk content/, parse each .md file's frontmatter, render the body through the markdown parser, pass the result to an html/template, write to public/.

Turn 2 — User¶

Check what the most recent active projects look like.

Turn 2 — Assistant¶

Tools used:

• WebSearch: minimal Go static site generator 2026

Tool results:

Hugo, Zola, Eleventy dominate the space, but there are a handful of minimal Go alternatives. Notable minimal ones in 2026:

• pelle-fk/tinysg — 180 LoC, markdown + frontmatter + one template
• geekgonecrazy/gosg — slightly larger but still under 500 LoC
• haahnah/minimd — 120 LoC, no frontmatter support (just markdown)

Most of the "complete" generators (Hugo, Zola) are 50k+ LoC. The minimal tier is a huge gap you could fill.

Turn 3 — User¶

Draft a directory layout and a list of the first 5 Go files I should write.

Turn 3 — Assistant¶

Tools used:

• Write: /Users/USER/Desktop/demo-beta/PLAN.md (748 chars)

# demo-beta — minimal Go static blog generator

## Directory layout

    demo-beta/
    ├── cmd/
    │   └── blog/
    │       └── main.go          # CLI entry
    ├── internal/
    │   ├── content/
    │   │   └── content.go       # frontmatter + markdown parsing
    │   ├── render/
    │   │   └── render.go        # html/template rendering
    │   └── walk/
    │       └── walk.go          # filepath.WalkDir wrapper
    ├── content/                 # user's markdown content
    ├── templates/               # user's html/template files
    ├── public/                  # output (gitignored)
    └── go.mod

## First 5 files

1. go.mod — `go mod init github.com/USER/demo-beta`
2. cmd/blog/main.go — 30-line CLI with flag parsing for content/ and public/
3. internal/content/content.go — frontmatter splitter + gomarkdown wrapper
4. internal/walk/walk.go — recursive walk that yields (path, frontmatter, body)
5. internal/render/render.go — loads templates/ and renders one post per file

Plan written to PLAN.md. You can start with cmd/blog/main.go next session.

Turn 4 — User¶

What should I call this?

Turn 4 — Assistant¶

For a "minimal Go static blog generator" in that tier, nameable options:

• stilo — stylo + stilo + style, short, available on pkg.go.dev
• gomik — go + mik(ro), easy to type
• minpost — mini + post
• brief — the genre (brief blogs), one word
• slat — short, evokes "slate" + "stat(ic)"

My vote: stilo. It's 5 letters, pronounceable, and the .dev + .io are both free to register.

Turn 5 — User¶

Locked, stilo it is.

Turn 5 — Assistant¶

Decision locked: the project name is stilo. Next session we can update go.mod to github.com/USER/stilo and start on cmd/stilo/main.go.