For decades, we have worked to improve the way IT systems are developed.

First came the waterfall model, with requirements, specifications, development and testing organised as an almost linear process. Then came Agile, introducing shorter iterations, continuous feedback and an understanding that both requirements and reality change along the way.

We are now facing another fundamental shift.

Artificial intelligence can already generate large parts of the code, propose system architecture, create tests, analyse logs, explain errors and modify existing solutions within seconds. The potential productivity gains are enormous.

But this also creates a significant paradox:

AI can produce code faster than humans can understand its consequences.

The most important question will therefore no longer be:

How quickly can we write the code?

It will be:

How do we ensure that what we build is still the right solution?

When AI changes the assumptions

One of the greatest risks in AI-driven software development arises when an AI model receives a defined process or system requirement but fills in missing information with its own assumptions.

The model may produce a technically logical solution that nevertheless conflicts with a business rule, a security requirement or an earlier architectural decision.

Developers have traditionally relied on several control points, including code reviews, test environments, desk checks, sprint reviews, retrospectives and acceptance testing.

But what happens when code is produced so rapidly that these established control mechanisms become bottlenecks?

We cannot simply do more of what we have always done. We need to develop new and more intelligent forms of control.

From writing code to asking the right questions

The software developer of the future must master more than programming languages and technical frameworks.

Developers must be able to ask questions such as:

• What assumptions is this solution based on?

• Which business rules might the AI have misunderstood?

• What happens if one of the assumptions changes?

• How can we demonstrate that the solution still works?

• Where could an error be hiding?

• What has the AI changed without explicitly telling us?

• How do we detect a logical error that passes every technical test?

This does not represent less technical expertise.

It represents a new form of technical expertise.

Software testing becomes more important – not less

It is tempting to believe that AI will make software testing less important because AI can also generate the tests.

That is a dangerous assumption.

If the same AI generates both the program code and the tests, we must ask:

Who tests the tests?

A test may confirm that the code does what we asked it to do. It does not necessarily confirm that we asked for the right thing.

Future quality assurance must therefore place greater emphasis on independent verification, traceability, contract testing, simulation, scenario analysis and explicit validation of assumptions.

We may not need fewer control points.

We need smarter control points.

The system architect takes on a new role

The system architect may become even more important in an AI-driven development model.

The architect will not necessarily be the person who writes the most code. The architect must be the person who understands the complete system: data flows, integrations, security, dependencies, performance, business logic and the consequences of change.

AI can propose ten possible solutions.

A human must be able to explain why nine of them should not be used.

That requires judgement.

How AI changes the role of the IT consultant

The value of the IT consultant will also change.

A consultant who only sells programming hours will face a challenge when AI can produce comparable code in a fraction of the time.

A consultant who understands the client’s organisation, asks difficult questions, identifies risks, challenges requirements and critically evaluates AI-generated proposals will become far more valuable.

The consultant of the future must therefore be a technologist, analyst, critical reviewer and trusted sparring partner.

The ability to understand the client’s actual needs will matter more than the ability to produce the greatest number of lines of code.

AI-driven development requires a new Agile toolkit

Agile was developed for a reality in which people wrote code in teams and change was introduced through iterations.

AI creates a different dynamic. Code, tests and architecture can change continuously and at a pace that people cannot follow through manual review alone.

We therefore need new working methods.

Development teams must be able to trace:

• What was changed.

• Why it was changed.

• Which assumptions formed the basis of the change.

• Which tests were performed.

• Which risks were identified.

• Which decisions were actually reviewed and approved by a human.

The development environment of the future may therefore need more than continuous integration and continuous delivery.

It will also need continuous verification.

Continuous verification must ensure that assumptions, business rules, tests and outcomes remain aligned throughout the development process.

Critical thinking becomes a core technical skill

Perhaps the most interesting aspect of the AI revolution is not that machines can write code.

It is that AI forces us to define what humans must be good at.

The answer is not necessarily to write code faster than AI.

It is to understand better than AI what should be built, why it should be built, what consequences it may have and how we can determine whether it is actually correct.

The software developer of the future must combine technology with logic, business understanding, critical thinking and the ability to detect errors.

AI will become an increasingly capable development partner.

But it should not be allowed to decide alone what is correct.

When AI can write the code, the human developer’s most important task becomes controlling the reality in which that code must operate.

This is not necessarily the end of the software developer’s role.

It may be the beginning of a far more important one.