For most of the last decade, "record-and-replay" was shorthand for "fragile, unmaintainable, don't bother." The critique was valid. First-generation recorders produced brittle XPath locators, generated spaghetti scripts nobody could maintain, and broke on every UI change. The industry moved on to Playwright, Cypress, coded frameworks — tests as software, maintained by engineers.
That was the right call. In 2018.
In 2026, BrowserStack's testing guide, BugBug's tooling review, and multiple analyst reports describe record-and-replay as a rehabilitated approach — viable again for sprint-based regression, cross-browser validation, and production monitoring. Agile teams are adopting it not as a fallback, but as a primary testing method.
The technology improved. But the real reason for the comeback is simpler: the alternative stopped scaling.
GitHub reports Copilot generates 46% of all code written by developers. Average output is up 76% — from 4,450 to 7,839 lines per month per developer. Mid-size teams saw output rise 89%.
QA didn't get a matching multiplier. SmartBear's 2026 survey found 70% of respondents say application quality has already degraded. The coverage deficit between code shipped and code tested is now roughly five to one. Tricentis's 2026 Quality Transformation Report: 60% of organizations still deploy untested code.
Coded test automation — the approach that replaced record-and-replay — takes a skilled engineer anywhere from hours to days per flow. When the engineering team was shipping ten PRs a week, that math worked. At fifty PRs a week, it doesn't. The flows pile up on the backlog faster than anyone can script them.
Record-and-replay solves a different equation: creating the test takes exactly as long as running the flow. A five-minute signup? Five-minute test. A checkout with a payment redirect? However long checkout takes. No framework selection, no locator strategy, no page-object model. You click through it, the test exists.
When you're staring at a five-to-one deficit, that's the only arithmetic that closes the gap.
The 2015 version of record-and-replay deserved to die. It produced tests that broke overnight and code that nobody could read. Three things changed:
Locator intelligence. Keysight describes three generations of element matching in their 2026 self-healing report. First-gen was simple fallbacks — try the ID, try CSS, try XPath. Second-gen used ML-based attribute similarity. Third-gen, shipping now, uses semantic understanding, contextual reasoning, and visual matching. When a developer renames a button, the system finds it through ARIA labels, nearby text, or visual position. The locator that broke every night in 2015 now survives refactors.
Proxy-level capture. The new generation of recorders doesn't just watch the DOM — it captures the wire-level reality. Every HTTP request, every response header, every cookie set during a redirect chain. This matters because the bugs shipping to production in 2026 aren't button-click bugs. They're authentication cookies that didn't get set during OAuth redirects. CORS headers that are misconfigured. Session state that leaks across tabs. A DOM-level recorder can't see any of that. A proxy-level recorder sees all of it.
AI-assisted maintenance. When a recorded test does break — a flow genuinely changed, not just a renamed element — AI can diff the old and new recordings and surface which steps need updating. This isn't self-healing (which, as we've written, fixes the wrong problem). It's assisted maintenance — the test breaks visibly, the system tells you why, and you decide whether the change is intentional.
Here's a number from the PractiTest 2026 State of Testing report: professionals using dedicated test management tools earn 23.7% more and are 13.5% more likely to adopt AI successfully. Tooling sophistication correlates with both compensation and capability.
The flip side: almost 60% of teams still do more than 40% of their application testing manually. Not because they chose to — because they don't have the framework expertise to automate. Writing a Playwright test for a flow with OAuth redirects, email verification, and conditional branches requires deep knowledge of async patterns, network interception, and browser contexts. Most QA teams don't have that. Most development teams won't prioritize it.
Record-and-replay eliminates the expertise gate. A QA analyst who can use the application can create the test. The person who knows the business logic best — what the user actually does, what the flow should look like, where the edge cases hide — is also the person creating the test. No translation layer, no ticket to engineering, no two-sprint wait.
The coded approach assumed that testing skill and automation skill lived in the same person. That was always a minority case. Record-and-replay separates them: the domain expert defines what to test, the tool handles how to automate it.
Record-and-replay still has limits. It can't generate edge cases it hasn't seen. It doesn't explore — it replays. It won't find the race condition in your checkout that only happens under load.
But the flows that are untested in that 60% number aren't untested because they need sophisticated exploration. They're untested because nobody ran through them at all. The signup-to-checkout path. The onboarding wizard with the email verification step in the middle. The settings page behind three OAuth redirects. These are known flows with known importance and zero automated coverage — not because the team doesn't know what to test, but because the test was too expensive to write.
A recorded flow that runs every night catches the regression that nobody had time to script a Playwright test for. It catches it because it exists, and the Playwright test doesn't.
The testing industry spent 2020–2025 building increasingly powerful frameworks and increasingly sophisticated AI agents to write increasingly complex test code. Quality degraded anyway. The coverage gap widened. The 60% number didn't move.
The approach that's actually closing the gap is the one that got buried a decade ago — rehabilitated not by better technology, but by worse math. When the code moves faster than anyone can script tests for it, the only test that matters is the one that already exists. And the fastest way to make a test exist is to record it.