Caught between ephemerality and materiality

Software engineering has always been an industry prone to recursive amnesia. Every decade, we repackage foundational truths about human collaboration, system architecture and abstraction boundaries, declaring them novel because the runtime or the syntax has shifted.

But sitting on the periphery of the Thoughtworks Future of Software Engineering Retreat in Engelberg, Switzerland, listening to the debates bouncing across the breakout rooms, it became clear we’re staring at structural discontinuity. This might look like the shift from assembly to higher-level languages, but it's arguably more than that: there's a sense that we’re witnessing a realignment of the engineer's identity, the economics of maintenance, the reality of corporate software ownership and the geopolitical boundaries of data.

Here are my reflections on the themes that dominated the retreat and the structural challenges much of the industry is at the moment largely choosing to ignore.

The ephemeral codebase and spec-driven engineering

For generations, the industry has understood code itself to be the canonical reference of software architecture. Design documents, wikis and architectural decision records (ADRs) are lossy abstractions that can begin to rot the moment they’re committed to a file system.

Yet, multiple practitioners at the retreat noted that when embracing "hardcore" agentic workflows at least code is becoming ephemeral. When an engineer works by updating a highly detailed specification and allows an LLM or agent to completely regenerate the application rather than line-patching it, the code behaves less like a permanent monument and more like a compiled binary.

This completely redefines our relationship with software quality. Historically, code quality was measured by its internal aesthetic, such as the elegance of its design patterns, its adherence to encapsulation and how easy it was for a human eye to scan. 

In an era of AI agents, though, a more pragmatic definition of quality has emerged: good design is that which minimizes the number of tokens an agent requires to safely generate a predictable outcome. 

If code is no longer the source of truth, where does the architecture live? We run the risk of trading the legacy technical debt of human spaghetti code for an entirely unmanageable "prompt swamp" or a chaotic collection of mutual state harnesses that are owned by everyone and no one.

The cognitive and psychological load

One of the most striking observations from the retreat focused on the shifting psychological and cognitive load on individual contributors. Developers practicing advanced agentic engineering reported a paradox of exhaustion and euphoria. Spawning eight or nine sub-agents to execute tasks concurrently changes the role from an individual contributor who writes code to a kind of overseer or structural validator.

This mimics the transition from a software engineer to an executive or tech lead—making rapid, high-consequence decisions based on asynchronous inputs from various channels without possessing full context. However, this 'leadership' role exists without the human element.

The crisis of the seven-to-ten year engineer and the threat to mentorship

While fresh graduates with a low barrier to entry treat LLMs as a natural extension of their academic workflows, and 20-year veterans leverage their deep systemic intuition to act as effective directors, a distinct segment of the engineering population is facing an acute emotional crisis: the mid-level engineer with seven to ten years of experience.

These professionals have spent a decade mastering syntax, memorizing design patterns and debugging system quirks. To watch a model execute these syntax mechanics faster —and often with a broader, if shallow, context — is provoking severe existential friction.

This intersects with a deeper, generational threat to our talent supply chain. Historically, seniors taught juniors by giving them smaller, bounded implementation tasks. This feedback loop was double-sided:

• The junior learned how to think systematically through the act of writing code, making mistakes and occasionally breaking production.

• The senior learned how to define guardrails and scope work packages effectively.

   

If we bypass the implementation phase entirely because an agent handles it instantly, how do juniors build the mental calluses necessary to become world-class problem solvers?

The apprentice-master model is fraying. If an organization hollows out its teams to include only high-level "critics" and agents, it destroys the through-line of foundational knowledge. The first time a team discovers this gap shouldn't be at 2:00 AM when a complex, distributed production system goes down and no one knows how the underlying abstractions actually work.

Shadow AI and the myth of citizen developer sovereignty

The promise of the citizen developer isn't new; it previously manifesteded itself in Excel macros and Lotus Notes databases. Today, however, non-technical teams (marketing, accounting, legal) are using tools like Claude or ChatGPT to generate complex automations and cloud infrastructure on the fly.

The retreat highlighted terrifying examples of this increased access: an accountant using an LLM to build a quick, highly functional internal app, only to inadvertently expose commercially sensitive customer data to the open internet via a Cloudflare proxy tunnel suggested by the AI to bypass a changing IP address.

LLMs are remarkably polite and highly confident sycophants; they will gladly convince a casual user to publish data or configure infrastructure in structurally catastrophic ways, validating it with statements like 'in 99.9% of cases, this is what we do'.

Organizations need to shift away from trying to completely block this experimentation, moving instead toward a tiered risk architecture:

• Personal productivity scripts running locally require no formal support — if they break, it's the responsibility of the individual running them .

• Team-level utilities and minor automated workflows need mandatory foundational training, and should be accompanied by basic threat modeling and compliance alignment.

• Enterprise-wide applications, high-risk processing and production environments should be restricted exclusively to professional engineering teams with strict infrastructure guardrails.

The underdiscussed frontier: Digital colonization and the death of open source

While the rooms vibrated with debates on agent platforms and token optimization, two critical topics received far less airtime but carry immense long-term significance for our industry: sovereignty and open source exploitation.

Geopolitical sovereignty vs. the cloud for coding

A massive wave of self-hosting models within enterprises is driven not by economic efficiency, but by a fundamental, systemic lack of trust in foreign federal governments and centralized hyperscalers. For European companies, relying on US-hosted frontier models for core software development represents an unacceptable concentration of geopolitical risk. If a state can weaponize critical payment rails or cloud access during complex trade negotiations, it can certainly weaponize access to intelligence.

Furthermore, there’s also a corporate sovereignty crisis: when you rely entirely on an external host's model to write your code, they’re learning on your behalf. You’re effectively outsourcing your company’s core capability to transform and evolve.

The end of the open source gift economy?

The open-source ecosystem is facing a quiet, structural collapse that the AI era is accelerating. Automated vulnerability discovery has scaled exponentially, forcing solo volunteers and small teams to maintain load-bearing pillars of global commerce under a relentless barrage of security exploits and AI-generated pull requests.

The retreat witnessed a stark, ideological clash between the traditional view of open source as a pure, unconditional gift to humanity and a more critical perspective that recognizes how permissive licensing (MIT/Apache) has allowed billion-dollar corporations to exploit open software without returning economic value to the creators.

Agents make this dynamic far more acute. Why adopt an open-source project and inherit its license constraints when you can simply hand the codebase or specification to an LLM and command it to cleanly reimplement a custom, unencumbered version inside your company's private safety bubble? We’re moving into a deeply transactional software landscape where the line between collaboration and exploitation is entirely blurred.

Staring into the Abyss: The materiality and ethics of AI

We need to anchor our engineering discussions in a broader historical reality. We speak of AI as an abstract, infinite resource, ignoring the stark materiality of data center infrastructure, regional water consumption and the massive capital concentration required to train frontier models.

As we seek to accelerate toward hyper-efficiency, it’s important to consider whether we risk widening the socioeconomic divide. There’s an argument that access to advanced frontier models is becoming a baseline requirement for social mobility and entrepreneurial scale; If access to these cognitive amplifications is restricted by economic boundaries, social mobility will become increasingly more entrenched.

We’re fond of drawing parallels to the Industrial Revolution, noting how the invention of the spinning jenny or automated looms structurally altered communities. But history also shows us that when industry and education fail to work in concert to prepare for these systemic shifts, entire generations are left behind in disenfranchised, collapsing environments. 

For software engineers, architects and technical leaders, the ultimate acceptance criteria cannot just be the deployment of leaner, faster agentic loops. It needs to include a conscious, deliberate responsibility to the human structures those loops leave in their wake.