Hey, y’all -- Sherveen here.
If you aren’t a gamer, let me set the scene: Epic and Valve are two video game publishers that also have their own storefronts, allowing third parties to sell their games and users to manage and launch those games from a centralized app.
These sorts of launchers are often the source of major complaints from gamers, because they can be laggy, buggy, and janky.
Yesterday, Epic launched a refactor/rebuild of their app with a massive increase in performance and startup speed.
Epic’s tweet about this admitted and embraced that this improvement was primarily driven by AI code generation: “We vibe coded the Epic Games Launcher to be faster than the other guy.”
While we don’t have all of the details about all the ingredients that went into this improvement, it points at something that is happening across AI-pilled product teams that I’ve been wanting to talk about for a while:
AI is superhuman at software performance, and we’re going to see massive shifts in software quality and competitive factors based simply on people embracing this fact.
I want to talk about why, because I think it teaches us a lot about AI capability and offers us an intuition for how it might transform certain industries and spaces.
“Jarvis, please make this faster”
Again, without knowing exactly how much went into Epic’s refactor, let me begin by suggesting their tongue-in-cheek reference to ‘vibe coding’ might trivialize what’s really required for these types of transformations:
This is autonomous, closed-loop optimization of performance engineering.
This is what Codex and Claude Code got superhuman at in late 2025 and throughout 2026, borne of 3 major agent evolutions:
Agents got much better at measuring things within a loop. In 2024/2025, an agent could already help you add analytics to your app, but to get information back to an agent for actionability was still a manual process, limited by integrations and the ability to reckon with context-switching mid-task.
Agents got much better at running apps. Through a combination of code, vision tools, and computer + browser use tools, agents can open and operate an app, tap through the interface, and walk through the same steps as a human user. Hell, it’s expensive, but they can even play complex video games with a virtual controller.
Most importantly, agents got much better at holding context over longer tasks -- which, when combined with the above two evolutions, plus AI’s existing traits of being endlessly patient and no-ego, adds a level of “persistent action orientation” we’ve never really been able to access before.
That last thing is the thing that’s most important to have an intuition about.
Let’s compare this to the human version of things to make it visceral. In 2019, if you’re the development team at Epic Games and you receive a goal to improve the performance of the app… I cannot overstate the degree to which this would have been tiresome, thankless, tedious work for the product people and engineers involved.
The team would have to…
look through performance logs and analytics to spot defects and opportunities
for any spotted opportunity, they’d have to investigate the cause
there’d be a calculation in an engineer’s head, fallible, about the opportunity cost of investigating that particular problem, because six hours of looking into a hunch might only yield 1.5% of a speedup or even be a dead end
the root cause could lead you somewhere, nowhere, to one thing, or to a complex intersection of 5 things, and you could assess that it’s happening all the time or sometimes, and you’d begin to wonder whether your fixes could reach all people, some people, or a few people
smart engineers would have to have theories of a fix at all -- can it be patched, does it need a rebuild, is there a third party dependency?
this part is very vulnerable to entropy -- does that team realize which knob is precisely causing what percentage of the issue, do they know a fix exists, and are they keeping up with the literature?
then, they’d try their fix, and optimize their fix
if we’re talking about a large company with a lot of customers, you then have to QA the hell out of that fix -- does it work on Windows and Mac?
does it work on Windows 11 and Windows 10 and Windows XP, even on a version of Windows 11 that hasn’t been updated in months?
why does the fix have a bug if the user is using 2 monitors, but not 1?
does the fix work for users on Wi-Fi or with a slow connection?
automated testing coverage can begin to solve some of this, but you’ll never stop needing to add new devices, device formats, operating systems, use cases, or dependencies until the day you pass from this planet
then, and only then, you’ll know if your candidate fix shaved 1 second out of 7 seconds of just one subprocess of that launcher… so, you have to find 20 more fixes of that type, and then maybe you’ve made a real impact
It isn’t enough to know you want to make the thing faster. You have to understand all of the available knobs, how they integrate, tune them, and make sure you didn’t break something else along the way.
Now think about the agent evolutions we’ve seen in 2026.
Agents were already patient and willing participants in coding tasks. Now, they can add measurement and telemetry to a thing, run that thing across any environment they can access, get back the metrics from that run, change things, and do it all over again. And they can do that over and over, without ego or sunk cost.
Add web research so that they can learn from the latest methods and implementations across the industry and enough ‘budget’ to try multiple ideas across even the smallest of theories, and you’ve got something special.
Add that they can now run for 5 minutes, 20 minutes, 2 hours, or 4 hours at a time without losing coherence about an individual prompt, and you’ve got magic.
Again, within the AI enthusiast community, this has been a popular process throughout the past year and a half. People will point agents at their own personal applications or open source projects, ask for performance improvements across specific or general parameters, and post screenshots of incredible results.
Beyond building my own personal applications throughout the past few years, I’ve made them faster and faster as models have become more capable at this style of activity. I’ve also made any open source or modifiable application much faster, too.
For example -- I use an open source app called qimgv as my image viewer on Windows. It fits a few very particular needs I have, and it was already fast, but I noticed a bit of latency that I wanted to improve.
I asked Claude Code to target any performance or latency improvement to the app for load times, viewing images, switching folders, scrolling through images, etc. I told it to test its changes for effect. Less than an hour later, I got back this message:
This is just one almost-trivial example of many I’ll be sharing about in the coming weeks, but notice: we have some non-wins, some huge wins, some small wins, all as a response to…
“Could you begin to, dive a little bit deeper into this application in general and see if you can find places where we can make it even more performant, reliable, composable from a technical architecture perspective, since we’re going to be in here and making this our own over time. Port the app to [machine], do all of this there, including measuring whether you’re winning (by any amount is fine, don’t overdo gates) for these, so it doesn’t require intervention w/ my active machine?”
The agent looked at the code, measured the actual performance before changes, made changes, measured the after, and did 3 rounds of testing to verify the impact.
There are a bunch of things I want to say to close things out that are a mix of lessons, vibes, desires, calls to action… so allow me to just ramble:
every piece of software we use could go through this sort of cleanup process, making it faster, more compatible, more reliable
open source software that allows users to modify it for themselves (or contribute improvements centrally) has a huge advantage in this era, because it allows people to do this on their own time and dime
think about this in adjacent industries: where were we limited because a team of competent humans had to spend energy, attention, and emotion on problems we deemed too small, but a patient and ego-less agent can just run loops?
this changes the economic calculus of change, and what we as consumers are willing to put up with, in ways we probably don’t understand yet
Overall, none of what I’ve said above is really new to anyone deeply working with agents already, but I don’t think we’ve quite seen the effects of this on at-scale applications quite yet. In other cases, I’m not sure companies are admitting it quite yet.
But we aren’t yet embracing this kind of change, with large parts of the modern economy still assuming that “vibe coding” is only for amateurs or that AI releases can’t have a science and craft to them.
Epic was in a unique position to be loud and proud that their improvements were largely AI driven because its founder, Tim Sweeney, is majorly AI-pilled and a bit of a public belligerent.
Unfortunately, the video game audience is still majorly reactive to AI, and so a lot of replies to their announcement are people mocking them, swearing them off for using AI, and otherwise being naive and self-defeating.
What are we protecting here when we don’t embrace this type of change?
Was the code powering the older, slower launcher not just… human slop?
Anyway, I’ll end with this:
If you run a team or are otherwise responsible for software, there’s no reason to wait. Point your favorite agent at it, give it a prompt like mine above, and do all of your customers an almost-free favor with improvements to performance. In the age of AI agents, all that’s stopping you is pressing enter.
Pressing enter,
Sherveen