One change request, two lifecycles: the enterprise path to the ADLC.

What one change costs today

Start with the honest picture. Your analysts already use AI agents. The investigation that used to take weeks now takes days. An agent searches the code, drafts the impact summary, proposes the specification update. And then the real cost begins, because everything it produced is opinion. The agent read the same stale documents everyone else reads, looked at the code it happened to be pointed at, and nobody can say whether the impact list is complete. So the meetings still happen, not to find the impact but to double-check the AI’s version of it. Sign-off still crawls, because putting your name under an unverifiable analysis is a career risk. The build proceeds on probably right, and the arguments about what was agreed still land in UAT.

There is a quieter tax too. The next change request starts from zero. Those days of AI investigation produce a disposable document, not accumulated knowledge. Every request re-derives the same understanding of the same system.

We tried to put numbers on this.

Coding was never the expensive part. In the classic phase studies it sits around 12 percent of a change, while avoidable rework runs at 40 to 50 percent of development effort, with unclear requirements named as a major cause. Put AI in every phase and the picture improves less than anyone expected. Analysis, development and testing get cheaper, and review and rework get more expensive, because the knowledge the AI needed was never recorded anywhere it could use. Reviewers report spending more time on AI code, 45 percent of developers say debugging AI output takes longer than writing it, duplication keeps climbing, and review pipelines could not absorb a mandated doubling of AI output. Our model puts today’s best case around 91 percent of the old cost. Eighteen points saved, nine handed straight back.

Why agents made it worse first

Part 1 readers know the mechanism. The documents and the system were always connected by people. In most companies, a conversation. An analyst rewrote a paragraph because a developer mentioned that reality had moved on, or because something broke. In the best companies, a formal gate. Every change through an analyst first, specification updated before the code. Accurate, and one of the most expensive processes in software.

Agents break both. They multiply the changes and never raise a hand, so the conversation goes quiet. And no gate staffed by senior people clears agent volume. What you get instead is the ritual you probably recognize, fast unverified analysis feeding slow human verification. A 2026 review of the evidence concluded that specification discipline, not model capability, is what limits how dependable AI-assisted delivery gets. And studies of LLMs in requirements work add the uncomfortable detail. Models produce plausible but wrong output when their context is wrong, and they won’t notice that your specification stopped matching reality.

The same request in the ADLC

Now run the same change request through a delivery that has a verified model of the system. Every requirement, rule, screen and interface is a statement, every statement is linked to the code that implements it, and every link is checked automatically.

The impact map exists in minutes. Not an agent’s essay about what might be affected. A query against evidence. These rules, these screens, these integrations, these owners, and whose sign-off that means. You know what the change costs before anyone commits to a date or a price.

Design happens against current truth. The analyst shapes the change in the model, not in a document that will start drifting the day it is approved. Business sees a prototype and approves the thing itself, not a promise wrapped in language. Approval starts meaning something again.

The work goes to agents as briefs. What to change, what must not change, what evidence to bring back. Scoped context instead of a repository and a prompt. Long-context research backs this. Even million-token windows are read unevenly, so the answer is better selection, not a bigger window.

Delivery closes the loop. The evidence comes back with the code, approved versus delivered becomes a comparison instead of a meeting, and the documents are current because they were never separate from the work.

Our model says a change request in this world costs around 30 percent of the classic one, with the knowledge waste removed. The re-deriving, the double-checking, the re-explaining. Treat that number the way we treat it, as a model to calibrate against your own change data, not a promise. The direction is what matters.

Analysts stop typing and start deciding

The people this changes most are the analysts. The gate the best organizations built keeps its authority and loses its bookkeeping. Tracing impact, updating paragraphs, chasing sign-offs, assembling context for engineers, all of that runs through the model. What stays with the analyst is the part that was always the actual job. Deciding whether the change is right.

How the model stays true

None of this works if the model rots the way the documents did. It doesn’t get the chance. Every merge request checks the statements it touches. What does this change affect, and does everything still hold. Drift gets caught in review, when it costs minutes to fix, and no one has to remember to mention anything.

Getting there

You don’t need a transformation program. One system is enough. Connect its statements to the code, with your existing documents as the seed. They make the model far richer than starting from code alone. Work through the discrepancies that surface, some harmless, some not. Then take the next real change request and run it through.

The regulator points the same way

If you run a bank or an insurer, there is a regulatory reason to care. The EU’s Digital Operational Resilience Act, DORA (no relation to the DevOps research program from part 1), has applied since January 2025 and expects you to keep a map of your ICT-supported business functions and the assets and dependencies behind them, reviewed at least yearly and after every major change. That map is the impact map. In the ADLC you produce it as a side effect of delivery instead of as a recurring project.

The head start won’t wait

Every quarter of agent-speed delivery makes the old routine more expensive, and the people who compensated for it retire, rotate and leave. And here is the encouraging part. In your organization, the picture already half-exists, in the documents you already paid for. Finishing it is a far shorter journey than the one everyone else has to make.