When a controlled benchmark handed five leading AI tools one simple CSS component to refactor, every tool shipped at least one regression. As AI makes code cheap, that finding relocates the defensible, billable asset to the senior human who reviews the output. For an agency without a deep dev bench, a productised review layer is a service to sell, not overhead to cut.
Ask most agency owners what AI has changed about front-end work and you will hear a version of the same reassuring line: we will just get AI to tidy the CSS. It sounds safe. Stylesheet cleanup is the low-stakes, unglamorous job that feels perfect to delegate to a machine. The reality is more interesting, and it should change how you price the work. When a repeatable benchmark actually tested that assumption on the simplest possible component, the AI tools did not quietly get it right. They got it subtly, expensively wrong, and the value moved to whoever was reviewing them.
"We'll just get AI to tidy the CSS," and what actually shipped
The assumption is everywhere right now, and the tools are encouraging it. Vibe-coding went mainstream through an Australian-born platform when Canva shipped Canva Code 2.0, with generation the company says is faster and slicker than the last version. Even Canva's own head of AI products, Danny Wu, conceded the gap that matters here, telling Australian outlet SmartCompany that "a tool that only solves for 'does it work' and ignores 'does it feel like mine' is solving half the problem." When the vendor admits its output only clears the "does it work" bar, the other half of the job is exactly what an agency sells.
So a developer put the "does it work" assumption on trial. In a benchmark published on the LogRocket blog, a single-file product-card component was seeded with seven deliberate CSS traps, then handed to ChatGPT, Claude, Copilot, Cursor and Gemini with one fixed prompt. The result was not close. Every single tool introduced at least one visual or functional regression on a component simple enough to fit in one file. This was not legacy spaghetti across forty stylesheets. It was one card, and none of the five got through it clean.
The failures weren't exotic: cascade, stacking contexts, over-modernised hacks
The regressions were not edge cases you would forgive. They were the fundamentals of how CSS actually resolves.
All five tools kept a `box-shadow` value that never applied in the original file, because a competing `!important` declaration won the cascade. The hover shadow that shipped was visibly different from the one the source rendered, which the benchmark author calls a genuine regression rather than a matter of taste. Four of the five also bolted on a CSS transition the original never had, turning an instant hover into an animation nobody requested. Only Claude left it alone.
Then there was stacking context, arguably the hardest thing to reason about in CSS. Four tools (ChatGPT, Claude, Copilot and Gemini) stripped the `z-index` that gave the card its own stacking isolation, a change that renders fine today and breaks the moment the card sits next to any other positioned element. Gemini and Claude merged two intentionally different Material greens (`#4caf50` and `#43a047`, adjacent Green 500 and Green 600 shades) into one, quietly collapsing two independently adjustable colours into a single point of failure. And three tools silently dropped a hover-opacity cue on the "Add to Cart" button, a bug the author only caught by testing the demos in a browser, not by reading the diff.
The one trap every tool respected is the tell. A decade-old, non-standard line-clamp hack that truncates the description to two lines is exactly the kind of thing an eager cleanup pass loves to "modernise" into a newer property that most browsers still do not support. Every tool left it untouched. They dodged the obvious trap and walked straight into the subtle ones. That is the signature of pattern-matching without comprehension, and it is why AI CSS refactoring is not a job you can hand off unwatched.
Why agentic editors beat chat tools, and why the winner still needed a human
There was a clear pattern in the rankings. Cursor finished first and Gemini finished last, the only tool to fail three of the seven tests. The top two spots both went to agentic, editor-based assistants rather than chat interfaces, and the reason is structural. Agentic tools edit files in place, while chat tools regenerate the whole stylesheet from the prompt, a process where it is far easier to drop or mangle an existing property on the way through.
Useful to know when you pick a tool. Useless as a substitute for review. Even Cursor, the winner, flattened generically named selectors like `.btn-primary` and `.tag` out of their scope, the kind of change that is invisible in a demo and a live collision risk in a real codebase with global styles. The benchmark's own conclusion is blunt: AI can speed up a refactor, but developers still need to review the output, spot the visual regressions, and check that the cascade resolves as intended. AI accelerates the keystrokes. It does not supply the judgement, which is the argument that AI-assisted builds relocate failures rather than remove them makes in full.
This is not a CSS quirk, and the wider data says so. In the 2025 Stack Overflow Developer Survey, the single most common frustration with AI tools was "AI solutions that are almost right, but not quite," named by 66% of developers who answered that question, with "debugging AI-generated code is more time-consuming" close behind on 45.2% (based on 31,476 respondents). Independent code analysis points the same way: reporting on GitClear's study of 211 million lines of changed code found duplicated code blocks rose sharply through 2024 while refactored ("moved") lines fell by around 40%, with code churn roughly doubling from its pre-AI baseline. GitClear is the primary author, so treat the churn figures as directional, but the direction is consistent. Close-but-wrong is the default output, and correcting it is the work.
Turning review into a line item
If the correction is the work, the correction is the product. That reframe matters most for the agency owner who has quietly worried that cheap AI code makes the shop redundant. The opposite is happening. As generation gets cheap, human judgement on the hard cases gets scarce, and scarce is what you charge for.
The pattern is already visible at scale. The Register reported that Microsoft's own Edge team is straining under the volume of AI-generated submissions, with review turnaround times climbing, and that their fix deliberately preserves people for "complex cases that benefit from human judgment." That is the whole thesis in one operational decision, and reframed for an agency, that judgement layer is a billable Website Review service.
Australia offers the honest counter-tension. At Australian Unity, as reported by iTnews, Head of Cloud and DevOps Abhay Sharma said AI "is genuinely increasing the volume of code" and that "our old approaches of relying on senior devs... just doesn't scale anymore," so they standardised automated quality gates that fail the pipeline when standards slip. Fair, and automation should catch syntax and security every time. But think of automated gates as a spellchecker and senior review as an editor. A spellchecker never once flagged the merged Material greens, the lost stacking context, or the dropped hover cue in that benchmark, because those are judgement calls about intended behaviour, not rule violations. That gap is the space a productised review layer fills.
The exposure is large and the discipline is not yet keeping up. In the Stack Overflow survey, 84% of developers said they use or plan to use AI tools and just over half use them daily (based on roughly 33,662 respondents), a professional-developer figure rather than an agency-specific one, but a fair proxy for how widespread unreviewed AI output now is. Trust is moving the other way: distrust of AI output accuracy rose to 46% against 33% who trust it, up from 31% distrust a year earlier per Stack Overflow. And a Sonar survey of more than 1,100 developers, carried by The Register, found 96% believe AI code is not reliably correct and 95% spend at least some effort checking it, yet only 48% always review it before committing. Between what developers know they should check and what they actually check sits a defensible service, and it is the same case that judgement, not production, is the asset clients now pay for has been making. Even conservative enterprises were early here: ANZ disclosed back in late 2024 that more than seven percent of its recent code was AI-generated, and that share was only expected to climb.
Broken rendering is also a visibility problem
Here the argument widens past aesthetics, because a silent CSS regression is rarely only cosmetic. A dropped focus or hover cue, a lost stacking context that hides an element, a broken truncation that overflows and wrecks contrast: these are the exact faults that put a client site out of step with accessibility duty. In Australia, the government standard requires WCAG 2.2 Level AA conformance, and accessibility sits within obligations under the Disability Discrimination Act 1992. The UK mirrors it: public-sector sites must meet WCAG 2.2 AA, and the Equality Act 2010 requires service providers to make reasonable adjustments so sites are perceivable and operable. A regression a spellchecker gate waves through can still be a legal exposure, which is why the accessibility gate is not something a modern-looking build gets to skip.
There is a search consequence too, and it is worth stating carefully. Unstructured or silently broken output is the same class of fault that keeps a page from rendering cleanly for crawlers and being parsed by AI answer engines. The terminology around AI search visibility is contested, and Google has pushed back on treating it as a separate discipline, so this is not a promise of citations. But a page that does not render and parse cleanly is a page that struggles to be read, let alone quoted, and clean, well-structured output is a precondition for both. That makes senior QA a safeguard for whether your client gets cited in AI answers at all, and it is the same structural discipline behind why citation rate diverges from ranking breadth. QA is not the cost of shipping AI-assisted work. It is what makes the work worth shipping.
Key takeaways
- Treat AI CSS refactoring as a draft, not a deliverable: a repeatable benchmark broke a single-file component with all five leading tools, most often on the cascade, stacking contexts and merged values.
- Prefer agentic, editor-based tools (Cursor, Copilot) over chat tools that regenerate whole stylesheets, but never skip human review, because even the top-ranked tool still needed a person.
- Productise the review as a line item: a senior Website Review layer sells precisely because generation is cheap and judgement on the hard cases is scarce.
- Automated quality gates catch syntax and security; they miss the visual-judgement regressions, so pair them with human review rather than treating either as sufficient.
- Frame QA as risk management: silent regressions can breach WCAG 2.2 AA and local accessibility duties, and they undermine whether a page can be cleanly read and cited.
Frequently asked questions
Can AI reliably refactor CSS without a developer reviewing it?
No. In a controlled seven-trap benchmark, all five leading AI tools introduced at least one visual or functional regression on a single simple component, most often mishandling the CSS cascade, stacking contexts or intentionally distinct values. AI can accelerate the cleanup, but the output needs human review before it ships.
Which AI tools were best and worst at refactoring CSS?
In the LogRocket benchmark, Cursor ranked first and Gemini last, failing three of seven tests. Agentic, editor-based tools that edit files in place outperformed chat tools that regenerate the whole stylesheet, because regeneration makes it easier to drop or alter existing properties.
Does AI code generally need human review, or is this just a CSS issue?
It generalises well beyond CSS. In the 2025 Stack Overflow Developer Survey, 66% of respondents named "AI solutions that are almost right, but not quite" as their top frustration, and independent analysis of 211 million lines of code by GitClear found duplication rising and refactoring falling in the AI era. Close-but-wrong is the common pattern.
How can an agency turn AI code review into a paid service?
Package senior human QA as a defined Website Review or white-label layer added to client retainers. As AI makes generation cheap, judgement on the hard cases becomes the scarce, chargeable asset, the same reason large teams like Microsoft's are deliberately reserving people for complex review cases.
Are silent CSS regressions an accessibility risk?
Yes. A dropped focus or hover cue, a lost stacking context or a broken truncation can put a site out of step with WCAG 2.2 AA, which is required under the Australian Government standard and the UK's public-sector accessibility regulations, and connects to duties under the Disability Discrimination Act 1992 and the Equality Act 2010. Review is how you catch them.
A site can look modern and still be invisible, and unreviewed AI output is a fast way to get there. Amina builds and reviews websites that are fast, accessible, and structured so search engines and AI can actually read and cite them. See how Amina approaches web build and review.
