You know that moment when someone new joins the team and instantly spots a bug that's been sitting there for months? "Oh, that link goes to the wrong page." Everyone else walked past it a hundred times. They saw it in five minutes.
That's not luck. And it's not that they're sharper than the rest of the team.
It's that they don't know anything yet.
I wondered if I could bottle that. What if AI could look at my app the way a total stranger would - no assumptions, no shortcuts, none of the baggage of knowing how the thing is supposed to work?
The Problem Is Me
Here's the uncomfortable part. I'm not bad at testing my own apps. I'm too good at using them.
I built the feature, so I test it the way I built it. I click the buttons in the order I expect. I type in the data that makes sense. I follow the happy path because I'm the one who designed the happy path. And you can't re-click every single combination every single time - so the parts I'm confident in quietly get a little less of my attention. Not because I skip them on purpose. Just because I'm sure they work, and there are a hundred other things to check.
That's the whole thing about "works on my machine." It's not that developers are careless. It's that your own confidence becomes a blind spot. The miss hides in the gap between "I'm certain this works" and "I actually went back and checked."
And throwing more people at it only goes so far. QA teams, code reviews, beta testers - every layer helps, sure. But people learn the app too. They build their own happy paths. Give it a few weeks and your fresh set of eyes has the same blindness you do. Automated tests don't save you either - they only check what someone already thought to check. They're a checklist, not curiosity. They confirm what should work. They never go looking for what doesn't.
The bugs that actually bite you live in the gap nobody thought to test.
So I Built Something That Doesn't Know Better
This started after hours, on a side project. I needed a second set of eyes and there was no way I was standing up a QA team for a personal app. So I asked it differently - could AI just explore my app the way a first-time user would?
Not run tests. Explore.
So I built one. It navigates the app with actual curiosity. It clicks links. It fills out forms. It tries paths that make no sense, because it doesn't know they make no sense. It has no idea what's supposed to work, so it just tries everything - including the stuff I'm sure of, the stuff that quietly gets less of my attention because I already "know" it works.
That last part is the entire point. The agent is never sure of anything. It doesn't get confident, doesn't get tired, doesn't decide a flow isn't worth re-checking. So it checks all of them.
The Bug I'd Have Walked Past Forever
Then it found one on WODSpark - my own CrossFit workout app, live, the one I know better than anything I've built.
WODSpark generates a YouTube link for every workout. And here's the detail that matters: that link gets built differently depending on the workout type. CrossFit constructs it one way, yoga another, calisthenics another. Three paths, three little builders.
The agent clicked a yoga workout's link and got served CrossFit content.
The yoga links were quietly resolving to crossfit. Right-looking link, wrong thing behind it.
Here's the honest part. I'd tested that page. All of it - every button, every flow, all the obvious stuff worked. I just didn't happen to click that one YouTube link in that one specific state, where you've flipped your global workout-type setting first. It's not that I'd never test it. I absolutely would have if it crossed my mind. It just didn't. One link, one setting, in a sea of things that all worked - and it slipped right through.
That's the thing though. You can't click every link in every state every single time. The agent can. It doesn't get to be confident, doesn't get bored, doesn't quietly deprioritize the link it figures is fine. It clicked the one I missed.
This wasn't a test suite catching a regression. No test covered that flow - because no human, me included, happened to test it in that exact state. You had to not-know the app to go looking there.
That late-night experiment is just part of how I ship now. Honestly it changed what "done" means for me - pushing something without running the agent over it first feels wrong now, like leaving the house with the stove maybe-on.
Fresh Eyes, Every Single Run
The real value isn't just that it catches bugs. It's that it catches them before a user does.
It doesn't get tired. It doesn't skip a flow because the flow is boring. It never learns the app well enough to start trusting it. Every run, it's the new person on their first day all over again.
Yeah, it adds time before I ship. More checking than I used to do. But that's my time, not the customer's - they just get an app that works. I'll make that trade every time though.
Why I Care About This More Than AI Writing Code
Everybody's obsessed with AI that writes code. I'm way more interested in AI that catches what I missed.
Generation gets all the hype - ship faster, more output, go go go. But the thing that actually kills a product isn't slow development. It's the bug a user trips over before you do. That's the embarrassing kind, and no amount of shipping speed saves you from it.
I stopped thinking of it as a QA tool. It's more like having someone on the team whose entire job is to see the thing I can't see anymore.
And it's bigger than QA, really. Code review, editing your own writing, checking your own data - it's all the same trap. The same brain that makes the thing goes a little blind to the thing it made. I built a way to be a stranger to my own work, on demand.
That's actually kind of wild when you sit with it.