Published: 2026-07-13
Analysis & perspective

AI Developer Workflows: The Pattern Beyond "Loop Engineering"

Chapters / key moments (click to jump — plays here on the page)

IndyDevDan (Dan Eisler) argues that "loop engineering" is a hype-filled rebrand of the software development life cycle, and that the real unit of agentic work is the AI developer workflow — the classic plan → build → test → review → ship pipeline, now executed by a mix of engineers, agents, and code. He builds from the smallest atom (prompt an agent, review the result) all the way up to a full "software factory," with validation loops feeding a build agent, dedicated test agents, worktrees graduating to per-agent sandboxes, ticket-driven scout/plan/build pipelines, and a production-crash hotfix workflow. This is a conceptual architecture talk — no commands or config files are shown.

Analysis, not a how-to

This is a mental-model / architecture video. It gives you a way to think about structuring agent work — not copy-paste commands. If you want hands-on setup, see the guide links at the bottom of this page.

Source video

"FORGET Loop Engineering. Agentic Engineering is about THIS" by IndyDevDan — Watch on YouTube →

The Argument, Step by Step

Reframe the mental model: three actors of value creation
Every unit of engineering work now involves three actors — engineers, agents, and code. Ranked by reliability, code wins by miles (deterministic, no hallucination, zero token cost, runs at the speed of light), then engineers, then agents. The whole game of agentic engineering is knowing when and where to place each actor.
Start from the atom: prompt → agent → review
The foundation of every workflow is an engineer prompting an agent and reviewing the result. Insert your favorite agent and model — Dan's point is that the specific harness no longer matters; the workflow you execute around it does.
Add the first "loop" — deterministic validation
Run a linter as real code. If it fails, route the result back into the build agent; if it passes, move on. That conditional routing is the "loop" everyone names — but it's just one node in a much bigger picture. Keep adding deterministic checks: formatter, type-checker, tests, each feeding failures back to the build agent.
Scale validation into a dedicated test agent
Collapse all the linting, type-checking, and testing into a single test agent — "scaling compute to add confidence." On failure it sends context back to the build agent; on success the engineer reviews and ships.
Add planning and parallelism
Wrap the pipeline as plan → build → test → review → ship. Push each agent into its own git worktree for isolation and parallelism — then graduate to full agent sandboxes (each agent gets its own computer) for true isolation you can step into and inspect.
Wrap it in an intake system
Feed the pipeline from a Kanban/ticket board. A scout agent gathers code, tickets, docs, and prior specs; a plan agent turns that into a plan; then build → test → CI/CD → engineer review → ship. Advanced teams skip the manual "translate ticket into a prompt" step and act on the meta layer instead.
Design a crisis workflow (production down)
Have an AI developer workflow ready before production crashes: support files a ticket → it lands in Slack/Teams → an engineer prompts a scout agent → a specialized hotfix agent (tuned to fix fast, not fix elegantly) → human approve/reject → spin up multiple sandboxes racing toward a fix → the first passing fix wins → engineer validates and ships.
Compose the software factory
At the top level, a factory router agent intakes each ticket and dispatches the right workflow — chore, bug, feature, or hotfix — at the right model, price, and speed (a lightweight model for a chore; state-of-the-art planners for anything that can't miss). You operate the agentic layer, not the app: "build the system that builds the system."

Gotchas & Caveats

Don't bury lint/test steps inside one giant skill. That's still just an agent calling code. Separate code from agents — use an Agent SDK, run the linter as real code, and feed failures back into the build agent with the same session ID — so you can set proper guardrails and information flow.
Worktrees are a great place to start, not a great place to end. They have real limits; per-agent sandboxes give each agent full isolation you can inspect independently.
Don't over-leverage agents. Code is deterministic, hallucination-free, and free to run. Once you productionize, move skill work into real code for performance, reliability, and speed — not just token savings.
This is not vibe coding. Vibe coding is not knowing (or looking at) how the system works. Agentic engineering is knowing your system so well you don't have to look.

Key Takeaways

The real unit of work isn't a "loop" — it's an AI developer workflow (plan → build → test → review → ship) combining engineers, agents, and code.
There are three actors of value creation; code is the most reliable and cheapest, then engineers, then agents. Put each where it belongs.
Engineers show up at exactly two constraints — planning (the prompt) and reviewing (validation). Everything in between should run without you.
Your highest-leverage work is the agentic/meta layer, not the app: "build the system that builds the system."
Start simple (one build agent + one linter) and add nodes only as real problems appear. Design each workflow by first doing the work end-to-end yourself — sketch it with a Mermaid diagram before you automate it.