小白也能上手的Loop Engineering：从概念到最小闭环实践

Recently, many people have started discussing Loop Engineering. What exactly is it? Is the AI world introducing another new concept? To be honest, AI is evolving so fast that many new concepts have emerged in the past two years. Most are just hype and not worth following. But after looking into Loop Engineering, I feel it's different. It's not some suddenly appearing new technology, but a new set of norms and frameworks for coexisting with AI. It didn't come out of nowhere. It's more like reorganizing the actions you've already been doing when using AI—setting goals, executing step by step, checking results, reworking after finding problems, recording status, setting stop conditions, and handing over to humans when necessary—into a clearer set of working rules. In the past, when you used AI, you were already doing these actions. You generated something, looked it over, modified a sentence and threw it back, and if you weren't satisfied, had it redo it. You were the loop engine. It's just that these actions have always been driven manually, and no one gave it a name. The most valuable part of this set of rules is that it clarifies one thing. Many people think they are making AI work, but in reality, they have been watching the process on the sidelines.

So in this article, I want to clarify three things. What exactly is it, how is it different from ordinary prompts, and how can a beginner run a small loop first.

First, let's look at it as an ordinary question. What is the difference between it and our usual way of writing prompts? Your typical scenario when using AI should be familiar. You open a dialog box, write an instruction, AI gives you a result, you look at it, add another sentence if you're not satisfied, copy it away if you are. Each round starts from you initiating and ends with you accepting. The Loop approach is different. You design a set of working rules in advance, and you don't need to give instructions round by round. This set of rules tells the AI what the goal is, what to do in each step, how to check after completion, how to handle failures, when to stop, and when to find you. Let me first clarify a few easily misunderstood points. An ordinary prompt is more like describing a one-time task clearly: you tell the AI what to do, it gives you an answer, and that round ends. A Loop connects goals, execution, checking, feedback, and stopping into a set of working rules. After the AI completes one step, it advances to the next step according to these rules, without waiting for your next instruction. The prompt hasn't disappeared. It has just been transformed from the entire interaction into a component within the loop. In the past, your prompt was the whole conversation. Now, your prompt is the rule you set for the loop, telling the AI what counts as pass, what counts as fail, and what to do in case of failure. Another easily confused phrase is AI self-awareness. A more accurate description is that the AI performs quality self-checks based on the rules you preset. In advance, you tell it what is pass, what is fail, how to retry after failure, and when it must stop and seek human intervention. It's not that the AI suddenly gained consciousness. After reading it, I feel it's not that mysterious. Loop Engineering is better understood as a practice method that is being renamed and standardized in the era of AI Agents. It's not a suddenly emerging new technology, nor is it a mature discipline.

The recent discussion around this term is closely related to an article written by Addy Osmani in June. In his article, he made it very clear: you don't drive AI round by round yourself; you design a system to drive it for you. On the underlying technology front, Simon Willison has previously talked about similar concepts when discussing agentic loops. The LLM, driven by a goal, calls tools, looks at results, and then takes action. It's just that Simon was talking about an agentic loop, not directly naming it Loop Engineering. If I had to explain it in one sentence, Loop Engineering is designing a set of working cycles for AI that can repeatedly execute, check, correct, and continue advancing around a goal, rather than having humans prompt every step.

Not all tasks are worth implementing a Loop. Tasks suitable for a Loop must meet at least three conditions. First, it happens repeatedly. You do it every week or every new project. A one-time task is not worth designing a cycle. Second, the result can be checked. You can clearly define what 'pass' means, and this standard can be written as a checklist or verification steps. Third, failure can be fed back. If the previous round didn't do well, the next round can adjust based on the failure reason. If the reasons for failure are different each time and no pattern emerges, the Loop won't help much.

Let me give a few examples of suitable scenarios. Personal knowledge base: compiling scattered materials into traceable, linkable wiki pages for further questioning. Content production early stage: topic judgment, material decomposition, outline generation, fact verification. Code testing and repair: modifying code, running tests, fixing errors reported. Project status check: task progress, risk items, next steps. Learning review: structuring what you've learned, identifying blind spots. The common features of these tasks are clear deliverables, verification standards, and the need for multiple iterations. Let me also give a few examples of what's not suitable. Pure creativity: asking AI to draw a good picture, you can't clearly define what counts as 'good'. Major value judgments are also not suitable: whether to change jobs or start a business, AI cannot make the call for you. Tasks with insufficient factual sources or vague standards: running a Loop will only amplify uncertainty. If you don't know what is right or wrong, how can you get the AI to check itself? High-permission operations go without saying: involving accounts, payments, deletions, and publishing, once it runs automatically, there's no undoing it.

A special note: in the knowledge base organization scenario, there is a common trap. When you can't find an association, it doesn't necessarily mean the AI made a mistake. It could mean it's a new concept, an isolated node, or inherently low-value noise. Forcing a connection will pollute your knowledge base. The result of the Loop check isn't just 'redo'; sometimes it should be 'mark, stop, and hand over to a human for judgment'. The criteria for judgment are not complicated: can you clearly state in advance what 'done' and 'well done' mean? If you can't, don't use a Loop.

Your first small Loop doesn't require complex tools or a full understanding of all Agent architectures. First, prepare seven things: Goal, Input, Execution, Check, Feedback, Record, and Stop. Goal: What exactly is to be accomplished in this round? Don't write a wish; write something that can be verified. 'Organize my knowledge base' is a wish. 'Compile these three materials into a minimal knowledge base, generate source summaries, concept pages, index, and log, and mark items for verification' is a goal. The difference between a goal and a wish is whether you can clearly state what you got after completion. Input: What materials can the AI look at, and what can it not look at? Many people skip this step, but it is the boundary of the entire Loop. The AI doesn't know what not to use; you have to tell it. For example, only rely on these three materials, don't search the internet, and mark uncertainties. Execution: Let the AI take one small step at a time. Don't bite off more than it can chew. Not 'help me organize the entire knowledge base', but 'process three materials on the same topic first, only generate source summaries, one concept page, index, and log'. Check: Use a checklist, citation verification, or manual review to determine if it's acceptable. Checking is the heart of the Loop. Without checking, the cycle is just repeated execution. Check items should be specific: Is there evidence of a source? Is there fabrication? Are there key pieces of missing information? Feedback: What to do if it's not qualified? Different failures require different handling. Missing sources means supplementing sources, a concept page that's too scattered means rewriting it, uncertain facts mean marking them, and key conflicts mean pausing and handing over to a human. Record: What has been done, where it failed, and what the next step is. You don't need a complex system; a simple status description is enough, clearly stating the current round, completed items, pending items, failed items and reasons. Stop: Stop upon success, stop after too many failures, stop on low confidence, stop on rule conflicts, stop when human judgment is needed. The core of a Loop isn't to run more rounds, but to know when to stop. A loop without stop conditions will eventually become a situation where AI keeps running, but no one reads the output.

Here's something many people get confused about: having repeated actions does not equal having a Loop. Suppose you ask the AI to automatically traverse 100 files and generate a summary for each. This seems like a 'cycle', but it's just batch processing. It's because it won't adjust the next action based on the result of the previous one. Whether the first summary is good or bad doesn't affect how the second one is done. In a real Loop, the output of the previous round determines what to do in the next: redo, adjust, skip, or stop.

Next, let's run through a concrete example so you can see what a Loop that even a beginner can try looks like. The example chosen is 'building your own personal knowledge base'. More precisely, borrowing the LLM Wiki concept that Karpathy mentioned, we'll run a minimal version first. I'm not choosing high-permission tool automation for two reasons. First, it's safe: it won't delete files, spend money, or send anything out. Second, you can immediately feel its value. The materials are not summarized and then disappear; they enter a knowledge base that can be further queried and updated in the future. The core of LLM Wiki is simple. Original materials are kept in one layer, the AI-compiled wiki is in another layer, and a rules file tells the AI how to maintain it. You don't need to build a complete system right away; just getting the minimal closed loop running is enough.

The task goal is not to have the AI summarize a few articles. A summary is used and then thrown away. The real goal is to have the AI compile the materials into the knowledge base: each piece of material has a source summary, important concepts have independent pages, an index tells you what's in the library, a log records what was processed this time, and conflicts and uncertainties are marked. The minimal process looks like this. First, create a small directory structure. Place raw materials in raw/, source summaries in wiki/sources/, concept pages in wiki/concepts/, and then prepare a wiki/index.md and a wiki/log.md. If you're using Codex, put an AGENTS.md file in it; if you're using Claude Code, put a CLAUDE.md. This rules file does only one thing: tell the AI that original materials cannot be changed, every judgment should point to a source if possible, and after an update, it must write to index and log. Then, only put three to five materials on the same topic inside. Don't drop hundreds of files at once. First, ask the AI to read these materials, generate source summaries for each, and retain the original source and key information. Next, ask it to extract concepts. If a page for a concept already exists, update the old page; if not, create a new concept page. The focus isn't on shortening the original text, but on linking the information from the materials to a knowledge network that can grow continuously. Then, update index.md and log.md. index.md lets you know what sources, concepts, and entry points are in the knowledge base. log.md records what was added, what was changed, and where your judgment is needed.

Next is the checking phase, which is the most critical step in the entire Loop. Have it check itself. Are there any source summaries missing their source? Are there any judgments in the concept pages that can't find a source? Has it turned uncertain facts into certain facts? Did it forcibly connect two unrelated concepts to make the library look complete? Based on the check results, decide on the next step. If a source is missing, send it back to supplement the source. If a concept page is too scattered, rewrite the concept page. If there is a conflict, mark the conflict and pause to hand it over to a human. If no association can be found, mark it as an isolated node, don't force a connection. If there are consecutive failures or key judgments are involved, stop and hand it over to a human. The truly valuable part isn't that the AI summarized a few pieces of material, but that this knowledge base can be used by you in the future. Next time you want to write an article, create a course, or research a problem, you don't start by asking the chat window all over again; you have the AI read index.md first and find answers from the wiki you've already compiled. This step doesn't require you to know how to code. You can use AI agents like Codex or Claude Code that can read and write local files. If you're just using a regular chat AI, you can also paste the materials and directory structure into it to simulate the process. The key is that you must be the person doing the acceptance. An AI outputting a bunch of text doesn't count as passing. It only counts as passing if every judgment has a source, nothing is fabricated, and no forced associations are made.

The following is a minimal Loop template that can be directly copied, suitable for a 'personal LLM Wiki knowledge base'. (Template text omitted for brevity, but included in the output field as required by the prompt.)

A successful Loop run isn't judged by how many rounds the AI answered, nor by how much content was output. Running successfully isn't about the number of rounds; it's about whether you can answer these questions. Is the goal specific enough to be verifiable? 'Compile these three materials into a minimal knowledge base, generate source summaries, update concept pages, synchronize index and log, and mark items to be verified' is a goal. 'Help me organize my knowledge base' is a wish. Do you know what the AI is doing right now? Is it generating source summaries, updating concept pages, synchronizing the index, or doing a self-check? If you throw it in the dark and after two rounds you don't know whether it redid something or continued running, it's not a successful run. Do you know specifically what is unqualified? You need to really know: this judgment lacks a source, this concept conflicts with an existing page, the index wasn't updated, or this paragraph forcibly connected two unrelated things. Can you say how the next round should be improved? Missing sources means supplementing sources, a poorly structured concept page means rewriting it, a missing index or log update means updating it, and a conflict means pausing for human judgment. Not a vague 'try again'. Has the condition for stopping been clearly stated in advance? Stop upon successful check, stop after too many consecutive failures, stop on low confidence, stop on conflicting rules, stop when your value judgment is needed. Each situation has a corresponding stop action. The AI won't decide on its own to 'run another round and see'. Finally, have you reviewed it? Only when you have confirmed is it considered done. A special emphasis: completing one round of compilation does not mean stopping. The AI outputting a bunch of pages after a round doesn't mean those pages can pass your check. An update to the knowledge base after passing a quality check is considered a stop. A Loop without human validation can easily become the AI giving itself a gold star. It runs many rounds, outputs a ton, and you find out the direction went wrong a long time ago. The standard for a successful run is simple: the result can pass the checks you set.

Finally, let's focus on a few common traps for beginners. Mistaking a long prompt for a Loop: Writing a long prompt full of rules, then throwing a task into it each time. This looks complex, but it's still Prompt Engineering. You gave a complex instruction, and the AI executed it once. Unless it will check the result, decide to redo, and pause when encountering uncertainty, it's just a complex prompt, not a Loop. A long prompt is not a Loop; a feedback closed loop is the Loop. Goal too big: Wanting to fully automate organizing the entire knowledge base, writing full articles, or managing a project from the start. The result is that it goes off track as soon as it runs, and you don't know where to fix it. First, have the AI compile three to five materials on the same topic, and get the source summaries, concept pages, index, and log running smoothly. Standards too vague: Things like 'make it better' or 'analyze it more deeply'. Such standards are not checkable by the AI and not verifiable by you. Standards must be checkable, such as whether there is evidence, whether key information is missing, whether there is fabrication, and whether sources can be matched. No one to check, no one to stop: Letting the AI do the work, verify itself, and declare completion itself is the easiest place to go wrong. Execution and checking must be separated; the doer cannot grade their own work. The simplest approach is to have the AI do it first, then have it review itself against a checklist. Similarly, without a stop condition, it will keep running, consuming tokens and time, and finally produce a bunch of output no one reads. For your first loop, it's best to set a hard ceiling first: a maximum number of rounds, stop when the same type of error occurs repeatedly; don't let it refill indefinitely. Forcing connections where there are none: Some knowledge points are inherently isolated or new. Forcing them to be connected with existing content will pollute the entire knowledge base. When a Loop is organizing a knowledge base, marking 'unrelated' is also valid output. Giving too many permissions: Turning a low-risk practice into a high-risk accident. The first time you run a Loop, don't give it permission to delete files, send messages, submit forms, or operate accounts. One more thing: Loops are not free. They replace the time you spend staring at the dialog box with token consumption and checking costs. Design a closed loop for a one-time task only after calculating the cost. Automation without a checking standard is just automatically generating garbage. It's not hard to get it running; the hard part is knowing when to stop when it goes off track.