Cheap Code Does Not Erase the Craft

Every useful abstraction makes yesterday's difficult work easier to perform. That does not prove the work was never difficult. Compilers did not make assembly trivial. Managed memory did not mean memory safety had been imaginary. Frameworks did not erase the engineering buried inside routing, rendering, persistence, and deployment.

Agents are the next, larger abstraction. They can produce implementations, tests, migrations, and reviews at a speed no human team can match. That changes the economics of software delivery. It does not turn the work that trained the industry into clerical typing after the fact.

Our position is blunt: dismissing code as the easy part is both wrong and strategically useless. It insults the people who learned the craft, and it gives leaders a false model of the machine replacing parts of it. You cannot govern automated implementation if you refuse to understand what implementation demands.

When code becomes cheaper, the hard parts do not disappear. They move and multiply. A factory can generate ten plausible implementations where a team once had time to build one. Now somebody must define the destination precisely, select among competing routes, prove behavior outside the generator's preferred conditions, and decide which consequences are acceptable.

That is not evidence that programming never mattered. It is the consequence of automating more of programming. The output grows faster than human attention, so judgment has to move into specifications, architecture, policies, evaluations, and release gates that the machinery can execute repeatedly.

A weak organization responds by asking engineers to inspect an expanding wall of generated code. That preserves the old review ritual while removing the time that made review credible. A factory responds by turning engineering knowledge into controls: types, invariants, dependency rules, security boundaries, reproducible tests, independent evaluation, and production feedback.

The best engineering judgment has always been more than the characters committed to a repository. It is knowing which abstraction will hold, where state can leak, how failure crosses a boundary, what a future maintainer will misunderstand, and which apparently clean design will collapse under reality. Agents do not make that knowledge obsolete. They make its packaging decisive.

If those standards live only in a senior engineer's head, the factory cannot retain them. Every run has to rediscover the rules, and every review depends on that person being available. The organization gets machine-scale output with human-scale memory. That is not leverage. It is a faster route to inconsistency.

Put the craft into the harness. Encode the architecture. Make forbidden dependencies fail mechanically. Require evidence for performance and reliability claims. Preserve why an exception was granted. Feed production failures back into the next plan. The craft stops being a heroic correction at the end and becomes infrastructure every worker must pass through.

Respecting programming does not require pretending every programming job survives. Many will not. Repeatable implementation, test execution, ticket translation, routine review, and release coordination are becoming machine work. Companies that mechanize them will operate with fewer people than companies that preserve them as payroll out of nostalgia.

That is uncomfortable because programming became more than a task for many practitioners. It became identity, status, community, and a way of thinking. Economic change does not wait for those meanings to unwind cleanly. Leaders should tell the truth about displacement without telling the equally false story that the displaced work had been easy all along.

The people who adapt will move their judgment higher in the system. They will choose architectures, define standards, design evaluations, investigate failures, and decide what the machinery is allowed to do. Those are still engineering responsibilities. There will simply be fewer roles centered on manually producing each implementation.

Two bad stories are competing for control of this transition. One says code was always easy and agents merely exposed the truth. The other says code is a uniquely human expression that automation cannot touch. Both avoid the mechanism in front of us.

Programming is skilled work, and skilled work can be automated. The automation succeeds because generations of engineers made the work legible: languages, tools, patterns, tests, documentation, package ecosystems, and machine-readable repositories. Agents inherit that accumulated craft. They do not disprove it.

Build accordingly. Use machines for the repeatable production they now perform better. Move human judgment to the destination, the standards, and the consequences. Then force every generated change through proof the generating agent cannot negotiate away. Cheap code is real. The craft is real too. The winning factory depends on understanding both.