Lesson 5 · 16 min
In a long loop, the model's context will be compacted, reset, or swapped for a fresh session. What only existed in the conversation vanishes or comes back as a summary, mixing fact and guess. The way out: disposable session, state in files and in git, and every cycle starts by rereading. You build a cycle like this and interrupt it on purpose.
Start the lesson
Goal: build a disposable cycle that rereads the state from a file, does one item, verifies, and commits, and resume after an interruption without redoing anything.
Click each step of the cycle: what it reads and what it leaves recorded.
Scroll the page: each step below lights up its part of the diagram.
It could be a /clear, a compaction, a fresh codex exec, Ralph calling again, or someone else taking over. The design starts from the worst case: the session remembers nothing and can be interrupted midway.
In Anthropic's long-running harness (11/26/2025), every session starts like this: where am I (pwd), what has been done (git log and the progress file), what is the next item, and a basic test before coding. The item list is JSON with the passes field; the post says the model overwrites JSON less than Markdown.
Picks the first pending item and does only that one. In Anthropic's post, later sessions may only change the passes field; they do not rewrite or delete items from the list.
An item only becomes passes: true if its verification passed. The line in progress says when and what the result was. If it failed, the item stays pending and the reason is recorded.
The commit is the checkpoint: if the next session drops, nothing that was verified is lost; if an item came out wrong, git revert undoes it. LOOP-R uses the same principle for process versions ("git is the promotion and rollback mechanism"; details in course 5).
The session is disposable; the state is not. Whatever has to survive a compaction, a reset, or a model switch goes into a file and a commit before the end of the cycle.
The execucao-longa kit takes the idea to seven files (goal, plan, state, progress, failures, decisions, canal): it is lesson 1 of course 2.
Each run is a "session" that remembers nothing: it rereads, does one item, verifies, records, and commits. No model: the action is writing a file.
mkdir -p ~/ensaio-loop/estado && cd ~/ensaio-loop/estado && git init -q
cat > features.json <<'EOF'
[
{"id":"f1","descricao":"ler o CSV","passes":false},
{"id":"f2","descricao":"contar linhas","passes":false},
{"id":"f3","descricao":"gravar o resumo","passes":false}
]
EOF
git add -A && git commit -qm inicio#!/usr/bin/env python3
"""A cycle that starts from zero every time: rereads the state from files, does ONE item, records and commits."""
import json, subprocess, sys, datetime, pathlib
estado = pathlib.Path("features.json")
itens = json.loads(estado.read_text())
pendentes = [i for i in itens if not i["passes"]]
if not pendentes:
print("nada pendente: objetivo cumprido")
sys.exit(0)
item = pendentes[0]
print(f"releu features.json: {len(itens) - len(pendentes)} feitos, {len(pendentes)} pendentes")
print(f"faz: {item['id']} ({item['descricao']})")
pathlib.Path(f"{item['id']}.txt").write_text(item["descricao"] + "\n") # the "action"
item["passes"] = pathlib.Path(f"{item['id']}.txt").exists() # the "verification"
estado.write_text(json.dumps(itens, ensure_ascii=False, indent=2) + "\n")
agora = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
with open("progress.md", "a") as f:
f.write(f"| {agora} | {item['id']} | passes={item['passes']} |\n")
subprocess.run(["git", "add", "-A"], check=True)
subprocess.run(["git", "commit", "-qm", f"feito: {item['id']}"], check=True)
print(f"commit: feito: {item['id']}")python3 ciclo.py # close the terminal here, open another one and go back to the folder cd ~/ensaio-loop/estado python3 ciclo.py && python3 ciclo.py && python3 ciclo.py git log --oneline
$ python3 ciclo.py releu features.json: 0 feitos, 3 pendentes faz: f1 (ler o CSV) commit: feito: f1 --- (sessão descartada; outra começa do zero) $ python3 ciclo.py releu features.json: 1 feitos, 2 pendentes faz: f2 (contar linhas) commit: feito: f2 $ python3 ciclo.py releu features.json: 2 feitos, 1 pendentes faz: f3 (gravar o resumo) commit: feito: f3 $ python3 ciclo.py nada pendente: objetivo cumprido $ git log --oneline 58d590c feito: f3 16ff9e9 feito: f2 7345668 feito: f1 7f9664d inicio
The hashes will differ on your machine; the order and the messages will not.
Swap the "action" line for a call to the agent (codex exec or claude -p) and the "verification" line for a test that actually runs. The rest (reread, one item, mark only with proof, commit) stays the same. The verification in this toy version is weak on purpose: it only checks that the file exists (level 2 on the scale from lesson 6).
Each task is a cycle. Run it, interrupt it, and run it again: whatever already has a commit is not redone.
Illustrative simulation in the browser. The failure is intentional: an item without proof does not become passes: true.
On your machine. It doesn't use up quota: there is no model in the cycle.
Set up the folder, paste in the ciclo.py, and run it once. Close the terminal, open another one, and run it until you see "nada pendente".
Done when: The last run prints nada pendente: objetivo cumprido, and git log --oneline | wc -l → 4.
Add item f4 "arquivo vazio" and change the check to require a non-empty file (stat().st_size > 0). Make f4's action write an empty file and run it.
Done when: python3 -c "import json;print([i['passes'] for i in json.load(open('features.json'))])" → [True, True, True, False], and tail -1 progress.md ends with passes=False |.
Pick a real task that takes several hours and break it into at least 5 verifiable items in a features.json, all with passes: false, in a project folder with git.
Done when: python3 -c "import json;d=json.load(open('features.json'));print(len(d)>=5, any(i['passes'] for i in d))" → True False, and git log --oneline -1 -- features.json shows the commit of the list.
Question 1 of 4
After a compaction, the summary says "f3 done", but features.json shows f3 with passes: false and there is no commit for f3. Which one counts?competency
Question 2 of 4
Why does Anthropic's harness post keep the list of items in JSON and not in Markdown?
Question 3 of 4
What is the advantage of one commit per item instead of one commit at the end?
Question 4 of 4
In the simulation, the session dropped in the middle of an item. What happens to that item on resume?competency
Choose one answer. The explanation appears after you try.