AI-generated user interfaces

AI-generated · Lineage

Known gaps
  1. 1. Researched AI agents reviewed the literature on interface design choices with measured effects on users: 39 questions (31 answered, 8 contested), 144 sources. This article answers 10.
  2. 2. Verified A separate agent checked each claim against its source: 189 of 199 matched, 10 could not be checked. 2 sources cited here carry an unchecked claim; their citations are marked.
  3. 3. Written By Claude Sonnet 5.5, 13 November 2026. 22 sources cited, 10 only as an abstract (marked in the text).

An AI-generated user interface is a page, screen or component whose markup and styling were written by a large language model or coding agent, often from a text prompt or a screenshot. The studies measure how many defects such output contains, mostly accessibility defects found by automated checkers, and whether prompts, feedback loops or training reduce them. The main disputes are whether naming accessibility in the prompt helps reliably, whether models can judge interface quality at all, and whether generated interfaces are better or worse than human-built ones. Which general design choices help users is the subject of Evidence-based interface design; this article covers what is known about how well AI systems make those choices.

History

A history of how AI interface generation developed is missing; the earliest study cited here dates from 2024, and earlier text-to-GUI and screenshot-to-code work is not covered.

Core concepts

Accessibility defects

One survey of ChatGPT-generated websites reports that 84% of 88 sites had accessibility violations and only 14 were violation-free; automated checkers found 296 violations (AChecker) and 572 (WAVE) across the sites (Aljedaani et al., 2024). The same paper reports that ChatGPT fixed 70% of the violations in its own code and 73% in third-party code (Aljedaani et al., 2024). A CHI 2026 extended abstract found 541 semantic accessibility violations of six fault types across 300 UIs from three commercial models (Calò et al., 2026). Automated checkers cannot judge whether accessibility content is meaningful, for example alt text that passes the check but describes nothing useful (Calò et al., 2026).

Defects differ by feature. In a comparison of GPT-4o and Qwen2.5-Coder with human-written code, the models produced more accessible code than humans for colour contrast and alt text, but struggled with complex ARIA attributes (the markup that tells assistive technology what a custom control is) (Suh et al., 2025). Both models also struggled with font-size CSS, table scope and heading organisation (Suh et al., 2025). A factorial study with Claude 3.5 Haiku and GPT-4-turbo, ten UIs per model-by-prompt combination, found that under accessibility-agnostic prompts experts rated alt text (WCAG 1.1.1) and information structure (1.3.1) as violated in 100% of UIs (Gurita & Vatavu, 2025). In automated testing, text contrast (1.4.3) was met well under both prompt types, while page language, name, role and value, and non-text alternatives kept failing (Gurita & Vatavu, 2025).

Model choice mattered more than prompt wording in a benchmark of five models producing 58 HTML form components with 10 trials each (26,100 outputs): Gemini 3.1 scored an axe pass rate of 0.78 against 0.99 for Claude Opus 4.6 and Grok 4, and produced 125 of 5,220 invalid outputs (Ma et al., 2026b). (axe is an automated accessibility checker.) A self-published benchmark of 19 models on 150 UI tasks found that most flagship models never produced an artifact with zero detectable errors under any prompt condition; a high clean-output rate appeared only for a few small models (GPT-5-nano, GPT-3.5-turbo, GPT-5.1-codex-mini) (Kreer, 2026). Even the best flagship condition stayed above the error density of real pages measured by WebAIM, so guided AI output remained defect-dense per page element (Kreer, 2026). These are automated measures only: keyboard order, screen-reader announcements and cognitive load are not captured, and the author concludes that human review is still needed (Kreer, 2026).

Other defects

Expert evaluation of LLM-designed GUI mockups found that models create structured layouts effectively but face challenges in meeting accessibility standards and providing interactive functionality (Sawicki et al., 2026). DesignBench, a benchmark of 900 webpage samples, reports front-end compilation errors that depend on the framework (Angular showing the lowest success rate) and an average accuracy of about 27% for models asked to identify UI design issues (Xiao et al., 2025).

One survey bears on whether generated designs look generic. In it, 92 participants rated AI-generated and human-made prototypes without knowing the authorship; ratings on the UEQ-S questionnaire were positive for pragmatic qualities such as usability and efficiency and neutral or negative for hedonic qualities such as originality and innovation (Romero et al., 2026).

Benchmarks and measures

Benchmarks use different yardsticks, and they are not interchangeable. Accessibility benchmarks use automated checkers: PACE (axe results for form components) and WebAccessBench (axe-core only) (Ma et al., 2026b; Kreer, 2026). The PACE authors warn that it is a snapshot of model behaviour, not a ranking (Ma et al., 2026b). DesignBench tests compilation and issue identification (Xiao et al., 2025). EvoGenUI-Bench runs generated interfaces in a browser with automated checks and reports no human participants (Peng et al., 2026). A comparison of generated interfaces with a chatbot (TaskArtisan, 12 people) gave qualitative findings and no stated task success or time (Chen & Pavel, 2026).

Comparison with human-built interfaces

The comparisons are mixed. On automated accessibility checks, naive LLM code had an inaccessibility rate of about 0.35 against 0.425 for human code in one comparison (Suh et al., 2025), but the models were worse than humans on ARIA. In a blind survey of AI-generated and human-made prototypes, ratings were positive for pragmatic qualities such as usability and neutral or negative for originality and innovation (Romero et al., 2026).

Questions, controversies, and new developments

Does naming accessibility in the prompt help?

Contested

Small studies show large gains. With ten UIs per combination, expert-rated violation rates fell from 58.0% under accessibility-agnostic prompts to 19.0% under accessibility-oriented prompts; 1.3.1 fell from 100% to 0% and keyboard accessibility (2.1.1) from 80% to 0% (Gurita & Vatavu, 2025). Automated testing in the same study disagreed: the accessibility-oriented prompt had a slightly higher violation rate (17.32% against 15.93%) (Gurita & Vatavu, 2025). In a case study with GPT-4o, default prompts produced a page with WCAG violations (13 automated and 22 manual issues); after follow-up prompting all 13 automated and 20 of the 22 manual issues were resolved, leaving a table keyboard-focus problem and a focus indicator shown on only some sides (Ahmed et al., 2025a).

Across 19 models, a minimal “Make it accessible” nudge cut mean errors per artifact from 3.22 to 2.01, while expert implementation-level guidance gave 2.17, no better than the nudge (Kreer, 2026). Expert guidance was worse than the nudge for several models (GPT-5.2 2.40 against 1.98; Opus 4.6 2.76 against 2.02) (Kreer, 2026). In the five-model form benchmark, guidance changed the aggregate axe pass rate little (0.95 unguided, 0.97 guided), and the direction depended on the model: DeepSeek improved steadily, GPT improved to a plateau, Gemini got worse and Claude Opus changed little (Ma et al., 2026b). More detailed requests generally improved the axe pass rate, but the effect on schema score depended strongly on the model, and the authors conclude that prompt effects gave no dependable recipe for accessible output (Ma et al., 2026b). A 2026 systematic review reports that prompting approaches in the reviewed studies were mostly instruction-based or role-based and gives no pooled measure of their effect (Aljedaani & Mollik, 2026). The question is contested: the evidence shows that guidance can help, but sample sizes, models, outcome measures (expert or automated) and prompts differ, and the results do not converge.

Do feedback loops and training improve output?

Weak evidence

Zero-shot, few-shot and self-criticism prompting gave limited accessibility gains in one study, while a feedback loop that returned accessibility-tool output to the model (FeedA11y) did significantly better (Suh et al., 2025). FeedA11y with Qwen2.5-Coder had an inaccessibility rate of 0.300 on AChecker, the lowest of the compared methods and below the 0.425 of human-written code (Suh et al., 2025). It cut contrast issues by 53% for GPT-4o, left ARIA landmark uniqueness problems, and raised some other violation types (link title attributes, list link groups) (Suh et al., 2025). A later fine-tuning method, A11yn, reduced the inaccessibility rate by 87.5% and 58.1% under two WCAG auditors compared with its base model, in a single pass (Yoon et al., 2025).

Outside accessibility, rendering the page and having a model critique the screenshot raised benchmark scores. The WebGen-Agent system as a whole raised Claude-3.5-Sonnet’s accuracy on WebGen-Bench from 26.4% to 51.9% and its appearance score from 3.0 to 3.9, without isolating the feedback steps (Lu et al., 2025). A vision-language-model critic over three refinement cycles gave up to 17.8% higher solution quality than a single pass (Sansford et al., 2026); that loop was tested only with a model judge validated against existing pairwise votes, with no human task study (Sansford et al., 2026). Among three prompting methods for GUI generation, self-critique worked best (Kolthoff et al., 2024). In one study, human annotators preferred the full system with iterative refinement over a one-shot variant, which cost 14 points of overall win rate; this is pairwise preference, not task performance (Chen et al., 2025a). DuetUI, a human-agent co-generation system, reports improved task efficiency and usability in a 24-participant study, but the abstract names no comparison condition (Xu et al., 2025d).

Can models judge interface quality?

Weak evidence

Feedback loops and benchmarks often rely on a model as judge (see LLM-as-a-judge), so the judge’s reliability matters. Multimodal model scores of UIs correlated with crowd ratings (Pearson about 0.70) and fell within 0.35 points on average, but matched the exact score only 35-38% of the time, and Ease of Use correlations were near zero (Luera et al., 2025). In pairwise preference GPT-4o and Claude-3.5 agreed with the crowd about 60% of the time and only slightly above 50% when the human score gap was small (Luera et al., 2025). On 300 UI pairs whose winner was set by real A/B tests, models chose the winner at near-chance level (Jeon et al., 2026). Part of the difficulty is that trained designers disagree with each other (Krippendorff’s alpha 0.248 for binary preferences), and zero-shot GPT-5 matched designers’ binary preferences 57.70% of the time (Peng et al., 2025). Models also identify design issues poorly, at about 27% accuracy in DesignBench (Xiao et al., 2025).

Broader connections

Generated interfaces face the same accessibility standards that inclusive design applies to human-built ones, and automated checkers cover only part of the problems disabled users meet (Kreer, 2026). The design choices a model should make are the subject of interface-design. How agents fit into the stages of design work is covered in Interface design process, shared component libraries in Design systems, and testing with real users in Usability testing. Benchmarking and measuring agents in general is the subject of Agent evaluation tooling.

Further reading

  • Gurita and Vatavu (2025): a factorial study of prompt type with expert and automated scoring; shows how the two measures can disagree.
  • Ma et al. (2026b): a 26,100-output benchmark of HTML form components; shows that model choice and prompt effects interact.
  • Kreer (2026): a 19-model accessibility benchmark with three prompt conditions; self-published whitepaper.
  • Suh et al. (2025): compares LLM and human code and tests a feedback loop.
  • Luera et al. (2025): how well models predict human perception of interfaces.
  • Romero et al. (2026): blind human ratings of AI-generated and human-made prototypes.

Known gaps

  • No study was found that compares the task success or time of real users on generated and human-built interfaces.
  • No study was found that measures task success or time for real users on generated interfaces with versus without a feedback loop; refinement results are scored by models, automated auditors or pairwise preference.
  • Defects other than accessibility (layout, visual hierarchy, interaction, content) have no reported rates; they are described only qualitatively or as compile errors.
  • No study was found on design tokens, written requirements or human review as ways to improve generated interfaces.
  • Several key papers could be read only as abstracts or through review pages (the ChatGPT accessibility study, the CHI 2026 semantic-accessibility study, the TaskArtisan and EvoGenUI-Bench preprints), and most results are preprints.
  • No evidence was found on whether generated interfaces look generic or templated beyond one survey of originality ratings.

References

  • Ahmed, A., Fresco, M., Forsberg, F., & Grotli, H. (2025a). From code to compliance: Assessing ChatGPT's utility in designing an accessible webpage, a case study. arXiv:2501.03572. https://arxiv.org/html/2501.03572v1
  • Aljedaani, W., Habib, A., Aljohani, A., Eler, M., & Feng, Y. (2024). Does ChatGPT generate accessible code? Investigating accessibility challenges in LLM-generated source code. Proceedings of the 21st International Web for All Conference (W4A). https://api.semanticscholar.org/graph/v1/paper/DOI:10.1145/3677846.3677854
  • Aljedaani, W., & Mollik, R. H. (2026). Large language models for web accessibility: A systematic literature review. arXiv:2605.13873 (W4A 26). https://arxiv.org/html/2605.13873
  • Calò, T., Gurita, A., & De Russis, L. (2026). Measuring the Semantic Accessibility Gap in LLM-Generated Web UIs. Extended Abstracts of the 2026 CHI Conference on Human Factors in Computing Systems (CHI EA 26). https://tommasocalo.github.io/papers/semacces abstract only
  • Chen, J., Zhang, Y., Zhang, Y., Shao, Y., & Yang, D. (2025a). Generative interfaces for language models. arXiv:2508.19227. https://arxiv.org/html/2508.19227
  • Chen, M., & Pavel, A. (2026). TaskArtisan: Designing composable generative widgets for LLM-assisted analysis. arXiv preprint. https://arxiv.org/abs/2607.17394 abstract only unverified claims
  • Gurita, A., & Vatavu, R. (2025). When LLM-generated code perpetuates user interface accessibility barriers, how can we break the cycle? Proceedings of the 22nd International Web for All Conference (W4A 25). https://mintviz.usv.ro/publications/2025.W4A.3.pdf
  • Jeon, J., Kim, M. S., Yoon, J. H., Shim, S., Choi, Y., Kim, H., Kim, D. H., & Yu, Y. (2026). Do MLLMs capture how interfaces guide user behavior? A benchmark for multimodal UI/UX design understanding (WiserUI-Bench). arXiv preprint. https://arxiv.org/html/2505.05026v4
  • Kolthoff, K., Kretzer, F., Fiebig, L., Bartelt, C., Maedche, A., & Ponzetto, S. P. (2024). Zero-shot prompting approaches for LLM-based graphical user interface generation. arXiv:2412.11328. https://arxiv.org/abs/2412.11328 abstract only
  • Kreer, C. (2026). WebAccessBench: Digital accessibility reliability in LLM-generated web interfaces. Self-published whitepaper, conesible.de. https://conesible.de/wab/whitepaper_webaccessbench.pdf
  • Lu, Z., Ren, H., Yang, Y., Wang, K., Zong, Z., Pan, J., Zhan, M., & Li, H. (2025). WebGen-Agent: Enhancing interactive website generation with multi-level feedback and step-level reinforcement learning. arXiv:2509.22644. https://arxiv.org/abs/2509.22644 abstract only
  • Luera, R. A., Rossi, R., Dernoncourt, F., et al. (2025). MLLM as a UI judge: Benchmarking multimodal LLMs for predicting human perception of user interfaces. arXiv preprint. https://arxiv.org/html/2510.08783v1
  • Ma, Y., Wobbrock, J. O., Devon, J., Gustafson, A., Fairchild, M., Mankoff, J., & Potluri, V. (2026b). Prompt and circumstance: Evaluating accessibility in LLM-generated HTML form components. ASSETS 26, ACM SIGACCESS Conference on Computers and Accessibility. https://doi.org/10.1145/3797867.3828975
  • Peng, Y., Bigham, J. P., & Wu, J. (2025). DesignPref: Capturing personal preferences in visual design generation. arXiv preprint. https://arxiv.org/html/2511.20513v1
  • Peng, Y., Xia, L., Wang, Z., Ye, J., Ning, K., & Wen, H. (2026). EvoGenUI-Bench: Evaluating LLMs as multi-turn generative UI assistants. arXiv preprint. https://arxiv.org/abs/2608.29387 abstract only unverified claims
  • Romero, K., Wiese, I., Balancieiri, R., Leal, G. C., & Guerino, G. (2026). Usable but conventional: An empirical study on the UX of AI-generated interface prototypes. arXiv:2605.15124 (SEMISH 2026). https://arxiv.org/abs/2605.15124 abstract only
  • Sansford, H., Law, D. H. C., Liu, W., Tripathi, A., Agarwal, N., & van den Burg, G. J. J. (2026). Vision-guided iterative refinement for frontend code generation. arXiv:2604.05839. https://arxiv.org/abs/2604.05839 abstract only
  • Sawicki, B., Les, T., Parzych, D., Wycisk-Ficek, A., Trebacz, P., & Zawadzki, P. (2026). Qualitative evaluation of LLM-designed GUI. arXiv:2601.22759. https://arxiv.org/abs/2601.22759 abstract only
  • Suh, H., Tafreshipour, M., Malek, S., & Ahmed, I. (2025). Human or LLM? A comparative study on accessible code generation capability. arXiv:2503.15885. https://arxiv.org/abs/2503.15885
  • Xiao, J., Wang, M., Lam, M. H., Wan, Y., Liu, J., Huo, Y., & Lyu, M. R. (2025). DesignBench: A comprehensive benchmark for MLLM-based front-end code generation. arXiv:2506.06251. https://arxiv.org/html/2506.06251v1
  • Xu, Y., Xiang, S., Song, Y., Sun, R., & Tong, X. (2025d). DuetUI: A bidirectional context loop for human-agent co-generation of task-oriented interfaces. arXiv:2509.13444. https://arxiv.org/abs/2509.13444 abstract only
  • Yoon, J., Cho, J., Kim, J., Chung, J., Jeon, J., Lim, S., & Yu, Y. (2025). A11yn: Aligning LLMs for web accessibility-aware UI generation. arXiv:2510.13914. https://arxiv.org/abs/2510.13914 abstract only