---
title: "Who Owns Quality When AI Writes the Code? | Speedscale"
description: "Software QA moved into feature teams, test tooling, and production. See why AI gives the VP of Engineering a reason to fund verification across teams."
canonical: "https://speedscale.com/blog/who-owns-quality-when-ai-writes-the-code/"
---

[Site index](https://speedscale.com/blog/llms.txt) | [Markdown](https://speedscale.com/blog/who-owns-quality-when-ai-writes-the-code/index.md) | [Canonical page](https://speedscale.com/blog/who-owns-quality-when-ai-writes-the-code/)

![A payment terminal prints two matching receipts for a single purchase.](https://speedscale.com/_astro/featured-image.KPw_bp_W_2m9BUq.webp)

# Who Owns Quality When AI Writes the Code?

Nov 17, 2026

[By Matthew LeRay](https://speedscale.com/blog/author/matt-leray/)

[AI/ML](https://speedscale.com/blog/category/ai/ml/) [DevOps](https://speedscale.com/blog/category/devops/)

* * *

A CTO asked the engineering team to use AI to double the number of pull requests merged per engineer. The company reached that target in the tenth month. What happened to the people reviewing those changes? The median reviewer approved roughly twice as many pull requests without leaving a comment. Reviews where they wrote a comment held steady at about three a month. [Read the longitudinal study of 802 developers and 196,212 pull requests.](https://arxiv.org/abs/2607.01904)

Sooner or later, a VP of Engineering looking at those numbers has to decide what to buy next. Another coding agent? More time from the senior engineer who already reviews the billing service? That decision reopens a question software companies thought they’d settled when they gave developers responsibility for testing their own code. Where does quality assurance belong?

For an organization running many services, our bet is on core engineering. Feature teams should own what their software does. But somebody with a budget that spans those teams needs to own the tools and environments they use to find out whether it works. The distinction matters most when an experienced tester spots something everybody else missed.

## Where the QA department went

The claim that software companies eliminated QA runs into an inconvenient figure. The U.S. Bureau of Labor Statistics counted 187,600 software quality assurance analyst and tester jobs in 2025. It projects 198,200 in 2035. Those numbers tell us people still do this work. They tell us very little about who can hold up a release. [U.S. occupational projections, row 15-1253.](https://www.bls.gov/emp/tables/occupational-projections-and-characteristics.htm)

What some companies deliberately eliminated was the handoff. Microsoft described feature teams where developers and testers worked in separate organizations. A developer could finish a change, hand it to a tester, and move on. Combining the roles meant the engineer who built the feature had to follow it through testing and into production. Atlassian took a different route. Its QA specialists coached developers in how to test, including how to look for problems neither the developer nor the specification had anticipated. [Microsoft’s engineering account](https://www.infoq.com/articles/devops-lessons-microsoft/) and [Atlassian’s guide to quality assistance](https://www.atlassian.com/inside-atlassian/software-QA-skills).

Some of the work also moved later. With a canary release, the team can send a small share of traffic to the new version and compare its error rate with the version everyone else is running. If the new version fares worse, the team can stop the rollout. A question someone once had to answer at a release meeting now has a measurement and an owner on call. [Google’s SRE workbook on canary releases.](https://sre.google/workbook/canarying-releases/)

Regression checks survived this transition particularly well. Once a check runs on every build, it can outlast the team that wrote it. Exploratory testing has a more precarious home. There’s no red light on the build when everyone forgets to ask the same question.

## Two passing tests and one customer charged twice

Imagine a forward-deployed engineer on a call with a merchant. Customers abandon checkout whenever the payment provider takes too long to reply. The merchant wants checkout to retry. Before the call ends, the engineer has a coding agent add a retry and write two tests. An ordinary charge succeeds. A request that times out succeeds on the second attempt. The merchant sees the demo and agrees that this is what they wanted.

A tester looking at that second test might ask, _When the request timed out, had the provider already charged the card?_ Both outcomes look identical to checkout. The difference shows up on the customer’s statement.

| What the provider did on the first attempt | What checkout saw | What the test must establish |
| --- | --- | --- |
| Never received the request | Timeout | A retry can complete the purchase. |
| Recorded the charge, then lost the reply | Timeout | A retry leaves exactly one settled charge for the purchase. |

The agent’s tests could pass because the mock represented only the first row. A second agent reviewing the patch could read the same ticket and make the same assumption. A senior engineer could catch it, provided they know the provider’s behavior and have time to inspect the mock. That’s an expensive piece of institutional memory to borrow on every change.

The billing team can turn the second row into evidence. Give a simulated provider a ledger. Have it record the first charge and then drop the reply. Let checkout retry. At the end, count settled charges against that purchase in the provider’s ledger. Try the check against the broken version first. Seeing two charges there establishes that the test can catch the bug. Once the fix is in, the same check should find one. A final HTTP 200 tells you much less. [How to exercise a dependency failure in isolation.](https://speedscale.com/blog/application-level-dependency-chaos-testing/)

## What AI changes about the investment

Software teams have needed realistic test environments for decades. AI changes how many people can put those environments to work. A customer-facing engineer can propose a fix during a call. An agent can try several implementations before the engineer’s next meeting. If each attempt still needs the one person who understands settlement to reconstruct the failure, that person’s calendar sets the pace.

The gap between writing code and shipping it also shows up in a larger study. A 2026 NBER working paper matched AI usage with activity from more than 500,000 GitHub developers. Across successive generations of coding tools, the authors estimated a cumulative increase of 240% in commits and 30% in releases. Releases still increased substantially. The study leaves open how much of the difference came from review, testing, or other work involved in shipping. It gives a VP a good reason to ask what happens downstream of an impressive commit count. [Writing Code vs. Shipping Code.](https://www.nber.org/papers/w35275)

Stripe offers a look at what a company can do with that investment. In February 2026, it reported merging more than 1,300 wholly agent-written, human-reviewed pull requests per week. Its coding agents worked in the same standardized development environments available to engineers. After an initial CI failure, an agent could use the feedback to try a fix. Stripe capped the loop and handed the branch back to a human after the second CI run. The company had already spent years building tests. It could give each new agent access to that accumulated engineering judgment on its first day. [Stripe’s account of its coding agents and CI.](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents-part-2)

## What the VP of Engineering should own

Go back to the merchant. Billing can justify fixing a duplicate charge. It will have a harder time justifying a quarter spent building a way for billing, fulfillment, and subscriptions to simulate a dependency that did the work and lost the reply. The expense lands on one team’s roadmap. The benefit shows up on three. That’s the decision that belongs under the VP of Engineering.

Give core engineering a specific remit. It should maintain disposable environments and realistic test data, give teams a way to reproduce dependency failures, and return a CI result that tells the author what happened. Put experienced QA practitioners in the design conversations. Someone who knows which failures customers actually experience should help decide what those environments need to reproduce. On a small team, a named engineer with time set aside can do this job. A new department can wait.

Keep the domain decisions close to the customer. Billing decides what counts as a settled charge. A tester and the merchant can explore what the customer sees while settlement is pending. The feature team decides whether to ship and answers the page if the change goes wrong. If billing has to file a ticket with core engineering every time it wants to run the scenario, the old QA queue has survived its reorganization.

A VP can test this idea with one incident before funding a platform. Pick a failure that took a senior engineer to diagnose. Ask a second team to reproduce it from a clean checkout, using the evidence and tools the first team left behind. Time how long it takes to see the original version fail and the fixed version pass. Record each point where somebody has to call the original investigator. Those calls tell you where an investment in shared verification could pay off. They also give you a baseline to revisit alongside review wait times and customer-reported regressions. [More on verifying AI-written code.](https://speedscale.com/blog/ai-writes-code-but-we-own-the-consequences/)

The next time a merchant asks for a retry, the engineer on the call should be able to run one purchase, drop the provider’s first reply, and let checkout retry. Then they can show the merchant exactly one charge in the ledger. The tester who first thought to ask about that lost reply might be on vacation. Their judgment is still on the call.

## Frequently asked questions

### What happened to QA when developers took over testing?

At Microsoft, some teams combined developer and tester roles so the engineer who built a feature followed it into production. Atlassian kept QA specialists who coached developers in testing. Both approaches reduced handoffs and gave teams a way to use a tester's judgment earlier.

### Who should own quality when a coding agent writes the change?

The feature team should define what customers expect, decide whether to release, and respond if the change fails. Core engineering should give teams realistic environments and repeatable tests. The VP of Engineering can fund that shared work when its benefits reach across several teams.

### Why can a payment retry pass its tests and still charge someone twice?

A timeout tells checkout that it missed the reply. The provider may already have recorded the charge. To test that case, have a simulated provider record the charge and drop the reply. Let checkout retry, then count the charges for that purchase in the provider's ledger. There should be exactly one.

### How can a VP tell which testing tools are worth funding?

Pick a recent incident and give a second team the evidence and tools the first team used. Time how long it takes them to reproduce the failure and verify the fix. If they have to call the original investigator, ask what that person supplied. A reusable test fixture or a way to simulate a missing reply may be enough.

## Table of Contents

## Ship AI-generated code with confidence

AI writes fast but doesn't know your production environment. Speedscale replays real customer traffic against AI-generated changes and tells you whether the build is ready before it reaches users.

[See how it works](https://speedscale.com/features/ai-code-verification/) [Get started](https://app.speedscale.com/signup)
