uxskill
Star on GitHub
Language
English 简体中文 繁體中文 日本語 한국어 हिन्दी Bahasa Indonesia Tiếng Việt ไทย العربية Español Français Deutsch Português Русский Türkçe Italiano
Blog · Comparison · 2026-05-28

# AI-built websites in 2026: why every one looks the same.

Vercel v0, Lovable, Bolt.new, Replit Agent, Tempo, and Claude Code can all ship a functioning marketing site in under five minutes. They also all ship the same marketing site. The same gradient. The same trio of cards under the hero. The same body face stretched into a 90-pixel headline. Here is the honest comparison: what each builder is actually good at, where the shared fingerprint comes from, and the deterministic rules layer that catches it.

By the ux-skill team · 9 min read · MIT-licensed open source

## The six builders, in one table

Every name on the list ships a working website from a prompt. The architecture varies; the output convergence does not. Star counts are pulled live from GitHub on 2026-05-28 where the project has a public repo.

Builder | Stack output | Hosting | Where the design comes from
--- | --- | --- | ---
v0 by Vercel | Next.js, Tailwind, shadcn/ui | Vercel one-click | Inline model output · no rules layer
Lovable | React, Tailwind, Supabase backend | Lovable hosted · export available | Inline model output · no rules layer
Bolt.new by StackBlitz | Any (WebContainer) | Hosted or export | Inline model output · no rules layer
Replit Agent | Any (Replit Workspaces) | Replit Deployments | Inline model output · some Replit Designer assist
Tempo | React, Tailwind, shadcn/ui | Export to your stack | Inline model output · some block library
Claude Code / Cursor / Windsurf / Cline | Whatever you tell it | Your stack · your hosting | Reads project files · ux-skill plugs in here

The first five are end-to-end SaaS builders. The sixth row is the open IDE class: the model writes into your own repo, against your own files. Only the IDE class can read a deterministic rules layer from disk, which is why every blog post about the shared fingerprint ends up pointing at that side of the table.

## The shared fingerprint, named in detail

Send the same one-line prompt ("build a marketing site for a finance ops product") to all six. The output across all six rhymes hard enough that the screenshots are nearly interchangeable. Specifically:

- Body face at display sizes. A geometric grotesk like Inter or Geist is the default body face. The model reaches for the same face at the headline, sized to 88-96 pixels with a 1.0 line-height. The wordmark of every AI-built site reads as a body-typeface display.
- A multi-stop gradient over white. A wide gradient with hue spread over 100 degrees (indigo through violet to a blue endpoint, or a pink-to-blue counterpart) over a white or near-white surface. Used on the hero, sometimes on a card border.
- A trio of identical cards. Under the hero, on a 3-column grid, with a small icon, a one-word title, and a one-sentence subtitle. The icons are usually three of the same Lucide set: Zap, Shield, Heart, Sparkles, or Cube.
- Placeholder copy where product nouns belong. "Build something amazing." "Ship faster." "Beautiful experiences." The headline reads as a Stripe-era pitch deck written by no specific human.
- Fade-in-up on every section. Each direct child of every section enters with a 24-pixel upward translate and an opacity fade, on a 600-millisecond timing. No `prefers-reduced-motion` branch.
- Hairline 100-weight body type. Used for subtitles and small UI labels, which renders fine on macOS Retina and breaks on Windows ClearType.

None of those are wrong individually. The fingerprint is the combination. The model is not malicious or low-quality. It is reaching for the safest center of its training distribution every single time.

> Six builders, one aesthetic. The training data converged before the prompt was even written.

## Why all six converge

Three forces stack:

1. Training-set bias. The set of public marketing sites from 2021-2024 overweights startup landings from a narrow YC-and-Vercel-adjacent aesthetic. The model learns that aesthetic as the default. Anyone who has read more than ten Show HN comment threads in 2024 has read the same critique of the same trio.
2. Reward-model bias. Human raters who graded the post-training output preferred the safe option. Bright gradients and rounded cards score well in side-by-side preference tests. The reward model encodes that preference into the policy.
3. Prompt brevity. A short prompt ("build a marketing site for X") leaves every design decision to the model. The model picks the median of its distribution, every time.

Each of the six builders has its own system prompt, but the system prompts converge too. They all want the model to ship something demoable in seconds. Demoable in seconds means safe, and safe means the median.

## The two interventions that actually work

Adding ten lines of "do not use a body face at display size" to the system prompt fixes the issue for the first page. It does not fix it for the tenth. Prompt-only steering decays with context length, and every new chat throws the steering away.

The interventions that compound are upstream and downstream of the model:

- Upstream: a design system on disk. Token files (`tokens.css`, `manifest.json`, `MASTER.md`) in the repo that every prompt can read. The model picks tokens out of a constrained set instead of guessing.
- Downstream: a deterministic linter. Regex rules that scan the output after the model writes and fail the build if the fingerprint shows up. No LLM judge. No nondeterminism. Sub-second on a 200-file repo.

Both interventions sit outside the model. Both work in any IDE that runs on a real filesystem, which is the entire sixth row of the table above.

## How ux-skill plugs into the IDE class

ux-skill is a Python package with three install paths: `pip install uxskill`, `npx uxskill@alpha`, or the Claude Code plugin (`/plugin install ux@ux-skill`). After install, the engine exposes 25 commands across 17 IDEs and ships 145 deterministic regex rules over a 1,243-entry catalog.

The flow inside Claude Code, Cursor, Cline, Continue, Windsurf, Aider, Codex, or Roo Code is the same four steps:

1. `ux discover`: 10-field intake. Project type, audience, tone, must-haves, forbidden list, references, density, motion budget, accessibility floor.
2. `ux recommend`: five parallel lookups over the 1,243-entry catalog merge into one structured system. Output: `tokens.css` and `manifest.json` at the repo root, plus a per-IDE rules file (`.cursorrules`, `CLAUDE.md`, `.windsurfrules`, etc).
3. Any vibe-coding prompt: the model reads the rules file as part of its context window and writes against your tokens instead of its defaults.
4. `ux lint`: the gate. 145 regex rules over the generated code. Zero LLM cost. Exits non-zero on any high or critical finding. Plugs into pre-commit, GitHub Actions, GitLab CI, Husky, or any shell hook.

## The hosted builders: what they can and cannot do

v0, Lovable, Bolt, Replit Agent, and Tempo can not read a rules file from your laptop. They can not run a deterministic lint at preview time because there is no filesystem under their preview. The only mitigations available inside those products are:

- Better prompts. Long, specific intake. Reference real products by name. Name the anti-patterns explicitly in the prompt. Decay is real, but a long prompt buys you the first page.
- Block libraries. Tempo and v0 both ship some pre-made blocks. Picking from a block instead of generating from scratch sidesteps the fingerprint for the picked region.
- Export and finish. Bolt and Lovable both export to a real repo. Export, install ux-skill, lint, fix the findings, redeploy. That is the only path that closes the loop on a hosted builder.

The honest take: if you want to ship a hosted-builder result that does not look like every other hosted-builder result, your last step is always to export. That export will fail the lint on the first run. The lint findings will name the fingerprint by id. Fixing them in your IDE takes minutes.

## What an exported v0 page looks like under the lint

A typical v0 export of a 200-line marketing site, fresh from the prompt "build a SaaS landing for a logistics analytics product":

    $ uxskill lint apps/web/src --threshold high
    [FAIL] 7 findings at threshold high · exit 1

      high  font-stretched-display      src/components/Hero.tsx:14
                                        body face used at display size
                                        fix: pair the body face with a distinct display face

      high  saturated-multi-stop-grad   src/styles/hero.css:38
                                        wide-spread gradient over white surface
                                        fix: single restrained accent against neutrals

      high  three-equal-card-grid       src/pages/index.tsx:82
                                        three equal cards in a 3-column grid
                                        fix: asymmetric bento or 2-and-1 split

      high  filler-marketing-verbs      src/components/Hero.tsx:18
                                        filler verb in headline
                                        fix: name what the product actually does

      medium fade-in-up-everywhere      src/components/Section.tsx:24
                                        fade-in-up applied to every direct child
                                        fix: differentiate motion by role

      medium icon-emoji-stamp           src/components/Card.tsx:31
                                        emoji used as feature icon
                                        fix: use a real icon set, set aria-hidden

      medium inline-style-attribute     src/pages/about.tsx:44
                                        inline style on production component
                                        fix: move to tokens or utility class

Seven findings on a 200-line page, all named. The fix lines are written so the model can read them in its next prompt: "fix the inter-as-display finding on Hero.tsx line 14 by pairing the body face with a distinct display face from the recommendation." The next save passes the lint.

## Comparison: rules layers across the hosted builders

Builder | System prompt control | Tokens file | Deterministic lint | Export to ux-skill
--- | --- | --- | --- | ---
v0 | Custom instructions, paid tier | No | No | Yes: export to Next.js
Lovable | Custom knowledge file | No | No | Yes: export to Vite
Bolt.new | System prompt input | No | No | Yes: export to local
Replit Agent | Replit profile, agent.md | Limited | No | Yes: pull repo
Tempo | Project preferences | Limited | No | Yes: export to React
Claude Code · Cursor · Windsurf · Cline | `CLAUDE.md` · `.cursorrules` · etc | Yes: via ux-skill | Yes: 145 rules, sub-second | Native

Honest scope

#### This is not an attack on the hosted builders.

v0, Lovable, Bolt, Replit Agent, and Tempo are excellent at what they do. Going from prompt to running site in two minutes is a real piece of engineering, and the median user benefits enormously from it. The fingerprint problem is architectural, not effort: you can not run a deterministic filesystem lint inside a preview sandbox without a filesystem.

The honest workflow for serious teams in 2026 is hybrid. Use the hosted builder for the first draft. Export to your IDE. Install ux-skill. Let the rules layer take you from "looks generated" to "looks specific." It is a one-time install, not a per-project cost.

## The repeatable workflow

For the hosted-builder users, the loop is:

    # 1. Generate the first draft inside v0 / Lovable / Bolt / Tempo
    $ <use the hosted builder's prompt UI>

    # 2. Export to a local repo
    $ <the builder's "Download" or "Push to GitHub" action>
    $ cd ./exported-site
    $ git init && git add . && git commit -m "v0 export"

    # 3. Install ux-skill
    $ pip install uxskill
    $ ux init                # detects the IDE, writes the rules file

    # 4. Generate a system from a 2-minute intake
    $ ux discover
    $ ux recommend
    $ ux persist save

    # 5. Gate every future change
    $ ux lint --threshold high
    $ uvx pre-commit install   # or husky, or the GitHub Action

Total time on the loop: under fifteen minutes the first run, under ten seconds on every push after that.

## Where each builder fits today

Pick a builder by the job, not by the marketing.

- v0: best when the destination is Vercel, the stack is Next.js + shadcn/ui, and the deliverable is a marketing-grade landing page. The export is the cleanest in the field.
- Lovable: best when you want a working app with auth and a Supabase backend in one prompt. The hosted preview is the most polished of the SaaS class.
- Bolt.new: best when stack flexibility matters more than hosting integration. The WebContainer architecture means you can prototype literally any stack in the browser.
- Replit Agent: best when you want one product to cover prompt-to-deploy-to-prod (including a backend, scheduled jobs, and a database) without leaving Replit.
- Tempo: best when you have a designer who wants to drive the AI from a visual canvas rather than a prompt textarea.
- Claude Code / Cursor / Windsurf / Cline: best when the project is going to outlive the prompt, the team uses real source control, and the output needs a deterministic gate. This is where ux-skill lives.

## Related reading

- The centroid problem: why AI design regresses to the mean, the underlying mechanism.
- Vibe coding is real, but your AI still ships the same defaults, the workflow framing.
- Anti-AI-slop tools for Claude Code in 2026: the honest ranking, where ux-skill sits in the toolset.
- The AI design fingerprints every AI coding tool ships by default, the full taxonomy.
- Cursor design plugin walkthrough, the IDE install.

Install the rules layer

## Same prompt. Same builder. Different output.

145 deterministic regex rules, a 1,243-entry catalog, 25 commands across 17 IDEs. Drops in next to v0, Lovable, Bolt, Replit Agent, or Tempo, whichever shipped the first draft. MIT-licensed. No telemetry. No account.

$ /plugin marketplace add Laith0003/ux-skill
$ /plugin install ux@ux-skill
or
$ pip install uxskill
or
$ npx uxskill@alpha init

## Related reads

- The centroid problem
- Vibe coding + ux-skill
- Anti-AI-slop tools for Claude Code
- AI design fingerprints
- Cursor design plugin