- Subject
- Microsoft 365 & SharePoint
- Filed
- Source
- IPWITHEASE
- Loans
- 868
AI Engineering Gains Depend on Testing, Review and Delivery Controls
AI use is widespread, but faster delivery can come with stability costs. Teams should start with measurable tasks and keep human approval at key stages.

AI coding tools are common across software teams, but access alone doesn’t show whether they improve delivery. The practical question for engineering leaders is where assistance saves time, what extra review it creates, and whether the code remains stable after release.

Google Cloud’s 2025 DORA poll of 5,000 IT professionals found that 90% use AI at work, up from 76% the previous year. The 2025 results linked AI adoption with higher software delivery throughput, reversing the prior year’s finding. They also found a negative relationship with delivery stability: teams may ship more while experiencing more failures. Roughly 30% of respondents said they had little or no trust in AI-generated code, despite using it daily.
A separate result shows why adoption figures don’t settle the question. METR ran a randomised controlled trial with 16 experienced open-source developers completing 246 real tasks in repositories they already knew. The developers expected AI to make them 24% faster, but took 19% longer. Researchers attributed the result to familiarity with the code, repository complexity, and time spent prompting and reviewing AI output. It describes that specific setting; it doesn’t establish that AI slows every team or task.
Put AI into the delivery process
AI-accelerated engineering treats assistance as part of the delivery pipeline, spanning discovery, implementation, testing, review and release. Ad hoc use puts the emphasis on each developer’s editor and individual prompts. A pipeline approach instead shares architectural patterns, API contracts and test standards, and defines checkpoints where people review or approve work.
That difference changes what teams measure. Lines of generated code and acceptance rates can show tool activity, but they don’t establish better delivery. Cycle time, change failure rate and review workload connect AI use to outcomes that matter after a merge. Defined gates can also catch defects before code is merged, rather than leaving teams to discover them later.
AI tends to help most when the work is well specified and inexpensive to verify. Drafting user stories, edge cases and acceptance criteria can speed up an initial requirements pass, while a product owner still decides scope and priority. AI can generate an API contract from a selected architectural pattern or flag inconsistencies, but an architect remains responsible for the design choice and sign-off.
Implementation results depend on the codebase. Boilerplate, CRUD operations, data mapping, migrations and SDK glue are often suitable for assistance, particularly in new or unfamiliar code. In mature repositories, the gain may be smaller. The engineer who owns the change still needs to understand it and take responsibility for the merge.

Start where results are easy to check
Testing and documentation stand out as practical early uses. AI can draft unit and integration tests, fixtures and suggestions for coverage gaps. A QA lead should check what those tests actually assert: more test code doesn’t automatically mean better coverage. Documentation, runbooks, onboarding material and changelogs can also be produced quickly, but the owner needs to verify that they match current behaviour.
AI can make a first pass over code for obvious defects and inconsistent style, which may reduce reviewer workload. A human reviewer still approves each merge. For legacy systems, AI can help explain unfamiliar code and map dependencies, supporting onboarding. Surgical changes to an inherited system call for closer validation by a senior engineer before any refactor.
The pattern is consistent: assistance is most useful where human context is limited, such as a new service or inherited system. It may add less value where experienced engineers already know a mature codebase well. Teams should treat that variation as a reason to choose pilot work carefully, not to assume the same result across every repository.
Keep human decisions and evidence in the pipeline
Four areas need clear human ownership. Engineers must choose architecture with maintenance costs and trade-offs in mind. Every merge needs an accountable owner who understands the change and can address problems. Developers also need to check generated code for security issues and verify that referenced dependencies exist. In payments and financial services, teams may need a record of who approved important actions and why.
For teams working under PCI DSS, PSD2, scheme certification criteria or the EU’s Digital Operational Resilience Act, traceability matters alongside the code itself. Approval gates, sign-offs and audit trails can record how changes progressed through the delivery process. The practical requirement is evidence that shows who reviewed and approved work, rather than relying on an agent’s output without a review path.
Roll out in measured stages
Establish a baseline before changing the workflow. The rollout sequence described here captures cycle time, change failure rate, time to restore and review turnaround for at least one full quarter. That gives teams a reference for judging whether later changes improve delivery or shift work into review and rework.
Next, pilot tasks with cheap verification, such as test generation, documentation and first-pass review. Before expanding, give agents shared project context: architectural patterns, API contracts, naming conventions and testing standards. Then define which steps need human approval, who provides it and what evidence the pipeline records.
Expand one stage at a time and watch stability. If the change failure rate rises, pause expansion and revisit the relevant gate. A rollout that increases output while leaving teams unable to review or test it can undermine the delivery gains it was meant to produce.
Measure delivery outcomes, not generated volume
Cycle time from first commit to production is a headline measure of speed, and it can be affected by how approval gates are designed. Change failure rate tracks stability and helps teams decide whether a rollout is ready to expand. Review turnaround and reviewer load show where AI review saves effort and where it adds work.
Teams can also track defect escape rate by stage to see whether gates catch problems, onboarding time for new engineers to assess support on unfamiliar systems, and the share of delivery time spent on rework. Time to restore service provides another view of operational impact. Taken together, these measures make it easier to distinguish useful acceleration from a rise in generated code that requires substantial correction.
Two measures make a useful starting pair: cycle time and change failure rate. Faster delivery alongside stable failure rates offers stronger evidence of a process improvement than output volume alone. METR’s difference between expected and observed performance is also a reminder that developer impressions can be misleading; compare results with the baseline.
What effective teams have in common
Teams seeing results focus on pipeline design, not just the number of tool licences. They pilot on unfamiliar code, invest early in testing and documentation, and maintain a shared reference for project conventions. They also adapt review practices to the amount of code being produced, so added volume doesn’t outrun the team’s ability to assess changes.
For engineering leaders, the useful next step is a bounded pilot with clear baseline measures, a task that is inexpensive to verify, and a named human owner at each approval point. Expand only when delivery measures show that the workflow is helping without eroding stability.