We’re Converging on a New Shape for Software

A funny thing happened after I finished my new white paper, Software Manufacturing.

I read Anthropic’s new AI-Native SDLC playbook.

I had not read it while developing the ideas in the paper. What surprised me was not that Anthropic also thinks AI will make writing code dramatically cheaper. That conclusion is becoming fairly obvious.

What surprised me was how much of the system around the code looked familiar.

Anthropic starts with essentially the same premise as Software Manufacturing:

Code is no longer the bottleneck.

Once implementation collapses from weeks to hours, the constraints move elsewhere. Planning, verification, deployment, governance, and operations cannot continue running at human speed while agents generate software at machine speed.

But the convergence goes considerably deeper than that observation.

Anthropic’s AI-Native SDLC turns intent into a versioned, machine-actionable artifact. Standards are encoded so agents can act against them. Continuous evals replace much of traditional stage-gate QA. Governance is enforced while agents act rather than being applied only through human review afterward. Production monitoring feeds failures back into the lifecycle as new intent.

That is remarkably close to the system I describe in Software Manufacturing.

Intent enters the system. Standards define what must remain true. A factory turns intent and violations into bounded work. Harnesses constrain individual executions. Agents perform the work. Evidence determines whether it is acceptable. Production signals create new work and close the loop.

This is more than both of us saying, “agents can write code.”

We independently arrived at something that looks much more like a closed-loop production system for software.

There are differences in emphasis.

Anthropic reorganizes the SDLC around AI and shows how the familiar stages of planning, design, building, testing, deployment, and maintenance change when agents participate throughout the lifecycle.

Software Manufacturing focuses more directly on the control architecture underneath that lifecycle.

The question becomes not simply how does work move through the SDLC?

It becomes who is allowed to decide what, under which constraints, based on what evidence?

That leads to a control stack: intent and standards above the product, a factory managing its lifecycle, harnesses governing individual runs, agents executing the work, and an operator controlling the boundaries of the overall system rather than inspecting every output.

It also leads to the part I increasingly think is critical: the actuator.

Traditional software controls mostly observe. A test fails. An alert fires. A security scanner finds a vulnerability. A dashboard turns red.

Someone then has to notice and initiate the work.

A software factory can make those controls active. A violation becomes bounded work. The system investigates it, attempts a repair, verifies the result against the same standards, and either closes the loop or escalates the decision.

Anthropic’s playbook gets surprisingly close to this too: a breached production control can become new intent and flow back through the system.

That is why I find the convergence interesting.

As code becomes abundant, software engineering starts reorganizing around intent, artifacts, standards, evidence, delegation, and feedback.

The exact terminology will vary. AI-Native SDLC. Agentic SDLC. Software factories. Software manufacturing.

But increasingly, we seem to be drawing the same underlying machine.

And independent convergence on the architecture feels like a much stronger signal than any one of us arguing for it alone.

Read my Software Manufacturing white paper