From Prompt Engineering to Loop Engineering

Gonzalo Chacaltana — Sun, 18 Oct 2026 19:20:13 +0000

In recent years, we have seen a rapid shift in how we interact with Large Language Models (LLMs). Between 2022 and 2024, prompt engineering dominated, focusing on best practices for crafting detailed instructions.

In 2025, the focus shifted toward Context Engineering—prioritizing the structure and strategic retrieval of information within the context window through RAG. By 2026, however, we're firmly in the era of Loop Engineering.

Engineers on the Anthropic team summarize this transformation with a categorical maxim: ‘Stop writing prompts and start building loops.’ Peter Steinberger (developer of OpenClaw) emphasizes that developers should no longer send prompts directly to code agents; instead, they should design structured loops that guide the agents and automatically issue prompts to them.

Anatomy of an Agentic Loop

Think: The LLM reasons explicitly about the current state of the task, analyzes previous errors, and decides on the next logical step.
Act: The model selects and invokes a specific tool—such as executing a Python script, querying a REST API, running an SQL query, or performing a web search.
Observe: The model captures the output or error message returned by the tool and incorporates it into its context window to inform the next cycle of reasoning.

Fundamental Agent Formula

Agent = LLM + Memory + Planning + Tool Use

The loop acts as the execution engine, orchestrating these four components into a unified system and enabling self-correction in the face of unexpected errors. Without a loop, memory remains static, the plan is never re-evaluated, and tool use is reduced to a one-off, static call.

Design Patterns

An examination of the technical documentation for prominent frameworks—such as LangGraph, AutoGen, and CrewAI, as well as CLI-based agents like Claude Code and Cursor—reveals four primary architectural patterns:

ReAct (Reason + Act): Combines explicit, text-based reasoning with the execution of tools. Research indicates that allowing models to reason and act within a loop outperforms imitation and reinforcement learning methods, achieving up to 34% higher success rates on decision-making benchmarks.
Reflection Loop: Follows a cycle of Generate → Critique → Refine → Repeat. On the HumanEval coding benchmark, incorporating reflection increased model accuracy from 80% to 91%. However, performance gains follow a pattern of diminishing returns: while the initial review identifies the majority of errors, extending the process beyond three iterations primarily increases token consumption with negligible further improvement.
Tool Use Loop: The model executes targeted tool calls—including database queries, API requests, and compiler operations—iterating iteratively until it gathers sufficient context to produce a final response.
Multi-Agent Loop: Coordinates multiple specialized sub-agents within nested loops. This typically takes one of two forms: the Supervisor Pattern (a central agent manages the workflow) or the Swarm/Handoff Pattern (agents pass tasks directly to one another, much like a relay race).

How do you program a loop?

In modern engineering, loops programmed within CLI environments (such as Claude Code, Cursor, or automation servers) consist of five essential structural blocks.

Trigger: The event or condition that initiates execution (e.g., a Git webhook triggered when a Pull Request is opened, or a daily cron job set for 8:00 AM).
Goal: The concrete, measurable outcome the system is intended to achieve (e.g., "ensure 100% of unit tests pass without errors").
Actions: The set of authorized tools the AI can employ to make progress toward the goal.
Verification: The most critical step in the loop. The system does not stop simply because the model claims "I’m finished"; rather, it stops only when an objective executor—such as a linter, a compiler, or a test script—validates that the goal has been met.
Memory: A record of the context, including previous attempts, ensuring that the same failure is not repeated in the next iteration.

The AI Engineer’s Golden Rule: "Workflow First, Prompt Last." Begin by designing the workflow architecture: define the actions, the impartial verification step, the iteration limit (max_iterations), and the objective stopping conditions. The initial prompt (or "kickoff prompt") is, quite literally, the very last thing to be drafted.

Three Essential Loops in the Software Development Life Cycle (SDLC)

To apply this concept to academic or production-grade projects, let’s look at three high-impact loop patterns drawn from the Loop Engineering practice catalog:

🛠️ Self-Review Loop: A loop configured to automatically execute linters, run unit tests, and check style conventions for a Pull Request—all before a human engineer is even asked to perform a review.
🔍 Product Evaluation Loop: An autonomous agent that takes the specifications for a SaaS platform or mobile application, simulates real user stories, compares the UI state against privacy policies, and automatically reports any inconsistencies.
📚 Documentation Sync Loop (“Docs until complete”): One of the biggest headaches in software development is the misalignment between code and documentation. This loop scans for changes in APIs or backend contracts and automatically updates Markdown files and documentation repositories to ensure 100% synchronization.

Conclusions

The transition from Prompt Engineering to Loop Engineering marks a critical milestone in the maturation of Artificial Intelligence, advancing it from a conversational interface into a robust, autonomous execution engine. Consequently, loop-based architectures represent a pivotal core competency in contemporary software engineering, enabling the design of systems capable of iterative reasoning, self-correction, and autonomous decision-making.

Sources:

AI Agents: "Super Mushroom" or "Game Over" for Programming?

Gonzalo Chacaltana — Fri, 13 Feb 2026 23:46:03 +0000

Recently, Anthropic, the company behind Claude Code, has equipped its LLM models with "skills": the ability to use tools, execute code, and perform specialized tasks autonomously. In other words, Claude no longer just writes code; now he "has skills". Meanwhile, the industry, academia, and software development professionals watch in amazement as teams of AI agents build complex compilers in weeks. The question arises: Is programming dying, or is it simply evolving? What we are witnessing is the end of code typing and the birth of intent engineering.

This article mentioned that programming is an "art" based on logic and creativity, sorry, it's in spanish. The question that arises now is:

Is programming still an art based on logic and creativity?

Anthropic's publication on agents with skills marks a milestone: we are no longer just looking for a model that "talks" about code, but an agent that "acts" on it. This means that the mechanical aspects of programming—writing boilerplate code, correcting syntax errors, or implementing standard functions—are being absorbed by LLM models hungry for efficiency.

However, this doesn't negate the article's view that programming is an art based on logic and creativity. On the contrary, I believe that AI elevates it.

Logic is the necessary structure for a system to be functional and predictable; it's the physics of the digital world. But creativity is what allows that logic to solve complex human problems in elegant ways. An algorithm may be functional, but a well-designed system is a work of art in terms of maintainability, efficiency, and user experience.

Today, AI can replicate the "how" (the logic), but it remains incapable of understanding the "why" (the creative intent). As a programmer, you no longer "chip away at the stone"; now you are the architect who designs how these agents should interact with each other. The art now lies in defining the boundaries, objectives, and ethics of these autonomous systems.

So, the question that arises is:

What will be the role of the software engineer with the advancement of AI?

We are leaving behind the era of the "code writer" and entering the era of the Agent Architect. That is, the role will evolve from code writer to conductor, leading an intelligence team.

The tasks that many software engineers who use AI agents already perform are:

Agent Orchestration: You decide what skills each agent needs and how they should be linked together to solve a real business problem.

Validation and Security: AI can generate solutions, but the engineer must be the ultimate judge of the accuracy, security, and efficiency of those solutions.

High-Level Abstraction: The engineer will move away from low-level details to focus on the system architecture and the human experience.

Conclusion: Do you eat the Super Mushroom or quit the game?

Programming was born as an art based on logic and creativity, and it will remain so as long as there is a human with vision. AI is, without a doubt, that "Super Mushroom": it makes you bigger, allows you to break through blocks that previously held you back, and gives you superhuman agility.

However, "Game Over" will only come for those who put down the controller and stop creating. For the rest of us, for those of us who remain passionate about solving problems, AI is not the end of the game, but the power-up that will allow us to build the most ambitious level of our lives.

The question isn't whether AI will replace you, but what wonder you will paint today now that your brush moves at the speed of light.

Posts that may interest you:

DEV Community: Gonzalo Chacaltana