From prompter to loop designer.

For two years the way you got something out of a coding agent was: write a prompt, share context, read what came back, write the next prompt. The agent was a tool and you held it the entire time.

Loop engineering is building a small system that finds the work, hands it to the agent, checks the result, records what happened, and decides the next move — on its own. You design that system once. It prompts the agent from then on.

The task repeats

A loop amortizes setup across many runs. If the work doesn't recur weekly, you don't have a loop — you have a script you ran once.

Verification is automated

A test, type checker, linter, or build that can fail the work without you in the room. No automated check → you're back in the chair reading every diff.

Budget absorbs the waste

Loops re-read context, retry, explore — burning tokens whether or not a run ships. Obvious on free tokens, reckless on a metered plan.

Senior-engineer tools

Logs, a reproduction environment, the ability to run the code it writes and see what breaks. Without that, the loop iterates blind.

The Automations tab — pick a project, set a prompt, set a cadence, choose local checkout or background worktree. Runs that find something land in a Triage inbox; runs that find nothing archive themselves.

Three primitives that compose into the same shape: /loop for session cadence, Desktop scheduled tasks for restart-survival, Routines for laptop-off cloud runs. Pair with hooks for lifecycle events.

Re-runs on a cadence. Use it when you want regular checks regardless of state.

Keeps going until a condition you wrote is actually true — checked by a separate small model, so the agent that wrote the code isn't the one grading it. The maker-vs-checker split, applied to the stop condition itself.

The second you run more than one agent, files start colliding. Two agents writing the same file is the same headache as two engineers committing to the same lines without talking first.

A git worktree fixes it — a separate working directory on its own branch sharing the same repo history, so one agent's edits literally cannot touch the other's checkout.

Builds worktree support in — several threads hit the same repo at once without bumping into each other.

Exposes git worktree directly, a --worktree flag to open a session in its own checkout, and an isolation: worktree setting on subagents — each helper gets a fresh checkout that cleans itself up after.

A Skill is how you stop re-explaining the same project context every session like a goldfish. Both tools use the same format: a folder with a SKILL.md inside — instructions and metadata, plus optional scripts, references, and assets.

A loop without skills re-derives your whole project context from zero every cycle. With skills, intent compounds — conventions, build steps, "we don't do it like this because of that one incident," written once on the outside and read by every run.

name: ci-triage
description: Classify CI failures by root cause (env,
  flake, real bug, dependency, infra), draft fixes for the
  easy ones, escalate the rest. Trigger on workflow failure
  or the morning triage loop.
---

# CI triage skill

## Classification rules
- env: missing secret / infra not provisioned. # human
- flake: passes on retry, no code change. # retry, file
- bug: deterministic, tied to recent commit. # draft fix
- dependency: tied to a version bump. # draft rollback
- infra: timeout, OOM, runner issue. # escalate

## Never do
- Disable failing tests — file an escalation instead
- Modify CI config without human approval
- Touch src/payments/ or src/billing/

## State
Update STATE.md after each run: paths checked,
classifications, PRs opened, items escalated.

Spawns subagents only when you ask, runs them at the same time, folds results into one answer. Define agents as TOML in .codex/agents/ — name, description, instructions, optional model and reasoning effort. Security reviewer = strong model on high effort; explorer = fast read-only.

Same, with subagents in .claude/agents/ and agent teams that pass work between them. The usual split: one explores, one implements, one verifies against the spec.

It sounds too dumb to matter and is the spine of every working loop. A markdown file, a Linear board, a JSON state — anything that lives outside the single conversation and holds what's done and what's next.

Agents have short memory by default. What they learn this session is gone tomorrow unless you write it down.

# Loop state · ci-triage

## Last run
2026-06-09 03:30 UTC · 7 classified, 3 drafted, 4 escalated

## In progress
- fix-auth-token-refresh — passing locally, awaiting CI
- fix-flaky-payment-webhook — retry applied, monitoring

## Completed today
- bump-axios-1.7.4 → merged (CI green, deps verified)
- lint-fix-pass-june-9 → merged

## Escalated to humans
- src/billing/refund.ts — failing 3 ways, unclear
- ci/staging-runner — infra timeouts, not code

## Lessons learned (here, not in chat)
- 06-08: PowerShell hits TLS 1.2 on this runner. Use bash.
- 06-07: e2e/checkout needs Stripe secret. Skip if missing.

## Stop conditions met
- /goal "tests pass + lint clean" ✓ commit 3a7b8c1

Not tokens spent, not tasks attempted, not loops scheduled. Below a 50% accepted-change rate, you're doing the review work the loop was supposed to save you — and the loop is losing.

Just a second agent asked to "review," no objective signal. Two optimists agreeing.

"Done" defined by the agent's judgment, not by a test, build, or type check.

Loop runs until something external kills it — a rate limit, you noticing — rather than until success is verified.

Each summarization is lossy; "don't do X" disappears by turn 47.

The agent that wrote the code is too nice grading its own homework.

The loop declares "done enough" at partial completion.

Comprehension debt

The faster the loop ships code you didn't write, the larger the distance between what the repository contains and what you understand.

The bill that hurts isn't the token bill — it's the day you debug a system no one on the team has read.

Cognitive surrender

The pull to stop forming an opinion and accept whatever the loop returns.

Don't read what the loop ships → you rent comprehension debt at compound interest.

Verify a few PRs the loop opened — does the approving test actually catch the failure you care about? Gates rot.

Keep it on small, machine-checkable changes. Judgment calls accelerate the debt.

A second pair of eyes catches blind spots the loop would otherwise exploit forever.