Is QA Dead? What Software Testing Looks Like in the Age of AI
Software testing checks whether software behaves as intended; quality assurance also shapes the habits and systems that prevent defects. Neither belongs only to a final test phase anymore. In modern teams, developers, QA engineers, automated pipelines, and AI tools share the work, but people still decide what quality means.
I’m Ernie Castro, a Filipino software engineer in Seattle. Across large engineering organizations, I’ve seen teams argue about testing as though they must choose between speed and care. That is a false choice. A team can ship quickly and still take responsibility for the people who rely on its software. The hard part is making quality work visible, useful, and shared—without turning every change into a mountain of paperwork.

What Is Software Testing and QA?
Software testing is the act of checking software against expected behavior. A test might ask whether a button saves a form, whether a service handles a burst of requests, or whether a change broke a feature that worked yesterday. Tests can run at different levels, from a single function to a complete user workflow. They can also be automated or performed by a person.
Quality assurance (QA) is broader. It includes testing, but also the processes, tools, design decisions, and team habits that help prevent defects in the first place. A useful distinction is this: testing looks for evidence about a product; quality assurance improves the way the team builds that product. In everyday conversation, people often use QA and testing as if they mean the same thing. Job titles make the confusion worse.
A QA engineer at one company might spend most of the week running manual test cases. At another, the same title might mean designing test frameworks, improving build pipelines, or helping teams plan how to verify a feature. Some organizations use the title quality engineer to signal that broader scope. The job description matters more than the label.
The old picture of testing is simple: a developer finishes the code, then another person checks it against a list. That can still be useful, but it is a poor model for many software teams. Features change often, services depend on one another, and software may use machine-learning systems that produce valid variation rather than one fixed answer. A test that expects the same exact wording every time could fail even when the product works correctly.
I’ve seen teams treat a green test run as a promise that the feature is safe. It is not. A test only tells you what its author chose to check, under the conditions it ran. A good quality practice asks a wider question: does the software serve users reliably, and can the team detect and correct harm when something goes wrong?
Testing also has several common forms:
- Unit tests check small pieces of code, usually in isolation.
- Integration tests check whether connected components work together.
- End-to-end (E2E) tests exercise complete workflows through an application.
- Regression tests check that earlier behavior still works after a change.
- Performance and load tests examine response and stability under expected or heavy traffic.
- Exploratory testing uses human judgment to probe unusual cases, confusing interactions, and behavior no one thought to script.
These types are not competing philosophies. Each catches a different class of problem. The practical question is which mix gives a team useful feedback at a reasonable cost.
Why Software Testing Still Matters
Testing matters because software failures cost real time and trust. A broken checkout can block a purchase; an incorrect payroll calculation can affect someone’s rent; an outage can keep a patient or customer from getting help. Quality is not an abstract score. It affects people who may never know which team wrote the code.
Here are the main benefits I see when testing is treated as part of engineering work rather than a release chore:
- Earlier feedback. A small test that fails while a developer is changing a function is usually easier to diagnose than a production incident days later. The code and the reason for the change are still fresh.
- Safer change. A dependable regression suite gives a team evidence that important old behavior still works. It does not eliminate risk, but it can make a change less like stepping into a dark room.
- Clearer design. Writing a test often reveals that a component has too many responsibilities or depends on hidden setup. That is useful information, even before the test catches a defect.
- More predictable releases. Automated checks can give every code change the same basic scrutiny. That consistency matters when several developers are working in parallel.
- Better teamwork. Shared examples of expected behavior can reduce arguments between product, engineering, and QA. A test cannot settle every product question, but it can expose where people disagree.
- Faster recovery. Monitoring and a clear path to reproduce failures help teams find and fix problems sooner. Testing is one part of that broader response system.
Frankly, a pile of tests is not automatically a quality practice. I have seen a team celebrate a high coverage number while its tests checked only that code ran, not that it produced a correct result. That kind of measure can soothe a dashboard without protecting a user. Meaningful assertions and risk-based choices matter more than a vanity percentage.
Tests also support responsible stewardship of engineering time. A small amount of careful work before release may prevent a larger, more painful repair later. That does not mean every corner case deserves an expensive automated test. It means the team should spend its effort where failure would hurt most, explain that choice, and revisit it when the product changes.
A practical testing strategy uses several layers. The test pyramid explained by Martin Fowler describes the value of having many fast, focused checks and fewer broad, slower ones. Google’s discussion of why teams should avoid simply adding more end-to-end tests makes a related point: more tests do not help much if they are slow, fragile, or poorly targeted.
How to Build Testing into the Development Process
A useful process does not begin with a tool purchase. It begins with the risks a feature creates and the evidence a team needs before releasing it. Here is a practical way to build that process.
- Describe the behavior that matters. Write down what a user should be able to do, what must never happen, and which unusual conditions are important. Keep the description plain. If product and engineering cannot agree on the expected result, an automated test will not resolve the disagreement by magic.
- Rank risks before writing a long test list. Consider the impact of failure, how often the feature is used, and how hard a problem would be to notice. A payment calculation deserves different scrutiny from a low-risk decorative animation. I have found that asking what would harm a user first helps teams spend testing time more sensibly.
- Choose the smallest useful test level. Check calculations and rules with unit tests when possible. Use integration tests for boundaries such as databases, message queues, and service calls. Reserve E2E tests for workflows where the connection between multiple parts of the product is the thing you need to verify. This keeps feedback quicker and failure causes easier to locate.
- Put checks close to code changes. Developers should normally add or update unit and integration tests as part of a code change. A pull request can show the new behavior, the test that covers it, and the result from continuous integration (CI). QA specialists can help teams choose coverage, review the test design, and build tools that developers can use without wrestling with them.
- Run a dependable CI pipeline. Start with fast checks that give quick feedback, then run slower suites where they make sense. Keep test data and environments stable. A test that fails intermittently for unrelated reasons teaches developers to ignore failures—a dangerous habit. Track flaky results and repair the causes instead of repeatedly clicking rerun.
- Include human exploration. Automation is good at repeating known checks. People are better at noticing a confusing label, an odd workflow, or a strange combination of events no one predicted. Ask testers to explore around the feature’s purpose, not just follow a script. Record useful findings so the team can decide whether a new automated test would prevent a repeat.
- Review results, not just totals. Look at failures, escaped defects, time to detect and resolve issues, and trends in test reliability. Code coverage tells you which lines ran during a test; it does not tell you whether the test would catch a wrong answer. Use metrics to start a conversation, not to rank people.
- Learn from production. Use logs, monitoring, customer reports, and incident reviews to find holes in the test plan. When a defect reaches users, ask how it passed through the system and what would have caught it earlier. Do not turn the review into a search for someone to blame. The goal is a better system and a fairer outcome for users.
I have watched a team improve its release confidence simply by making failures easier to understand. The breakthrough was not a shiny testing product. It was a clear owner for each failing check, a short path to reproduce it, and permission to fix flaky tests instead of treating them as background noise. That is unglamorous work. It pays off.
For teams building software with AI support, these same steps still apply. The NIST Secure Software Development Framework emphasizes building security practices into the development life cycle rather than saving them for a final inspection. The broader lesson holds for quality too: define expectations, test important behavior, and improve the process as evidence arrives.

Manual Testing vs. Automated Testing
Manual and automated testing are often framed as rivals. That framing is too neat. They solve different problems, and a healthy team uses both where each makes sense. Automated checks repeat known steps quickly. Human testers explore behavior with judgment and can notice friction that a script cannot describe.
| Area | Manual testing | Automated testing |
|---|
| Best suited to | Exploratory checks, usability, new or unclear behavior | Repeated checks, stable rules, regression protection |
| Feedback speed | Depends on the tester and task | Often fast after the suite is built; slower for broad E2E tests |
| Repeatability | Can vary between people and sessions | Consistent when the test and environment are reliable |
| Setup cost | Lower for a one-off check; ongoing staff time | Higher initial design and maintenance effort |
| Main risk | Important steps may be missed or repeated inconsistently | Brittle tests, weak assertions, and maintenance burden |
| Human judgment | High | Limited to the choices encoded in the test |
Automation is valuable when a check must run often and has a clear expected result. A calculation that can be wrong in a specific way is a strong candidate. A new screen whose labels and flow are still under discussion may benefit more from a person exploring it first. Automating an unclear requirement can freeze confusion into code.
The Google Testing Blog’s advice on end-to-end tests is a useful reminder that broad tests can become slow and hard to diagnose. It does not mean E2E tests are useless. A small set of well-chosen workflows can catch integration failures that unit tests cannot. The trick is not to make each E2E script carry the whole quality strategy.
AI-assisted testing adds another tool to the mix, not a replacement for either approach. GitHub’s guide to writing tests with Copilot describes using an assistant to help draft tests. A generated test can save typing, but a reviewer still needs to check the cases, assertions, and assumptions. Otherwise, the test may confirm only that the code repeats its own mistake.
The useful choice is not manual or automated. It is: what kind of evidence will reduce risk for this behavior, and what is the cheapest reliable way to get it?
Common Software Testing Mistakes to Avoid
Mistake 1: Treating QA as the last stop. When testing begins only after development is declared finished, testers inherit unclear requirements, rushed timelines, and late-breaking changes. Shift-left testing brings quality conversations earlier. It does not mean every developer must become a full-time tester. It means the team should discuss how it will verify a change before the change is difficult to alter.
Mistake 2: Measuring coverage as if it were correctness. Coverage can show which code a suite exercised. It cannot show whether the test would detect a meaningful defect. I have seen tests execute every line in a small module while asserting almost nothing about the result. Use coverage to find untested areas, then inspect whether the tests contain useful checks.
Mistake 3: Automating every manual step. Some advice makes automation sound like a finish line. It is not. A one-time exploratory check may cost less than building and maintaining a script for an uncertain feature. Automate stable, repeated work; leave room for people to investigate new behavior. A script that no one trusts is expensive decoration.
Mistake 4: Ignoring flaky tests. A flaky test fails sometimes without a relevant product change. Teams that accept repeated false alarms train people to dismiss the pipeline. Track how often tests fail intermittently, find the cause, and give someone time to fix it. If a check is too unreliable to guide a release, quarantine it deliberately and set a repair plan; do not quietly pretend it is useful.
Mistake 5: Letting AI output pass without review. A test generator may produce plausible code that misses the real risk, repeats an implementation detail, or checks only a happy path. AI can help create a first draft, and it may point out cases a developer overlooked. But the test must still reflect product intent. Human review is not a ceremonial checkbox; it is where someone asks whether the test would fail for the defect the team cares about.
Mistake 6: Using the wrong scorecard. A team can optimize for the number of tests, lines covered, or bugs filed and still ship a poor experience. Better signals include defect escape rate, time to detect and resolve issues, and test reliability. Even those measures need context. A rise in reported defects might mean the product got worse—or that reporting and detection improved.
Mistake 7: Treating quality as someone else’s job. Developers, QA specialists, product managers, security engineers, and operations staff see different risks. If one group owns all quality, others may stop raising concerns. Shared responsibility does not mean vague responsibility: name who maintains the test system, who reviews a failing change, and who decides whether a known risk is acceptable.
Here’s the kicker: adding a new tool rarely repairs a broken agreement about what the product should do. Clear ownership, useful communication, and honest review are less glamorous than a dashboard, but they keep quality work connected to the people affected by the software.
Frequently Asked Questions
Is the QA engineer role disappearing as developers write more tests?
The role is changing more than disappearing. Developers commonly take responsibility for unit and integration tests close to the code they change. Dedicated QA and quality engineers can then focus on test infrastructure, automation frameworks, broader E2E coverage, risk planning, and exploratory testing. Some companies still need manual test execution, especially when products or environments require it. The job title alone will not tell you how a team divides the work. Read the responsibilities and ask who designs, maintains, and reviews the testing system.
Does more AI-generated code mean more production bugs?
Not automatically. The risk depends on the quality of review, testing, and release controls around the faster flow of code. If changes arrive more quickly but test suites, code review, and monitoring stay weak, gaps can grow. If a team keeps those practices strong and checks what AI-generated code actually does, it can manage the higher rate of change. AI output still needs a human owner who understands the behavior and accepts responsibility for shipping it.
What is the difference between test coverage and test quality?
Coverage estimates how much code automated tests execute. Test quality asks whether those checks would detect defects that matter. A suite can have high coverage and weak assertions, which means it visits code without verifying meaningful outcomes. Review the expected results, failure cases, and risks each test covers. Pair coverage with production defect trends and the time needed to detect and fix problems; no single number can describe quality on its own.
What does shift-left testing mean?
Shift-left testing means moving testing activities earlier in development. For example, developers may write a unit test while implementing a behavior, and the team may discuss edge cases before a feature is complete. The purpose is to find defects closer to when they were introduced, when the context is fresh and fixes are often simpler. It does not remove QA specialists or eliminate later testing. It distributes useful checks across the work instead of saving them all for a final phase.
Can AI tools fully automate software testing?
Not for most real products. AI tools can help draft tests, generate scripts, group similar failures, and update some UI selectors when interfaces change. But they cannot reliably decide, without human direction, whether a result is fair, safe, or useful for every user. They may also create tests that look convincing but verify only superficial details. Teams should treat AI output as a proposal, review its assumptions, and use human exploration for behavior that is new or hard to describe in fixed rules.
Final Thought
QA is not dead, and calling it more important than ever does not settle anything either. The useful question is whether a team can show how it learns that its software works, where that evidence is weak, and what it does when a failure reaches users. Quality is a practice made of many small decisions: a clear expectation, a test that checks the right thing, an honest review, and a fix when the evidence says the system is falling short.
In my experience, good testing does not make software perfect. It makes risk easier to see and failures less likely to surprise everyone at once. AI changes how quickly teams can produce code and tests, but speed does not decide whether a product is trustworthy. People do. Their judgment, care, and willingness to take responsibility are still the difference between a test suite that looks busy and a system that serves its users well.
I’m Ernie Castro. I believe engineering work deserves the same care we bring to any responsibility that affects other people. Build checks that matter, give them owners, and pay attention when they fail. That is not glamorous. It is how a team earns trust, one release at a time.