# FORGET Loop Engineering. Agentic Engineering is about THIS

## Executive summary

The video argues that 'Loop Engineering' is an insufficient and inaccurate mental model for modern software development with AI agents. The superior approach is **Agentic Engineering**, which focuses on building complex AI developer workflows (ADWs) within a 'software factory.' These ADWs orchestrate three core actors of value creation—Engineers, Agents, and Code—to automate the entire development lifecycle, from planning to deployment, thereby scaling impact and accelerating development far beyond what simple loops can achieve.

## Key takeaways

- Shift Focus from Loops to Workflows: Loop engineering is a poor rebrand of the Software Development Life Cycle (SDLC). The focus must be on building comprehensive AI developer workflows that combine code execution with agents, rather than focusing solely on iterative loops.
- The Three Actors of Value Creation: Successful agentic engineering requires understanding and strategically placing three actors: the human engineer, specialized AI agents, and deterministic code. Code is highlighted as the most reliable actor because it costs zero tokens and runs consistently.
- Scaling Developer Workflows: Advanced workflows move beyond simple loops by integrating multiple validation steps (e.g., linting, type checking, formatting) and scaling compute through specialized sandboxes for parallel execution. This process is the core of building a 'software factory.'
- Meta-Engineering: Building the System: The most valuable engineering effort is not working on the application layer, but performing meta-work on the agentic layer—building the system that orchestrates and manages all other components (the 'system that builds the system').

## Technical details

- Agentic Engineering vs. Loop Engineering: Loop engineering is too constrained; it fails to account for necessary components like condition engineering, function engineering, and exception engineering required across the entire SDLC.
- Core Workflow Components (The Three Actors): 1. **Engineers:** Provide planning (prompting) and validation (reviewing). 2. **Agents:** Execute specialized tasks (e.g., scout agent, hot fix agent). 3. **Code:** Provides deterministic, reliable execution (e.g., running a linter or type checker).
- Workflow Architecture and Scaling: Workflows should be built by separating concerns: using dedicated sandboxes for each agent, and ensuring that deterministic code (like linters or type checkers) is run separately from the agents to maintain reliability. The process involves planning $\rightarrow$ building $\rightarrow$ testing $\rightarrow$ reviewing $\rightarrow$ shipping.
- Production Incident Response: A robust ADW for a production crash must involve specialized agents (e.g., hot fix agent), running solutions in multiple parallel sandboxes, and requiring human review/approval before shipping the fix.

## Practical implications

- When designing AI developer workflows (ADWs), prioritize separating code execution from agent logic to ensure reliability and performance.
- Focus engineering effort on the 'agentic layer'—the meta-system that orchestrates agents, prompts, and code—rather than modifying the application layer itself.
- Start by modeling simple ADWs using classic development patterns (plan $\rightarrow$ build $\rightarrow$ test) and gradually introduce complexity through specialized sandboxes and multi-agent orchestration.
- Recognize that while LLMs are powerful, deterministic code remains essential for speed, reliability, and cost efficiency.

## Topics

Agentic Engineering, AI Developer Workflows (ADWs), Software Factory, Build Systems, LLM Orchestration, CI/CD, Meta-Engineering, Tactical Agentic Coding, Thinking In Threads, Mermaid.js

Source: https://www.youtube.com/watch?v=VQy50fuxI34