AI writes code faster than any programmer. According to software engineer and trainer Corné van de Pol, the focus of the profession is therefore shifting toward design and quality assurance. As AI takes over more work, thinking carefully about what to build before starting becomes increasingly important.
When Corné van de Pol entered a lecture hall as a first-year computer science student at Eindhoven University of Technology, he was immediately confronted with a discouraging message. On the screen appeared a quote from computer science pioneer Edsger Dijkstra: “It’s practically impossible to teach good programming to students that have had a prior exposure to Basic: As potential programmers, they’re mentally mutilated.” As a child, Van de Pol had spent plenty of time programming in GW-Basic and QBasic. “So, I was written off from day one,” he laughs. “But I didn’t give up.”

After graduating, Van de Pol joined VSTEP, a Rotterdam-based developer of training simulators. Through engineering consultancy Alten, he subsequently ended up at Philips, where he specialized in test automation, continuous integration, refactoring and software design. At Alten, he also discovered his passion for teaching. What started with a presentation on behavior-driven development evolved into delivering software engineering training courses.
Today, Van de Pol teaches, among other courses, “Emergent object-oriented design in the age of AI” at High Tech Institute. He shows developers how to turn requirements into a well-considered software design. That might seem like an old-fashioned skill at a time when AI can generate complete programs in seconds. Van de Pol argues the opposite.
Amplifying the mess
“Programming is a dying profession,” Van de Pol says. “I’m fairly convinced of that. AI already generates code so quickly that human programmers simply can’t keep up. Anyone who sees their job purely as writing code will have less and less added value.”
That doesn’t mean software engineers will become obsolete. Van de Pol expects their work to shift toward the upper levels of the V-model, where design decisions are made and software quality is assessed. “AI can accelerate development enormously, but humans increasingly become the bottleneck as quality attributes such as maintainability, extensibility and understandability carry more weight.”
'Before you know it, your greenfield project has turned into a brownfield situation'
Course instructor Claus Neeleman
Van de Pol uses AI constantly himself. He notices a clear difference between code generation and design. When programming, AI regularly comes up with solutions he hadn’t considered. When designing, however, he has to intervene, correct and steer the process much more often. Complex dependencies and trade-offs involving future changes are particularly challenging.
In Van de Pol’s view, this has to do with how large language models work. They can produce convincing solutions, but their output isn’t always reliable. Moreover, a good score from an automated quality check says little about whether the underlying design decisions are sound. A system can meet all kinds of measurable quality criteria and still be poorly designed.
The problem grows as software becomes larger and more complex. In existing systems with millions of lines of code, countless dependencies and a long development history, AI becomes less effective. Even those who start from scratch and let AI generate everything will eventually encounter the same problem. “Before you know it, your greenfield project has turned into a brownfield situation.”
For professional applications that need to last for years and accommodate constantly changing requirements, good design therefore remains essential. “AI is often described as an amplifier. But if you don’t design properly, you’re amplifying a mess. And at tremendous speed.”
Assurance
According to Van de Pol, the rise of AI introduces a new design question: How many decisions should you leave to the machine? Software architecture spans multiple levels of abstraction, from the overall system structure down to individual statements in code. Generally, the lower the level at which developers hand design decisions over to AI, the smaller the risks.
Where to draw that line depends on the application. For a one-off script or a prototype, it’s often perfectly acceptable to give AI almost complete freedom. Software for medical equipment is a different matter. “There are patients lying under those machines. You don’t want to blindly trust a nondeterministic code generator.”
It’s not just about the quality of the generated code, but also about accountability. “If something goes wrong, you can hardly say there was nothing you could do about it.” For critical applications, Van de Pol therefore wants to understand which design decisions have been made and why. AI can do much of the work, provided the developer can adequately assess the results.
The same applies to testing. Van de Pol regularly sees AI modify code and simultaneously generate new tests that all pass. That may seem reassuring, but it can undermine the very purpose of testing. After all, an existing test should be able to demonstrate that a change hasn’t introduced unintended consequences. If AI changes both the implementation and the checks, some of that assurance disappears. “Without reviewing the generated tests, passing them provides no guarantee that the code behaves correctly.”
To keep the review workload manageable, developers are better off checking the specification and design earlier in the process. “If you’ve reviewed the structure beforehand, you don’t have to reconstruct it from thousands of lines of generated code.” A specification captured in a reviewed test suite also reduces verification work, while quality tools can monitor measurable aspects of architecture and code quality.
Integrating AI
This development aligns remarkably well with the principles of object-oriented design (OOD), which Van de Pol aims to teach participants in his High Tech Institute course. He also sees many similarities between OOD and the currently popular approach of spec-driven development. In this approach, developers first establish a specification, then work out a design in the form of a plan and finally define a series of implementation tasks. AI supports the entire process. “We’ve been doing this in OOD for decades, just without AI.” According to Van de Pol, the real innovation lies in the tools and the collaboration between humans and machines.
In the OOD course, participants start by analyzing the problem domain. They identify objects and their relationships and use use cases to explore how the system should function. Sequence and state diagrams help visualize interactions, responsibilities and state transitions. Participants then transform the domain model into a software design, guided by quality attributes such as maintainability and extensibility.
The process is highly visual. Van de Pol considers diagrams an important tool for understanding complex structures and dependencies. People can often grasp such information more quickly from an image than from an extensive textual description.
This is precisely where Van de Pol sees opportunities to integrate artificial intelligence. With text-based modeling tools such as Mermaid, developers can have AI generate and modify diagrams. The models remain visually accessible to humans, while their textual representation lends itself to version control and automated processing.
'Once you've specified everything, you tell AI: okay, go ahead and generate it'
Course instructor Claus Neeleman
Van de Pol wants to give this approach a more prominent place in the course. Until now, participants have largely drawn models on paper or whiteboards and discussed the consequences of their choices. With AI, they can actually implement their designs and immediately experience what works and what doesn’t. “Perhaps we can even have working code by the end of the course,” he says. “Once you’ve specified everything, you tell AI: okay, go ahead and generate it.” That would be a significant addition to the current course format, in which the implementation is generally worked out in advance.
This doesn’t mean drawing will disappear. Van de Pol still wants to teach participants how to analyze a problem, build models and justify design decisions. Otherwise, there’s a risk that AI takes over the thinking without developers understanding what’s happening.
Staying in control
Van de Pol sees another interesting way to combine AI’s speed with the predictability of traditional software engineering: model-driven development. In this approach, models are converted into code through predefined transformations. AI could generate the models, developers could review them and deterministic tools could handle the implementation.
A similar approach is conceivable for automated refactoring. Van de Pol points to tools such as TNO-ESI’s Renaissance, which can perform code transformations according to predefined recipes. AI could help create these recipes while execution remains reproducible. If the result is unsatisfactory, the developer can roll back the transformation and adjust the recipe.
This creates a workflow in which AI takes over much of the work without developers losing control. For Van de Pol, that’s where the profession is heading: less hands-on programming, more specification, design and review.
It gives a familiar message from his training courses new urgency: Thinking ahead can prevent a great deal of rework. That was good practice before AI; now that machines can produce software at breakneck speed, it’s more important than ever.
Recommendation by former participants
By the end of this training participants are asked to fill out an evaluation form. To the question: 'Would you recommend this training to others?' they responded with a 8.5 out of 10.
