Are Design Patterns Still Useful in the AI Era?

This article is translated by AI, if have any corrections please let me know.

Have you noticed that AI-generated code often requires significant rewriting every time you integrate it? Since the launch of Coding Agents, there have been constant voices claiming that software engineers will be replaced. However, through my recent collaboration with colleagues, the overall situation still aligns with the reality that “professionals remain.”

Some might think that with Coding Agents, “there’s no need to learn software development,” but they fail to realize that much of advanced software development knowledge isn’t about “implementation” - it’s about “design” and “architecture.”

Maintainability

In my development experience, most software development knowledge is about solving the problem of “how to maintain software.” Put simply, it’s about “how to make code easier to modify.”

For example, we write tests so that when adding Feature A, the original Feature B still works correctly. Tests confirm that both features function properly within their scope (such as unit test boundaries).

Similarly, refactoring is mostly preparation for future modifications. Architecture theory aims to make long-term feature expansion easier. Essentially, most software delivery quality assessments are highly likely related to “can we continue to modify it.” Even Design Patterns are collections of common design approaches that ultimately come back to the question of “ease of modification.”

Looking at Coding Agent performance, while they can generate code at speeds far exceeding humans, and their “correctness” has reached a level where most engineers would say “just let AI implement it,” the software design and architecture are still randomly assembled and not always easy to modify or maintain.

Foundational Skills

In the AI era, a software engineer’s abilities are no longer about “memorization.” We don’t need to understand every programming language’s syntax or the implementation details of every software development theory.

However, we need to be familiar enough with SOLID principles, Design Patterns, Clean Architecture, and all software design theories that when facing relevant situations, we can immediately think “this looks like that pattern” or “this is where we should use that approach” to adequately handle software development requirements.

As a work example, my colleague and I were each responsible for different projects that ultimately needed to be integrated for validation. We both used Coding Agents for development, but what kept bothering me was that every time I received new files, I had to have the Coding Agent rewrite them before I could use them.

If it’s just Vibe Coding or creating small tools with ChatGPT or Gemini’s Canvas, this might be acceptable. But for building products, this defeats the purpose of AI helping us develop faster. It becomes me receiving an 80% complete document and re-implementing everything.

So my colleague and I spent some time making adjustments:

• Define interfaces
• Abstract the processing

This might sound simple, but these are applications of software development fundamentals. In our specification, our implementations would only have Get and Create scenarios, but previously too many details were “exposed” to me. Defining interfaces is about distinguishing what should be “encapsulated” and not used externally.

Next, we needed to handle application scenarios. Since I was responsible for a validation system to confirm that my colleague’s implementation matched the design before deploying to production, we needed special behavior for the validation environment. This is where defining interfaces proved valuable again - we could use Dependency Injection to swap between validation and production service behaviors.

Going further, since my colleague’s implementation should only expose Get and Create to me, we applied the Factory pattern’s Creation Method from Design Patterns, providing a simple build_local_runtime(...) method to make project integration straightforward.

This looks very similar to writing tests, but our project is AI-related, so we couldn’t use traditional testing methods and adopted a different mechanism.

Clearly, if we just let Coding Agents implement directly without upfront design or guidance, it’s difficult to handle these details properly. This is why software development fundamentals remain highly valuable even in the AI era. To some extent, it also reduces the frequency of AI iterations. After all, these practices already improve human development speed, and combined with AI, they can accelerate development even more.

Design-Driven

Before the AI era, software development was largely limited by development timelines, so engineers who could code fast and well were nearly ideal. But now that human speed is the limiting factor, good design becomes more valuable.

I remember sharing with colleagues last year that “Cohesion” might become an important concept in the future. We’ve always focused on “Coupling” issues, working hard to avoid coupling, but rarely considering whether we’ve kept related implementations cohesive.

Why does cohesion matter? Because it’s more suitable for Coding Agent modifications. If our design reaches an ideal state, every time we ask AI to make changes, it will find the specific file according to the specification, and that file will contain all the parts that need modification, naturally completing edits with fewer steps (searching, reading).

When everyone is fast, these small details can become factors for being even faster. This creates an interesting phenomenon. In the past, we were reluctant to spend time thinking and discussing to clarify things because we were constantly pressured by deadlines. But now, spending more time on clarification and discussion yields a faster-developing, more stable system, because good design makes it harder for Coding Agents to make mistakes and changes become more controllable.

This is why fundamentals like Design Patterns are so important. If we’re familiar enough with this knowledge, we only need to judge when to introduce appropriate designs, and we can get very close to the high-quality software that humans used to spend enormous effort creating, but faster and with less effort.

The prerequisite for all of this is still having sufficient expertise in the domain. Relying solely on AI’s knowledge is not enough. Professionals remain precisely because these fundamentals cannot be replaced.