What developers and QA need from each other when AI writes the code Google's 2025 DORA report, based on a study of nearly 5,000 technology professionals, found that teams adopting AI deliver more software while delivery stability — how often changes fail in production or need unplanned fixes — gets worse. The report's findings are being applied to the development-to-QA handoff, where AI-generated edits to shared components arrive faster than anyone documents their dependencies, as in a case where a small change to a shared component passed code review and green tests but broke the background step converting a subscription purchase into working access, caught only by live-system log alerts. The recommended fix is a written handoff and sign-off contract covering affected components, dependent services, changed interfaces, open items and required evidence at each gate, with QA testing from approved requirements before reading the code. The change was a small edit to a shared component. It passed code review and QA; the tests were green and the code did what the ticket asked. When a customer purchased a subscription and closed the browser, the system normally turned that order into working access in the background. The change, however, broke that step. An alert from the live system’s logs caught the failure that QA and the code reviewers did not. The tests weren’t what failed. The handoff was. No one had documented which other services used that component, or in what order they had to change. Developers’ work and QA’s work come together at the handoff. AI strains that handoff by multiplying changes like this one: small edits to shared code, arriving faster than anyone documents their dependencies. DORA’s 2025 study https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report of nearly 5,000 technology professionals found that teams adopting AI deliver more while their delivery stability, meaning how often changes fail in production or need unplanned fixes, gets worse. A green build tells you the code passed its own tests. But those tests were usually written from the same reading of the ticket as the code, so they agree with it by design. A release you can defend to the business needs proof from outside the change, and the handoff decides whether that proof arrives. In most delivery teams I work with, the handoff from Development to QA is a ticket changing status and not much else. Architecture, Development, QA and Product all need to agree on the minimum context and evidence that should accompany every change. That agreement becomes the handoff and sign-off contract. The contract defines what the change should do, in pass-or-fail terms. It names the affected components, dependent services and changed interfaces or data contracts. It lists the open items unresolved questions, unfinished agent work and defines the evidence required at each gate and who can accept the residual risk. During the review, an AI requirements reviewer https://www.cio.com/article/4207438/the-code-review-crisis-and-how-you-should-rebuild-review-models.html reads the ticket and checks that the code meets its promises. QA independently assesses whether what the ticket asked for is safe to release, which involves checking whether the specifications were right and whether the system around the change still works. The communication is reciprocal. QA needs to provide Development with a release signal that differentiates product defects from noise in tests and the environment. QA also needs to call out any missing evidence and say which parts of the handoff helped. That feedback goes into the contract, the test strategy and the automation rules for the next change. QA has to know what “correct” is before it looks at the code. That comes from the ticket, as approved scope and acceptance criteria that can each be marked pass or fail. The tests that come with a change usually rest on the same reading of the requirements as the code, so they confirm the code’s own narrative. Take a ticket that states a subscription is canceled at the end of the paid period. QA will write tests based on that statement. If QA instead writes them from the finished code, and the code cancels immediately, those tests confirm that behavior as correct. This is why testing from the requirements should come first. Then, QA compares two maps. One map shows what the ticket requested, the other what the handoff says was touched. Even if the ticket didn’t mention it, a redeployed shared service belongs on the second map. If dependent services haven’t been updated, or extra work hasn’t been declared, the change is incomplete. Services that are just along for the ride widen the test plan. Reading the code still matters later for diagnosis, such as stabilizing a test that keeps failing with no product defect behind it. Not every change an AI makes requires the same level of proof. Three things make one change much harder to prove than another: whether the code is new or old, how much of the feature the AI generated and how much freedom the tools were given. Real tasks involve a mix of all three. The easy side is a minor new feature where the engineer still has control of the tools and the quality checks are already in place. The hard side is a major change to an older system that was built with very little supervision, where the context must be rebuilt, so the same change costs more to prove. In that case, proof might require contract tests, integration checks, security or performance evidence and explicit human sign-off. How much proof you need depends on the business impact and the blast radius, meaning how much else the change can take down. Our small edit showed this when it broke the step that gives a paying customer working access. Teams collect proof at different checkpoints, like finished tests, completed reviews and checked requirements. The closer you get to release, the higher the bar. And the handoff carries what the next stage would otherwise have to rebuild. We log each test as a pass or a fail. If a team starts a test but can’t finish it, we mark it as blocked. If we never ran it, we leave it empty. Blocked and empty show where the proof is missing, and so a green build can’t pretend that every test passed. Confidence per unit of time is how quickly a team can turn a change into a release decision backed by proof. It equals evidence completeness divided by validation lead time, counted only after completeness clears the threshold set for that risk class. Completeness is the share of required evidence items recorded as passed or failed for that risk class, so blocked and empty items don’t count. Validation lead time runs from when a change is ready for review to the recorded release decision. Faster validation is not an improvement if completeness falls. Take our own change. The build was green, but the checks on the dependent services were empty, which would have meant low completeness and an unfinished release. Empty checks are common. A Tricentis-commissioned 2026 Quality Transformation survey https://www.tricentis.com/news/2026-quality-transformation-report of 2,501 IT and QA professionals found that 60% of organizations report deploying untested code to production. As changes multiply, raw counts mislead. If your throughput doubles and your escaped defects go up by half, quality improved, even though a raw count reports a regression. You only need seven signals to get going. Change failure rate stays as it is, and the other six are read as rates or durations. Escaped defect rate is production defects as a share of all defects found. Next comes the share of those escapes rated critical. Validation lead time, defined above, is a segment of DORA’s lead time for changes. The non-product failure rate is test or environment failures as a share of all failures. Sixth is rework on generated code inside a fixed window, such as two weeks after acceptance. Evidence completeness is the one measure with no parent in the standard set, and it uses the four states from the previous section. Then add two pieces of context: build speed and how often a person has to step in, and make three comparisons: build speed against validation lead time; escaped defects against their severity and change failure rate; rework against non-product failures and human intervention. Expect a dip at first. DORA’s ROI of AI-assisted software development https://cloud.google.com/blog/products/ai-machine-learning/how-to-measure-the-business-value-of-generative-ai research describes the early path as a J-curve: a temporary productivity dip and a period of instability while teams pay what it calls a verification tax, the extra time spent reviewing generated code as volume rises. McKinsey’s 2026 State of AI survey https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai found that nearly three-quarters of AI high performers had fundamentally redesigned workflows, compared with roughly a quarter of other respondents. Redesign doesn’t have to start everywhere. One real delivery path is enough. Before the next AI-generated change hits that path, the four functions need the handoff and sign-off contract in place. They should measure the handoff against its own baseline and then watch whether checking keeps up with generating. They can give AI tools more freedom only when confidence per unit of time improves and delivery stability holds. QA is moving from re-running the obvious checks to designing the proof. Development is producing changes the next stage can confirm on its own. Neither role should be evaluated by the number of bugs found. If you’re accelerating your coding without accelerating your proof, then AI will just help your team reach its next bottleneck faster.