A King’s Day Reflection on AI, Architecture, and the Speed of Change

Today, as the Netherlands turns orange and celebrates King’s Day, I want to start with a small pause. Happy King’s Day to everyone celebrating.

It feels like a good moment for reflection. Not only because King’s Day has that slightly unusual Dutch mix of tradition, optimism, public energy, and controlled chaos, but also because that combination feels strangely familiar when looking at the current state of Generative AI. There is excitement everywhere. There is experimentation everywhere. And underneath it all, there is also a growing architectural question: what kind of structures are we actually building while everything is moving this fast?

For some time now, I have been trying to publish a reflective architecture article every Monday. Not because I think I have all the answers, but because writing helps me make sense of what I am seeing. And with AI, especially Generative AI and agentic systems, there is a lot to make sense of.

I have been closely involved with this subject since 2022, when ChatGPT first appeared and made the broader public aware that something had shifted. What struck me almost immediately was the similarity with the disruptive nature of the web around the millennium transition. I had seen that earlier wave from within IT. The first websites, the first search engines, the first digital business models, the first serious debates about new roles, new risks, new architecture, and new power structures. At the time, many things looked like isolated experiments. Looking back, they were early signals of a much larger transformation.

That is why, on June 2, 2023, I published an article titled The Profound Influence of Generative AI on the IT Landscape. In that article, I explored the parallels between the rise of Generative AI and the early web, not from a pure AI research perspective, but from the perspective of an architect trying to connect dots across technology, business, governance, and human behavior.

The interesting part is that many of my current insights and Enterprise Architecture reflections are still grounded in something very practical: hands-on experience. I don’t write about AI from a distance. Most of the topics that end up in my articles start because I have tried something, built something, broken something, or became puzzled by something during real use. That hands-on friction is often where the writing starts.

The Hands-On Side Behind the Architecture Thinking

So what am I actually working on?

Over the past years, I have had many AI sessions around images, music, articles, software, automation, and business ideas. But especially during the last three or four months, my focus has shifted strongly toward creating software and content through agentic platforms and factory-like setups.

That word “factory” keeps returning. At first, it sounds a bit exaggerated. But the more I experiment, the more it starts to feel like the right metaphor. Not because everything is fully autonomous or perfect, but because the pattern is changing. Work no longer feels like a single human manually producing one artifact at a time. It starts to feel more like designing a repeatable system in which intent, context, constraints, tools, prompts, agents, validation steps, and output pipelines are assembled into something that can produce at scale.

One concrete example came after writing an AI-assisted children’s book. That project did not remain just a book. It triggered the idea of a complete book factory: a system that can generate, structure, prepare, and publish new titles almost at the press of a button. Of course, there is still taste involved. There is still judgment involved. There is still editing, positioning, and quality control. But the center of gravity changes. The question shifts from “Can I write this one book?” to “Can I design a publishing system that repeatedly creates coherent books?”

The same pattern appears elsewhere. I am working on a social media automation factory. I am developing a sales chat agent for my webshop. I am building gamification functions for that same webshop using AI-assisted software development. And around those bigger initiatives sits a long list of smaller projects, experiments, tools, workflows, and half-finished ideas that all seem to emerge from the same underlying force: AI lowers the friction between idea and artifact.

That is powerful. It is also exhausting.

The Speed Is Both Motivating and Frustrating

What keeps me motivated, and at the same time deeply frustrated, is the speed at which agentic platforms are currently developing. It is almost impossible to keep up. The insights change daily. The tooling changes daily. The vocabulary changes daily. What felt like a good practice last month may already feel incomplete today.

The more intensively I use these systems, the more visible the limitations of the current models become. Not in a theoretical way, but in a practical way. Context starts to degrade. Agents lose track of earlier decisions. Generated code can look convincing while missing the real architectural intent. A tool can complete a task, but not always the right task. A model can follow instructions, but still drift away from the deeper design rationale.

And then the ecosystem responds. Platforms, methods, and tools such as Superpowers, GSD, and BMAD evolve around exactly these pain points. New terms begin to appear and spread: agent harnessing, context rot, Context Atomicity, holdout scenarios, memory-as-architecture, skills, commands, workflows. Some of these terms may turn out to be temporary labels. Others may become part of the future language of software delivery. But their existence already tells us something important: we are no longer just prompting models. We are trying to engineer the conditions under which autonomous or semi-autonomous systems can behave usefully.

That feels like a much deeper shift.

From AI-Assisted Development to Agentic SDLC

At the moment, I am especially interested in the possibilities around Agentic SDLC. Not just agentic software development in the narrow sense of generating code, but the larger iterative feedback loop around software delivery.

That distinction matters. Generating code is impressive, but it is not the whole story. The real architectural question starts when the system begins to participate in the broader lifecycle: reading repositories, understanding intent, generating artifacts, detecting inconsistencies, preparing documentation, creating test strategies, evaluating implementation quality, suggesting refactorings, and feeding insights back into the next cycle.

I am currently developing agentic tools that analyze code repositories and create different kinds of artifacts from them. This can include documentation, architectural summaries, quality signals, implementation plans, or other structured outputs that help make a codebase more understandable and more governable. In a traditional setting, these activities often sit around the SDLC as supporting work. In an agentic setting, they may become part of the operational loop itself.

That raises a question I keep returning to: are we still looking at AI as an assistant inside the existing SDLC, or are we slowly watching the SDLC itself become an executable system?

The difference is subtle, but important. In the first case, humans remain the operators and AI helps them move faster. In the second case, humans increasingly design the constraints, feedback loops, boundaries, and validation mechanisms of a delivery system that can perform meaningful stretches of work on its own.

That does not remove the architect. It may actually make architecture more important. But the architectural focus changes. It moves from designing applications and processes toward designing behavior, autonomy boundaries, trust models, verification loops, and escalation paths.

The Pull of Semi-Autonomous Applications and Dark Software Factories

This is also why I am increasingly intrigued by subjects such as semi-autonomous applications and dark software factories.

A semi-autonomous application is not just an application with an AI feature bolted onto it. It is a system that can interpret intent, act within boundaries, learn from feedback, and adapt parts of its behavior without every step being manually designed in advance. That may sound futuristic, but many early ingredients are already visible in today’s tooling.

The idea of a dark software factory goes even further. It borrows from the manufacturing metaphor of a “dark factory”: a production environment that can run with minimal human presence. In software, this could mean an environment where requirements, code generation, testing, documentation, deployment preparation, telemetry interpretation, and improvement loops become increasingly automated inside defined constraints.

I am not saying this is fully here. I am also not saying it should be adopted without caution. But I do find the direction hard to ignore. Once you start working hands-on with agentic platforms, the old boundaries between idea, software, content, workflow, and automation begin to blur. What used to be separate projects start to look like different expressions of the same factory logic.

A book factory. A social media factory. A sales agent. A gamification module. A repository analysis tool. An agentic SDLC workflow.

Different outputs, perhaps, but the underlying architectural question is similar: how do we turn intent into controlled, repeatable, inspectable execution?

The Unknown as the Real Landscape

There is a lot happening in AI right now. Too much, perhaps, to reduce to a simple roadmap. The unknown is not a temporary inconvenience; it is part of the landscape itself.

That is what makes this period so interesting. It is also what makes it uncomfortable. We are building while the tools are changing. We are forming opinions while the evidence is still moving. We are designing governance around systems whose capabilities are evolving faster than most organizational structures can absorb.

Perhaps that is why I keep writing these Monday reflections. They are not meant as final conclusions. They are attempts to slow down the thinking just enough to see patterns emerge.

And the pattern I keep seeing is this: Generative AI is no longer only about content generation, productivity, or clever prompting. It is becoming an architectural force. It changes how software is created. It changes how content is produced. It changes how business processes are imagined. It changes the relationship between human intent and machine execution.

Maybe the real question is no longer how we use AI inside our existing structures.

Maybe the deeper question is which structures AI is quietly forcing us to redesign.