How Tecovas automates bug fixes with LogRocket’s Galileo AI
Alton ChaneyDirector, Frontend Engineering, at Tecovas
See how LogRocket's Galileo AI surfaces the most severe issues for you
No signup required
Check it out
Alton Chaney is Director of Frontend Engineering at Tecovas, the Western apparel brand. This post has been adapted from a conversation between Alton and the LogRocket team. It has been edited for length and clarity.
At the start of August, one error was showing up in more than 3,000 sessions per week on our website. A shopper would land on an error page with no way out. A browser refresh would have cleared it, but the page didn’t offer one.
It wasn’t a showstopper, so it wasn’t going to get fixed. We’re a team of three developers, and errors like this one never made it to the top of the list.
But for this issue, we shipped a patch on August 12. Within two days, the error had stopped appearing entirely.
The most important thing here wasn’t that we fixed it; it’s that none of us had to. Nobody on my team found the error. Nobody wrote the 11 lines of code in the patch. And nobody had to prioritize it. One of us reviewed the pull request and approved it without asking for a single change. Then it deployed.
That’s routine for us now at Tecovas. We built a patching agent that automatically turns LogRocket’s Issue Digests into actionable GitHub PRs using their Galileo AI.
Finding the bugs and telling us which ones matter is Galileo’s job. The AI watches user sessions, serves up the most important issues, and gives our Claude coding agent the context it needs to write the fix.
We still require a human to actually do the code review, sometimes make changes to ensure that it’s release-worthy, and merge it. But 60% of our agent’s PRs ship without us having to change anything.
Before we built this agent, we were constantly bogged down by finding these “non-showstopper” bugs, figuring out which ones demanded our attention, and actually fixing them. Now, we don’t have to prioritize them, and they’re being patched automatically.
For a three-person team, that’s impactful. It lets us focus on the bigger picture: the features that we want to ship and the big initiatives that we have as a company. We get to look ahead, rather than look back.
We never had time to prioritize the “non-showstopper” bugs
At Tecovas, we run a server-side rendered website, and we ship on a two-week sprint cadence. That combination means we’re dealing with frequent bugs, and the client-side ones are often the hardest to pin down.
With just three developers on our team, the big, showstopper bugs got our attention.
Over 200k developers use LogRocket to create better digital experiences
Learn more →
For the transient, non-showstopper issues, we had to decide which ones to prioritize. There was a lot of thinking involved in sifting through all of those: what bugs are important and which ones are worth our time? And fixing everything proved to be a real challenge.
Galileo watches user sessions and surfaces the most impactful issues, with a suggested fix
We’ve used LogRocket since we rebuilt our digital experience three years ago. Session replay, network requests, and console logs let us see what a shopper actually did when something went wrong.
The piece that made the patching robot possible is Galileo. Galileo watches the sessions behind the issues, works out the severity and how many shoppers are affected, and writes up what’s going on with a likely fix.
Our weekly LogRocket Issues Digests bring the issues that matter to the top, already ranked and analyzed.
How the patching agent works
Over time, we’d had enough bug reports and enough requests from internal stakeholders. It was time to build out an automated workflow to handle these transient issues.
Here’s the architecture we came up with:
Galileo watches real user sessions and prioritizes the ones we need to pay attention to. It writes up its analysis for each issue, along with a likely fix
Every week, LogRocket’s Issues Digest compiles those issues and sends them to a Cloudflare Worker via webhook
The Worker opens a GitHub issue built from Galileo’s write-up and linked sessions
Each new issue triggers a GitHub Action that tasks Claude with drafting a fix and opening a pull request
A developer reviews every PR before it ships
To be clear, no code hits production at Tecovas without human eyes on it. We’re just eliminating a lot of the time of figuring out which bugs are most important, and typing out the actual fix in the code.
One example: a Turbostream error
Let’s go back to the example from earlier. Recently, a TurboStream error was resulting in shoppers seeing an error page with no way out except refreshing the browser. At its peak, it hit more than 3,000 sessions in a week.
Galileo watched the relevant sessions and reported that shoppers were repeatedly backing out, refreshing, or trying alternate ways to get where they wanted. Some eventually made it. That told the patching robot the error was transient, so its fix gave shoppers a way out: a screen they can refresh from, and an automatic refresh when the app detects the error.
Our agent got the fix right on the first try: a “one-shot,” if you will. The PR changed 11 lines, our human reviewer approved it without changes, and we shipped it. Two days later, the error had dropped to zero.
It’s not magic, and it doesn’t need to be
We’re not one-shotting everything. About three out of five of the agent’s PRs ship without us changing anything, even if we’re reviewing every line of code.
The agent does well on the transient, SSR-related errors: the “paper cuts.” If it doesn’t have high confidence in the fix, it’ll label it as “Needs Human Review.”
If the error includes anything more nuanced, like network request issues or architecture decisions, our team still steps in.
What Galileo and the patching agent changed for us
We don’t have to prioritize the small stuff anymore. If a bug comes through the digest, it often gets patched automatically. Our job is reviewing a few more PRs, which we would have been reviewing anyway.
We call it self-healing. Our goal was never to take people out of the loop. Instead, we’re cutting out the time spent prioritizing and typing fixes for transient issues.
Now most weeks, we’re looking ahead at the roadmap instead of back at the backlog.
If you’re an ecommerce dev team and want to build something similar
Start by tuning LogRocket for your developers. We set up dashboards and issue settings that separate engineering concerns from what our product and digital teams look at. That engineering view is what made a developer-specific workflow like this possible.
Is react-markdown slowing down your app? We benchmarked three top streaming Markdown renderers to find the fastest, most efficient alternative for React.
Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.