Speed work used to follow a predictable rhythm. An engineer ran Lighthouse, squinted at a waterfall chart, compressed a batch of images, and then moved on until the next quarterly audit.
That rhythm is falling apart. Machine learning models now sit inside the delivery path itself, deciding what to preload, what to compress, and how aggressively to compress it. And they’re making those calls per visitor, not per site.
From quarterly audits to continuous tuning
Traditional performance work is diagnostic. You measure, you find the bottleneck, you patch it, and the patch sits frozen until somebody remembers to look again.
AI-driven tooling reverses that sequence. Models trained on real user monitoring data catch regressions within hours of a deploy, and several platforms (Cloudflare, Fastly, and Akamai among them) now adjust caching and routing rules automatically instead of waiting for a ticket. The feedback loop shrank from months to minutes, which matters more than any single technique on the list.
Granularity is what separates this from the old rules engines. A static configuration treats every visitor from Warsaw identically, while a trained model can weigh device class, connection quality, and even time of day before picking a compression level. Uxify’s take on artificial intelligence optimization covers how that per-request decision-making behaves on production sites.
Predicting the next click
Prefetching isn’t new. What’s new is that the guess is no longer a guess.
Models trained on navigation logs assign each link on a page a probability score, then quietly fetch the two or three most likely destinations during idle time. Google’s open-source Guess.js project did this years ago with Analytics data; the browser-native Speculation Rules API has since made the technique far easier to ship.
The payoff maps directly onto human perception thresholds. Jakob Nielsen’s three response time limits still hold: 0.1 seconds feels instant, 1 second keeps a train of thought intact, and past 10 seconds attention is gone. Shaving 400ms off a click that was going to happen anyway moves a page across one of those lines.
There’s a cost, though. Aggressive prefetching burns bandwidth on visitors who never click, which matters on metered mobile plans. Good implementations cap themselves at two or three predictions and back off when the Network Information API reports a slow connection.
Media is still where the weight lives
Images and video account for the bulk of bytes on a typical page, and that hasn’t changed much in a decade. What has changed is that quality settings no longer need to be picked by hand.
Per-image models analyze content and choose an encoder and quality level for each asset: flat illustrations get pushed hard, faces and textured photography get treated gently. Cloudinary and imgix have offered automatic quality modes for years, and the results usually beat a designer’s blanket “85% JPEG” rule by 20% to 40% in file size.
Format negotiation got smarter too. Instead of serving AVIF to everyone and hoping, delivery layers check browser support, screen density, and viewport size before deciding. Mozilla’s web performance documentation remains the clearest reference for how those signals fit together on the client side.
Where the models stop helping
Inference has moved to the edge, which is the only place it makes sense. Running a prediction in a US-East data center to serve a visitor in Singapore defeats the purpose, so vendors push small models onto CDN nodes where the round trip is measured in single-digit milliseconds.
But none of this rescues bad architecture. A 3MB JavaScript bundle stays a 3MB bundle no matter how clever the routing gets, and no model will refactor a component tree that re-renders on every keystroke.
Teams that treat AI tooling as a substitute for engineering discipline tend to plateau fast. The ones getting real gains use it for the work humans are bad at: constant micro-adjustment across thousands of asset and visitor combinations, running around the clock without anyone watching a dashboard.
What comes next
Expect the boundary between monitoring and remediation to keep dissolving. Systems that currently flag a slow endpoint will increasingly reroute traffic, swap a cached response, or downgrade an image tier before an on-call engineer opens a laptop.
That raises an uncomfortable question about control. When a model decides what a visitor receives, reproducing a bug means reconstructing a decision nobody wrote down, and the teams thinking hardest about logging those decisions today will be the ones still shipping confidently in three years.
