[July 2026 edition]

The Skill of Not Building in the AI Agent Era (3) — Run the Loop Instead of Writing by Hand

Published: Jul 25, 2026
Reading time: ~6 min

Part 1 looked at third parties swallowed by the platform; Part 2 at implementations jerked around by the platform’s APIs and erased along with the problem as the model advanced.

Not every AI implementation can be avoided. But there’s little point in perfecting the craft of hand-writing that gap-filling code and then throwing it away, because agents are already taking that work over. Part 3 starts with treating code as disposable rather than an asset worth hoarding, then turns to the loop that agents run in.

What to Keep, What to Throw Away

The further agents advance, the more that gap-filling code becomes ephemeral, generated on the spot and discarded once it has served its purpose. A future where every implementation is disposable has already started arriving.

What survives, then, is the spec rather than the code, and maintenance shifts with it. It’s the same instinct behind Infrastructure as Code, where you declare the desired state and rebuild it as many times as you need: idempotency, applied to development itself.

At the 2025 AI Engineer World’s Fair, OpenAI’s Sean Grove argued that the fundamental unit of programming is becoming the specification, not the prompt or the code. Tools that have you write the spec first and generate the code from it, like GitHub’s Spec Kit and Amazon’s Kiro, have arrived. As long as the spec and the evaluations remain, the implementation can be rebuilt any number of times.

Writing and Discarding Is No Longer a Person’s Job

A coding agent runs a loop and writes code inside it. It revises until the goal is met or the tests pass, and once the task is done, that implementation is thrown away.

Anthropic frames this loop as gather context, take action, verify the work, and repeat, putting particular weight on the verify step. By their account, an agent gets more reliable the more it can check its own output against something real: tests and lint, a screenshot, or another model’s judgment.

Boris Cherny, who built Claude Code, described the shift at Fortune Brainstorm Tech in June 2026: he no longer prompts Claude, he says, and his job is to write loops. He hasn’t hand-written a line of code in eight months. It isn’t the user who prompts Claude; another Claude does. The human’s role is moving toward designing the loop: a trigger, a task, a verification step, and a reason to stop. The craft of polishing prompts one at a time is giving way to the craft of designing loops.

Separate the Maker and the Evaluator

Ask a model to grade the code it just wrote and it tends to overlook its own errors and over-report success. So a common setup separates the agent that generates the code from the agent that evaluates it against tests, lint, and the spec. Generation and evaluation cycle back and forth until the evaluation passes. In most loops the rate limiter turns out to be the quality of that verification rather than the model’s intelligence.

Convergence happens only when the check is clear. A condition like “the tests pass and lint is clean” lets iteration approach quality, while a vague goal like “make the code better” tends to leave the agent circling a guessing grader and settling for merely plausible output. Because each step’s output becomes the next step’s input, an early deviation tends to amplify downstream. So the deterministic steps are often pinned into scripts or skills, and only the parts that need judgment are handed to the loop.

This division of labor is already in the products. OpenAI’s Codex CLI shipped /goal first, on April 30, 2026, and Claude Code followed 11 days later, on May 11. Both run across turns until a condition you wrote is true, verifying before they stop. In Claude Code, a separate small model (Haiku by default) grades the work after each turn. The principle that the author doesn’t grade their own work is built right in.

Between Cost and Safety

The loop is powerful, but not free. By Anthropic’s own measurements, an agent uses about 4× the tokens of a chat, and a multi-agent setup about 15×. In 2026, Uber ran through its AI budget in four months and capped each coding tool at $1,500 per person per month. Code Review, which Anthropic shipped for Claude Code in March 2026, runs a team of agents in parallel over every pull request to catch what a skim misses, and it bills on token usage at roughly $15–25 per review. Which is why Boris Cherny argues the bill should be compared against what the same work would have cost an engineer.

There’s a safety line to draw too. In March 2026, Anthropic added Auto Mode to Claude Code. It replaces the actions a human used to approve with a classifier; by Anthropic’s own account, users were approving 93% of those permission prompts anyway. An action judged dangerous is sent back with an instruction to find a safer path rather than route around the block. Against a set of real overeager actions pulled from actual sessions, the classifier still misses 17%, and a session escalates to a human after three consecutive denials or twenty in total. Anthropic describes fully automatic operation as dangerous in almost every situation, and it doesn’t replace human review. In practice teams sandbox the work and keep human checkpoints at the decisive moments. For much of the work, as practitioners point out, an interactive session with a good agent is faster and safer than engineering a loop at all. Loops pay off where the check is unambiguous and the iteration is worth its cost.

The Human Stays in the Loop

Even with the work delegated, generation wavers from run to run and wanders down wrong paths, so checking and correcting stay on the human side. Writing in The Batch in June 2026, Andrew Ng described development as three nested loops running at different speeds: an agentic coding loop the agent runs in seconds to minutes, a review-and-steer loop you run in tens of minutes to hours, and an external loop the world runs in hours to weeks. While code is written and discarded in the inner loop, the human works the outer ones, updating the spec and correcting the course.

What remains as an asset, then, is not the code. It’s the spec, the skills, and the loop’s design.

Code written by hand carries sunk cost. Once regenerating an implementation on demand becomes routine, that hold breaks. That is what development looks like in the next era of AI.

Part 4 turns to the implementations that shouldn’t be built at all, and the case for waiting.