Software delivery is leaving the complex domain
Dave Snowden’s Cynefin framework sorts problems by the kind of causality they have. In the Complicated domain, cause and effect exist but take expertise to see, so the right move is to sense, analyze, respond, and good practice is repeatable. In the Complex domain, cause and effect are clear only in hindsight, so you probe, sense, and respond, and practice is emergent. (Cynefin is Snowden’s framework, and the terms are his.)
Ever since software became the work of more than one person, building it sat squarely in the Complex domain. The moment it stopped being a solo craft, outcomes depended on the whole organization of the work and on the skill and experience of every person in the chain, interacting in ways no one could fully predict. That is why Agile, when it arrived, was correct. Iterative, empirical, probe-sense-respond delivery is exactly the right response to a Complex problem. Scrum did not win because it was fashionable. It won because it matched the domain.
Then a new kind of teammate joined the team: the Silicon Software Engineer, the AI agent. It changes the balance in a specific, under-appreciated way. Part of the team is now far more stable in skill and experience than any human contributor. You can rely on it, with a known correction for hallucination, in a way you never could with a variable roster of people. That reliability moves the work out of the Complex quadrant and toward the Complicated one. The more the humans shift from producing code to directing Silicon Software Engineers, the more the problem behaves like a Complicated one, analyzable and repeatable, rather than a Complex one you can only feel your way through.
A shift in domain demands a shift in the management cycle. If the work is no longer purely Complex, a purely emergent probe-sense-respond process is no longer the only correct answer. Room opens for sense-analyze-respond: for analysis, for planning, for repeatable good practice. The management process starts to look less like a craft and more like a factory. Not a simple factory, a complexly organized one, with many moving parts and dependencies, but a factory, with the predictability a factory implies. That predictability is the next level of opportunity in software delivery.
It helps to place this in the sequence of benefits. The first derivative of AI was speed. The second was removing the translator’s burden from people, the shift from writing code to specifying and delegating it. This factory-grade predictability is the third derivative, and the one with the largest economic consequences.
The mistake would be to leap straight to the factory. That is not the next step. The next step is an evolution on two fronts at once: making the Silicon Software Engineer more manageable and more repeatable, and developing the new management skills to direct it well. These are two sides of one coin. Neither advances alone, they have to be pulled forward interactively and together. And the honest part: upskilling people is the hard side. Reaching the new equilibrium is gated far more by human skill development than by model capability.
For a business, the destination has a name. It is the move from a custom, unpredictable service toward Business Process Outsourcing. In a custom service you sell the heroics of talented people and you cannot promise the outcome. In a BPO you sell a process: stability, the quality of the process itself, people trained to do typical work well, and the right tools in their hands. Those are what make the service both dependable and economically efficient. Software delivery is becoming ownable as a process, not only deliverable as a craft.
And software is only Patient Zero. By the same fractal logic, any white-collar field with the same structure follows the same path once agentic tools reach mid-level competence in it. Whoever learns to move the work from complex to complicated first, by co-evolving a repeatable Silicon teammate and the humans who direct it, will own the predictability, and the economics, that come with it.
Written by Pavel Khodalev, author of RACE Programming and CTO of First Line Software. Follow new essays via RSS.