what changed this week?#

Debian voted on LLM usage in Debian

“responsible use of generative AI” won: disclosure of AI assistance is encouraged, not required

also lots of model releases

today’s beats#

the transcript and the git log are the only account of the work that doesn’t rely on your memory

the “compound” step: write what you learned into the harness

CI runs the same checks on a machine that isn’t yours

demo: can it reconstruct fourteen years of my tooling from the git log alone?#

then we leave it running and talk about what the work leaves behind

your lab notebook#

the transcript: every prompt and every tool call

the git log: every diff and every commit

the CI runs: every verdict

together they are the only account of the work that isn’t recollection

running programs have had this for decades#

programming languages call it introspection: a running system that can examine itself

a git log alone already tells you a lot

the transcript is what agentic work adds: the deliberation itself, on disk

the logs are just files#

~/.claude/projects/<your-project>/ — one .jsonl per session, one JSON object per line

each record has a timestamp, the cwd and the git branch it ran on

so grep/rg and jq are all you (or your agent) needs

the loop that improves itself#

compound engineering (Kieran Klaassen, Every): plan, work, review, compound — write the learnings back into persistent context, so the next cycle starts further along

this is what reflections/ and your CLAUDE.md have been asking of you since week 2

hoard things you know how to do#

work a trick out once, keep the documented example, and it becomes an input to every later project

ref: Agentic Engineering Patterns

what has my public dotfiles history worked out once and kept?

a correction that stuck#

a correction that lands in the chat is gone next session

one that lands in the harness is permanent

where has one landed in that same history — and what does the before/after look like?

the log says what changed — does it say why?#

the timeline falls out of the filenames and the dates alone

the reasons, where they survived, are in the commit messages

watch for the seam: where does the evidence stop and the story start?

and what does it reckon I’ll pick up next?#

a reading of the past is cheap until it predicts something

so we’ll have it commit the call, and check it next semester

the agent writes its own#

CLAUDE.md is what you wrote; auto memory is what Claude decided was worth keeping — your corrections, your preferences, facts about the project

~/.claude/projects/<project>/memory/, one markdown file per fact, with a MEMORY.md index read at the start of every session

on by default, per repo, machine-local, and yours to read, edit or delete: /memory

ref: How Claude remembers your project

a file the agent trusts#

Cisco Talos got a poisoned MEMORY.md onto a machine through an npm postinstall hook

memory content was reaching the system prompt as though you had written it; Anthropic stopped that in v2.1.50

ref: Cisco Talos

what compounding costs#

every rule you compound in is context you pay for in every session after it, and it rots quietly

it had silted up into documentation: superseded decisions, dated changelog entries, war stories

my own commit message, cutting a CLAUDE.md from 669 lines to 250 — and the rule that fell out of the clean-up went straight back into the harness

how much of this is true?#

the number that circulates is 300–700% faster, sourced to a bracketed note citing nothing

Klaassen’s own claim is one hedged anecdote: two weeks, “maybe”, down to a few hours

faster at what, measured how, against what baseline?

Ben uses… a timer that ships the logs home#

every session from every machine, synced into one sqlite table

> select host, count(*)
  from sessions group by host;

daysy |7625
weddle|8279

because the logs are just files

yes, and…#

how does it get pushed further? weird ideas welcome

CI (Github Actions)#

a series of checks that runs on every push, on a machine that isn’t yours

GitHub Actions in our case, but the idea is decades older

the same verdict at two distances#

local: pnpm check in seconds, while the agent still holds the context that produced the mistake

the runner: the same command, answering a different question — does this work anywhere other than the machine it was written on?

if CI gives different results to local dev, then…

reading a red run#

a red run is a sensor talking to you; pasting the log makes it a sensor talking to the agent

$ gh run watch
$ gh run view --log-failed

“the build failed” gives it nothing; the failing step and its output give it a file, a line and an expected-versus-actual

a permanently red check isn’t a sensor#

week 3’s fourth property was trustworthy, and this is where it gets spent

an always-red check trains you to scroll past it, and then the signal is gone

green when the sweep runs#

the crit sweep starts fifteen minutes after your cutoff: pushed, live at its URL, reflection in the folder — and then it reads your checks

green: the full shipping mark

red, still running, or no checks: half

those fifteen minutes are settling time — push early enough that the run finishes

nothing is marked until you /ship#

it flips the repo public, turns Pages on, triggers the deploy, then checks the URL actually serves

/preflight first — going public is the one irreversible thing you do in this course

(C6 is a retro: no prototype and no checks, so that half is just PROCESS.md in the repo by the cutoff)

over the break: fifteen minutes of fly#

from week 7 your repos deploy themselves — CI ships every push, and you never handle a deploy credential

but flyctl is how you read your running app’s logs and status: onboarding step 7, no account, no billing of your own

your tutor checks it works in c6 (no marks)

yes, and…#

how does it get pushed further? weird ideas welcome

your assignment 2 repo is live#

/comp4020:start clones it, like every other deliverable

the brief is final now — and the one thing that moved since last week is this morning’s lesson

PROCESS.md has a spine: what you decided a good course looks like, which of those decisions you encoded in CLAUDE.md or spec/, and which you left out

new: your course key generates images#

one curl on the key you already hold (no Replicate account required)

300 images for the semester: flat-rate, separate from your weekly Claude budget in both directions

the URLs expire, so download what you want to keep, immediately

update the course plugin#

claude plugin marketplace update comp4020, then claude plugin update comp4020@comp4020, then restart Claude Code

do it before the break: assignment 2 ships on whatever copy you’re holding

yes, and…#

how does it get pushed further? weird ideas welcome

did the steer show up in the result?

C6: the assignment 2 retro#

no fresh provocation: the crit reflects on assignment 2

pick the specific change that made the course click and show it as a before/after — the breakthrough comes from the PROCESS.md you already submitted

the crit page has the spec

deadline radar#

noon, Monday 21 September: assignment 2 — the first day back, so it’s closer than it looks

Monday/Wednesday, week 7: C6, with your PROCESS.md in the repo by the cutoff

the break: two weeks, and fifteen minutes of it is installing flyctl

tl;dr#

the transcript, the git log and the CI runs are the only account of the work that isn’t recollection

write the correction into the harness rather than the chat, then prune it: every rule is context you pay for in every session

CI is the same verdict on a machine that isn’t yours — be green when the sweep runs, and /ship before the cutoff

ask your agent#

ask until you can explain these back:

• the compound step: what should this session’s corrections write back into your CLAUDE.md?
• auto memory: open /memory and read what it has kept about you
• CI as a verdict: which failures could only happen on the runner?
• fly: install flyctl over the break, and confirm it answers