Is QA Dead? What Software Testing Means in the Age of AI
Software testing checks whether code does what users and product teams expect; it probes single functions, connected services, full workflows, heavy traffic, and changes over time. Quality assurance also builds habits and systems that prevent defects, so a QA role can mean anything from manual checks to test engineering and release design.
I’m Ermenildo Castro, and I’ve watched testing move from a late release checkpoint toward a shared engineering responsibility. That shift is useful, but it is not magic: teams can ship more code while knowing less about whether it works. AI coding tools add speed, and speed makes weak checks more costly. The practical question is not whether a company needs QA. It is which quality problems need human judgment, which checks can run automatically, and who owns the result when software fails. A good answer protects users, respects the people doing the work, and gives engineers time to fix problems before they spread.
What Is Software Testing and QA?
Software testing is the act of checking software against expected behavior. A test may ask whether a function returns the right value, whether two services exchange data correctly, or whether a customer can complete a purchase from start to finish. Some checks are automated and repeatable. Others require a person to explore the product, notice confusing behavior, or try a path nobody thought to script.
Quality assurance (QA) is broader. It includes testing, but it also includes the working practices that make defects less likely: clear requirements, useful code reviews, safe release steps, good monitoring, and quick feedback. Testing finds evidence about quality. QA helps shape the conditions that produce quality. In everyday hiring and team talk, people often use QA and testing as if they mean the same thing. That is common, but it can hide what a role actually involves.
A job called QA engineer might focus on running written test cases by hand. At another company, the same title might mean building test frameworks, setting release standards, or helping developers design checks. Read the duties, not just the title. Frankly, a title tells you less than the first week of work will.
Most teams use several kinds of tests:
- Unit tests check small pieces of code, often one function at a time. Developers usually write them while building the feature.
- Integration tests check whether connected parts behave properly together, such as an application and its database.
- End-to-end (E2E) tests follow a complete user task through the application, such as signing in and submitting an order.
- Regression tests repeat earlier checks after a change, looking for behavior that used to work but now breaks.
- Performance and load tests examine how software responds to normal or heavy demand.
- Exploratory and manual testing use human judgment to probe confusing screens, unusual inputs, and cases that planned scripts miss.
These layers have different costs and strengths. A focused unit test is usually quick and easy to diagnose; an E2E test can catch a wider failure but may be slower and more fragile. The practical test pyramid explains why a healthy suite usually has many fast checks and fewer broad, costly ones. When I reviewed a release that had passed its automated checks, I found that a test verified the page loaded but never checked whether the user’s saved change actually persisted. The green mark was real. The confidence behind it was not.
Testing also gets harder when software does not always produce the same answer. A normal form should return the same result for the same valid input. An AI feature that writes a summary may produce different wording each time while still being useful and correct. Teams must test meaning, safety, and limits—not demand identical text in every run. That changes how tests are written, but it does not remove the need for them.

Why QA Still Matters
Quality work matters because users experience the whole product, not the team chart. They do not care whether a defect came from a missed requirement, a code change, a model response, or a broken deployment. They see a failed payment, missing record, unsafe answer, or wasted afternoon. A clear quality process lowers the chance of those failures and helps the team respond when one gets through.
The value is practical:
- Catch defects sooner. A small mistake found while a developer is still working is often cheaper to fix than one found by a customer after release. Early checks also keep teams from building more work on top of a faulty assumption.
- Make changes safer. Useful regression tests let teams improve old code without guessing which nearby feature might break. They do not promise zero risk, but they give people evidence before release.
- Protect customer trust. Good tests check more than the happy path. They also consider permissions, privacy, confusing inputs, and what the product does when a service is slow or unavailable.
- Reduce wasted work. Reliable automated checks save people from repeating dull steps by hand. That time can go toward usability, edge cases, and real user problems.
- Support steady delivery. When a CI pipeline gives quick, trustworthy feedback, developers can make changes in smaller pieces and fix failures before they pile up.
- Clarify ownership. Shared quality practices make it harder for teams to treat testing as somebody else’s last-minute chore.
I have seen a release meeting turn into a debate over whose job it was to check a key user flow. The test existed, but it lived in a separate document, ran only before launch, and had no clear owner. The fix was not another meeting. The team moved the check into its repeatable release process and made one person responsible for keeping it useful. That is the difference between saying quality matters and arranging work so it does.
Here’s the kicker: a test suite can be large and still provide weak protection. Code coverage reports how much code ran during tests, not whether the tests would notice a wrong answer. A test can execute every line and assert almost nothing. I use coverage as a clue about gaps, never as a medal. The Microsoft unit-testing guidance similarly stresses clear, focused tests that check behavior rather than merely touch code.
QA also has a human purpose. A defect may block someone from getting paid, using a public service, or protecting private information. Careful testing is a form of stewardship: it treats other people’s time, data, and dignity as worth protecting. That is not lofty talk. It is a reason to test the failure paths, not only the polished demo.
How to Build a Practical Testing Process
A testing process should fit the product, the risks, and the team’s ability to maintain it. Copying another company’s tools or test count rarely solves the real problem. Start with the user’s needs and work outward.
- Name the important user outcomes. Write down what must remain true: a customer can sign in, a payment is recorded once, private data stays private, or an account change survives a restart. Use plain language. If the expected behavior cannot be explained clearly, a test cannot fix that confusion.
- Mark the costly failures. Ask what would hurt users or the business most. A typo in a low-use help page and an incorrect bank transfer do not deserve equal attention. Consider safety, privacy, money, access, and the number of people affected. Put the strongest checks around the largest risks.
- Choose the smallest useful test. Test a rule at the unit level when that is enough. Use integration checks for service boundaries, databases, or queues. Reserve E2E tests for critical full workflows that need proof across the actual application. Google’s guidance to avoid piling on end-to-end tests is a useful reminder that broad tests can be slow and harder to diagnose: Google Testing Blog.
- Give each check an owner. Developers should usually write unit tests for the code they change. Quality engineers can build the shared framework, improve E2E coverage, and probe cases that need a human eye. Product and design partners should help define what correct behavior means. Ownership should be clear without turning quality into a blame hunt.
- Run checks in the right places. Run fast tests during development and on every code change. Run slower integration, browser, and load checks at appropriate points in the CI pipeline or before a release. A failed check should explain what broke and point to useful logs. A red build that nobody trusts soon becomes decoration.
- Test failure and recovery. Ask what happens when a network call times out, a user submits twice, a service returns incomplete data, or a release needs to be rolled back. For AI features, check harmful or misleading outputs, privacy risks, refusal behavior, and whether a person can review consequential decisions. The NIST Generative AI Profile offers a risk-based way to think about these concerns.
- Review the results and repair the suite. Track defects that reach production, time to detect and fix them, and flaky tests that fail without a real product problem. Remove tests that no longer protect a meaningful behavior. Add checks after incidents, but first learn why the earlier process missed the issue.
When I have helped teams untangle an unreliable pipeline, the quickest win was often not adding more tests. It was deleting or repairing tests that failed for random reasons. Engineers had learned to rerun a red build until it turned green. Once the suite became trustworthy, failures earned attention again. That sounds small; it changes how people work.
For AI-generated tests, add one more review step: read the assertion and ask what bad result it would catch. A tool can produce a neat test that only repeats the implementation’s current behavior. That test may confirm a bug forever. Treat generated tests like a draft from a fast assistant: useful starting material, not evidence of quality until a person checks the intent.

QA Engineering vs. Developer-Owned Testing
These approaches are often framed as rivals. They are not. Developer-owned testing puts checks close to the code change, while a dedicated QA or quality engineering function can build shared systems and bring a wider view of user behavior. Strong teams combine them and decide ownership by the kind of risk involved.
| Area | Dedicated QA / quality engineering | Developer-owned testing |
|---|
| Main focus | Test systems, automation, release confidence, exploratory checks, and cross-feature risks | Unit and integration checks tied to the code being changed |
| Best fit | Shared test infrastructure, critical user journeys, usability probes, and complex system behavior | Fast feedback on small code changes and local behavior |
| Typical strength | Sees across services and user flows; can challenge assumptions outside one code change | Knows implementation details and can fix a failing check close to its cause |
| Common blind spot | Can become a late-stage handoff if excluded from planning and design | Can miss cross-system risks or user confusion when focused only on the changed code |
| Useful measure | Reliable coverage of important flows, defect escapes, and time to find issues | Useful assertions, fast feedback, and stable unit or integration checks |
| Main risk | Becoming the final gate for work everyone else considers finished | Treating testing as optional when delivery pressure rises |
The table is not a staffing formula. A small team may share these duties among a few engineers; a larger product may need test infrastructure specialists, accessibility experts, performance engineers, and exploratory testers. The right mix depends on risk and scale. The useful question is not “Which role wins?” It is “Who is equipped to find this kind of failure, and who will act on the result?”
A separate QA team cannot rescue unclear requirements or a development team that never checks its work. Likewise, asking every developer to build browser automation infrastructure from scratch wastes effort and produces uneven results. Give developers close-to-code checks, and give quality engineers room to improve the shared system. Then let both groups learn from production issues without turning the review into finger-pointing.
This division fits the wider move toward shift-left testing: finding issues earlier in design and development rather than waiting for a final test phase. It does not mean every test must happen early. Load tests, real-user monitoring, and exploratory work can matter later too. The aim is fast feedback where possible, plus enough independent scrutiny to catch what the code author may miss.
Common QA Mistakes to Avoid
The biggest testing problems often come from good-sounding rules applied without thought. More tests, more automation, and higher coverage can all be useful. None is a quality plan by itself.
- Treating coverage as proof. A high percentage does not show that assertions check important behavior. Review whether tests fail when the feature is wrong, not just whether code ran.
- Automating every manual step. Some repeated checks belong in automation, but a script is not automatically cheaper to maintain. Exploratory testing can reveal confusing flows and unexpected behavior that a fixed script cannot imagine.
- Building too many brittle E2E tests. Browser tests can fail because a button moved, a shared service slowed down, or timing changed. Keep them focused on important user paths and test smaller rules at lower levels when possible.
- Ignoring flaky tests. A test that fails at random teaches people to ignore failures. Track flaky results, find the root cause, and fix or remove the check instead of normalizing reruns.
- Leaving QA until the end. A late test phase gives testers little time and developers little chance to fix what they find. Involve quality thinking during planning, while keeping space for a final independent look when risk warrants it.
- Trusting AI-generated tests without review. Generated code can be syntactically tidy and conceptually empty. Check its assumptions, edge cases, and assertions; compare its test with the actual requirement.
- Confusing self-healing with correctness. Tools that adjust selectors after a user interface changes may reduce maintenance, but they can also update a test to follow the wrong element. Review the change and confirm the user outcome still matters.
Let’s be real: teams sometimes celebrate a green pipeline because it is green, not because it is trustworthy. I have seen people rerun failed tests several times and accept the first clean result without asking why the first run failed. That is not reliability; it is wishful thinking with a progress bar.
A related mistake is measuring only the number of bugs found. More reports can mean better detection, more defects, or simply more users. Better measures include defect escape rate—issues that reach production—alongside time to detect and time to resolve. Also watch the flaky test rate, because noisy checks slow delivery and drain trust. The DORA metrics guide gives useful context on measuring software delivery outcomes; no single number should stand in for the whole system.
Finally, do not make QA the group blamed for every incident. A test can miss a defect because the requirement was unclear, the data was unrealistic, or the system changed after the check was written. Ask what the process failed to reveal and how to improve it. Blame may close a conversation. It rarely fixes the pipeline.

Frequently Asked Questions
Are QA jobs dead?
No. The work has shifted. Many teams expect developers to write unit and integration tests as part of normal development, so a QA role focused only on running a fixed checklist may be less common in some organizations. Dedicated roles still matter for test infrastructure, automation, performance, accessibility, exploratory testing, and risks that cross many features. Job titles vary, so inspect the actual duties. Look for whether the role shapes quality early or only checks a nearly finished product.
Who is responsible for software testing?
The whole team has a part, but shared responsibility should not mean vague responsibility. Developers usually own checks close to their code. Quality engineers may own shared frameworks and broader testing strategy. Product teams help define expected behavior, while operations and support teams can report real failures and patterns. Assign a clear person or group to each critical check, and make sure someone can fix the failure it reveals.
Does AI-generated code need more testing?
It needs testing suited to its risks, not a blanket number of extra tests. AI coding tools can produce more code and first-draft tests quickly, but they can also repeat faulty assumptions or miss a requirement. Review generated code, test its behavior, and check edge cases, security, and dependencies. For AI features that produce variable answers, evaluate whether outputs meet clear quality and safety goals rather than expecting every response to match exactly.
What is the most useful QA metric?
There is no single best number for every team. Defect escape rate is useful because it shows issues that reached users, while mean time to detect and resolve shows how quickly the team responds. Flaky test rate reveals whether automated feedback can be trusted. Code coverage can help locate untested areas, but it does not prove that tests check meaningful behavior. Use a small group of measures and investigate the story behind each one.
Final thought: QA is not a gate that a product passes once. It is the collection of choices that helps people build, change, and operate software without treating users as test subjects. Automated checks matter. Human judgment matters too, especially when a product behaves unpredictably, a failure harms someone, or the written requirement does not match how people actually work.
AI tools will keep changing how quickly teams write code and tests. That makes careful ownership more important, not less. Let developers test the code they change, let quality engineers improve the systems everyone uses, and make room for exploratory work that scripts cannot replace. Measure real outcomes instead of collecting attractive numbers. When a test fails, learn from it; when a test is noisy, repair it.
My rule is plain: trust comes from evidence, and evidence comes from checks that reflect real needs. A green build is a useful signal, not a promise. Keep asking what the test protects, who it protects, and what happens when it fails. That is how testing serves both good engineering and the people who depend on the result.