The Scaffolding the Agent Doesn't Build

I sent Adam Bender’s Software Engineering at the Tipping Point to Claude with a one-line note: this is the single most insightful take I’ve heard on our industry and AI’s effects on it. Draft me a LinkedIn caption.

The draft came back competent. It opened with a praise line. It cited Bender’s strongest idea. It ended with a CTA. It also had me admitting, in the first person, that I’d been “optimizing the wrong thing” in my own work.

I read that line twice and realized I didn’t believe it.

What the Commits Actually Said

The last two months of commit messages in my own repos:

• automated checks that block agent-generated code from landing when it breaks the system’s rules, and the work of consolidating several parallel UI design systems into one
• a layer that joins GitHub issues, the git log, and a Cloudflare D1 store and flags every place those three disagree
• a way to pin each prototype change back to the spec it implements, so a reviewer can verify intent before reading code
• templates that name a human owner for every module’s behavior, paired with a linter that flags documentation that’s fallen behind the code it describes
• tooling that reads git history as a source of past-decision context, plus the connective work of keeping documentation surfaces (READMEs, agent context files) coherent across projects, plus patterns for sequencing multi-layer agent execution so the steps stay legible

None of it shipped a user-facing feature on its own. All of it was scaffolding for the thing that ships.

“Optimizing the wrong thing” was the exact opposite of what was happening. The confession the draft put in my mouth was fabricated, and it was fabricated in a specific direction — toward a position I don’t hold and haven’t been working from.

The interesting question is why it got fabricated that way.

Bender’s Word for It

Bender’s central claim — the line the draft correctly identified before getting the rest wrong — is that AI is a directionless amplifier. It scales magnitude, not direction. Strong fundamentals get 10x’d. Confusion and technical debt get 10x’d just as fast. The agent doesn’t care which one you’ve got more of.

The body of his talk is a walk through what breaks when code generation goes 10x while the rest of the ecosystem stays where it is.

• Code review becomes the bottleneck. Tech leads cannot sustain the review rate that 10x developers produce.
• Dependency graphs grow quadratically with codebase size. Bender means quadratically, not “a lot.”
• Integration testing stops being a nice-to-have and becomes the actual quality strategy, because per-service unit tests don’t survive a 10x increase in service-to-service chatter.
• Version control wasn’t designed for this commit velocity.
• Internal APIs that used to be polite suggestions need to be hardened like public ones, because agents will find them and call them.

None of those failures live at the layer of “the agent wrote code.” They live in the ecosystem the code lands in.

That sentence is where the fabricated caption and the actual work diverged.

The Scaffolding Isn’t the Side Project

If you spend two months building substrate of that kind, you don’t read Bender’s talk as a cautionary tale. You read it as someone giving public language to a category of work you’ve been doing in commits for months.

I’ve written before about directing agents instead of typing code. The position there was that the gate moved, not the job: the architect tier never did require typing, and the AI shift just removed the requirement for the team of engineers underneath.

What I didn’t have a clean word for in that post: the work that replaces typing isn’t prompting. It’s scaffolding. It’s the surrounding apparatus that keeps the agent’s output from drifting into the ecosystem unchecked.

Bender names this directly at the end of his talk. The pivot: stop optimizing the code machine. Use AI to keep humans able to reason about systems no single one of us can hold in our head — interactive architecture maps, queryable dependency state, intellectual control as a first-class output.

The pivot lands harder when you’ve been quietly building toward it for months.

Why the Caption Confessed

The reason the draft fabricated a confession is instructive, and it isn’t about Claude in particular.

The voice this blog has, by design, includes self-interrogation. The voice guide that governs it says: open with tension, show the work, examine your own process, end provisionally. An LLM trying to write in that voice without evidence will reach for the shape of self-interrogation — “I’ve been optimizing the wrong thing” — and produce a confession that isn’t grounded in anything.

Confession has a structural job in good writing. Used correctly, it’s the beat where the writer admits where the argument almost broke, and shows you why it didn’t. Used as decoration, it becomes the verbal equivalent of a sad-jazz cue in a movie — the audience knows it’s supposed to feel like something, but nothing actually happened.

The same mechanism is what Bender is naming, one abstraction up. The voice without the evidence. The codebase without the integration tests. The agent without the scaffolding. The thing that’s been generated, but not reasoned about.

Magnitude without direction.

What I’m Calling the Work

Bender’s frame gives me a clean word for it. The work the agent doesn’t do is mine.

The checks that block bad agent output before it lands. The joins that surface where independent systems disagree. The traces that tie code back to the intent it was supposed to serve. The templates that say who owns what. The dashboards that make scattered state legible. These aren’t side projects to the thing the agent ships. They’re what makes the thing the agent ships safe to land.

The forest, not the leaves.