Software Developers become Gardeners

“I like to think (and the sooner the better!)
of a cybernetic meadow
where mammals and computers
live together in mutually
programming harmony
like pure water
touching clear sky.”

– Richard Brautigan, 1962

When I get asked about my vision for the future of software development I can't help thinking of Brautigan's "All Watched Over By Machines Of Loving Grace". In his iconic poem the author dreams of a "cybernetic meadow where mammals and computers live together in mutually programming harmony".

Recent advancements in machine learning, particularly large (huge) language models, have made it evident that more-than-human co-creation of software is here to stay. Indeed, some have started proclaiming "the beginning of the end of the software developers". I believe in some sense this is true. However, while Brautigan's poem longs for a place where "we are free of our labours and joined back to nature" I rather see a shift in what software development entails and with what mindset we will approach it.

We have to understand modern software as more than human ecologies

Ville Radieuse (The Radiant City) by Le Corbusier

The dominant view of software development often departs from a static understanding, treating software like an architecture made up of (static) interchangeable blocks. This view ignores the complexity of software as a living system. This idea is reminiscent of Le Corbusier's plan-cities, which aimed to create a utopia through rigid planning and architecture. However, the fallacies of Le Corbusier's plan cities became apparent as they failed to take into account the organic and ever-changing nature of human society.

Similarly, our current understanding of software and software development might be misguided. Treating software as a static, tested and predictable structures (put number 4 in, get number 8 out) ignores the complexity and fluidity of software in action. To truly understand today’s and tomorrow's software, we need to view it as a living system, embedded in a larger ecosystem of human and AI actors. This requires a more holistic and flexible approach to software development, one that recognizes the dynamic and ever-evolving nature of software and its creators, operators and consumers. It's time for software developers to become gardeners, not architects, to cultivate an ecosystem rather than focusing on artefacts.

These ecosystems include tools, platforms, frameworks, practices and protocols for software development, deployment, adoption, and operation, and requires cooperation between developers and AI systems. They always entail a diverse set of actants (code, energy, compute, brands, algorithms, coders, founders, capital etc) and always are bigger than the sum of their parts.

And of course software ecosystems have long existed before human-ai code generation - even if little understood and under researched. The evolution of software has long gone beyond "a single, isolated program's intent" (if it could ever be understood in isolation at all), becoming an entangled dynamic entity through open source collaboration, dependencies and contributions. At the latest Heartbleed was a testimony to how all software is already part of an ecosystem and can no longer be understood in isolation.

However, now with the advent of code generators and large language models, software is being pushed even further towards ecological behaviours as it can no longer be understood as a set of mathematical instructions for a computer nor are humans the only contributors to the ecosystem. Instead, the software ecosystem has become a complex, more-than-human ecology that has taken on a life of its own.

The implications for developer practice are profound

Let's take Scale AI's hackathon project "GPT is all you need for backend" as an example. It formulates the vision that "future tech stack is to completely replace the backend with an LLM that can both run logic and store memory".

@DY tweets

"You can "call" the API with add_five_household_chores() or deleteAllTodosDealingWithFood() or sort_todos_by_estimated_time(). And it will do exactly that, even though you never wrote any of those functions!"

But will it? And how would you know? We are confronted with a transition from programming certainty to incorporating AI’s best guess.

The truth is: We are just starting to understand the new realities and challenges of prompt engineering. I am reminded of Karlton's truism: "There are only two hard things in Computer Science: cache invalidation and naming things." Maybe naming things and formulating prompts become interchangeable as we see software progress to more than human architects of code.

New Ecological Principles

The dynamics of the previous paragraph among other drivers such as increased developer velocity, continuing momentum of open-source, a clear trend towards real-time and ever more ephemeral production environments makes me believe that we will see the following transitions:

Plan for stability -> Plan for anti fragility Create protocols -> Make sure you get viable results Focus on microservices -> Focus on events at intersections Choose a Stack -> Create an assemblage (sandbox multiple solution approaches with blue green strategies)

Software Developers become gardeners

So what do I mean when I say “Software Developers become gardeners”? The before mentioned principles approach software like managing a biological ecosystem. In fact I am borrowing ideas from permaculture principles here.

In my imagination a software gardener will:

• manage the evolution of software with new features and capabilities being added and older, less useful elements being phased out. This process is similar to the way species evolve through natural selection.
• leverage diversity the way different species work together in an ecosystem to achieve a common goal and contribute to the overall health and stability of a biological ecosystem
• leverage and manage interdependence within ecosystems much like the way different species in a biological ecosystem rely on each other for survival.
• establish highly adaptable practices with the ability to respond to new challenges and opportunities in real-time similar to the way biological ecosystems can adapt and evolve in response to changes in the environment

This modern type of developer will focus on higher level abstractions and the ecosystem at large rather than the code itself. They will embrace high velocity and constant refactoring, stack-diversity (min. vendor lock in) towards anti-fragility, collaboration and contribution within their stack(s) (open source), make observability/incident management a first priority and adopt a responsive real time culture ensuring viable results (shift left). Most importantly they will incorporate more than human cooperation in every step and way possible.

We are still at the beginning of this shift but I predict we will see a whole new class of "gardener-tools" fostering new practices and cultures supporting a new breed of hyper agile squads and organisations.

If you are woking on such a tool, I'd love to hear from you!