Log in
← Blog

The Evolution of Software Quality: From Test Phase to Quality Engineering, and What Comes Next

How testing went from a phase at the end of a project to a job woven through every change, what each shift taught us, and the skills that matter in the AI era.

Vihari Panyam

August 12, 2026 · 5 min read

A dashboard of metric tiles, including a Quality Score, with small trend lines under each number

In short

  • Quality started as a phase at the end of a project, owned by a separate team that found bugs after the code was done.
  • Agile, continuous delivery and DevOps pulled testing into every change and spread ownership across the whole team.
  • With AI writing more code, the scarce skill is no longer running tests but judging risk: knowing what could go wrong and proving it didn’t.
On this page

Ask three people what a QA engineer does and you will get three answers. One says they run test cases before a release. One says they write automation. One says they help the team decide whether a change is safe. All three are right, because each answer belongs to a different era of the job, and all three eras are still alive in different companies today.

Knowing how we got here helps you see where the job is going, and which skills will keep mattering.

01Era one: testing as a phase at the end

For a long time, software was built in long stages: requirements, design, build, then test. Winston Royce’s 1970 paper on managing large software projects is usually cited as the picture of this sequence, even though Royce himself warned about its risks. Testing was the last gate before release.

  • Who owned quality: a separate QA team, often handed the build weeks before release.
  • What the work looked like: detailed test plans and test cases written from requirements, run by hand, results logged in a test management tool.
  • What it got right: discipline. Test design techniques like equivalence partitioning and boundary value analysis come from this era and are still the backbone of good testing.
  • What it got wrong: bugs were found when they were most expensive to fix, and "QA found it" became "QA delayed the release".

02Era two: agile pulls testing into the team

The Agile Manifesto in 2001 changed the rhythm. Work arrived in short iterations, so testing couldn’t wait for the end. Testers joined development teams, worked from user stories, and tested each feature as it was built.

Automation became necessary, not optional: you can’t re-run a full manual regression every two weeks. The test pyramid, popularised by Mike Cohn and later explained in depth on Martin Fowler’s site, gave teams a shape to aim for: many fast unit tests, fewer service tests, and a small number of slow end-to-end tests.

03Era three: continuous delivery and DevOps

The 2010 book Continuous Delivery made the case that software should always be in a releasable state, with every change going through an automated pipeline. DevOps joined development and operations, and Google’s site reliability engineering practices, published as a book in 2016, brought error budgets and production monitoring into the conversation about quality.

IdeaWhat it changed for testers
Shift leftTest earlier: in design, in code review, in unit tests, before a feature is "done"
Shift rightKeep testing in production: monitoring, canary releases, feature flags, synthetic checks
PipelinesTests run on every change, so flaky tests became a real cost and reliability became a skill
DORA metricsQuality measured by outcomes: change failure rate and time to recover, not bug counts

This is when the title quality engineer spread. The job was less about executing tests and more about building the systems that let a whole team ship safely: frameworks, pipelines, test data, environments and the habits around them.

04Era four: AI writes the code

The current shift is the fastest yet. Google said in October 2024 that more than a quarter of its new code was AI-generated; by April 2026 it said 75%. When code is that cheap to produce, the limiting factor is no longer writing it. It is knowing whether it is right.

That moves testers toward the centre, not the edge, but the work looks different:

  • Reviewing generated tests, which often confirm what the code does rather than what it should do.
  • Designing strong negative tests, because removed or weakened rules are the bugs a green suite misses.
  • Evaluating AI features, which don’t give the same answer twice and need evaluation sets and failure rates instead of single expected values.
  • Judging risk quickly, across far more change than any team could test exhaustively.

05What each era got right

EraKeep thisLeave this behind
Test phaseRigorous test design techniquesQuality as one team’s job at the end
AgileTesters in the conversation before code existsTreating automation as a side project
Continuous deliveryFast, reliable checks on every change; outcome metricsCounting tests or bugs as a measure of quality
AISpeed, and tools that draft tests and find gapsTrusting generated tests without reading the assertions

06Skills that keep paying off

Tools come and go. These have mattered in every era, and matter more now.

  1. Test design. Partitions, boundaries, decision tables, state transitions. AI can generate tests; choosing the right ones is still judgement.
  2. Reading code. Enough to review a pull request, spot an untested branch and understand what a generated test really checks.
  3. Automation you can trust. Small, fast, deterministic tests, and the discipline to fix or delete flaky ones.
  4. Production awareness. Logs, metrics and alerts, so you can tell whether a release is healthy after it ships.
  5. Evaluating AI behaviour. Building evaluation sets, defining acceptable answers, and tracking failure rates over releases.
  6. Explaining risk. A clear "this is safe to ship because… and this is what we didn’t test" is worth more than any report.

A one-year plan for a tester who wants to stay ahead

  • Master the core test design techniques and use them on every story
  • Get comfortable reading code and reviewing pull requests
  • Own one reliable automated suite, including its flakiness
  • Learn the DORA metrics and the monitoring your team already has
  • Build an evaluation set for one AI feature, or one AI tool your team uses
  • Practise writing a short risk summary for every release you test

Frequently asked questions

What is the difference between QA and quality engineering?

QA traditionally meant checking software before release, often as a separate team. Quality engineering means building the practices, tools and pipelines that let the whole team ship safely, with quality owned by everyone and checked on every change.

What does shift left mean in testing?

Moving testing earlier in the work: reviewing requirements, testing designs, writing unit tests and checking code in review, so problems are found when they are cheapest to fix.

What does shift right mean in testing?

Continuing to check quality after release, using monitoring, canary releases, feature flags and synthetic checks in production to catch what pre-release testing missed.

Is manual testing still needed?

Yes, for exploratory testing, usability, new features and anything where judgement matters more than repetition. What has faded is repeating the same scripted checks by hand every release; those belong in automation.

What skills should a QA engineer learn for the AI era?

Strong test design, reading code, reliable automation, production monitoring, evaluating AI features with evaluation sets, and explaining release risk clearly.

Written by

Vihari Panyam

QualityAIQ

Sources and further reading

  1. Manifesto for Agile Software Development (2001)
  2. Martin Fowler: The Practical Test Pyramid
  3. Continuous Delivery (Humble and Farley)
  4. Google: Site Reliability Engineering books
  5. DORA research program
  6. Google: Sundar Pichai shares news from Google Cloud Next 2026