The use of large language models (LLMs) is already reshaping software development. Code can be generated, existing systems analyzed, and integrations implemented faster than ever before. Tasks that previously required specialized expertise can now often be accomplished with relatively little effort.
This naturally leads to a common expectation: if technology takes over more of the implementation work, managing complexity in existing systems should become easier as well.
In practice, the reality is more nuanced.
Productivity increases – complexity remains
LLMs are highly effective at leveraging existing structures. They can generate code based on established patterns, extend existing logic, and significantly accelerate repetitive tasks. In well-structured systems, this results in measurable productivity gains.
In long-lived and poorly understood systems, however, a different dynamic emerges.
Where business relationships are unclear and system boundaries are not well defined, the models lack the necessary context. The generated output aligns with existing structures—regardless of whether those structures are meaningful or problematic.
In this scenario, complexity is not reduced. It is reproduced.
Context as the decisive factor
LLMs do not operate in isolation. They always depend on context, which is derived from code, data, descriptions, and implicit assumptions about the system.
If this context is incomplete or inconsistent, the effects become visible in the results. Common patterns include:
- Generated code does not align with the existing architecture
- Business rules are implemented inconsistently
- Dependencies are reinforced rather than reduced
- Technical debt grows faster than before
These effects are not a weakness of the models themselves. They are a consequence of the environment in which they are used.
Why domain understanding becomes more important
Against this backdrop, the importance of domain understanding increases rather than decreases.
Domain-Driven Design provides the structure required for the effective use of LLMs. Clear business boundaries, defined responsibilities, and a shared language between business and IT create the context that these models rely on.
In systems with well-defined domains, the quality of results improves significantly. Requirements can be formulated more precisely, prompts become more specific, and generated code is more consistent. Decisions remain traceable because they are grounded in clearly defined relationships.
The difference lies not in the capability of the technology, but in the quality of the underlying structure.
A shift in perspective
The current discussion around LLMs often focuses on the extent to which human development work can be replaced. This perspective is too narrow.
The more relevant question is: under which structural conditions can LLMs be used effectively?
The answer leads back to fundamental principles of software design: clear responsibilities, understandable domain models, and well-defined system boundaries.
These principles are not new. However, they become significantly more important with the introduction of LLMs.
The role of modern IT leadership
For organizations, this creates a new challenge. It is not enough to introduce new tools and expect immediate gains in efficiency. What matters is the ability to structure systems in a way that allows these technologies to deliver value.
Modern IT leadership, in this context, means making complexity visible, shaping structures deliberately, and enabling decisions based on a clear understanding of domains.
LLMs act as an amplifier. They accelerate existing structures—for better or worse.
Conclusion
LLMs are a powerful tool, but they do not fundamentally change the challenges of complex systems. Without a clear understanding of the underlying domain structure, their impact remains limited.
Domain-Driven Design is therefore not an alternative to AI, but a prerequisite for using it effectively.
Organizations investing in LLMs should invest equally in the structure of their systems—not as a theoretical exercise, but as a practical foundation for sustainable IT modernization.
