Write loops, not prompts.
Boris Cherny built Claude Code. He doesn't prompt it anymore: "My job is to write loops." Peter Steinberger built OpenClaw: "You should be designing loops that prompt your agents." Geoffrey Huntley left one loop running for three months on a single prompt and got a compiled programming language with an LLVM backend. $297 in API costs against an estimated $50,000 of developer time. In the language, slay means func and yeet means import.
The loop is easy. The verifier is the whole game. Tonight you write both, on your own project, and leave with it still running. We check what shipped at breakfast.
- Connect to the Wi-Fi — credentials are posted at the venue.
git clone https://github.com/vibecodingnights/loop-engineering.gitcd loop-engineering && bash preflight.sh- Pick your path: Beginner or Advanced.
preflight.sh checks your Claude Code version (≥ 1.0.34 for /goal — current stable is 2.1.x, so this only catches ancient installs), your API key, your git config, and installs the Ralph Wiggum plugin if it's missing. No project of your own tonight? Open no-project.md.
Goal: leave tonight with one loop running on your own project.
1. Pick your task (10 min). Open your project. Find one thing with a mechanically checkable outcome. Good: "all tests pass," "type checker clean," "these 12 endpoints return 200." Bad: "improve the code," "make it faster" — the loop never knows when to stop. Stuck? verifiers/good-vs-bad.md has a decision tree.
2. Pick your loop pattern (5 min). Read one file in patterns/:
- patterns/01-ralph-loop.sh — the original
while truebash hack. Three lines. Start here to see the guts. - patterns/02-slash-loop.md — Claude Code's built-in
/loop. The easiest entry. - patterns/03-slash-goal.md —
/goaladds a separate verifier model that checks each iteration. Use it for anything longer than 10 minutes.
3. Write your verifier (15 min — this is the hard part). Copy the closest match from verifiers/templates/ and edit it. Your verifier must:
- be a command that exits 0 (pass) or non-zero (fail)
- run in under 30 seconds
- require no human judgment
- test the actual outcome, not the process
Example — migrating a codebase from JavaScript to TypeScript:
#!/usr/bin/env bash
# verifier: no .js files remain in src/, and tsc compiles clean
set -euo pipefail
JS_COUNT=$(find src/ -name "*.js" | wc -l | tr -d ' ')
[ "$JS_COUNT" -eq 0 ] || exit 1
npx tsc --noEmit4. Set your cost cap (2 min). Read safety/cost-caps.md and set a spending limit in your API dashboard. $5 is plenty for the evening. $10–20 if you run overnight.
5. Start the loop (1 min). Fire it off. Watch the first iteration to make sure it isn't immediately broken. Then work on something else, help a neighbor, or get dinner.
6. Post your loop in the channel (2 min before you leave). One message: what you're looping on, what your verifier checks, when you started, your cost cap, your repo URL. That's what we check at breakfast.
Already run /loop or /goal? Pick a track. Combine them if you want.
| Track | What you build | Start |
|---|---|---|
| A. Verifier engineering | Composite, semantic, and cost-aware verifiers — checks good enough to trust unsupervised output. The templates are the floor, not the ceiling. | verifiers/ |
| B. Task hypergraph | Decompose a large goal into a parallel DAG of agent tasks, each with its own verifier, driven as concurrent waves. The most complex path. | hypergraph/ |
| C. Background agents + overnight | A loop that survives your laptop closing. Server-side sessions, draft PRs, context-exhaustion recovery. Close the lid at 10, check the PR at breakfast. | patterns/04-background-agent.md |
| D. Parallel loops | Multiple concurrent loops in git worktrees, plus a coordinator that merges and re-verifies the integrated result. | patterns/06-parallel-agents.md |
On Codex instead of Claude Code? patterns/05-codex-goal.md.
| Path | What it is |
|---|---|
| README.md | You are here. |
| preflight.sh | Run once on arrival. Checks your setup, prints pass/fail. |
| no-project.md | 10 open-source repos with loop-ready issues, each with a suggested verifier. |
| patterns/ | Six loop patterns, from a three-line bash loop to parallel background agents. Read one, copy it, go. |
| verifiers/ | The real curriculum. Thesis, decision tree, copy-paste templates, anti-patterns, and a cost/time watchdog. |
| hypergraph/ | The full task-hypergraph skill. Advanced path, self-directed. |
| safety/ | Cost caps, kill switches, context rot. Read before running overnight. |
| host/ | Organizer-only. Not for attendees. |
| Level | You leave with |
|---|---|
| Minimum viable | You understand the difference between a good and bad loop goal. You ran /loop or /goal at least once on your own project. You saw it iterate. |
| Beginner target | A loop running with a mechanical verifier (a script that exits 0/1). A cost cap set. Your loop posted in the channel. You understand why the verifier is harder than the loop. |
| Advanced target | A non-trivial verifier — composite, semantic, or cost-aware. Maybe parallel loops or a hypergraph-orchestrated build running. Designed for overnight autonomy, with the design rationale in your channel post. |
| Night-one target | A loop still running when you walk out. Your loop posted in the channel. You check what shipped at breakfast. |
Post your loop to the shared channel before you leave — goal, verifier, cost cap, repo URL. In the morning, post what your loop produced, how many iterations it ran, what it cost, and whether your verifier held up. The verifiers that failed overnight are the most interesting data points.
We check what shipped at breakfast.