Nathan Lambert’s Get Good at Agents (as discussed on AI Daily Brief episode Skills for the Code AGI Era) captures something real: once you’ve had agents implement substantial chunks of work, the role shift feels visceral. You stop thinking "how do I code this" and start thinking "what should exist, how should it fit, and how do I keep multiple parallel efforts converging?"
His own framing is honest and useful. He’s noticing that micromanagement, tiny tasking, and synchronous supervision leave leverage on the table; he’s also naming the emerging craft of stacking "bricks" into coherent long-horizon projects.
That’s the right direction. It’s also where the mainstream narrative tends to step around the central constraint.
The bottleneck is not agent management. The bottleneck is coherence under extreme iteration velocity.
When execution becomes cheap, it’s easy to confuse "more output" with "more progress." But the failure mode of the Code-AGI workflow isn’t that nothing gets built—it’s that too much gets built that cannot be proven correct, integrated safely, or kept conceptually intact as it evolves.
This is the core argument behind two living texts I maintain: the 10× Coordination Shift and the Centaur Manifest.
Where the framing breaks
Lambert keeps returning to the right question: "How do we stack these bricks into coherent long-term projects?" The industry answer is drifting toward orchestration: better task decomposition, better agent UX, better async workflows, more parallelism, more "prompt architecture."
That helps, but it dodges the hard truth: coherence is not primarily an orchestration problem. It is a verification and boundary problem.
If the inner loop accelerates, then any missing invariant, ambiguous interface, or unstated constraint becomes a compounding error. You don’t solve that by pointing the army harder. You solve it by changing what "done" means: done is evidence, not output.
The Centaur framing is blunt about this: verification dominates execution. The system must be designed so meaningful behavior can be exercised deterministically, observed precisely, and falsified quickly—by humans and agents—without relying on heavyweight process. That is governance, but at the right layer: executable evidence in the inner loop, not committees in the outer loop.
The hidden trap
"Software is becoming free" is rhetorically effective, and directionally true for greenfield prototypes and many classes of implementation work. But it can also be dangerously misleading.
Integration is not free. Blast radius is not free. Maintenance is not free. Accountability is not free.
As generation gets cheaper, the cost center shifts to what survives reality: contracts, invariants, testability, operational fitness, and the ability to localize failure. The winning strategy is not "more ambitious agent tasks." It’s building architectures where partial understanding is safe—narrow interfaces, strong boundaries, and verification that prevents drift from propagating.
In other words: as software gets cheaper to produce, slowness gets more expensive, because coordination defects are amplified by speed.
Takeaway
The practical takeaway is simple: "getting good at agents" is necessary—but insufficient. The real skill is building systems that stay coherent at machine speed: evidence over theater, falsification over persuasion, and boundaries that make rapid change safe.