19 November 2026 · Nick Finch
How we build AI systems that improve themselves
A build, test and review loop now costs minutes a pass. Three systems we run that improve themselves, and why each depends on a judge who can say no.
An engineer with a few more decades behind him than most commented this week on a post I wrote in January. Agentic engineering, he said, follows the loop he learned on punch cards. Build, submit, review, repeat.
He is right. That loop is one of the oldest ideas in the software industry. What has changed is the price of one pass. A model now writes the change, so those cycles can run continuously, in minutes.
Build that cycle into a system, put something in it that can judge the result, and the system starts to improve itself. We have this running in a growing number of places, and I’ve picked out three below. None of the three works by magic. Each has a judge inside the loop, and in one of them a person still holds the switch. This post sets out our method.
The code that passed its tests
The first loop is the one we use to write software. One model writes the code. A different model reviews it, with a single job, to find what is wrong. The first model fixes what the reviewer found, and the reviewer looks again. That repeats until the reviewer finds nothing serious.
Earlier this week we replaced the PDF reader in our knowledge platform, and the loop went round three times in one afternoon.
Round one. The new code passed more than six hundred tests. The reviewer still found a list of problems, graded by severity, and the first model fixed them.
Round two. Checking those fixes, the reviewer found a serious fault the tests had missed. When the reader failed on a page, the page came back blank and was recorded as read. Our knowledge base would have reported a document as fully loaded while part of it was missing.
Round three. With that fixed, and new tests added to catch it, the reviewer found nothing serious left. The change merged.
The fault was found by the judge, on its second pass. Passing tests did not find it, and a single review would not have either. Because each round costs minutes, we can keep going until the reviewer has nothing left to say.
The knowledge that has to earn trust
The second system is an expert system we built for a client’s engineering team. It answers technical questions from a knowledge base, and much of that knowledge has passed through a model on the way in. A transcript of an expert talking, for instance, is turned by a model into sections the system can search.
A model can summarise an expert wrongly and sound entirely confident doing it. So everything a model has touched is marked untrusted from the moment it is created.
Use is the test. The agent draws on that content when it answers questions from the client’s own senior engineers. Once a piece has been served three times without negative feedback from the engineer who received it, the untrusted flag comes off.
Three is a setting. We can raise it or lower it as the evidence comes in, and that number is the plainest expression of how far we trust the machine today.
The skills that get rewritten
The third system improves the way we build software. Our coding agents work from skills, written instructions that tell a model how we do a particular kind of job. The quality of the code depends heavily on the quality of those instructions.
The code quality improvement engine in our software factory records, against every change to our code, which skills were used, at which version, and how good the resulting code was. That gives each skill a rating, and a rating gives us something to act on.
Last week it showed that a skill covering how we structure React applications was hardly ever being loaded for everyday edits. Its description only mentioned designing or reviewing an application’s architecture, so the agents did not reach for it during routine work. The engine wrote a brief with the evidence. A model drafted a revised skill. A person reviewed it and merged it.
The engine now compares the code written before and after. At the tenth change, or after four weeks, it gives a verdict of improved, worse, mixed or no clear change. That verdict is not in yet.
This loop is still started and approved by hand, and deliberately so. The engine holds a few weeks of data, which is not enough to act on unattended. The intention is to let it run itself once the data can carry that weight.
The objection worth taking seriously
A model writing and a model judging sounds like automated agreement. Two systems with the same blind spots will pass each other’s mistakes. And three quiet servings prove that nobody complained, which is a different thing from the content being right.
Both points hold whenever the judge is weak. So everything rests on the judge.
In the client’s system the judges are senior engineers. They are experienced, they hold strong views on what correct means, and they want the tool to be accurate because they will rely on it. If an answer is even partly wrong, they will say so. The client has also asked every engineer to spend at least fifteen minutes a day questioning the system, so new content is tested quickly, by people who know the subject. When engineers like that read an answer and raise nothing, that is evidence. The same silence from users who could not tell a right answer from a wrong one would prove nothing.
That fifteen minutes is the client paying for judgement. It is the one part of the loop that did not get cheap.
The same holds for the code. The reviewer was a different model with a different brief, and the fix was proved against the real library, not against our assumptions about it.
Four rules we build to
Mark everything a model produces as unproven. Content, code and instructions all start untrusted. Trust is a state that has to be earned, and the system should record whether it has been.
Decide what a pass looks like before you run anything. Three clean servings. No serious findings left. A verdict at the tenth change. A loop without a defined pass will go round for ever and tell you nothing.
Put a judge in the loop who is qualified and will object. An expert with a stake in the answer, a second model briefed to find fault, or a measurement with enough data behind it. If nothing in the loop can say no, the loop improves nothing.
Keep a person on the switch until the evidence removes them. Start every loop by hand. Hand over control one setting at a time, when the data shows the judge can be relied on.
Any process with a goal
The cases here are all about model output, because that is where the risk sits. A model can produce more than any team can check, and unchecked output is a liability however quickly it arrived.
The pattern is wider than that. Any process you can measure, with a goal you can define, can be run this way. Measure it, test the result against the goal, make an informed change, and go round again.
The loop is no longer the expensive part. Building one takes days. What takes thought is deciding what good looks like and who is fit to judge it. Get those two right and the system gets better every week it runs.