What is agentic software engineering?

Using AI agents across the delivery lifecycle rather than as an autocomplete, together with the verification and governance that make their output trustworthy enough to release.

How is this different from using an AI coding assistant?

An assistant suggests and a person reads every line. Agents produce complete changes faster than they can be reviewed that way, so review has to shift from reading the diff to verifying the behaviour against the requirement.

Where should a team start?

With the question of how you would know an agent had got it wrong. Teams that cannot answer that gain velocity and lose the ability to tell good output from bad, which is the expensive way round.

Product demo

Agentic development is easy. Agentic software engineering is hard.

AI agents can plan a ticket, generate code, create tests and open a pull request in minutes. The harder problem is independently establishing whether they understood the requirement correctly.

A worked fictional demonstration on an invented travel booking product. No customer repository is analysed, and every result below is prepared demonstration data.

The ticket

TRV-2841

Prevent late booking cancellation

Customers may cancel a booking until 24 hours before departure.

Once departure is less than 24 hours away, cancellation must be rejected.

Acceptance criteria

AC1Cancellation is permitted more than 24 hours before departure.
AC2Cancellation is rejected less than 24 hours before departure.
AC3The 24-hour rule must be enforced by the booking service and not rely solely on UI validation.
AC4The customer receives a clear explanation when cancellation is rejected.

What this demonstrates

This demonstration runs a full agentic delivery workflow: plan, implement, test, review, pull request. Every stage passes its own checks. The behaviour that reaches the end is still wrong.

Every stage passed, and the result was still incorrect

Each stage validates its own output against its own input. The planner produces a plan consistent with its reading of the ticket. The implementer writes code consistent with the plan. The test writer writes tests consistent with the code. Every handoff is locally correct.

If the reading of the ticket was wrong at the first step, every later step is correctly derived from a wrong premise. Nothing downstream is positioned to notice, because nothing downstream goes back to the requirement.

Adding more agents does not fix it

A reviewing agent does not help if it reviews the code against the plan, because the plan is where the error entered. The work has to be checked against the requirement, by something that took no part in producing it.

Generation is the easy half

Agentic development is straightforward to adopt. The tools work, the output is plausible and the velocity is real. Agentic software engineering is the harder problem of establishing that the output is correct, and that is a verification problem rather than a generation problem.

Common questions

What is agentic software engineering?: Using AI agents across the delivery lifecycle rather than as an autocomplete, together with the verification and governance that make their output trustworthy enough to release.
How is this different from using an AI coding assistant?: An assistant suggests and a person reads every line. Agents produce complete changes faster than they can be reviewed that way, so review has to shift from reading the diff to verifying the behaviour against the requirement.
Where should a team start?: With the question of how you would know an agent had got it wrong. Teams that cannot answer that gain velocity and lose the ability to tell good output from bad, which is the expensive way round.