Telling Technology · Learning in public
All episodes
EP.92 — THE UNATTENDED LOOP
A Claude Code workflow that keeps working after you leave

35 minutes, 29 versions, one resume — and I was on the couch for 15 of them

I needed a resume page. What I actually wanted to test was whether a session can keep raising its own bar without me in the chair. It ran twenty-nine rounds on its own, looked at its own screenshots after every one, and sent a Telegram message when it stopped finding things worth changing.

A dark changelog column of twenty-nine numbered versions scrolling upward, each with a one-line note, with version 24 highlighted in teal and marked shipped
⌁ 29 unattended versions · ~15 min of runtime · v24 shipped
It starts with the most boring possible request: I need a page about me.
01 The ask

The brief was a resume page. The real brief was: do not design anything twice.

I already had a site with a finished visual language — tellingtechnology.skogstrom.se, ninety episode pages, a locked palette, a headshot, a render for every build. A resume page that invented its own look would have been a second design system to maintain, and a worse one. So the first instruction was not build, it was look: take scroll screenshots of the reference site, pull the design tokens out of what is already shipping, and treat every number on the new page as something that has to trace back to a file in my AIOS rather than something you write because it sounds good.

claude code — desktop
> before you write any code, scroll-screenshot tellingtechnology.skogstrom.se and give me the design tokens it actually uses - colours, type scale, spacing, card treatment
Captured 8 scroll positions desktop, 8 phone.
Tokens extracted from shipped CSS, not guessed:
  --bg #0a1110   --ink #eaf3f1   --teal #0EA5A6
  --teal-bright #2ee6d6   --card rgba(255,255,255,.035)
Headshot and 31 episode renders already exist — reusing, not regenerating.
Every claim on the new page will be pulled from AIOS and cited to its source file.
A grid of eight narrow scroll screenshots of a dark website stacked left to right, with extracted colour swatches and type sizes annotated down the right side
8 desktop · 8 phone
Study the thing that already works before writing a line. The tokens were read off shipped CSS, not invented.
02 The round

One round: read the changelog, change one thing, screenshot yourself, judge it, write it down, sleep

The first draft took about twenty minutes. Then I typed a self-paced /loop and left. A round is deliberately small and deliberately closed: read CHANGELOG.md so no idea gets tried twice, pick three to five concrete improvements — broken interaction first, then mobile layout, then motion, then typography, then copy — implement them, re-run Playwright at all sixteen scroll positions, read the resulting images, write a short report, then schedule its own next wakeup. No fixed interval. No human between rounds. The loop decides when it runs again, and it keeps going until the reports stop finding anything worth doing.

claude code — desktop
> /loop polish the resume page until it holds up on desktop and phone. read loop-prompt-resume-01.md and follow it exactly
round 12 — read CHANGELOG (11 entries, no repeats)
changes: hero type scale down 1 step at 390px; stack cards were clipping at scroll pos 6; ease on the count-up was linear, now expo-out
verify: playwright 8 desktop + 8 phone → re-read all 16 → clean
report written · next wakeup scheduled · sleeping
A circular six-step diagram: read changelog, pick changes, implement, screenshot with Playwright, judge the pixels, write report, with a sleep arrow closing the loop back to the start
no human in this circle
The verify step is the whole trick. It looks at rendered pixels, not at its own code, so it is able to disagree with itself.
03 The ping

Twenty-nine versions later it stopped, and told me so on Telegram

I was on the couch for roughly fifteen minutes of that. When I looked at my phone there was a message saying it was done and where to look. I opened it, asked for two changes — two, after twenty-nine rounds — and it went live. The version that shipped was number twenty-four, not twenty-nine: the last rounds were the loop confirming it had run out of real improvements, which is exactly the signal I wanted those reports to produce. Thirty-five minutes end to end, fifteen of them unattended.

claude code — desktop
> show me the changelog - which version am I actually looking at, and what did the last rounds change
Live: v24.
r25 spacing nudge, reverted — worse on phone
r26 no change, report: nothing above the bar
r27 copy tightening, reverted — lost meaning
r28 no change   r29 no change
Five rounds without an accepted change → stopping and pinging you.
A phone showing a Telegram message from a build bot saying the resume page is done, twenty-nine versions run, version twenty-four recommended, with a link to review
2 changes asked after 29 rounds
Get pinged, not stuck. A loop that ends itself is the feature — an unattended loop that never stops is just a bill.
⚠️

The uncomfortable part

I wrote the loop-setup skill for client work — “keep tuning X until it is good” pointed at a dashboard, a prompt, a test suite. The first thing it got pointed at seriously was my own career page. The tool built to iterate on someone else’s product spent a TV episode iterating on how I present myself, and it did a better job of it than I would have at 22:00 on a Tuesday.

04 What 29 rounds look like

The paper trail an unattended loop leaves behind

Every round wrote something down — that is what makes it auditable instead of magic. Tap any image to enlarge it and read the exact prompt that drew it.

LIVE AT /RESUME · VERSION 24

The page that argued with itself twenty-nine times is the page you can open right now

Dark theme locked, tokens borrowed from the episode site, every number on it traceable to a file. It is a resume that documents the way it was built as one of its own sections — which, for the kind of work I am looking for, carries more of the argument than the bullet points do.

A dark resume web page shown on desktop and phone side by side, with a navigation rail reading Method, Story, Work, Recipe
35 min total · ~15 min unattended · 29 versions · 2 revisions asked · shipped v24
06 Steal this

Steal the unattended loop

The valuable half is not the resume page — it is a round small enough to be safe and a stop condition honest enough to actually fire. Everything in this episode is free and open — clone it, run it, make it yours.

skill loop-setup (turns “keep tuning X” into a runnable self-paced loop) cmd /loop with no interval — the session schedules its own next wakeup template loop-prompt template (guardrails, one round, quiet hours, stop condition) assets Playwright 8+8 scroll-shot verify script the loop reads back
run it gh repo clone tellingtechnology/loop-setup # repo not published yet

No GitHub? Comment LOOP on the post and the bot DMs you the link.

Next episode

Next: what happens when the loop is wrong and nobody is watching

Twenty-nine rounds went well. That is the easy case. The interesting question is what an unattended loop does when its own verify step passes something that is actually broken — and what has to be true before I would let one of these run against a client repo overnight.

A dark round counter ticking upward with a green pass badge, and one round in the sequence quietly marked with a red flag nobody has read
drops soon · follow so you don’t miss it