Web Design

AI builds the site. Core Web Vitals still grade it

Point an AI builder at a prompt and a working page comes back in minutes. The generators we tested all do this now: layout, copy, images, and a deploy button. The page works. What the prompt never specifies is the speed contract with the person who opens it, and that contract has numbers. Google measures every page on three of them, and the generators do not optimize for those numbers unless you make them.

The three numbers

Core Web Vitals reduce page experience to three measurements, each with a threshold for a "good" rating at the 75th percentile of real visits. Largest Contentful Paint should land under 2.5 seconds: the moment the main content appears. Interaction to Next Paint should stay under 200 milliseconds: how fast the page responds when someone clicks or types. Cumulative Layout Shift should stay under 0.1: how much the content jumps around while it loads. LCP, INP, and CLS each have a documented method, and none of them cares whether a human or a model wrote the markup.

Where generated pages lose points

The failures cluster, and they follow from how builders assemble a page. LCP suffers when the hero image ships at full resolution with no dimensions and a JavaScript framework hydrates before anything paints. INP suffers when the whole page runs as a client-side app and every click triggers a re-render. CLS suffers when images arrive without width and height, web fonts swap in late, and an embed loads after the text and shoves it down. A generator optimizing for "looks done" produces all three at once, because looking done and loading fast are different objectives.

The fix is not a better prompt. It is a separate pass with a measuring tool. Google's LCP guidance lists the levers: serve the hero at the size it displays, preload it, remove render-blocking resources, and ship less JavaScript. Run the generated URL through Lighthouse, read the three scores, and work the list. The draft is free. The budget is not.

What our pipeline gets by construction

This blog passes the three checks for an architectural reason, not a tuning reason. The site is static: the HTML ships pre-rendered, so there is no client framework to hydrate before paint. The AI work, writing the post and generating the hero, happens at build time on our machine, not in the reader's browser. The hero is a sized, compressed JPG with explicit dimensions, so it reserves its space and never shifts the layout. Content pages carry almost no interactive JavaScript, so INP stays near zero.

That is the decision worth copying. When a page is mostly content, move the generation off the critical path. Let the model do its work before deploy, ship the result as static markup and optimized assets, and keep the browser's job to displaying what already exists. The code-on-the-canvas tools make generation fast; the architecture decides whether that speed reaches the reader or disappears into hydration.

The checklist before you ship

Measure the generated URL first. Then set width and height on every image, compress and resize the hero to its display size, and defer any script the first paint does not need. Reserve space for embeds and ads so late content cannot push the page. If the site is a blog, a portfolio, or a marketing page, choose a static or island architecture over a full client app. Re-measure after each change and stop when the three numbers clear their thresholds.

The generator gave you a site. The reader's patience is the budget, and Core Web Vitals is how you spend it. Enforce the budget after the build, every time, because the model will not enforce it for you.

Sources

The performance facts in this post come from these references:

  • web.dev defines Core Web Vitals and the good-rating thresholds measured at the 75th percentile of real users.
  • web.dev documents Largest Contentful Paint and its 2.5-second threshold.
  • web.dev documents Interaction to Next Paint and its 200-millisecond threshold.
  • web.dev documents Cumulative Layout Shift and its 0.1 threshold.
  • web.dev lists the techniques for improving LCP: right-sized heroes, preloading, and removing render-blocking resources.

More in Web Design