How to Build Scalable AI Developer Workflows

TL;DR

Build AI developer workflows by assigning engineers, agents, and deterministic code to the tasks each handles best. Engineers should primarily plan at the beginning and validate at the end, while agents execute intermediate work and code supplies reliable checks, routing failures back for correction until the deliverable is ready for review.

Transcript

It's time for us to talk about loop engineering. I was hoping this would just blow over after a couple weeks. I was hoping a cracked engineer would call this stupid phrase what it really is, but no one has. So, I'll do it myself. Forget about loop engineering. It's the wrong way to think about building valuable software with agents at scale consist... Read More

Key Insights

• Agentic engineering is the design of developer workflows that combine engineers, agents, and deterministic code. The workflow is the complete system through which information and work travel, while a loop is only the routing behavior that sends failed results back for another attempt.
• Code is the most reliable of the three value-creation actors because it runs consistently unless instructed otherwise and does not incur token costs. It should handle deterministic activities such as linting, formatting, type checking, testing, conditions, routing, and orchestration whenever those activities can be expressed directly.
• Engineers are most valuable at the boundaries of a well-designed agentic workflow. They define intent through prompting and planning at the beginning, then assess correctness and usefulness through review and validation at the end, with some exceptions for cases requiring additional intervention.
• Validation loops work by running generated code through deterministic checks and returning failures to the build agent with relevant context. Linting, formatting, type checking, and testing can accumulate into increasingly strong feedback loops that improve confidence before the engineer performs the final review.
• A test agent can consolidate multiple validation responsibilities into one stage of the workflow. It can execute the specified checks, report failures to the build agent for correction, and pass successful work to an engineer, allowing additional compute to provide additional confidence in the deliverable.
• Specialized agents can represent familiar software development stages such as planning, building, testing, and reviewing. Agentic workflows do not discard the established development process, but move more of its intermediate execution into coordinated agents and code before merging and shipping.
• Work trees provide isolation and parallelism for multiple agents running plan, build, test, review, merge, and ship pipelines. They reduce the chance that agents interfere with one another, although the transcript presents them as a useful starting point rather than the final architecture.
• Separate agent sandboxes provide stronger isolation by giving each agent its own computer environment. Engineers can enter a sandbox to inspect the work, webpage, tests, application, or other results directly, then merge and ship the completed work after reviewing the outputs.

Questions & Answers

Q: What is an AI developer workflow?

An AI developer workflow is a defined process that combines engineers, agents, and deterministic code to produce a software result. A prompt or plan enters the workflow, agents perform tasks such as planning, building, testing, or reviewing, and code handles repeatable checks and routing. The final result reaches an engineer for validation before it is merged or shipped.

Q: Why is loop engineering an incomplete mental model?

Loop engineering is incomplete because a feedback loop describes only one part of the larger development system. A real agentic workflow also contains prompts, functions, conditions, deterministic checks, specialized agents, isolation mechanisms, human review, merging, and shipping. Focusing only on loops can obscure the broader task of designing how information and work move through the entire software development process.

Q: What are the three actors in agentic engineering?

The three actors are engineers, agents, and code. Engineers supply intent, planning, judgment, and final validation. Agents perform flexible intermediate work such as planning, implementation, testing, and review. Code supplies fast, consistent, deterministic behavior for checks and control flow. Effective agentic engineering depends on placing each actor at the appropriate point in the workflow.

Q: Where should engineers participate in an agentic workflow?

Engineers should generally appear at the beginning and end of a scaled agentic workflow. At the beginning, they prompt or plan the work and define the intended result. At the end, they review and validate what the system produced before shipping it. The goal is to avoid adding unnecessary manual effort between these boundaries, while allowing exceptions when intervention is needed.

Q: How do validation loops improve agent-generated code?

Validation loops run agent-generated code through checks such as linting, formatting, type checking, and testing. When a check fails, its result is routed back to the build agent as context for another attempt. When every required check passes, the deliverable moves to engineering review. This structure uses repeatable code to catch problems before a person performs final validation.

Q: How can a test agent support software validation?

A test agent can consolidate the testing and validation work that would otherwise appear as several separate stages. It receives the checks the engineer wants performed, runs them against the build, and returns failure context to the build agent when something goes wrong. If the work passes, the test agent forwards it to an engineer for review and possible shipment.

Q: Why use work trees for parallel coding agents?

Work trees give separate agents isolated places to perform their assigned tasks, which supports parallel execution and reduces the chance that agents interfere with one another. A deterministic script can create multiple work trees from a prompt, after which each can run a plan, build, test, review, merge, and ship pipeline. The transcript describes this approach as a practical starting point.

Q: Why give each coding agent its own sandbox?

A separate sandbox gives each agent stronger isolation by providing its own computer environment instead of only a work tree. This lets multiple agents operate independently and allows the engineer to enter each environment to inspect the implementation, webpage, tests, application, or other output. After review, completed work can be brought together, merged, and shipped.

Summary & Key Takeaways

• Agentic engineering is best understood as designing complete AI developer workflows, not merely engineering loops. A prompt enters a software factory, a defined combination of agents and deterministic code performs the work, and a result emerges. Loops matter, but they represent only one control mechanism inside this broader system.

• The workflow begins with an engineer planning or prompting and ends with an engineer validating the result. Between those points, build agents perform implementation while deterministic tools lint, format, type-check, and test the output. Failed checks return useful context to the build agent, which revises the work until validation succeeds.

• Developer workflows can scale through specialized planning, building, testing, and reviewing agents. Running these pipelines in parallel work trees provides isolation, while separate sandboxes improve isolation further and let engineers inspect applications, tests, and results directly. The engineering focus shifts toward building the system that repeatedly produces valuable software.