The identity shift that unlocked real throughput and how to make it stick (plus an in-depth builders guide for 2026)

We solved the wrong problem.

For two years, we optimized for capability. Better prompting. Smarter tool selection. More tokens. We treated AI fluency as a skill pack to acquire—learn the right incantations, and the machine would obey.

It worked. The capability ceiling lifted. An average engineer can now produce code at a rate that would have seemed impossible in 2023. Steve Yegge is running 10 to 20 parallel Claude Code instances through his Gas Town orchestrator, churning through implementation plans so fast that the bottleneck isn’t the agents—it’s keeping them fed with work.

And yet.

Cal Newport’s recent New Yorker piece landed with the force of a correction: “Why A.I. Didn’t Transform Our Lives in 2025.” The Year of the Agent dissolved into what Andrej Karpathy now calls “the Decade of the Agent”—a quiet admission that we don’t actually know how to build the digital employees we were promised. Sam Altman said agents would “materially change the output of companies” in 2025. Marc Benioff claimed a “digital labor revolution” worth trillions. OpenAI’s ChatGPT Agent spent nearly a quarter of an hour trying to select a value from a drop-down menu on a real estate website.

Gartner predicts over 40% of agentic AI projects will be canceled by the end of 2027—not because the models fail, but because of escalating costs, unclear business value, and inadequate risk controls. The agents don’t fail because they’re too dumb. They fail because—as Gary Marcus puts it—we’re building “clumsy tools on top of clumsy tools.”

Meanwhile, in the narrow domain of software development, something different happened. Coding agents did work. Claude Code and Codex became genuinely useful. Developers who figured out the workflow reported productivity gains that ranged from meaningful to transformative.

The question is: why the divergence? Why did coding agents succeed where general agents failed?

Newport points to one factor: the terminal is a constrained, text-based environment with immediate, unambiguous feedback. But there’s a deeper answer that matters more for what comes next.

Something doesn’t add up. The models got smarter. The tools got better. And yet the builders I talk to—the ones actually shipping with AI daily—describe a different constraint entirely.

“Raw ability to build is not my limitation anymore,” a friend told me recently. He’d just shipped an iOS app with a full backend in a few weeks, vibe-coded through Claude. “The constraint is how much I can concurrently think sensibly about.”

That’s the shift. The bottleneck moved from capability to cognitive architecture. And almost nobody has updated their operating system to account for it.

Here’s what’s inside:

• The engineering manager identity shift. Why thinking of yourself as a fleet commander—not an engineer who uses AI—changes how you allocate attention.

• Killing the contribution badge. The legacy instinct costing you throughput, and why starting before you’re “ready” produces better output.

• Strategic deep-diving. How to move between altitudes—delegating implementation while maintaining embodied understanding.

• Temporal separation. Why building and reflecting require different brain chemistry, and how to create feedback loops that make you better, not just faster.

• Two kinds of architecture. The distinction between patterns you can delegate and taste you cannot.

• The experience problem. What gets lost when you can manifest a vision overnight, and how to preserve the discoveries that reveal what you actually want to build.

The practices that follow aren’t prompting techniques. They’re cognitive architecture for a world where raw capability stopped being the constraint.