Evolving Software
2026-11-15 · Scott
The Tools Have Changed
It's the nature of the tools we have. Today, we are no longer assembling rigid, deterministic machines with physical, structured tools. We are building adaptable products that grow, using dynamic tools driven by language.
As traditional software engineering evolves, so too does the mental work of the engineer. They must transition into something more like a technical product owner, one who sits closer to the action. Instead of thinking purely in terms of numbers and if statements, they need to evolve into the intelligence layer between end consumers and end agents and systems.
The software lifecycle is changing with them. I see us arriving at a combination of both worlds from the past: a genesis stage akin to a traditional waterfall cycle for the initial release, followed by more agile-like adaptation after that release.
The currency is still the underlying idea, the undiscovered need or opportunity, and that should drive all the work that comes after. What has been unlocked is the faster realization of these ideas. They can be evaluated and adapted more quickly, to either prove them and capitalize, or disprove them and shelve them.
Learning from Nature
If we fully embrace these changes and the idea of "evolving" software, then we should look to the patterns exposed in nature for inspiration. Which raises the obvious question: how do we "evolve"? How can we take what's been proven in the crucible of nature and apply it to GenAI, software engineering, and application development?
In many ways, life is driven by a mixture of inherent desires and crafted, or learned, desires. If we want to emulate this pattern, we can apply similar logic to our agents and agentic systems.
For inherent desires (think of the system prompt), we ask ourselves: what is the system itself, and what is its purpose? In my opinion, every system, in this case every agent or agentic system, should have these defined at the beginning of development. They set the "North Star" (to use an overused term, my apologies) of what the system's inherent "desires" are.
User behavior, feedback, and outcomes then become the learned desires: something to iterate toward to achieve an end goal. Working in tandem, both sets of desires can drive this software "evolution" by aligning toward what's best. The true feat is figuring out how this pattern can be applied to software development itself.
Context and Emergence
For emergent behavior in agentic systems, I see a key role for context: context management, context engineering. As a simple thought experiment, think of "context" as the maximum amount of knowledge or wisdom possible for any given person. Simply put, no one can know everything. There is just too much to know.
This same limitation holds at the agent level. Agents and models can only effectively deal with so much context before they become overwhelmed or confused. As a result, we are seeing a pattern of tightly scoped agents that go deep in one specific area. The neat part is that when you have a large number of these specialists that can communicate and coordinate, they start to demonstrate swarm-level emergent intelligence. This leads to both unexpected successes and unexpected failures, and both need to be planned for.
When it comes to writing requirements for these swarm or emergent systems, I return to the same idea from earlier: define requirements as inherent versus learned. The initial requirements are the most inherent, North Star–type "requirements" that solve the underlying issue or question we are asking. They should be written in a way that allows the underlying agentic system to make design and development choices along the way, effectively making development non-deterministic and evolutionary.
The Human as Environment
We are already seeing some of these behaviors in bleeding-edge software development, where engineers run many "trees" of work, accept the best code lineages, and discard the undesirable ones, much like a fitness function. In this case, the human mind is the environment. We, as thinkers, must determine what is valuable in the end and which path to take. We cannot expect these systems or agents to understand what is truly, functionally desirable for end users. They can be told, and they can be reactive, but we cannot expect proactive understanding.
I also think this is why we are seeing an explosion of telemetry and observability tools in the market. Following natural patterns starts with collecting massive amounts of signal data and using LLMs to quickly interpret those vast data sets for patterns that can be acted upon. This layer of perception, turned into data that can invoke change in line with the system's desires, is in my opinion a key aspect of future iterative development.
So that's the shape of it, as I see it. Inherent desires to set the direction. Learned desires to refine it. Specialists that know their limits, working together. Senses that never stop collecting. And a human standing in the middle, deciding what's worth keeping. The tools have changed. The job of knowing what matters hasn't.
Related: Rethinking How We Build in the Generative Era, on what this means for how a team works day to day.