Video: "5 Insane Claude Loops You Need To Use Right Now" by Julian Goldie on YouTube.
What loop engineering actually is
The standard way to use Claude is prompt-and-wait: you write something, Claude produces an output, you evaluate it, you write something else. That works fine for one-off tasks. It falls apart the moment a job has more than a few steps, because you become the glue — the human in the middle re-prompting after every stage.
Loop engineering is the attempt to remove yourself from that middle position. Instead of a single prompt, you configure a cycle: Claude builds something, a second Claude instance (or the same one with a judge prompt) evaluates it against a defined standard, and if the standard is not met the loop runs again. The cycle continues until either the output passes the judge or a set number of attempts is reached. You set the goal and the stop condition at the start. After that, Claude is on its own.
The practical result is that Claude can now handle multi-step jobs — write, review, revise, re-check — without you touching it between steps. That is not a dramatic leap from where things were a year ago; it is a gradual shift. But the five specific loops Julian Goldie walks through show what that looks like when it is actually wired together.
Loop one: builder and judge
The simplest and most reusable loop. One Claude agent takes a brief and produces an output — a piece of writing, a section of code, a structured plan. A second agent (running the same model, but given a different system prompt) scores the output against a rubric. If the score is below a threshold, the builder tries again, incorporating the judge's notes. The cycle runs until the score passes or the attempt limit is hit.
In practice this is the loop that improves consistency the most. Without a judge, Claude's first attempt is as good as it gets. With a judge in the cycle, the output is nearly always meaningfully better by the second or third pass, without any human involvement between runs. Worth knowing: the judge prompt matters more than the builder prompt in most cases — vague quality criteria produce vague feedback, and the loop stalls.
Loops two and three: Kanban and pipeline
The Kanban loop maps the job to a task board: a planner agent breaks a goal into discrete tasks, a builder agent picks one up and works it, a reviewer agent checks the output before it moves to done. Multiple builder agents can run in parallel against the same board, which makes this the most useful pattern for content-at-scale work — keyword clusters, product descriptions, SEO page sets.
The pipeline loop is simpler: each stage passes its output directly to the next, like a production line. Idea to outline to draft to formatted post, each stage handled by Claude with a different prompt, no human handoff between them. This one is straightforward to set up and reliable for well-defined workflows where the stages do not need to branch or backtrack.
The main limitation of both is that they handle scope well but struggle with ambiguity. If the brief is underspecified, the planner agent produces a task list that looks reasonable but misses the point — and the rest of the loop faithfully executes the wrong plan. The human oversight point is at the brief, not in the middle of the cycle.
Loops four and five: Oracle monitoring and SEO pipeline
The Oracle loop is scheduled rather than triggered by a prompt. Claude checks a source — a news feed, a competitor page, a data endpoint — at a set interval, summarises what has changed, and takes a configured action if a threshold is crossed. Julian Goldie uses this for automated news monitoring: the loop runs every few hours, and if a relevant story appears, it drafts a summary and queues it for review. The human only sees the output, not the running cycle.
The SEO loop is the most opinionated of the five: keyword research feeds a content brief, the brief feeds a draft, the draft goes through the builder/judge cycle, and the finished piece is formatted for publish. It is not especially fast — Claude working through a 1,500-word article with two judge passes takes a few minutes — but the output quality is more consistent than a single-pass draft, and the whole thing runs without you once the keyword is set.
What is overhyped and what is genuinely useful
The idea that loops make Claude "autonomous" in any meaningful sense is overstated. What they actually do is remove you from the middle of a process, not from the edges. You still need to write a good brief, configure sensible stop conditions, and check the output before using it. The loop is not making creative decisions; it is running the same judge-and-revise cycle more reliably than you would do manually.
That said, the builder/judge pattern is legitimately useful for tasks where consistency matters more than novelty — compliance documents, structured data, product copy, technical summaries. The Oracle loop is worth setting up for anyone who needs to monitor a source regularly. The SEO pipeline is useful if you are producing content at a volume where manual re-prompting is the bottleneck.
The Kanban setup has the highest overhead — it takes time to configure properly — and the benefit depends almost entirely on how well the planner prompt is written. If you are not already running multi-agent workflows in Hermes or a similar tool, the simpler builder/judge loop is a better starting point.
Where this connects to NordSys
If tracking this kind of AI-agent news makes you wonder whether one could actually run inside your business, that's exactly what our AI Agents do — named, briefed and managed for you, no setup fee, from £6 a day.
See our AI Agents →