As agents take over the inner execution loop, Aditya Mani argues the scarce resource is no longer generating code but judgment backed by evidence. The engineer's job shifts to the outer loop — deciding what's worth doing, verifying the evidence, and owning what ships — because agents can execute a runbook but cannot inherit the consequences.
Aditya Mani opens by insisting on the human side before the architecture: the engineer of the future is the person who can choose what is worth doing and who will own the evidence, the understanding, and the verdict around work that agents increasingly automate. By "verdict" he does not mean playing Judge Judy — he means being accountable for production decisions: does something ship, do we block it, redirect it, or accept the risk?
He distinguishes quality from responsibility. Quality produces evidence, but a verdict assigns responsibility, and answerability is what lets a person stand behind that verdict. Citing language he attributes to Boris Cherny, he notes that old craft boundaries are blurring and roles are rebundling around the work itself — prototype, build, sweep, grow, and maintain — so the important question becomes less about your title and more about what part of the system you can own.
Mani traces why the shift is happening. Harness engineering treats the coding agent as the model plus everything around it — context, tools, file system, git — turning intelligence into something you can delegate. Loop engineering goes further, designing systems that keep prompting, checking, remembering, and deciding what happens next, which is when agents start to feel like infrastructure. Put together, these produce the software factory (a pattern he credits Dex with covering well), where agents run the inner loop and evidence comes out.
The wind, he says, is moving human judgment to the highest-leveraged checkpoint. With one of Sonar's 2026 surveys reporting that AI-assisted code is no longer marginal, answerability becomes an engineering requirement. He also notes Sonar research finding that clean and messy repos had roughly the same pass rates, but clean code used fewer tokens and caused fewer revisits — so maintainability directly fuels factory efficiency.
Mani introduces two terms for the career portion of the talk: alpha, the gap between what you can do today and what current models can do, and decay, the clock on that gap. If the thing that makes you special is a capability, the frontier will eventually come for it. He engages the taste debate — quoting Paul Graham that choosing what to make matters when anyone can make anything, and preferring Mitchell Hashimoto's sharper definition of taste as making high-quality qualitative judgments where no objective metric exists yet.
Applying a "decay test," he argues speed, recall, and verification have already moved into harnesses and tooling, and even taste resets as models learn from examples and preferences. The strategic question is therefore no longer "what can the agent do" — that list only shrinks — but "what can only a human be answerable for," because some decisions genuinely require ownership, context, and risk acceptance.
Mani names three failure modes. Cognitive debt is the erosion of your understanding of how to solve problems as you defer more to AI — the gap between how much code exists and how much your team genuinely understands, worsened by delegation depth and long-horizon tasks. Cognitive surrender is blindly accepting AI's answer before forming your own opinion; he cites a Wharton study where, even when AI was wrong, most people adopted the wrong answer and felt more sure — the danger of borrowed confidence.
The third is orchestration tax: running ever more agents in parallel does not multiply you, because cognitive bandwidth does not parallelize. Every loop creates more decisions to route, merge, verify, and integrate. The fix is not fewer agents but designing your attention like a system — being deliberate about where you enter, what you require, and what you reuse.
Mani draws his central boundary: agents can run much more of the inner execution loop — investigate, implement, test, and report — but the outer loop is still engineering: deciding, verifying, approving, and owning. The agent returns evidence (diffs, tests, logs, rationale, traces, trajectories, screenshots), and then the engineering begins. Execution and responsibility are different things; an agent can follow your runbook but cannot inherit the consequences.
He offers an operational rule — "explain it or don't ship it" — not because humans must type every line, but because someone must understand the work well enough to defend it, much like an owners file in a large codebase. He closes on optimism: every time software got easier to write, latent demand appeared and the world needed more of it, not less. Agents move the bottleneck from "can we build this" to "should this exist and can we answer for it." His parting line: build the factories, keep the lights on, own the verdict.
the scarce resource becomes judgment that's backed by evidence
The boundary is not human looks at AI output. The boundary is evidence and responsibility.
The agent can follow your runbook, but it can't inherit the consequences.
So build the factories, keep the lights on, own the verdict.
| Time | Topic |
|---|---|
| 00:00 | Keeping the human in the loop: choosing what is worth doing |
| 02:04 | Harnesses, loop engineering, and the software factory |
| 03:06 | AI-assisted code is normal code; answerability as a requirement |
| 05:39 | Alpha and decay: no capability is a permanent moat |
| 09:16 | Three things to avoid: cognitive debt, surrender, orchestration tax |
| 14:55 | Inner loop is capability, outer loop is agency |
| 17:27 | Build the factories, keep the lights on, own the verdict |