Software QA is not dead; its work has moved. Testing now happens throughout development, with developers checking their code, automated systems checking each...
Is QA Dead? What Software Testing Means in the Age of AI
Software QA is not dead; its work has moved. Testing now happens throughout development, with developers checking their code, automated systems checking each change, and QA specialists tackling harder risks. AI-generated code makes that work more urgent, not less, because fast code changes can spread defects just as quickly.
I’m Ermenildo Castro, a Filipino software engineer who has worked at large technology companies and now lives in Seattle. I’ve seen the same argument recur: one group says testing belongs to every developer, while another warns that shared responsibility can become nobody’s responsibility. Both concerns are real. The answer is to make ownership explicit, choose tests that match the risks, and treat quality as part of building software—not a final inspection at the door.
That distinction matters more as AI coding assistants increase the pace of change. A test written in seconds can be useful, or it can simply repeat the code’s mistaken assumptions. The question is not whether a team uses AI or hires QA engineers. The useful question is whether people can trust the software when it reaches them.

What Is Software Testing and QA?
Software testing is the practice of checking whether a program behaves as expected. A test might check that a button saves a form, that a payment is not charged twice, or that a service stays responsive when many people use it. Tests can be run by a person, a script, or a mix of both. They can focus on one small piece of code or on a full user task.
Quality assurance (QA) is broader. It includes testing, but it also includes the decisions and working habits that help a team prevent defects: agreeing on clear requirements, reviewing code, managing changes, and learning from failures. Testing asks, ‘Does this work in this case?’ QA also asks, ‘What in our process makes this kind of failure more or less likely?’ Companies do not always use the terms consistently. A job called QA engineer may focus on manual checks at one company and test systems, automation, and coaching at another.
A useful way to see the range is through common test types:
- Unit tests check a small function or component, usually in isolation. Developers often write them while building that code. The Microsoft guide to unit-testing practices covers useful habits such as keeping tests focused and repeatable.
- Integration tests check that connected pieces work together, such as an application and its database.
- End-to-end (E2E) tests follow a complete workflow through the application, from a user’s action to the result.
- Regression tests rerun checks after a change to catch older behavior that has broken.
- Performance and load tests measure how software responds to normal and heavy demand.
- Exploratory testing gives a person room to try unusual paths and notice confusing behavior that no one thought to write a test for.
These tests have different costs and strengths. Martin Fowler’s practical test pyramid explains why teams often benefit from many small tests, fewer integration tests, and a smaller number of broad E2E checks. The point is not to follow a diagram blindly. It is to avoid asking slow, fragile tests to do every job.
The old picture of QA as a line at the end of development no longer fits many teams. Quality work happens during design, code review, testing, release, and support. At the same time, a passing test does not prove that a product is good. A test can be wrong, incomplete, or aimed at an unimportant detail. Frankly, counting green checks is easy; knowing whether they protect real users takes judgment.
Core Benefits and Why QA Still Matters
Quality work is not paperwork added to the ‘real’ engineering. It helps a team ship useful changes without asking users to absorb every mistake. I’ve watched teams move faster after they made tests more reliable—not because they wrote the largest suite, but because engineers could trust its warnings and act on them quickly.
The main benefits are practical:
- Fewer defects reach users. A small test can catch a wrong calculation before it affects a bill or a report. Testing is especially important when errors can cost money, expose private data, or block access to a service.
- Changes become safer. Regression checks give developers a quick signal when a new feature breaks an older one. That makes it easier to improve software without treating every release as a gamble.
- Teams learn what they are building. Writing a test can expose unclear rules. If two engineers disagree about what should happen when a user submits an empty form, the disagreement is a design issue—not merely a testing issue.
- Failures are easier to diagnose. A focused test often points to the part of the system that broke. A large, slow test may only say that something failed somewhere.
- People can spend time on judgment. Automation can repeat known checks, leaving human testers more time to look for confusing steps, surprising combinations, and problems that requirements missed.
- Releases earn trust. Users rarely see a test suite. They do notice when a product loses their work, charges them twice, or fails during a busy hour.
At a large engineering organization, I saw the cost of testing treated as a real design choice. A service change could look small in a code review yet touch a shared dependency used by many teams. The useful question was not simply, ‘Did the author add tests?’ It was, ‘What could this change break, who would notice, and how would we know?’ That question led to better checks than a blanket rule about test counts.
QA work also protects the dignity of people doing and using the work. A broken system can waste a customer’s afternoon or push unnecessary cleanup onto a support worker. Engineers have a responsibility to consider those costs. That does not mean every low-risk feature needs an elaborate testing program; it means the effort should fit the harm a failure could cause. Here’s the kicker: a team can release quickly and carefully when it spends its effort where risk is highest.
A Step-by-Step Guide to Testing in a Modern Team
There is no single test plan that fits every product. A banking service, a game, and an internal scheduling tool have different risks. Still, a clear sequence helps teams make good choices without turning testing into a separate phase that starts after the work is done.
- Name the user need and the risk. Write down what should happen, who depends on it, and what a failure would cost. Include less common cases, such as a slow network, missing data, or a user repeating an action. In one project I worked on, a feature seemed straightforward until we asked what happened when a request was sent twice. That simple question changed what the team needed to test.
- Choose the right level of test. Use a unit test for a small rule or calculation. Use an integration test for the connection between a service and its storage. Use an E2E test when the important question is whether a real user can finish a workflow. Do not make every check an E2E test; those tests can be slower and more sensitive to changes in the interface.
- Make expected behavior clear. Tests need an answer they can compare with the result. For ordinary software, that might be an exact value, a saved record, or a displayed message. For AI features that produce varied answers, it may be more useful to check rules such as correct citations, privacy limits, or whether the response stays within a safe range. If the team cannot explain what a good result means, adding tests will not settle the question.
- Put ownership near the work, and name the gaps. Developers should usually write and maintain unit tests for the code they change. QA or test engineers can help set up shared test tools, review risk, build E2E coverage, and test unusual cases. Make the handoff clear: who decides which tests are needed, who fixes a failing test, and who can stop a risky release? Shared responsibility only works when each task has an owner.
- Run checks automatically when code changes. A continuous integration (CI) system can run fast tests on each change and broader tests at suitable stages. A useful continuous integration practice keeps changes small and gives teams quick feedback. Do not make every slow test block every small edit if a safer, faster path is possible—but do not hide important failures either.
- Check the tests themselves. A test that fails for no real reason wastes time and trains people to ignore warnings. Track flaky tests, investigate the causes, and fix or remove unreliable checks. Google’s report on flaky tests describes why repeated, inconsistent failures create a serious reliability problem.
- Learn from releases and incidents. When a defect reaches users, ask why the existing checks missed it. Add a test when it would catch the same failure again, but also examine unclear requirements, risky release steps, and weak monitoring. Testing cannot prevent every defect; the team should still be able to spot trouble and recover.
This process does not require a separate QA department. It does require people to agree on what quality means for their product. I’ve seen automation create a false sense of safety when a team treated the test report as the whole story. The stronger approach is to combine repeatable checks with human review, production signals, and honest conversations about risk.
AI tools fit into this process as assistants. They can propose a first draft of a test or group similar bug reports, but a person still has to check whether the result matches the actual requirement. NIST’s Generative AI Profile provides a broader risk-management framework for teams using generative AI. The practical lesson is simple: keep people responsible for decisions that affect users.
Comparison: Dedicated QA-Led Testing vs. Developer-Led Testing
These approaches are not enemies. Many teams do both, and that is usually healthier than picking a side. The comparison is useful because it shows where ownership tends to sit and where a team may need more support.
| Area | Dedicated QA-led approach | Developer-led, shift-left approach |
|---|
| Main focus | Independent checks, test planning, exploratory work, and release confidence | Testing code while it is being built, especially units and service connections |
| Typical owner | QA or test engineers, often working with developers | Developers who change the code, with QA guidance as needed |
| Strong point | A separate perspective can reveal missed assumptions and confusing user flows | Fast feedback helps catch mistakes close to where they were introduced |
| Common risk | Testing becomes a late handoff and can delay fixes | Testing gets rushed or overlooked if no one owns broader quality work |
| Best use | Complex workflows, usability, cross-system checks, and risk review | Small, repeatable checks that run frequently in development and CI |
| What it needs | Clear access to requirements, test environments, and engineering support | Time, test skills, useful tools, and agreement on who handles broader risks |
Shift-left means bringing checks earlier into development. It does not mean moving every task onto developers and removing independent testing. In my experience, that misunderstanding causes trouble: a developer may know the intended design so well that they test the path they meant to build, not the confusing path a new user might take.
A dedicated QA group can also struggle if it is asked to test a finished feature on a tight deadline without a say in its requirements. Meanwhile, developer-led testing can miss product-wide issues if people only check their own small changes. The answer is a working partnership. Developers write quick, close-to-the-code checks; test specialists improve shared tools, test complete workflows, and challenge assumptions; product and support teams help identify what users actually need.
The balance should follow risk, not job titles. A low-risk text change may need only a quick check. A change to account access or payment handling deserves deeper review and stronger monitoring. No org chart can replace that conversation.

Common Quality Mistakes to Avoid
Most teams do not fail because they never heard of testing. They fail because they turn a helpful practice into a ritual. I’ve seen test counts rise while confidence stayed low, and I’ve seen teams ship safely with a smaller set of checks because they knew what those checks covered.
- Treating code coverage as proof of quality. Coverage shows which code ran during tests. It does not tell you whether the tests checked the important outcomes. A test can execute a line and never question whether its result is correct. Use coverage to spot areas with no checks, then review whether the checks matter.
- Making QA the last stop. If a test specialist sees a feature only after it is finished, a major flaw may require expensive rework. Bring testing questions into design and planning. That does not mean writing every test before code; it means agreeing on important behavior early.
- Automating every manual check. Some repeated checks are good candidates for automation. A one-time exploratory session, a visual judgment, or a new product flow may need a person first. Automate stable, valuable work; do not build a fragile script just to claim that it is automated.
- Ignoring flaky tests. When a check fails randomly, people rerun it and carry on. After enough repeats, they stop trusting the whole suite. Record the failure rate, find causes such as timing or shared test data, and give the issue an owner. The Google discussion of flaky tests is a useful reminder that unreliable signals have a real cost.
- Assuming AI-generated tests are meaningful. A tool can produce polished-looking tests that only restate the code’s current behavior. Ask whether the test would catch a plausible mistake, whether it covers a user need, and whether its expected result is sound. AI can speed up a draft; it cannot certify that the draft matters.
- Tracking numbers no one can act on. Defect counts, coverage, and speed can all mislead when used alone. A metric should help the team choose a next step, not shame an individual or make one team look busy. In my experience, disagreements about what the numbers mean can be as damaging as missing tools.
- Leaving ownership vague. If everyone is supposedly responsible for a test but no one repairs it, the test will rot. Assign clear owners for test code, environments, failures, and release decisions. Ownership is not blame; it is a way to make sure important work gets done.
A useful quality scorecard balances leading signals and real outcomes. Teams commonly track defect escape rate—how many defects reach users—alongside test coverage, mean time to detect, mean time to resolve, and flaky test rate. None is a perfect measure. Read them together, ask what changed, and connect them to user impact. A chart is not a plan.

Frequently Asked Questions
Is the QA engineer role disappearing as developers write more tests?
The role is changing more than disappearing. Developers increasingly write unit and integration tests as part of their work, but teams still need people who can build test systems, review risk, test whole user workflows, and explore cases that were not planned. Some companies combine those tasks under quality engineering; others keep a dedicated QA group. The job title matters less than whether the work has a clear owner. If a company removes manual test execution but does not invest in automation, product thinking, and exploratory testing, it may simply create a new quality gap.
Can AI replace software testers?
Not reliably. AI can draft test code, suggest edge cases, summarize failing results, and group similar bug reports. A person still needs to check whether a suggested test matches the requirement, whether the result is safe, and whether the test will catch a meaningful failure. AI systems can repeat the assumptions in the code or produce tests that pass without checking the risk that matters. They also cannot decide on behalf of a product team how much harm a failure could cause. Use AI to reduce tedious work, not to remove human responsibility.
What is the most important software quality metric?
There is no single metric that tells the whole story. Defect escape rate is useful because it focuses on bugs that reach production, but it should be read alongside how quickly the team detects and fixes issues. Coverage can show where tests are missing; it cannot prove the tests are strong. Flaky test rate shows whether automated checks are trustworthy. Pick measures that help your team improve a real outcome, and avoid turning them into a target that can be met while users still have a bad experience.
Should every team have a dedicated QA department?
Not always. Team size, product risk, rules, and the nature of the software all matter. A small team can share quality work if developers have time and skills to test their changes, and someone owns broader checks. A large service with complex user flows may benefit from dedicated test engineers who build shared tools and test across team boundaries. The important thing is not a particular org chart. It is making sure that test infrastructure, user-facing checks, exploratory work, and release decisions are covered.
Final Thought
The useful question is not whether QA is alive. It is whether a team can explain how it knows its software is safe enough to release, what it still does not know, and who will respond when something goes wrong. Testing should help people answer those questions without hiding behind a green dashboard or an impressive coverage number.
In my work at Google, Microsoft, Amazon, and Zulily, I learned that good engineering depends on more than clever code. It depends on people taking care with the work entrusted to them and making room for others to raise concerns. That is true whether a test comes from a developer, a QA engineer, or an AI assistant. Tools can speed up the work; responsibility still belongs to people.
I’m Ermenildo Valdez Castro, Jr. The best quality practice I know is plain: understand who could be hurt by a failure, test the risks that matter, and listen when the evidence says your assumptions were wrong. That is not glamorous. It is how trust gets earned, one release at a time.
FAQPage Schema
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "Is the QA engineer role disappearing as developers write more tests?",
"acceptedAnswer": {
"@type": "Answer",
"text": "The role is changing more than disappearing. Developers increasingly write unit and integration tests, while teams still need people to build test systems, review risk, test user workflows, and explore unplanned cases. The title matters less than clear ownership of the work."
}
},
{
"@type": "Question",
"name": "Can AI replace software testers?",
"acceptedAnswer": {
"@type": "Answer",
"text": "AI can draft tests, suggest edge cases, summarize failures, and group bug reports, but people must check that tests match requirements and cover meaningful risks. AI should reduce tedious work, not remove human responsibility."
}
},
{
"@type": "Question",
"name": "What is the most important software quality metric?",
"acceptedAnswer": {
"@type": "Answer",
"text": "No single metric tells the whole story. Defect escape rate, detection and resolution time, test coverage, and flaky test rate each provide different signals. Choose measures that help improve outcomes for users."
}
},
{
"@type": "Question",
"name": "Should every team have a dedicated QA department?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Not always. Team size, product risk, and software needs matter. Teams can share quality work if test infrastructure, user-facing checks, exploratory work, and release decisions all have clear owners."
}
}
]
}