Beyond Loop Engineering: Building AI Software Factories

The Three Actors of Value Creation

IndyDevDan argues that the current industry obsession with "loop engineering" is a superficial rebrand of standard software development life cycles. Instead, he proposes a framework based on three distinct "actors of value creation": Engineers, Agents, and Code. The goal of agentic engineering is to know exactly when and where to deploy each actor to maximize throughput and reliability. Code is highlighted as the "unsung hero"—it is deterministic, free to run, and provides the necessary guardrails for agentic output.

Scaling from Workflows to Factories

An AI Developer Workflow (ADW) begins with a simple prompt-response loop but must evolve into a robust system. The progression starts by adding deterministic code (linters, formatters, type checkers) to validate agent output. As complexity grows, these validation steps are offloaded to specialized "test agents." The architecture scales by moving from simple Git worktrees to isolated agent sandboxes, where each agent operates in its own environment. This isolation allows for parallel execution and prevents agents from interfering with one another.

The Software Factory Architecture

At the highest level, these workflows are integrated into a "software factory" managed by a routing system. Tickets from product, support, or engineering are funneled into this factory, where a router agent analyzes the request and dispatches it to the appropriate specialized workflow (e.g., a hotfix agent, a feature-build agent, or a chore-runner). This meta-layer approach allows engineers to stop "vibe coding" and instead build systems that reliably produce software, effectively templating their expertise into repeatable, automated processes.

The Role of the Engineer

In this model, the engineer's role shifts from writing code to designing the system that writes the code. The engineer acts as the human-in-the-loop at the two critical constraints: planning (the initial prompt) and validation (the final review). By focusing on the meta-work of orchestrating these agents and code-based guardrails, engineers can achieve massive leverage, turning a single developer into a force capable of managing complex, multi-agent production environments.