AI writes code faster than I can read it now. The problem? AI testing hasn't kept up with AI coding, so a lot of fast code ships with bugs nobody catches. In this video I plant a real bug in a real app on purpose, then let Ito run it and try to catch me.
Ito doesn't just run static checks like "tests pass, linter's happy, green check." It actually builds and runs your app, drives it like a real user through whatever your change touched, and posts a QA report right on the pull request — with a video of the run, screenshots, the exact lines responsible, and steps to reproduce. You don't write any test cases. Connect a repo, open a PR, and it writes its own test plan.
I hid a bug in my workout generator (no matter how many days per week you pick, it always returns 3). It still compiles, tests don't flag it — you'd only catch it by using the app. Ito caught it. It even found a real bug I didn't plant (a print link that breaks under strict CSP).
👉 Try Ito free — one-click GitHub install, no credit card, 10 free pull requests: https://www.ito.ai?james Works on backend/API projects and frontend apps.
This video is sponsored by Ito. As always, my opinion is my own and I only work with tools I actually use. #sponsored
⏱️ Chapters 0:00 AI ships code faster than we can check it 0:25 What Ito actually does (runtime QA on your PR) 1:34 The workout app + the bug I planted 2:42 Ito catches it — video + repro steps 3:57 The real bug I didn't plant (strict CSP) 4:16 Try it free (10 PRs) + wrap-up
🔧 Tool in this video: • Ito — runtime code verification on your pull requests: https://www.ito.ai?james
🙏 "In all toil there is profit, but mere talk tends only to poverty." — Proverbs 14:23 (ESV)
AI Generated·May contain errors
Video Summary
AI Generated
The speaker introduces Eto, an AI-powered QA tool designed to bridge the gap between rapid AI code generation and quality assurance. Unlike static checks, Eto builds and runs applications to simulate real user behavior, identifying functional bugs and providing detailed reports, videos, and reproduction steps directly within GitHub pull requests.
So I run almost all my businesses completely with AI agents now,
and they write and ship code faster than I can read it.
But the question now is not, can AI write code? We know that it can.
The question is, how do I know that this code it's writing is actually working?
So I'm trying out a new tool.
It's called Eto and what I'm going to do today, I'm going to take a real app.
I'm going to break one thing on purpose, let it run,
and I'll show you what happened. So here's what Eto is in plain terms.
So normally when you open a pull request,
so you write some code and you want to merge it back into the existing code
base, the checks that you get are static. So test pass,
the linter is happy, a green check appears.
And that tells you that nothing broke on paper, but Eto does something different.
So Eto actually builds and runs your app and drives it like a real user through
the flows that would have changed through the changes that you made.
And then it posts a QA report right on the pull request.
It also does a video of the run and screenshots. And if something did fail,
it shows the exact lines responsible and how to reproduce it.
So the way it works is pretty simple. You connect a repository,
you open a pull request and Eto writes its own test plan,
runs your app and reports back to the pull request.
You don't have to write any test cases or anything like that.
Then anyone on the team can open that report and see what the change actually
did.
So this is very handy for developers who are shipping really fast,
writing AI code and not able to review the AI code as fast as we're writing it.
So this is a workout generator app that I actually built quite a while ago,
but you can put what your goal is, your experience level days per week.
These are the normal questions I ask when I'm building a workout.
All right, everyone get ready for this. Behold the ultimate power.
Yes. Look at these massive muscles.
I don't know if you can tell, but I, I work out sometimes,
but a bug that I noticed is if I put days of per week to work out and do
generate workout, it actually only gives me three days of workout. Okay.
So this is a bug and it's not going to necessarily throw, you know,
it still compiles. It's not going to necessarily throw an error in that way.
So this is a bug that you might miss unless you just use the app.
So I actually put a bug into this code.
So I made it that when you, no matter how many days per week you say,
it's going to always generate three days in the workout.
So this is a bug that tests it's going to still compile.
Tests might not notice this. You'd have to see it as a user to notice it.
I'll show you here.
See I put five days per week to generate a workout for it only does three.
That's a bug I introduced.
Then what I did is I screened a pull request with Ido and said, Hey,
take a look at this code. And so Ido spun up my actual app,
clicked through it like a user and reported back here on the pull requests,
the problems. And it found this bug that I introduced that, Hey,
no matter what happens,
it's going to give three days of workouts when you're intending five.
So it's very cool. It can even tell the intent of the app,
not just the code itself.
So then it even shows a video of it trying to run the app and doing this.
And then it gives a reproduction steps to see this bug.
So this makes it very easy for a human to come in and see what exactly is
wrong. So, and the link to Ido is in the description,
go try it on one pull request yourself. I think this is pretty cool technology.
I've been telling people that AI coding has moved a lot faster than AI
testing has. And so what's resulting is AI is writing a lot of code,
but the code quality that's coming out has not been great.
So I'm really excited for tools like Ido to help on that side of things on the
testing side of things. So we can get the quality.
We're getting this stuff out fast,
but let's get the quality of things out fast as well.
So, and I was very happy with Ido again,
I put in a bug and it found it. It didn't just say, Hey, this all looks good.
It also found this was a bug I didn't introduce.
This was just an actual legit bug that I hadn't found before,
but the print link breaks under strict CSP.
So this is something I would have never found this,
but it's did this QA pass and found even kind of this low priority
bug that I would have never found on my own.
So I think this is worth trying out. If you write any type of code,
if you ever have done a pull request on GitHub, it's worth trying out, you know,
just hook it up to your repository and give it a shot, but you can try it free.
It's a one click GitHub install, no credit card.
You get 10 free pull requests to test it out before you decide if this is
something that you want to pay for. It works on backend API projects.
And obviously as we just saw front end apps as well. So again,
link in description,
let's work on the quality of our code getting better,
not just the speed of it.
Give Edo a try and shout out to Baron and the Edo team.
You guys have been amazing to work with. Thank you guys so much for watching.
God bless you all and have a great rest of your day.