Leave the Loop, Keep the Map
IndyDevDan argues that agents now out-program you inside the loop, so the best engineers are moving from prompting to approving to observing. He is right about the direction. The part that decides whether it works is his own best line: agentic engineering is knowing what your system does so well you don't have to look. You can leave the loop. You cannot leave the map.
Contents
“If the agent is a better programmer inside the loop, why are you still sitting in it?”
That is the question IndyDevDan opens with in “Elite Agentic Engineers Are Leaving the Loop” (opens in new tab), and I have not been able to shake it. It is a good question because it is uncomfortable. Read a trace from a frontier model on a hard task and you see what he means: tool call after tool call, bash commands chained in ways most of us would never type, and it keeps doing it, back to back. Inside the loop, the agent is often the better programmer.
So I agree with where he is pointing. What I want to add is the condition that decides whether leaving the loop is engineering or abdication. Conveniently, he already said it.
The argument, compressed
Dan’s case has three parts.
You are the bottleneck. His claim is that 80% or more of the work we do right now could run without us, with the right system in place. Years of experience do not unlock that automatically. They only pay off if you change how you operate.
There are three positions. In the loop, you prompt. Near the loop, you approve. Out of the loop, you observe. Jumping from the first to the last is hard, so near the loop is the deliberate stepping stone: the agent does the work and comes to you for one decision.
The trigger should not be you. A webhook, a cron, a user action, a classified log event. “There are a million other ways to kick off your agent. Why are you still the main one?” His recipe for getting there is a durable agent that survives crashes and restarts, an event trigger, and a sandbox with a full computer. Put those together and you get an agent that “does not wait for you to work, it works for you then waits.”
His examples are concrete. An on-call agent that detects an incident, investigates, finds the root cause, and prepares a fix for you to review and deploy. A news agent that has run nonstop on a Mac mini for over a week. A UI replicator that loops build, screenshot, judge until a screen matches a mock, while he is somewhere else.
And then the scorecard: “Your measure of success is how many agents are working for you right now.” Not token maxing, he is careful to say. Useful work, this second, without you.
The line that holds it together
Halfway through, Dan draws a distinction that I think is the most important sentence in the video.
Vibe coding is not knowing what your system does, and not looking. Agentic engineering is “knowing what your system does so well, you don’t have to look.”
Read those two side by side. In both, you are not looking. The difference is entirely in what you know. One person stopped looking because they gave up on understanding. The other stopped looking because they understand well enough that looking adds nothing.
He makes the same point from the other direction when he describes someone juggling three terminals with no idea what is happening in any of them, “just trusting the model more and more. That is not engineering.” Engineering, in his words, is building systems you reliably know will do what you need.
That is the whole post. Leaving the loop is not a matter of trust. It is a matter of understanding, encoded well enough that your attention is no longer required.
Take one: the map is what you keep
I argued in You Can’t Forward the Understanding that the work a tool cannot do for you, reading, verifying, re-expressing, is the work that keeps your judgment sharp. At first glance that sounds like the opposite of Dan’s message. It is not. It is the precondition for it.
When you step out of the loop, you do not stop needing to understand the system. You stop needing to watch it. Those are different things. The understanding has to go somewhere, and it goes into the map: the written intent, the criteria for done, the evals that check them, the traces that record what happened. The map is how your knowledge keeps working while you are gone.
An engineer who leaves the loop with a map is delegating. One who leaves without a map is hoping. From the outside, on a good day, they look exactly the same.
Take two: near the loop is where accountability lives
Dan treats near the loop as a stepping stone. For a lot of work, I think it is the destination, and that is fine.
The approve step is not a tax. It is the one place where a human with context makes a decision that someone will later have to explain. The on-call agent prepares the fix; you click deploy. In a regulated environment, that click is the control. It is where attribution lives, and where a reviewer can later find a name next to a decision.
The experience side of the argument is real too. Nobody wants to be paged to babysit a fix the agent already understood better than they would at 3 a.m. The near-loop design gives you both: the agent does the work at machine speed, and the human shows up for exactly one decision with all the evidence already assembled. That is a better job than the one it replaces, not a smaller one.
So my version of his ladder has a fork. Some work graduates to out of the loop: news triage, reports, refactors with strong tests. Other work should live near the loop permanently, because the decision itself is the thing an institution has to own. The skill is knowing which is which.
Take three: what earns the next step
If leaving the loop is earned, what earns it? From building my own pipeline, I would say three things, and each one maps to a step.
From in to near: a trigger, durability, and a sandbox. This is Dan’s recipe, and he is right that it is mostly infrastructure. I covered the durability half in The Harness Is Becoming the Runtime. Once the agent can start itself, survive a restart, and work in an isolated computer, you can stop being the one who types the first prompt.
From near to out: evals, traces, and reversible actions. You can stop approving only when a machine can check the result as well as you would, when every step leaves a record you can read later, and when a wrong outcome can be undone. Without all three, removing the approval is not progress. It is just removing the evidence that anyone checked.
Underneath both: the map. If you could not write down what done means, you have not earned either step.

Image description
Leaving the loop is earned: in the loop you prompt, near the loop you approve, out of the loop you observe; trigger, durable agent, and sandbox move you from in to near; evals, traces, and reversible actions move you from near to out; underneath all three runs the map, knowing what the system does without looking
This blog is where I test it. In Building the Dark Factory I described the pipeline that produces these posts. It runs near the loop by design. Research, drafting, illustration, the confidentiality scan, the slop check, the build, and the narration all run without me. I show up twice: once to approve the plan and once to review the pull request. I could remove those two steps. I have chosen not to, because those are the two decisions with my name on them.
Take four: count closed loops, not agents
Dan’s scorecard, “how many agents are working for you right now,” is a great provocation. It is also easy to game, and he knows it, which is why he rules out token maxing.
I would make it stricter. Count the agents that have an owner, a definition of done, and a check that runs without you. An agent running all night with none of those is not working for you. It is spending for you. The number that matters is closed loops: work that starts on its own, finishes on its own, and proves it finished correctly.
By that measure, most of us have fewer than we think. That is not a reason to feel behind. It is a to-do list.
What I have not solved
Dan is probably right that most of us stay in the loop longer than we need to. Habit is a powerful thing, and so is the small pleasure of watching the agent work. I catch myself doing it.
The map decays. A system you understood perfectly six months ago has drifted, the model under it has changed, and your confidence is now a memory rather than a fact. I do not have a good rhythm yet for re-earning the right not to look.
Out of the loop also means out of practice. If the agent handles every incident, the engineer who has to step in during the one it cannot handle is rustier than before. Some deliberate in-loop time may be a feature, not a failure.
And his framing is aimed at individual builders. In an organization, trusting your agents is half the question. The other half is whether everyone downstream can see what they did. That is a governance problem, and it does not get easier as the number of agents goes up.
Ask his question, then mine
Before your next session, ask Dan’s question: is there a reason I am still in the loop for this work?
Then ask the second one: if I left, could I write down what this system does well enough that I would not need to look? If the answer is yes, write it, wire the checks, and step back. If the answer is no, that is the work. Build the map first. The loop will let you go when you are ready.
If this was useful, read You Can’t Forward the Understanding for why the comprehension has to stay yours, and Building the Dark Factory for what a near-loop pipeline looks like in practice.
Find me on X @orestesgarcia (opens in new tab) or LinkedIn (opens in new tab).
Get the next field note.
Regulated AI, architecture and platform economics — in your inbox as they publish.