Tech: Castles in the Code

Following the AI craze in development reminds me of my kids building castles in the sand. In the Finnish Gulf, the waterline isn’t set by big tides, but by the shifting winds¹. This constant ebb and flow requires a fluid approach to designing sand structures—a natural force mirroring AI’s role in development as a powerful current reshaping the landscape. I’ve been thinking about this while working on some personal projects and listening to folks like the Syntax² crew. And the most interesting finding is how large language models are altogether redefining what we mean by “software architecture.”

The premise is simple: many decisions once considered foundational, permanent, and architecturally significant are becoming more fluid. AI is demonstrating a remarkable capacity to automate tasks that were once high-effort, high-risk architectural transformations. Allowing us to focus on more creative and strategic aspects of our work.

At the core of this transformation is the fundamental capability of modern large language models (LLMs). These models can understand, generate, and, most importantly, transform code with a level of sophistication that far exceeds traditional static analysis tools. This capability introduces a new abstraction layer over implementation details, enabling developers to express their intentions—such as “Modernize this legacy system for memory safety” or “Decompose this monolith for improved scalability”—while the AI manages the complex implementation tasks³.

The shift significantly reduces the risks associated with architectural changes. The upfront costs, risks, and efforts that were previously considered—such as migrating from Node.js to Rust or breaking down a monolithic architecture—now seem less daunting. What were once monumental choices have become more flexible, driven mainly by the available tools. Switching between a monorepo and sub-repositories, or even between programming languages, now feels less like a strategic choice and more like a decision based on the tools at our disposal, similar to choosing between Webpack and Vite.

The tide has carried the decision away, leaving a smoother path.

However, while this newfound fluidity diminishes the significance of the underlying decisions, it is a mistake to discount the value in architecture. The weight of an architectural decision lies not in the difficulty of its implementation but in the breadth and permanence of its consequences. We’re confusing the ease of the tide moving the sand with the unchanging, solid bedrock that lies beneath. An LLM can generate plausible code, but it often lacks the meticulousness and strategic design required to satisfy the real-world needs of the users, or critical NFRs like security, performance, and maintainability.

In summary, AI excels at syntax but lacks an understanding of semantics—the meaning and purpose behind the code. It does not grasp business context, organizational goals, or real-world constraints, which are essential for making practical and informed trade-offs rather than simply producing technically elegant solutions.

As the influence of AI continues to expand, it brings new responsibilities that may shift the focus away from traditional architectural concerns. The emphasis is transitioning from the structure of code to the architecture of intelligent systems. Consequently, the role of architecture is evolving to encompass topics such as Socio-Technical System Design and Context Engineering⁴. Ultimately, the architecture becomes a tool to manage the cognitive load for both developers and machines.

The message here isn’t about replacing architects with the machine; it’s a call to start designing the very ecosystem in which humans and machines can effectively collaborate, shaping the new coastline of software.