What is an AI coding loop?

An AI coding loop is a workflow in which an AI agent repeatedly plans a change, makes it, and runs a real verification check — feeding each failure back into the next attempt — until the check passes or a retry ceiling stops it. It replaces the fire-once prompt with a self-correcting cycle that stops on proof, not on the model's say-so.

Put another way: a one-shot prompt asks for an answer and trusts the reply. An AI coding loop asks for a result and won't stop until a command your machine ran agrees the result is there. The loop is the control structure; the model is just the worker inside it.

The anatomy of an AI coding loop

Every self-correcting AI agent loop, whatever the tooling, is built from the same five parts. In LoopFlow — a small natural-language DSL for writing these loops as .loop files — each maps to one line:

• A goal — what "done" means, in plain language. The goal is the objective the agent is working toward.
• Context — the files and prior failure the agent may read before it acts. Scoping this keeps the agent in your module instead of wandering the whole repo.
• Actions — what the agent may do on its own, and what needs a human. Risky, irreversible work (migrations, deploys, pushes) gets gated.
• Verification — the check that decides pass or fail. In LoopFlow this is done when, and it runs a real command.
• Stopping — when to quit: the goal is met, or the loop has thrashed past a try ceiling.

The engine that ties them together is a repeated cycle: plan (decide the smallest change), act (make it), observe (run the check). On a red check the loop reflects — it reads the failure output, writes a short diagnosis, and hands that to the next plan. That back-edge is what makes the agent self-correcting rather than blindly retrying.

Why a loop beats a one-shot prompt

A single prompt fires once and stops when the model stops typing. You are the verification step: you re-run the test, notice it failed, and re-prompt — every time. The failure mode is silent. The model replies "Done — fixed the rounding," and you find out later that the test never went green.

An AI coding loop closes that gap on three fronts:

1. "Done" is provable. The verdict never comes from the model. At the observe step, deterministic runtime code spawns your check as a real OS process and reads the exit code. Exit 0 = pass; anything else = fail. The agent does the work; the operating system grades it.
2. Failure is fuel, not a dead end. A red check triggers a reflect-and-replan instead of a stop. The loop learns from each miss automatically.
3. Risk is gated, scope is bounded. The agent works on a branch, never pushes to main/master, and pauses at the gates you set.

A concrete .loop, walked through

Here is a complete AI coding loop for a failing test. Every line is one of the five parts above:

loop "fix the checkout tax test":
  goal: the checkout tax test passes with no regressions
  done when the test "checkout.spec.ts::tax" passes

  look at: the checkout code, and the last failure
  allow edits automatically, but ask me before pushes

  each cycle: plan, then act, then observe
  when it fails: reflect, then plan again
  after 6 tries: stop and warn "tax fix thrashing"

Reading it top to bottom — the finish line first, the safety net last:

• goal and done when are the contract. The check is written before any behavior — if you can't state the check, you don't yet know what you're building.
• look at and allow … ask me before … are the boundaries: what the agent may read, and what it may do alone. Ending look at with and the last failure is what feeds the reflect diagnosis into the next plan.
• each cycle is the engine — the repeated plan → act → observe unit.
• when it fails and after 6 tries are the safety net: recovery, then a hard floor so the loop can never spin forever. (LoopFlow also enforces an absolute cap of 25 cycles regardless.)

Run it and the loop runs the test every cycle. Red? It reflects on why, edits, and re-checks. It stops only when checkout.spec.ts::tax is green — or warns after six attempts. The same file works tomorrow, and a teammate can read exactly what "done" meant.

Verification is the whole trick

The check is the loop's definition of reality, so it has to be real. LoopFlow supports several predicate forms, and you can list as many as you need — all must pass:

loop "harden the auth module":
  goal: auth is covered and free of high-severity findings
  done when "pnpm test src/auth" passes            # a shell command, exit 0
  done when "semgrep --severity=high" finds nothing # exit 0 AND empty output
  done when the skill "code-review" approves         # an LM-judge eval

  look at: src/auth, and the last failure
  each cycle: plan, then act, then observe
  when it fails: reflect, then plan again
  after 8 tries: stop and warn "auth hardening stuck"

The command runs in your shell with your privileges — treat a .loop from an untrusted source as you would their shell scripts. A test runner that exits 0 on failure will make the loop lie to you, so write the check like you mean it.

Where AI coding loops scale

One loop fixes one thing. Real work is a sequence of them, and LoopFlow composes loops two ways:

• A pipeline is an epic broken into stages — each stage is itself a loop with its own goal and check, and stages run in order; a failing stage halts the rest. You can gate a stage on a human (a human approves before charging the card) for the risky steps.
• A flow chains whole .loop files, passing each step's text result forward as context for the next — build, then test, then deploy behind an approval.

Because each stage carries its own verification, a multi-step AI agent workflow degrades safely: the pipeline can only advance past a stage whose check actually went green.

How to run one

With LoopFlow installed (npx @loop-lang/loop init), there are two surfaces:

• In a Claude Code chat via the /loopflow skill — describe the work and it authors the .loop, then /loopflow run <file>.loop runs it natively in the session. You watch every plan → act → observe → reflect step and answer human gates inline.
• Headless via the CLI — loop-run run <file>.loop to execute, or loop-run show <file>.loop to print the shape and catch a missing check or thrash guard before you run it.

The default installed into CLAUDE.md means you rarely type the slash: ask for something repeatable and verifiable and the agent reaches for a loop on its own; ask a one-off question and it just answers.

The takeaway

An AI coding loop is the difference between an agent that claims it finished and one that keeps working until the world agrees it did. Give it a goal, scope its context, gate the risky actions, hand it a check it can't fake, and cap the retries — and you get a self-correcting AI agent you can leave running, review in a PR, and re-run tomorrow.

Try it: write a .loop and watch its shape in the playground, or learn the whole language line by line in the tutorial.