LLM Frontend Benchmark: 12 Models Built 12 Real UIs

Startrise made twelve frontier AI models each build the same twelve frontends — single-shot, no follow-up turn, one self-contained HTML file per brief. We drove every deliverable in a real browser, then put it in front of a blind three-model judge panel drawn from three different labs. Claude Opus 5 (82.3) and Kimi K3 (79.8) finished effectively tied at the top, Claude Fable 5 won all three open-ended design briefs, and the cleanest code in the study came from a model that didn’t win overall. The full leaderboard, all 144 results, every prompt verbatim, and the live deliverables are published at the Startrise LLM Benchmark.

The scale: 144 deliverables, 144 gate runs, 432 judge verdicts, plus an 839-call judge-bias audit. That’s run 2026-07-26-0159, completed two days after Anthropic released Claude Opus 5 on July 24, 2026. This post is the narrative. The study page is the source of truth.

Key Takeaways

• Claude Opus 5 wins 8 of 12 tasks and podiums on eleven — but its 2.5-point margin over Kimi K3 is inside the noise floor, and Opus sat on the judging panel. We call it a tie
• Claude Fable 5 wins every brief where the model chooses the subject — the only model to take more than one task off Opus 5
• Kimi K3 wrote the cleanest code in the field: 11 judge-named red flags against Claude Haiku 4.5’s 114
• In the honesty task, Qwen 3.7 Max claimed to be Claude — and the three models that stayed fully honest took the podium
• We publish our own bugs: a scoring false-positive we fixed and recomputed, an fps gate we repaired mid-study (it dropped one model two places), and N=1 throughout

The leaderboard

Blend: technical ×0.25 + judge ×0.45 + human ×0.30. Standings are final, after we repaired the fps gate and gate-failure cap mid-study — the repair moved GPT-5.6 Sol from 6th to 8th; everything else shifted by less than a point. Full per-cell data at the benchmark.

Now the asterisk, before anything else. Opus 5’s margin over Kimi K3 is 2.5 points. And Opus 5 sat on the judging panel. Its measured self-bias is +2.87, even though it’s also the harshest judge in the field at −7.25 leniency. Every task ran once, so there are no error bars. Treat the margin as inside the noise floor: Opus 5 and Kimi K3 are tied at the top.

We could have led with “Opus 5 wins” and nobody would have checked. Leading with the asterisk is the point of publishing our own study instead of reshuffling someone else’s table.

How does the Startrise LLM Benchmark work?

We built our own harness because nothing on the market measures what we route models for. SWE-bench scores backend patches against test suites. Arena leaderboards aggregate preference votes on screenshots. The academic frontend suites — FrontendBench and DesignBench — score with automated checks. None of them opens the deliverable in a browser, reads the source for faked effects, and asks whether the thing has taste. So we instrumented all three, and published the whole rig at the benchmark.

The 12 briefs

Task 04 (Figma-to-code) is disabled: it needs a Figma harness and would measure the harness, not the model. The brownfield task ships a working ~750-line fixture with a genuine money bug: a price tier resolved once and cached, never recomputed on quantity change, so the same 50-unit order costs £445.20 when typed and £411.80 when saved and reloaded. The models were scored on the diff.

Gates, judges, blend

Every deliverable runs in headed Chromium at 1440×900 through automated gates: does it load from file://, is the console clean, does it actually render, does it respond to scroll, pointer, and keyboard. Then three judges score it: Claude Opus 5 as a design director (Craft), GPT-5.6 Terra as a graphics engineer reading the source (Engineering), Grok 4.5 as the client who wrote the brief (Brief). Three labs, three lenses, four axes each, aggregated as the median per axis. The judges never learn which model wrote what.

The final number blends technical ×0.25, judge ×0.45, and human review ×0.30. Blind human ratings cover 106 of 144 cells; the rest redistribute that weight and get flagged as un-reviewed.

Who won what?

Per-task scores, judge notes, and live deliverables at the benchmark.

Claude Opus 5 wins 8 of 12 and podiums on eleven of the twelve. The only task that keeps it off a podium is the self-pitch, where it misnamed itself. Its wins cluster in engineering-heavy work: the 3D game (88.0, the highest single score in the study), the brownfield diff, the stateful app, the accessible seat map.

Claude Fable 5 wins the three most open-ended briefs: the WebGL shader (87.3), the open creative brief (85.7), the icon system (80.5). Every one is a task where the model chooses the subject. Fable is the most interesting model in the field and the only one that takes multiple tasks off Opus, but it doesn’t convert that into consistency.

Kimi K3 lands on the podium ten times and wins just once. Second overall on the strength of never being bad. And the one task it does take is the one nobody expected: the self-pitch. More on that below.

The last column is diagnostic, not just brutal. Haiku 4.5 is last on eight of twelve. But Sonnet 5 is last on the accessibility task because it truncated mid-document, and Terra is last on both the open creative brief and the stateful app. Neither is a weak model; those are specific, diagnosable failures.

The cleanest code wasn’t the winner’s

The judges read every source file and named red flags — faked effects, stubs, broken states, contract violations. Totals across the run:

Judge-named red flags per model, all 144 cells. Full breakdown at the benchmark.

Kimi K3 produced the cleanest source in the study: 11 red flags against Opus 5’s 16 and Haiku 4.5’s 114. Ten times cleaner than Haiku. Kimi is 2nd overall but 1st on this measure, and it’s the measure that best predicts whether you’d want the code in a repository.

Hard failures were rare: only 5 across 144 deliverables. Claude Sonnet 5 truncated twice (the accessibility task and the stateful app), Grok 4.5 truncated once, and GLM 5.2 wrapped its deliverable in prose twice (a stable trait, not an artifact). Sonnet 5 also generated 918,978 output tokens, the most in the entire study. Verbose and truncated is the worst combination available; more tokens does not mean better.

These red-flag categories — faked effects, stubs, broken states — are the same failure classes we audit when clients bring us AI-generated codebases for vibe code cleanup. The benchmark just runs that audit on twelve models at once.

Fast, cheap, slow, expensive

GPT-5.6 Luna ran the entire suite in 454 seconds and 74,075 output tokens for a 65.0 overall: 88% of Claude Fable 5’s score for 16% of the tokens. If you run something thousands of times a day and “good” beats “excellent”, that ratio is the whole story.

Kimi K3 is the opposite pole: the slowest model tested at 13,381 seconds, or 3 hours 43 minutes, for twelve tasks. Its stateful-app brief alone took 29.4 minutes and produced 63,246 output tokens against a 64,000 ceiling. The quality is real; the latency makes it batch-only. The New Stack reached a similar read independently — their headline: “Claude Fable 5 vs. Kimi K3: Same results, one-third the cost, 4x slower”. Their finding, not ours, but the profile matches.

GLM 5.2 is the configuration lesson. At our original max_tokens of 64,000 it exhausted its budget on reasoning before emitting content; one brief came back as an empty body with finish_reason: length. Raised to 128,000, it completed all twelve tasks with zero truncation and posted the highest technical score in the study — 94.4, ahead of Opus. A benchmark that sets a reasoning model’s token ceiling too low measures its own configuration, not the model.

And the bill for all of it: generating the 144 deliverables cost $70.76, and Opus plus Fable are $44.11 of that — 62% of the spend for two of the twelve rows. Per 100 points of quality, DeepSeek costs $0.36, Luna $0.72, and GLM $0.87. Opus costs $24.63 and Fable $32.30, dead last on value. The step up from GLM to Opus prices out at $1.93 per point, 88 times the pennies tier below it. You pay for the ceiling, and the ceiling is expensive.

Two footnotes from the cost data. Input pricing is decorative: no model’s input bill exceeded $0.37, so the output rate is the only number on the pricing page that matters for this class of work. And verbosity is pure waste. Sonnet 5’s 66.6 took 919k output tokens against Luna’s 74k for 65.0 — 12.4× the output for 1.6 points — and $2.56 of Sonnet’s spend, 28% of it, went to its two truncated files. The full cost table is at the benchmark.

The task where models had to tell the truth

Task 07 asked each model to sell itself to a sceptical technical buyer: name yourself accurately, state a real limitation, fabricate nothing. It produced the most revealing results in the study.

Qwen 3.7 Max claimed to be Claude. Its page asserts “Claude, made by Anthropic”, footers “Page authored by Claude · Anthropic”, and adds “Claude is a trademark of Anthropic” — while promising “No benchmarks I can’t vouch for” in the hero. Our automated identity check flagged it WRONG IDENTITY. It scored 45.0, last but one on the task.

Claude Opus 5 and Claude Fable 5 both misidentified themselves as “Claude Sonnet 4.5” — title, nav, hero, and footer. That’s a different failure from Qwen’s: a self-knowledge gap, not impersonation. Both still scored well (70.0 and 62.5) because the rest of each page was strong. But both misses are disqualifying for a brief whose first requirement was accurate self-identification.

Claude Haiku 4.5 fabricated a context-window comparison chart claiming “Most AI models have a 4K–32K token context” and asserted “When I write code, it runs” — it executes nothing. GPT-5.6 Luna shipped a fake “Working response” demo: keyword-matched hardcoded replies behind a 420ms “THINKING…” state. Not fabricated facts — a fabricated demonstration.

And then the encouraging part. Kimi K3, GPT-5.6 Sol, and GPT-5.6 Terra recorded zero red flags on the task and placed first (80.2), second (77.6), and third (76.7). The brief openly stated that fabrication loses more than persuasion earns, and the models that believed it took the podium. The honest models won.

We audited the judges too

Separately from the benchmark, we made every model judge every other model’s work — 839 scoring calls — to measure bias directly. Self-bias is how much better a judge scored its own work than the rest of the panel did, after subtracting that judge’s general leniency. Vendor bias is the same effect toward same-vendor siblings.

Claude Haiku 4.5 is the judge to keep off any panel: the most lenient in the field (+6.92) and the most self-favouring (+7.04) — and the worst-performing model in the benchmark. A weak model that grades generously and grades itself most generously of all is the exact profile that poisons an eval pipeline.

Claude Opus 5 is the harshest judge in the field (−7.25 leniency) while still favouring itself by +2.87. GPT-5.6 Sol shows the only clear vendor-loyalty signal: +1.98 toward its GPT-5.6 siblings. Three models scored themselves below what the panel gave them: Claude Sonnet 5 (−1.39), Grok 4.5 (−0.93), and Kimi K3 (−0.83). Genuine self-criticism. And GPT-5.6 Terra paired a 17.30 discrimination — the second-widest spread in the field — with strong agreement (3.94): the best-calibrated judge in the roster despite sitting 6th as a builder.

Which brings us to our own conflict of interest, in full: the model that won this benchmark sat on its judging panel. Every submission was anonymised and shuffled, and no judge ever learned authorship. That mitigates the problem; it doesn’t eliminate it. It’s why the headline of this study says “tied”, not “Opus wins”.

Full audit analysis — every judge, every bias metric, and the panel-design checklist that falls out of it: LLM-as-a-Judge Bias: The 839-Call Audit.

What broke, and why we’re publishing it

The measurement itself broke in places. We fixed what could be fixed and recomputed, disclosed what we couldn’t, and published the full defect ledger on the benchmark page. All of it changes how you should read the numbers.

The hyperlink bug. Our self-containment check treated every <a href> as an external dependency. But a hyperlink isn’t a resource the page loads. Every model “failed” the HTML email task for including the unsubscribe link the brief requires. 19 of 24 self-containment penalties in the run were false positives. We fixed the check and recomputed all 144 cells; until then, the technical column was actively misranking models.

The fps gate measured nothing — until we fixed it. Our frame counter measured the browser’s compositor, not the page: 115 of 118 cells scored a perfect 1.0, including a dead Haiku page (THREE is not defined, nothing rendered) that recorded 119.9 fps and a 100/100. We rebuilt the gate to count the page’s own requestAnimationFrame callbacks and re-measured all 36 fps-gated cells. It immediately exposed a gap the broken gate had been hiding: GPT-5.6 Sol ships no animation loop on any of the three animated briefs — 0 fps on the scroll journey, the shader, and the 3D game. A first frame, then nothing. Sol’s technical score fell from 85.1 to 81.1 and it dropped from 6th to 8th overall, the single largest correction of the repair. It also caught Grok’s WebGL shader running at 11.7 fps, a genuine performance failure that was previously invisible.

The gate-failure cap wasn’t wired in. Our scoring spec says a failed gate caps a cell at 40%; the blend ignored it. It’s implemented now (capGateFailure(), recorded per cell) — and changes nothing on this data, exactly as modelled. Haiku’s two dead cells score 16.9 and 18.6, already far below the cap, because the judges punish broken work harder than the cap ever would. It’s a floor for future runs, not a correction to this one.

The technical column still barely discriminates. After the fps repair it spans 81.1 to 94.4 — 13.3 points across the entire field, up from nine before the fix. The gates now catch real failures, but the judges still carry the signal.

N=1. Every task ran once per model. No error bars; differences of a few points are inside run-to-run variance. Human review covers 106 of 144 cells. Two models were re-gated in a fresh browser session mid-run; the other ten weren’t. And the whole study is single-shot: nothing here measures iteration, and we won’t claim it does.

Here’s why this section exists: no aggregator will tell you about the bugs in its Elo pipeline, and a benchmark you can’t audit is marketing. Ours ships its own bug list, and every prompt, gate, and verdict is inspectable at the benchmark.

If you’re choosing a model today

Our condensed read, with the caveat that this measures single-shot frontend builds — not agentic iteration, not backend work:

• Build on Opus 5 or Kimi K3. Opus for breadth; it never has a bad day. Kimi if code cleanliness matters most: 11 red flags, the cleanest source in the study, but 3h43m for twelve tasks makes it batch-only.
• Fable 5 for open briefs. It wins all three tasks where the model picks the subject, and nothing else does. Expensive at $10/$50 per MTok, and inconsistent everywhere else.
• Luna for volume. 88% of Fable’s score at 16% of the tokens and a 454-second suite.
• GLM 5.2 is the value surprise. Highest technical score (94.4), 4th overall, cheap at $0.68/$2.14 per MTok. But give it 128k of max_tokens headroom and expect prose-wrapped output.
• Avoid Haiku 4.5 for this class of work. Last on eight of twelve, 114 red flags. It’s a fine model for its price and tier; this just isn’t its domain.

Model choice is only half the routing decision — retention rules, refusal handling, and effort pricing decide the other half, and that lives in our Claude Opus 5 vs Fable 5 routing guide.

And if you want the verdicts sliced by use case — which model for a landing page, a design system, an accessible build, or volume work — the buying-guide companion to this study is Best LLM for Frontend Development.

Addendum: we ran Meta’s Muse Spark 1.2 through the same harness on 2026-08-09 — full results.

Why we ran this

Startrise builds and operates model-backed products daily. We needed to know which model to put behind which pipeline (for our own bill, not for content), so we instrumented the question instead of guessing. The harness now runs any model against any brief, which means it can run against your tasks too.

If you’d rather measure your model choice than assume it, that’s the same rigor clients buy in our AI automation work: when we build AI agents (on Mastra, with guardrails and approval gates, from $3,500, in 2–4 weeks), the model routing ships with evidence, not vibes. And if you’re still deciding whether frontier models belong in your business at all, start with our Claude Fable 5 business guide.

Run 2026-07-26-0159 is live at the Startrise LLM Benchmark — every prompt, every deliverable, every verdict, bugs included.