The Coming Loop: Agentic Engineering and the Shift Toward Software as an Organism

The Shift from Agent Loops to Harness Loops

Software engineering is moving beyond simple AI-assisted coding toward "harness loops"—autonomous systems where a machine manages a queue of tasks, attempts a solution, evaluates the result, and iterates until a goal is met. While a standard coding agent operates in a local loop (calling a tool, reading a file, and editing), a harness loop exists outside the agent, deciding whether the agent's output is sufficient or if a new session with modified context is required.

This pattern allows tasks to persist far beyond the point where a model would normally signal completion, effectively automating the trial-and-error process of development.

The Risk of "Slop" and the Loss of Comprehension

Autonomous loops often amplify the inherent weaknesses of current Large Language Models (LLMs), leading to a decline in code quality for long-term projects.

The "Defensive Code" Problem

Models tend to produce code that is overly defensive and locally reasoned. Instead of establishing strong invariants—making bad states impossible by design—LLMs frequently add fallbacks and redundant error handling for cases that should be unrepresentable. This behavior, described by Andrej Karpathy as being "mortally terrified of exceptions," results in systems that appear robust but are actually more complex and less understandable.

The Erosion of Human Understanding

When these loops operate without human oversight, the resulting code often lacks "taste" and architectural coherence. The author notes that hands-off harnesses can produce worse code than human-in-the-loop processes because the AI may work uninterrupted for long periods, layering local fixes over a flawed design. This creates a cognitive dependency where engineers merge code they cannot fully explain, eventually treating software not as a deterministic machine to be understood, but as an organism to be monitored and stabilized.

Where Autonomous Loops Excel

Despite the risks to long-term maintainability, harness loops are highly effective in domains where the output is either short-lived or mechanically verifiable:

• Code Porting: Automating the translation of code from one language to another (e.g., porting MiniJinja to Go or Bun from Zig to Rust).
• Performance Exploration: Running iterative experiments, benchmarking results, and discarding failures to find the optimal implementation.
• Security Scanning: Exploring complex problem spaces to find vulnerabilities without needing to commit lasting code.
• Experimental Workflows: Creating and executing temporary scripts to surface findings or prove a concept.

In these cases, the "done" signal does not need to be a human judgment; it can be a binary test case or another LLM acting as a judge.

The Inevitability of the Looping Future

Opting out of agentic loops may be impossible due to external pressures:

• Security Asymmetry: Attackers and security researchers use loops to find vulnerabilities at a volume and speed that human defenders cannot match. To survive, defenders must also adopt looping tools to triage and reproduce issues.
• Competitive Velocity: Teams using orchestrated machines can out-build competitors through raw speed, achieving with a few people what previously required dozens.
• Cognitive Dependency: As codebases are produced, reviewed, and patched by loops, the human ability to maintain them without machine assistance diminishes, creating a permanent dependency on specific model classes and providers.

Community Perspectives on Agentic Engineering

Discussion among engineers highlights a tension between productivity and professional identity:

"If these loopers mean we all have to move at this continuous wave of software happening... all the programmers have to become business analysts/market researchers/businessmen... the language used may be required to make us all turn into business analysts and software architects more than syntax knowers."

Other contributors emphasize that the bottleneck has shifted from coding to specification. The "meat brain" phase—the time required to actually understand a problem—cannot be bypassed by agents. Success with loops requires extreme clarity in specifications; without it, agents simply produce "broken crappy versions" faster.

There is also a recurring critique of LLM "code smell," specifically the obsession with unnecessary null checks and hasattr calls in type-checked environments, which contributors argue is a byproduct of training data or reinforcement learning that prioritizes avoiding crashes over elegant design.