Blog #0194: The Time Cost of How Is Zero

Source: Photo by Daniel Fraede on Unsplash

[ED: When the machine handles the how, value shifts to why and what. Agentic coding as the latest rung on a very old abstraction ladder — from assembly to high-level languages to frameworks to here. 3/5 hats.]

Why, What, How

Any time you want to get something done, you need to know three things. Why you want to do it. What has to be done. How to do it.

The value of any given project distributes across all three. You need people who understand the business case. You need people who can define the outcomes. You need people who can write the code. Each layer has cost, and each layer has specialists.

Agentic coding changes the arithmetic. Not vibe coding, which is little more than "vibe debt", good for prototyping and not much else. Agentic coding is something different. It's where the machine handles the how, and the time cost of the hands-on-keyboard-writing-the-code part of the implementation approaches zero.

When that happens, value shifts. It moves from the how - where most of the labour has historically sat - towards the why and the what. The real currency becomes asking the right questions and defining the right outcomes. Someone said to me recently: we're moving from a world of "easier said than done" to a world of "easier done than said."

The Abstraction Ladder

This is not a rupture. It's the latest step in a pattern that has repeated for as long as humans have built tools.

Almost no one writes assembly language anymore. Almost no graphic artist calculates spline curves by hand. Almost no architect drafts structural steel connections on paper. Each generation of technology adds a layer of abstraction. Each new layer trades granular control over the previous layer's primitives for more expressive power at the compositional level.

Agentic coding tools are tools. They can reason and behave with something approximating intelligence. They are more capable than any tool we've had before. But they are tools that allow those wielding them more expressive power — not replacements for the people doing the wielding.

There is a loss at each step. When you move from assembly to a high-level language, you lose direct control over register allocation and memory layout. When you move from hand-drawn animation to digital rigs, you lose a certain quality of line. Every abstraction trades something. But every abstraction also grants something that wasn't possible at the layer below — the ability to compose the old primitives in ways that the previous generation's practitioners couldn't have imagined, because they were too busy managing the primitives themselves.

The IDEO principle applies here: nobody is in the market for drills; everyone is in the market for holes. We've been forced to care about drills because we had to operate them. When the tool cost approaches zero, only the outcome matters.

The Sculptor, Not the Builder

I wrote about this in On Knowing What Code to Throw Away. The Michelangelo metaphor: the David was always in the block. The sculptor's job was to see the form and remove everything that wasn't it.

This is how agentic coding feels now. The agent generates a block of marble — rough, overbuilt, full of potential. The job is to see the form inside it and cut away everything that doesn't belong. The skill set this demands is different from what we've historically valued in software engineering. It's less about construction and more about curation. Less about "can I build this?" and more about "should this exist?"

There's an old line that's stuck with me: you don't get the Nobel Prize for answering the question; you get it for asking it. When the time cost of implementation is zero, the value is entirely in knowing what question to ask.

The PM's job has always been to build the right thing. The software engineer's job has been to build the thing right. That boundary is blurring. Software engineering is moving from "build the thing right" towards "instruct the machine to build the right thing" — because we can increasingly assume the machine will build it right. We're all becoming PMs and SEs simultaneously, and I think that's a good thing, because it rewards creative, insightful questions over rote implementation.

The Open Question

Do we lose something of the old abstractions when we move up a layer? Probably. There's a quality of understanding that comes from working at the metal — from knowing how the registers move, how the memory allocates, how the bytes flow. That knowledge doesn't disappear, but it becomes specialised rather than universal, the way a metallurgist's knowledge of crystal structures is specialised rather than something every mechanical engineer needs daily.

Do we gain more from the new abstractions? That is a question worth sitting with rather than rushing to answer. Each previous abstraction jump — machine code to assembly, assembly to high-level languages, languages to frameworks, frameworks to declarative UI, and now declarative UI to agentic coding — has produced anxiety about loss and then delivered expressive power that wasn't imaginable from the layer below.

What matters now is articulation. The bottleneck has moved from execution to thinking clearly enough to express what you want. Your competitive advantage is the clarity of your thinking, not your technical dexterity. The tools are getting better. The question is whether you can wield them.

Regards,
M@

Originally posted on matthewsinclair.com and cross-posted on Medium.

[ED: If you'd like to sign up for this content as an email, click here to join the mailing list.]