Weekly Log Template

Sunday weekly journal. The discipline that compounds. The single non-negotiable habit of ROOT.

The weekly log is the load-bearing habit of the entire program. Phase docs go stale, tools get replaced, projects get archived. The log persists. It’s the single artifact that proves you actually did the program — and the dataset that fuels Year 4’s notes-rag and Year 5’s services/aiops/.

The shape is deliberately simple: bullets, not prose; specific, not abstract; written for future-you, not for anyone reading over your shoulder. Twenty minutes on Sunday, every Sunday, for ~250 weeks. The compounding only works if the data is honest, which is why the audience matters: the moment you start polishing for an outside reader, you start hiding from yourself.

If you’re using AI assistance for any other artifact — runbooks, ADRs, pattern entries — the AI Learning Protocol allows it under the validate-then-write rule. The weekly log is the explicit exception. AI can ask the prompting questions; you write the words.

The “I’m just busy this week” trap

The most expensive mistake in ROOT isn’t a bad commit — it’s the week you let AI (or a polished after-the-fact reconstruction) write the weekly log because you’re tired. The log is the only artifact that compounds across all 60 months. Skip the discipline once and the dataset has a hole; skip it three weeks running and the discipline is gone. A 3-line stub on a bad week is infinitely better than a polished entry written from memory two weeks later.

Re-read the log every 6 weeks

The patterns aren’t in any single week’s entry. They’re in the trajectory — the same open question recurring across four weeks; the same surprise hitting in three different phases; the energy score trending down over a month. None of that is visible week-to-week. Set a recurring 30-minute slot every 6 weeks to scan the last 6 entries and write a one-paragraph summary at the top of the most recent one.

---

Template

Copy into ops-handbook/weekly-logs/{year}/W{NN}-{YYYY-MM-DD}.md every Sunday:

---
title: "Week NN, YYYY — <theme>"
slug: WNN-YYYY-MM-DD
tags: [weekly-log, year-N, phase-N]
week: NN
year: YYYY
phase: N
---

# Week NN — <theme of the week>

## What I learned

- 2-5 bullets, specific, with concrete examples
- Not "I learned a lot about X" — instead: "Postgres' MVCC keeps multiple row versions; that's why long-running transactions block vacuum and bloat the table"
- "Argo CD's `Application` CRD distinguishes `sync` from `health` — a synced app can still be unhealthy, which is why my dashboard showed green while pods were CrashLoopBackOff"
- "K3s embeds containerd directly; there's no separate Docker daemon to debug"

## What I broke

- 1-3 bullets of specific failures
- "Broke `pg_basebackup` by setting `wal_keep_size=0` after the backup started; replica fell behind and re-bootstrapped from scratch"
- "Pushed a Helm values change without `--dry-run`; took down basecamp's Grafana for 12 minutes"
- "broke nothing" is OK occasionally but suspicious every week — if it's true, you might be operating below your edge

## What surprised me

- The "wait, that's not how I thought it worked" moments
- Often the most valuable learning of the week — these are where pattern entries come from
- "I expected Iceberg snapshots to be cheap but the metadata file count blew up after 4 days of hourly writes"
- "I assumed `kubectl exec` ran as root; it runs as whatever the pod's `securityContext` says"

## Open questions

- Things I don't yet understand but want to
- Often become next week's investigation prompts
- "Why does Trino plan a different join order on the same query 5 minutes apart?"
- "Is the WAL replay cost on Postgres replicas linear with WAL volume, or does fsync batching make it sub-linear?"

## Progress (against current phase)

- Phase: Year 1 Phase 7 (Kubernetes + GitOps)
- This week: shipped the K3s-on-homelab bring-up; ArgoCD reconciling basecamp's foundation tier; first triage deploy succeeded
- Validation criteria progress: 4 of 7 met (cluster bootstrap, ArgoCD installed, foundation tier deployed, triage deployed; remaining: etcd-corruption recovery drill, Day 2 ops doc, contribute-1-PR)

## Sustainability check

- Hours spent: ~13
- Energy: 7/10
- Anything I'm dropping or pacing?: deferred reading the second Kubernetes book to Phase 8; not behind, just sequencing
- Sleep / health / family — anything off?: sleep fine; one late night that I'll not repeat

## Next week

- 1-3 things I'll work on; realistic, not aspirational
- Run the etcd-corruption recovery drill (the missing validation criterion)
- Promote the `control-loops` pattern from STUB to OUTLINE (Phase 7 is the deepening phase)
- File one upstream docs PR against ArgoCD or K3s (the CONTRIBUTE step of the pattern-first scaffold)

## Patterns deepened or touched

- Pattern: [control-loops](../../patterns/foundations/control-loops.md) — first touched; promotion to OUTLINE planned next week
- Pattern: [layering-and-abstraction](../../patterns/foundations/layering-and-abstraction.md) — reinforced; nothing to promote yet
- Pattern: [state-vs-computation](../../patterns/foundations/state-vs-computation.md) — touched; STUB still appropriate

---

How to write a good weekly log

Five rules:

1. For future-self, not an audience. This is honest, not performative. If you’re polishing it for someone to read, you’re doing it wrong.
2. Specific over abstract. “Worked on Phase 3” → “Set up Postgres replication; broke pg_basebackup; found that the WAL was too small.”
3. Write the bad weeks too. Skipped weeks are fine; document why. The bad weeks are often where the most honest learning lives.
4. 20 minutes max. The point is the discipline, not the polish.
5. Re-read 6 weeks later. Patterns emerge from the cumulative log that you can’t see week-to-week.

---

When to skip

You can skip a week if:

• Travel / illness / personal emergency
• Genuinely had nothing to log

But you write a stub: "Skipped this week because <reason>. Resuming next Sunday."

The stub IS the log. The discipline is “always write something on Sunday,” not “always have rich material.”

---

The 5-year payoff

By Y5 you’ll have ~250 weekly logs. That archive is:

• The honest record of the journey — the only one that exists
• The source corpus for notes-rag (Y4) and services/aiops/ (Y5)
• The dataset Year 5 Phase 30 (capstone career-story exam) draws from
• Material for the journey-post genre on the blog

The cumulative weekly log IS the proof you actually lived ROOT. Without it, the program is a portfolio of artifacts; with it, the program is a lived narrative that maps to a real human across 60 months.

---

Anti-patterns

Anti-pattern	Why
”I learned a lot this week”	Vacuous; you’ll re-read this and regret the lack of specifics
Writing for an audience	Future-self is the audience; honesty > polish
Skipping multiple weeks silently	Discipline is the entire point; document the skip
Polishing into prose	20 minutes; bullets are fine
Log says “everything went well” 4 weeks running	Probably hiding from yourself; force the honest answer
Letting AI draft the log	Breaks the load-bearing habit; the log must be your words

---

Cross-reference

• Pattern: runbook-as-code (analogous discipline of writing-as-you-operate)
• Connects to: The Story (Y5 capstone narrative draws from these)
• Program context: Master Plan, AI Learning Protocol, ops-handbook plan
• Style guide: doc-style-guide.md