Loop Engineering

Loop Engineering

Vibe coding got us here. It will not get us there.

The frontier moved from "can the model write code" to "can you direct it." The answer is yes, and that changed the job. You are not typing the code anymore. You are running a loop: prompt, generate, verify, correct, repeat. The model is the hands. You are the engineer of the loop.

Most teams have not noticed the job changed. They still measure the old things: lines, commits, velocity. They cannot tell you what last week's AI work cost, which prompts were worth it, or what the agent learned that it should not have to learn again. They are not engineering the loop. They are gambling on it.

Loop Engineering is the discipline of making the loop accountable.

Three questions define it. A team that cannot answer all three is vibe coding with extra steps:

1. What did this cost? Not the monthly bill. The cost of this change, this loop, this week. If you cannot see it, you cannot manage it.
2. Was it any good? Did the loop converge on something correct and verified, or did it produce confident slop that passed review because it sounded right?
3. What did we learn? Every loop that hits a wall teaches something. If that lesson lives in one engineer's head, you will pay for it again next week, in another repo, with another agent.

Cost. Quality. Memory. The three are the same discipline seen from three sides, and they compound. A loop you can price is a loop you can improve. A lesson you can carry is a loop you do not have to run twice.

The unit of work is the loop, so the unit of accountability is the loop.

This is the shift. We used to ship features and measure features. Now the agent ships the feature in an afternoon, and the leverage is in how the loop ran: how much it cost to get there, how sure you are it is right, and whether the next loop starts smarter than this one did. Engineering moved up a level. The tooling has not caught up. Dashboards still count commits. Bills still arrive at the end of the month with no idea which loop spent the money.

Accountability is not a tax on speed. It is the thing that lets you go faster without going blind.

The fear is that measuring the loop slows the loop. The opposite is true. The teams that will pull ahead are the ones who can look at a week of AI work and say, in plain numbers, what it cost, what it shipped, and what it learned, and then make the next week cheaper and sharper. That is not bureaucracy. That is engineering.

What this looks like in practice.

RepoOps was built to make the loop accountable, and we use it on itself. Every change carries what it cost and where its lessons came from. When a loop hits a wall, the lesson is captured and carried, across sessions and across repos, so the next agent starts where the last one stopped. And the output of a build window is a receipt: what it cost, how many sessions, how many shipped changes, how many lessons learned. Honest, window-scoped numbers. We publish our own. The receipts here are real.

We do not claim to price a single pull request to the penny. Attribution at that grain is still hard, and we would rather show you a number we can stand behind than a number that looks precise and is wrong. That, too, is Loop Engineering: say what you know, mark what you do not.

The line is simple. If you can say what your loops cost, whether they were good, and what they taught you, you are a Loop Engineer. If you cannot, you are guessing, and the bill comes anyway.

The code is no longer the hard part. The loop is. Engineer it.

A note on the name: we did not coin "Loop Engineering," and we do not claim to own the term. We own the product the term points to. Every claim on this page maps to a surface that has shipped.