October 13, 2025

Why We Built AI Testing (And Why Now)

When we launched Decipher last year, we had one mission: stop bugs from ruining your users’ experience in production. Session replay plus intelligent alerting meant you’d know about issues before customers complained.


But we kept hearing the same thing: “This is fantastic—but we wish we’d caught it before it shipped.”



The Core Problem: Writing Tests Takes Forever


Every engineering team knows they should have comprehensive E2E tests. Here’s what actually happens:


  • Startups: “We’ll add tests after PMF.” (They rarely do.)

  • Growth companies: “Let’s launch this new product line first, and then write tests” (The suite falls behind.)

  • Enterprises: “We have 10,000 tests but half the app isn’t covered and they’re outdated.” (Never fully caught up.)


The issue isn’t that teams don’t value testing. It’s that writing tests are painfully slow and there’s always something with more immediate bang-for-buck that teams can spend time on.


Let’s do the math:

  • Writing one solid E2E test: 30–60 minutes

  • Typical app with ~50 critical flows: 25–50 hours to cover

  • Ongoing maintenance as the app evolves: 10–20 hours/month


That’s a real investment to reach basic coverage—then perpetual overhead.


So teams make a choice:

  • Ship features (and skip tests), or

  • Write tests (and ship slower)


Both options are bad.



The Bottleneck: Starting from Scratch


A senior engineer told me last month:

“I know I should write tests for onboarding. It’s important. But I sit down, stare at a blank Playwright file for 10 minutes figuring out where to start, get pulled into a meeting, and it slips.”


That’s the real problem. Test authoring is:

  1. Slow — Blank-page every time

  2. Tedious — Manually stepping through flows to understand them

  3. Unrewarding — People want to ship features, not boilerplate


So tests never get written.



What If Tests Wrote Themselves?


Here’s the realization:

Decipher already watches millions of real user sessions. We see every flow, every interaction, every critical path.


What if we just… suggested the tests you should write?


Better yet: what if we wrote them for you automatically?


That’s what we built.



How It Works


Step 1: AI watches your app
Our session replay learns real behavior to identify critical flows:

  • Signup and onboarding

  • Checkout and payments

  • Core feature workflows



Step 2: AI suggests tests
No more blank files. You get a prioritized queue like:

  • ✅ “Test signup flow (5,000 users/day)”

  • ✅ “Test checkout flow (revenue-critical)”

  • ✅ “Test dashboard load performance”


Each suggestion includes steps and assertions—already ~90% done.




Step 3: One-click generation
Click approve to produce a working E2E test in seconds:

What used to take 30–60 minutes now takes ~30 seconds.




Step 4: AI maintains them
As your UI changes, tests self-heal. The AI distinguishes between:

  • Breaking changes (bugs): alert immediately

  • Intentional changes (features): adapt the test, preserve intent


The Result: 10× Faster Test Coverage


Instead of:

  • 1–2 months to build an initial suite

  • 10–20 hours/month in maintenance


You get:

  • 1–2 days to stand up the suite (AI-suggested, one-click generation)

  • 1–2 hours/month to maintain (self-healing)


That’s 10–20× faster.


Why This Matters


Fast authoring changes the economics of testing.


Before: testing competes with features

  • “Do I spend 2 hours writing tests or ship the next feature?”

  • Features win.


After: testing is nearly free

  • “I’ll click Generate on these 10 suggested tests.” (5 minutes)

  • Tests get written.


When authoring is 10× faster, it stops being a trade-off.


Why Now?


Three things converged:

  1. Velocity up, context down. AI accelerates coding; assistants lack product intent and customer journeys. Regression risk rises as change volume spikes.

  2. Surface area outpaced testing. Rapid releases, experiments, and shifting UIs make hand-written suites brittle and behind. Coverage drifts from real user behavior.

  3. Reliability must scale with speed. Convert production behavior into self-healing, usage-aligned tests to meet SLAs and ship fast with confidence.


Get Started


If your test backlog grows faster than you can write tests, let’s talk.

Book a call with us here.

Written by:

Michael Rosenfield

Co-founder

Share with friends:

Share on X