Design Behaviour and Interface Consistency in Generative No-Code Tools: A Systematic Literature Review

Abstract

Generative no-code development tools enable users to create applications directly from natural-language prompts, shifting interface design from manual construction to AI-mediated generation. However, identical prompts frequently produce substantially different user interface (UI) outcomes across tools and even across repeated executions within the same tool. This paper presents a systematic literature review examining how generative no-code systems make design and aesthetic decisions with respect to layout structure, visual consistency, usability, accessibility, and reproducibility. Twenty peer-reviewed studies (2021–2025) were analyzed following a structured review protocol. Existing research predominantly evaluates usability and accessibility in isolation while providing limited insight into aesthetic coherence, design variability, and prompt-to-output stability. Across studies, generative tools exhibit implicit design priors and stochastic behavior that lead to inconsistent visual outcomes and partial misalignment with human-centered design principles. These findings indicate that generative no-code tools do not act as deterministic translators of user intent but instead introduce their own stylistic tendencies. The paper identifies critical evaluation gaps and outlines requirements for future systems, including reproducible generation, transparent design reasoning, and user-directed control, to support reliable and predictable interface development.

1. Introduction

Low-code/no-code (LCNC) platforms have transformed software development by offering visual environments and pre-built components that require minimal or no programming knowledge. This accessibility has contributed to the “democratization” of software creation, enabling non-technical professionals, often referred to as citizen developers, to construct applications quickly and cost-effectively [1]. LCNC solutions are widely adopted because they accelerate development, reduce labor costs, and improve agility, thereby addressing traditional challenges such as delayed delivery and high implementation effort [2]. Adoption is expected to continue growing, with projections indicating use in nearly 70% of enterprise applications by 2025 [3] and approximately 65% of software projects overall [4].

The integration of LCNC platforms with Generative Artificial Intelligence (GenAI) represents a further shift in software creation workflows. GenAI tools use deep learning models to generate new content and automate development tasks, enhancing LCNC environments by supporting ideation, prototyping, and feature refinement [1]. In user interface (UI) development, Multimodal Large Language Models (MLLMs) can translate sketches, screenshots, or natural-language descriptions directly into functional code (UI2Code) [5]. Commercial systems such as Bolt [6] and Replit [7], along with similar platforms, illustrate this emerging paradigm in which interfaces can be produced from textual instructions.

However, reliance on generative no-code tools introduces challenges related to design quality, consistency, and predictability. Natural-language prompts are inherently ambiguous, making it difficult for users to precisely specify design intent. Furthermore, because large language models operate probabilistically, outputs may vary across executions. Studies evaluating systems including Bolt, Replit, and comparable platforms report that identical prompts can produce substantially different layouts, styling decisions, and component structures across tools and across repeated runs within the same tool [8,9]. As a result, users frequently engage in iterative prompting to refine outputs, reducing expected efficiency gains.

Existing research primarily evaluates usability, accessibility, and correctness of AI-generated interfaces, but rarely examines how generative no-code systems make design decisions. Consequently, it remains unclear whether these systems function as translators of user intent or as agents that impose learned design behaviour. To address this gap, this study conducts a systematic literature review (SLR) synthesizing research on automated UI design in generative no-code environments.

While prior work assesses output quality, little research investigates the behavioral logic producing those outputs. This review therefore interprets generative no-code tools as probabilistic design agents rather than deterministic implementation tools. Instead of asking whether generated interfaces work, the study investigates how tools interpret intent, apply implicit design conventions, and produce variable yet structurally coherent interfaces.

The contributions of this paper are:

• It synthesizes reported evidence on layout, styling, usability, and accessibility into a structured synthesis of generative design behaviour;
• It shows that variability and inconsistency arise from learned design priors rather than isolated technical errors; and
• It identifies reproducibility, transparency, and controllability as necessary properties for reliable human–AI interface development.

The remainder of this paper is organized as follows. Section 2 introduces background concepts related to low-code/no-code platforms and generative UI systems. Section 3 reviews related work. Section 4 describes the systematic review methodology. Section 5 presents synthesized findings. Section 6 discusses their implications. Section 7 outlines threats to validity, and Section 8 concludes the paper.

2. Background

The evaluation of no-code tools for automated user interface (UI) design operates within the broader context of the evolving software industry, driven by the emergence of Low-Code/No-Code (LCNC) platforms and the subsequent integration of Generative Artificial Intelligence (GenAI). This background outlines the historical development of LCNC systems, the factors driving their adoption, the conceptual distinctions between low- and no-code approaches, and the transformative impact of GenAI, particularly Large Language Models (LLMs) and Multimodal LLMs (MLLMs), on automated UI generation. It also highlights the technical and aesthetic challenges that underpin the need for a systematic evaluation.

2.1. The Rise of Low-Code/No-Code Development

Building on the concepts introduced in Section 1, low-code/no-code (LCNC) platforms can be understood as an evolution of earlier visual and rapid application development paradigms that emphasize abstraction and model-driven design [10,11]. Rather than redefining their general characteristics, this section focuses on their role within contemporary software ecosystems and their implications for automated interface generation.

LCNC platforms have evolved into mature development environments that support rapid application creation through graphical modeling and reusable components. While these systems improve development efficiency and accessibility, they also introduce constraints related to scalability, customization, and control, which become particularly relevant in the context of AI-driven interface generation [12].

2.2. Defining Low-Code and No-Code

Although often grouped together, low-code and no-code platforms target different levels of technical expertise. As shown in

Table 1. Low-Code versus No-Code platform characteristics.

Feature	Low-Code (LC) Platforms	No-Code (NC) Platforms
Primary goal	Accelerate development with minimal manual coding [11].	Eliminate the need for traditional coding altogether [11].
Target user	IT professionals, developers, or “citizen developers” with some coding knowledge [12].	Business users or “citizen developers” who have minimal or zero programming background [10].
Customization	Allows a high degree of custom sation and flexibility, often enabling users to write some custom scripts/code [13].	Relies heavily on pre-designed components, templates, and ready-made functions [13].
Technical Approach	Acts as a middle ground, speeding up development with minimal coding [11].	Utilizes visual programming entirely through a graphical interface and drag-and-drop functions [11].

, low-code platforms support developers or technically skilled citizen developers by allowing limited scripting and customization, whereas no-code platforms rely primarily on visual workflows and pre-built components for users with minimal programming background [10,11,12,13].

Both approaches abstract implementation details through graphical development environments, enabling faster application creation while reducing reliance on traditional programming. This study focuses on generative no-code systems, which extend this abstraction by using large language models to produce user interfaces directly from natural-language prompts.

2.3. The Convergence with Generative AI in UI Design

The integration of Generative Artificial Intelligence into low-code/no-code platforms enables interfaces to be produced directly from natural-language descriptions rather than manually assembled components [1]. Using large language models (LLMs) and multimodal LLMs (MLLMs), these systems can translate prompts, sketches, or screenshots into functional UI code, commonly referred to as UI2Code or design-to-code generation [14].

This shift changes interface creation from deterministic configuration to probabilistic generation. While it accelerates prototyping and lowers technical barriers, it also introduces uncertainty in how design decisions are inferred, motivating the need to examine consistency, reliability, and alignment with human-centered design principles.

2.3.1. Multimodal Large Language Models (MLLMs)

Multimodal large language models extend text-based generation by incorporating visual understanding, allowing UI code to be generated from mockups, screenshots, or other visual artifacts [15,16]. Compared with earlier vision-based approaches, these models can produce more complete interface structures but still struggle with complex layouts and interaction logic [17]. As a result, generated interfaces may contain missing elements, incorrect component mappings, or inconsistent behaviors across pages.

2.3.2. Structured Approaches for Managing UI Complexity

Because direct prompt-based generation struggles with complex layouts, several approaches introduce intermediate structural representations to guide UI synthesis [5,16,17]. These methods decompose interfaces into hierarchical regions or layout trees before code generation, improving structural accuracy and reducing omissions. However, while structured pipelines improve reliability in controlled scenarios, prompt-driven no-code tools still expose variability because internal representations remain hidden from end users.

2.4. Challenges in Generative AI and No-Code UI Automation

The integration of generative AI into no-code environments introduces challenges related to predictability, correctness, and design quality. Because large language models operate probabilistically, identical prompts may produce different outputs, complicating testing and reproducibility [9]. The ambiguity of natural language further affects reliability by making precise specification difficult and increasing prompt interpretation variability [14,18].

At the implementation level, generated interfaces often contain structural and functional errors, including missing elements, incorrect component mappings, navigation inconsistencies, and compilation issues requiring manual correction [15,17]. These problems are particularly evident in multi-page applications, where consistent behavior across screens is difficult to maintain.

Beyond functional correctness, design quality also varies. Generated interfaces may exhibit homogenized layouts, lack pixel-level precision, or require manual visual adjustments to meet professional standards [19,20,21]. Finally, limitations inherent to LCNC platforms, such as scalability constraints, hidden platform bugs, and accumulated technical debt, can propagate into generated applications and further reduce reliability [3,22].

3. Related Work

Generative no-code UI research spans three primary directions: platform-oriented studies on low-code/no-code ecosystems, empirical evaluations of AI-generated interfaces, and accessibility or usability assessments. While these works (see

Table 2. Key related studies on generative no-code and AI-assisted UI design.

Study	Year	Methodology and Focus	Key Findings and Limitations
Zhou T. [15]	2025	Design-to-code pipeline using computer vision and multimodal LLMs to generate UI code from mockups and screenshots.	Structural accuracy; lacks user-centered evaluation.
Wan Y. [17]	2025	Divide-and-conquer UI generation pipeline using multimodal LLMs to decompose screenshots and generate HTML/CSS.	Focus on fidelity; limited usability and accessibility analysis.
Leung A. [8]	2025	Interactive UI-authoring system combining LLM generation with structured intermediate representations for guided prototyping.	Focuses on prototyping workflows and refinement; limited evaluation of UI design quality and user experience.
Liu D. [3]	2024	Empirical analysis of bugs in low-code platforms, focusing on UI-related defects and interaction logic.	Identifies design-stage defects in UI graphics and interactions; limited assessment of overall UI design quality and user-centered aspects.
Duan P. [19]	2024	Introduces UICrit dataset with expert UI critiques and applies visually guided few-shot prompting for design feedback generation.	Improves LLM-based design critique quality; focuses on issue-level feedback with limited coverage of holistic UI evaluation and reproducibility.
Gui Y. [5]	2025	UICopilot system using hierarchical UI-to-code generation with separated structural prediction and HTML/CSS synthesis.	Improves layout accuracy and visual similarity; limited evaluation of user-centered design qualities and restricted to static web interfaces.
Khalajza H. [23]	2025	Systematic literature review of accessibility in low-code development environments.	Synthesizes accessibility strategies and research gaps; does not address AI-generated UI artifacts or interface design quality.
Somer P. [24]	2025	Structured literature review on algorithmic accountability in low-code/no-code AI platforms.	Identifies governance risks and mitigation strategies; does not address user-facing UI design or generative interface behavior.
Kamouch H. E. [25]	2023	PRISMA-guided systematic literature review of low-code/no-code platforms and their technologies, applications, and challenges.	Provides a high-level overview of LCNC ecosystems; lacks empirical evaluation of UI design quality and generative behavior.
Gao D. [26]	2024	Introduces EDEQ-LCDP questionnaire to measure episodic developer experience in low-code platforms.	Focuses on subjective developer experience in limited task settings; does not assess UI design quality or generative behavior.
Roy et al. [27]	2025	Benchmark study of generative AI tools across software engineering tasks.	Highlights workflow trade-offs and educational implications; limited evaluation of detailed UI design and generative variability.
Lively et al. [28]	2023	Study on the impact of text- and image-based generative AI tools on creativity and UX design education.	Highlights effects on creativity and ideation; limited evaluation of UI design quality and generative system behavior.
Xu H. [29]	2025	Knowledge-augmented framework using visual prompting and retrieval-augmented generation to convert UI wireframes into React applications.	Improves code structure and scalability; focuses on code quality with limited evaluation of UI design and cross-tool generative behavior.
Dibia V. [30]	2024	Introduces AUTOGEN STUDIO, a no-code environment using structured representations for LLM-based multi-agent workflows.	Improves controllability, transparency, and reproducibility; not focused on UI generation or user-centered interface design.
Liu Y. F. [31]	2024	Evaluates an AI-enhanced mobile learning application using expert-based usability heuristics.	Identifies strengths in visual design and feedback; limited to a single application and does not assess generative UI systems.
Gurita A. E. [32]	2025	Evaluates accessibility of AI-generated user interfaces across 90 samples and analyzes the impact of prompting strategies.	Focuses on accessibility outcomes; limited coverage of broader UI design qualities and restricted to static outputs from a small set of tools.
Gurita A. E. [33]	2025	Evaluates 200 AI-generated user interfaces across five tools using WCAG criteria and prompt engineering analysis.	Emphasizes accessibility compliance and visual consistency; limited assessment of broader UI quality and reproducibility.
Iman J. A. [34]	2025	Comparative study of AI-generated and human-designed minimalist UI refinements.	Shows AI-refined designs can outperform humans in usability and efficiency under constrained settings; limited to minimalist scenarios with no broader evaluation of design variability.
Kamnerddee C. [35]	2024	Compares AI-generated and human-designed mobile UI prototypes using usability testing and interviews; proposes AID-UX framework.	Highlights human–AI collaboration in UI design; limited to prototype-level evaluation without analysis of reproducibility or cross-tool variability.
Shahab M. A. [36]	2024	Survey-based study using the SPACE framework to assess the perceived impact of generative AI on mobile UI design workflows.	Highlights perceived efficiency and workflow impact; relies on self-reported data with no objective evaluation of UI artifacts.
Doush I. A. [37]	2024	Evaluates AI-generated web code from ChatGPT and Copilot using metric-based measures of accessibility, correctness, and compatibility.	Focuses on code-level quality and compliance; limited evaluation of UI design and cross-generation variability.
Monteiro M. [38]	2025	Introduces NoCodeGPT, a task-oriented no-code interface using GPT models to guide structured application development.	Improves task completion for non-experts; limited to small-scale studies with no evaluation of broader UI design quality.
Fischer M. [39]	2024	Mixed-method study combining literature review and user evaluation (18 students) to assess generative AI support across development phases.	Highlights usability and workflow integration; limited by small sample size and lacks evaluation of UI design quality.
Paliwal G. [1]	2024	Conceptual review of the convergence between low-code/no-code platforms and generative AI, including a small case study.	Highlights potential for rapid development and automation; lacks systematic evaluation and relies on a limited illustrative case.
Guthardt T. [40]	2024	Empirical comparison of programmers and citizen developers using a prototype no-code builder.	Finds comparable performance and usability between groups; limited by simplified tasks and lacks evaluation of UI design quality.
Liu S. [41]	2022	Design and usability evaluation of Pathverse, a no-code platform for mHealth application development.	Focuses on platform usability and development; limited by small sample size and lacks evaluation of UI design quality.
Pinho D. [42]	2023	Systematic literature review of 38 studies on usability in low-code platforms.	Identifies common usability challenges and platform features; focuses on platform-level usability with limited relevance to generated UI design.
Velásquez A. P. [4]	2024	Systematic literature review of 15 studies on low-code development features, benefits, and challenges.	Identifies common platform trends and limitations; focuses on general LCNC aspects with no evaluation of UI design quality.
Rokis K. [43]	2023	Comprehensive literature review of low-code development covering concepts, lifecycles, and adoption patterns.	Synthesizes platform characteristics and adoption trends; limited relevance to UI design and interface-level analysis.
Ajimati M. O. [44]	2025	Multi-phase systematic literature review of 40 studies on low-code/no-code adoption.	Identifies key adoption factors and organizational impacts; focuses on high-level adoption with no evaluation of UI or artifact-level quality.
Sufi F. [45]	2023	Practical review of 47 studies on low-code/no-code usage patterns and applications (e.g., AI/ML, NLP, visualization).	Highlights data-centric workflows and capabilities; limited relevance to UI design and generative interface evaluation.
Zhang L. [11]	2024	Evaluates low-code/no-code platforms using the ISO 25,010 software quality model.	Identifies strengths in usability and development efficiency; focuses on general software quality with limited evaluation of UI design and generative behavior.
Cui J. [22]	2024	Qualitative review of academic and industry sources on the impact of low-code/no-code platforms on development efficiency and delivery.	Highlights faster prototyping and reduced coding effort; focuses on productivity outcomes with limited evaluation of UI design quality.
Abahussain O. [12]	2025	Review of benefits, risks, and hybrid approaches in low-code/no-code platforms.	Highlights development advantages and organizational challenges; focuses on technical and organizational aspects with no evaluation of UI/UX design.
Upadhyaya N. [46]	2025	Review of the impact of low-code/no-code platforms on traditional software development processes.	Highlights benefits such as faster delivery and citizen development; focuses on organizational and lifecycle impacts with no evaluation of UI design or empirical validation.

) provide valuable insights into productivity and compliance, they rarely examine design consistency, aesthetic reasoning, or reproducibility across generated interfaces. Consequently, existing literature offers fragmented perspectives on UI quality rather than an integrated understanding of automated design behavior.

3.1. Systematic Literature Reviews and Surveys on Low-Code/No-Code Platforms

Prior systematic reviews primarily examine LCNC platforms from technological and organizational perspectives, focusing on adoption, productivity, and governance [4,12,43,44,46]. These studies consistently report faster development cycles and improved accessibility for non-programmers but also identify scalability limitations, customization constraints, and vendor lock-in risks.

However, UI is typically treated as part of platform usability rather than as a design artifact. Evaluations therefore rely on perceived ease of use, workload reduction, or workflow efficiency rather than analysis of generated layouts, visual hierarchy, or aesthetic consistency [42,45]. As a result, the visual and behavioral properties of generated interfaces remain largely unexplored.

3.2. Empirical Studies Evaluating AI-Generated User Interface Designs

Empirical studies comparing AI-generated and human-designed interfaces report comparable baseline usability and efficiency but highlight differences in perceived intuitiveness and engagement [34,35]. Other investigations emphasize productivity improvements and faster ideation workflows rather than direct assessment of design quality [36,38].

Although these studies evaluate usability metrics such as task completion time, SUS scores, and cognitive workload, they rarely analyze aesthetic logic, layout consistency, or variability across repeated generations. Most experiments also rely on simplified tasks or single outputs, limiting insight into real-world generative behavior.

3.3. Systems for UI Authoring and Structured Representations

Several systems introduce intermediate structural representations to improve controllability and reliability in AI-assisted UI generation [8,15,17,29,30]. By constraining generation through layout decomposition or guided refinement, these approaches reduce structural errors and improve code correctness. However, they focus primarily on functional fidelity and implementation accuracy rather than human-centered design qualities such as aesthetic reasoning, usability, or cross-generation consistency. Consequently, they provide technical stability but limited understanding of emergent design behavior in prompt-driven no-code tools.

3.4. Accessibility- and Usability-Focused Evaluations of AI-Generated Interfaces

Accessibility-focused research evaluates AI-generated interfaces using WCAG and ARIA compliance metrics, generally finding acceptable baseline accessibility but frequent minor violations requiring iterative correction [32,33,37]. These systems often achieve compliance through standardized patterns, which can reduce creative diversity and produce visually similar interfaces.

Usability studies similarly report adequate task performance but persistent preference for human-designed interfaces, suggesting that technical correctness does not fully capture perceived design quality [35]. Across both research streams, accessibility and usability are typically assessed independently, leaving broader design coherence and reproducibility insufficiently examined.

3.5. Motivation for Further Systematic Review

Existing literature demonstrates that generative UI systems can support development efficiency and baseline usability but provides limited insight into design consistency, aesthetic variability, and reproducibility. Moreover, prior evaluations treat accessibility and usability as isolated properties and rarely analyze how automated tools interpret design intent across tools or repeated generations.

These gaps motivate a systematic review focused specifically on layout structure, visual aesthetics, consistency, usability, accessibility, and prompt-to-output reliability in generative no-code interface design.

4. Methods

This study employed a Systematic Literature Review (SLR) methodology to identify, evaluate, and synthesize research on automated user interface design in generative no-code tools. The review followed a structured protocol [47] to ensure transparency and reproducibility and focused on design decisions, aesthetic behavior, and consistency across generated interfaces. The review process and reporting were structured in accordance with the PRISMA 2020 (Preferred Reporting Items for Systematic Reviews and Meta-Analyses) guidelines [48].

4.1. Research Questions

This study was guided by one main research question (MRQ) and four supporting sub-questions designed to examine how generative AI–based no-code tools make UI design decisions, how consistent these decisions are, and how well they align with established design principles.

• MRQ: How do generative AI-based no-code tools make user interface (UI) design and aesthetic decisions when generating applications from natural-language prompts?
• RQ1: What underlying design principles, layout structures, or color strategies can be observed in the generated interfaces?
• RQ2: How do generative design tools (e.g., Bolt, Lovable, Replit) vary in the user interfaces they generate when given the same prompt, both across different tools and across repeated generations within the same tool?
• RQ3: To what extent do the generated interfaces adhere to established usability and accessibility guidelines (e.g., WCAG and Nielsen’s heuristics)?
• RQ4: What limitations, biases, or inconsistencies exist in the current generative UI design systems?

4.2. Review Protocol and Planning

The review followed an a priori protocol based on Kitchenham’s guidelines and PRISMA 2020 reporting standards [47,48]. The protocol defined the research questions, search strategy, eligibility criteria, quality assessment, and data extraction procedures before the search was conducted. This process aimed to reduce selection bias and ensure replicability of the study.

4.3. Search Strategy

Literature searches were conducted in IEEE Xplore, ACM Digital Library, and Google Scholar (See

Table 3. Summary of database searches and initial screening results.

Database	Search Strings Used	Total Retrieved	Records After Initial Screening
IEEE Xplore	No-code/low-code AND generative AI/LLM AND UI design	54	44
ACM Digital Library	No-code/low-code AND user experience/UI design	60	27
Google Scholar	No-code UI design AND evaluation/prompt-based tools	30	18

), selected for coverage of human–computer interaction, software engineering, and artificial intelligence research. Search expressions combined terms related to low-code/no-code platforms, generative AI or large language models, and user interface design. Essentially: (“no-code” OR “low-code”) AND (“generative AI” OR “large language model” OR LLM) AND (“user interface” OR UI OR UX).

Searches were restricted to peer-reviewed publications between 2021 and 2025. Academic theses were included when they provided empirical evidence directly related to generative UI design.

4.4. Inclusion and Exclusion Criteria

Studies were included if they examined AI-based low-code or no-code tools for user interface generation and evaluated design, usability, accessibility, or related quality aspects. Eligible sources consisted of peer-reviewed publications or reputable academic theses presenting empirical or structured analytical evidence.

Studies were excluded if they lacked a UI/UX focus, did not involve generative or automated design approaches, or consisted of non-academic sources such as tutorials, blogs, or white papers. The criteria were applied during both title–abstract screening and full-text review.

4.5. Study Selection Process

The selection process followed PRISMA guidelines [48]. After removing duplicates, titles and abstracts were screened for relevance. Remaining papers underwent full-text assessment using the eligibility criteria. Screening and full-text assessment were conducted using predefined inclusion and exclusion criteria to ensure consistency with PRISMA reporting standards. Twenty studies satisfied all criteria and were included in the final synthesis. The overall study selection process is summarized using a PRISMA flow diagram (Figure 1) that illustrates the screening reduction from initial retrieval to final inclusion.

4.6. Data Extraction and Categorization

A structured extraction form recorded publication details, tool type, generative approach, evaluation method, assessed UI quality dimensions, and reported findings. Extracted data were categorized to enable comparison across studies and support thematic synthesis of design behavior and variability.

4.7. Quality Assessment Criteria

Study quality was evaluated using criteria adapted from Kitchenham [47], assessing relevance, methodological clarity, and transparency of evaluation procedures. Studies were classified as high, medium, or low relevance (

Table 4. Quality assessment criteria for included studies.

Criterion	Relevance
QA1	Relevance to generative no-code or low-code UI design
QA2	Clarity of research objectives and contribution
QA3	Appropriateness of the methodological approach
QA4	Transparency of UI evaluation or analysis procedures
QA5	Clarity and validity of reported findings

). The classification informed interpretation but did not exclude studies from the synthesis.

4.8. Synthesis and Analysis Approach

The synthesis combined qualitative comparison with descriptive aggregation. Studies were grouped by UI quality dimensions, including layout structure, aesthetics, usability, accessibility, consistency, and developer effort. Frequency analysis (

Table 5. Frequency of UI quality dimensions assessed across included studies (n = 20).

UI Quality Dimension	Number of Studies (n = 20)
Layout & Structure	10
Aesthetics & Visual Design	5
Usability & Learnability	5
Accessibility	4
Consistency & Variability	7

) identified commonly evaluated aspects, while cross-study comparison revealed recurring patterns and limitations in generative UI behavior.

Individual studies may contribute to multiple research questions, reflecting the multifaceted nature of generative UI design and evaluation.

Table 6. Mapping of included studies to research questions.

Research Question	Number of Studies	Studies (Author [ref])
RQ1	11	Gui Y. [5], Vaithilingam P. [6], Leung A. [8], Zhou T. [15], Wu F. [16], Wan Y. [17], Lu Y. [20], Kamnerddee C. [35], Feng S. [49], Lee J. [50]
RQ2	9	Gui Y. [5], Duan P. [19], Huang T. [14], Zhou T. [15], Wu F. [16], Kamnerddee C. [35], Monteiro M. [38], Lee J. [50], Owen E. [51]
RQ3	6	Duan P. [19], Gurita A. [32], Shahab M. A. [36], Doush I. A. [37], Fischer M. [39]
RQ4	10	Gui Y. [5], Duan P. [19], Wu F. [16], Wan Y. [17], Kamnerddee C. [35], Shahab M. A. [36], Fischer M. [39], Feng S. [49], Lee J. [50], Owen E. [51]

maps the included studies to the research questions addressed in this review.

5. Findings

This section synthesizes evidence reported across the included studies to examine how generative no-code tools construct user interfaces, how consistent the outputs are, and how closely they align with established usability and accessibility principles. Rather than evaluating individual tools, the analysis aggregates recurring patterns and limitations documented in the literature.

5.1. RQ1—Design Principles, Layout Structures, Color Strategies

Across the reviewed studies, generative UI systems are consistently reported to approximate design intent using learned patterns rather than explicit design reasoning. Most approaches infer structure and styling from training data or reference inputs and are evaluated using similarity-based metrics rather than human-centered design criteria.

5.1.1. Design Principles and Usability Heuristics

Several studies report that generated interfaces commonly follow recognizable usability conventions such as grouping, alignment, readable contrast, and consistent spacing [15,16,19]. These properties are typically measured using visual similarity metrics, including CLIP and SSIM, which assess correspondence between generated outputs and reference layouts rather than perceived aesthetic quality [5,15]. Consequently, systems demonstrate structural plausibility but provide limited evidence of intentional design reasoning.

5.1.2. Layout Structures and Hierarchical Organization

The literature indicates that hierarchical representations form the foundation of automated UI generation. Many systems predict coarse structural layouts prior to detailed code generation, producing nested representations analogous to DOM or layout trees [5,15,16]. While this improves structural coherence, studies report that meaningful interaction hierarchy is not always preserved, suggesting that organization is learned statistically rather than derived from functional relationships.

5.1.3. Color and Styling Decisions

Color and styling attributes are typically inferred from visual examples or training distributions [17]. Studies report acceptable readability but frequent inaccuracies in contrast, color consistency, and semantic interpretation [5,19]. Automated methods may identify dominant colors or reproduce stylistic themes, yet manual adjustments are often required to achieve production-level quality [49].

Overall, the literature indicates that generative no-code UI systems rely on hierarchical layout representations, reusable component libraries, and heuristic-driven design principles to generate visually coherent interfaces. While automated techniques demonstrate strong capabilities in structural organization and aesthetic approximation, design quality is largely shaped by predefined representations and evaluation metrics that prioritize layout fidelity and visual similarity. The design principles and layout strategies identified in RQ1 are summarized in

Table 7. Design principles and layout strategies reported in RQ1.

Aspect	Common Approaches	Representative Studies
Layout representation	DOM tree, UI layout tree	Gui Y. [5], Zhou T. [15], Wu F. [16]
Design principles	Gestalt grouping, usability heuristics	Duan P. [19], Wu F. [16]
Color handling	Color similarity, contrast checks	Duan P. [19], Wan Y. [17], Feng S. [49]

.

5.2. RQ2—Cross-Tool and Within-Tool Variability

The reviewed studies consistently report variability in generated interfaces both across different tools and across repeated executions within the same tool [9,15]. Because generative models rely on probabilistic inference, identical prompts may produce different layouts, styling choices, or component structures.

Several works attribute this variability to implicit design priors encoded in training data and representation strategies [5,8,15]. Systems therefore interpret prompts rather than deterministically translating them, leading to multiple plausible outputs for the same requirements. Differences in underlying models, framework familiarity, and prompt interpretation further contribute to cross-tool divergence [15].

Within-tool variation is also frequently documented. Repeated executions of identical prompts can yield structurally distinct outputs, complicating reproducibility and testing [9]. Studies report inconsistent compilation success, layout changes across runs, and reduced coherence in multi-page interfaces [15]. As a result, developers often engage in iterative prompting to converge on acceptable designs [8].

Collectively, these findings indicate that generative no-code systems behave less like deterministic compilers and more like design assistants generating alternative interpretations of user intent.

Table 8. Reported sources of variability in generative UI systems (RQ2).

Variability Type	Source of Variability	Evidence Reported in Literature	Representative Studies
Cross-tool variability	Differences in underlying LLM/MLLM architectures	Different prioritization of visual fidelity vs. interaction logic when generating UIs from identical prompts	Gui Y. [5], Zhou T. [15]
	Framework and domain knowledge gaps	Reduced generation quality when models lack familiarity with specific UI frameworks	Zhou T. [15]
	Ambiguity of natural-language prompts	Divergent interpretations of layout, color, and component hierarchy	Leung A. [8], Chen Z. [9]
Intra-tool variability	Probabilistic inference mechanisms	Same prompt produces structurally different layouts across executions	Gui Y. [5], Chen Z. [9]
	Non-deterministic runtime behavior	Inconsistent compilation success and flaky outputs across runs	Chen Z. [9], Zhou T. [15]
	Limited cross-page coherence	Failure to maintain consistent navigation logic across multi-page interfaces	Zhou T. [15]

summarizes the primary sources of cross-system and intra-system variability reported across the reviewed studies.

5.3. RQ3—Usability and Accessibility Compliance

The literature reports that generated interfaces generally achieve acceptable baseline usability but frequently require refinement to satisfy professional standards [32,33,37].

5.3.1. Usability

Generated interfaces commonly support readability, learnability, and basic interaction clarity [11,19,21]. However, studies identify recurring issues in navigation logic, feedback mechanisms, and cross-screen consistency [15,17]. As a result, users often perform manual corrections to improve interaction transparency and error handling.

5.3.2. Accessibility

Accessibility evaluations indicate partial compliance with guidelines such as WCAG. Typical strengths include readable text and basic contrast, while common shortcomings involve missing semantic labels, incomplete keyboard navigation, and inconsistent structural markup [10,20,49]. Prompt refinement can improve compliance but does not eliminate the need for manual adjustment [32,33,37].

Overall, the evidence suggests that generative no-code tools support surface-level usability and accessibility but lack comprehensive understanding of interaction semantics.

Reported usability and accessibility issues identified across generative no-code UI systems are summarized in

Table 9. Reported usability and accessibility issues in generative no-code UI.

Dimension	Commonly Supported Aspects	Reported Limitations	Representative Studies
Usability	Learnability, visual clarity, template-based layouts	Weak error handling, limited interaction feedback	Vaithilingam P. [6], Huang T. [14], Naqvi B. [21]
Visual design	Consistent typography, spacing, and hierarchy	Pixel-level inaccuracies requiring manual refinement	Zhou T. [15], Wan Y. [17]
Accessibility	Basic contrast and readable text	Missing semantic labels, incomplete keyboard navigation	Sumit S. A. [10], Feng S. [49]
Interaction logic	Static layout generation	Incomplete navigation and cross-page coherence	Zhou T. [15]
Code usability	Structured output in advanced systems	Manual effort required for maintainability	Zhou T. [15], Wan Y. [17]

.

5.4. RQ4—Limitations, Biases, Inconsistencies

Across studies, several recurring limitations are identified in generative UI systems.

5.4.1. Functional and Structural Limitations

Generated interfaces may omit components, misinterpret layout structure, or produce incomplete navigation logic [15,16,17]. Code reliability issues, including compilation failures and framework inconsistencies, are also reported [7,15].

5.4.2. Non-Determinism and Consistency

Probabilistic inference leads to non-reproducible outputs across executions [9]. Multi-page applications are particularly affected, with inconsistent interaction patterns and fragmented user experiences [15].

5.4.3. Platform Constraints

Underlying low-code/no-code platforms impose customization and scalability constraints that propagate into generated applications [4,21,22]. Technical debt and platform-specific limitations further affect maintainability [3].

5.4.4. Bias and Ethical Concerns

Studies report potential bias and homogenization in generated designs due to training data patterns [10,20]. Responsibility for errors and accessibility failures remains unclear because generation processes lack transparency [9,10].

Overall, while generative UI design systems are effective in automating repetitive interface construction tasks and reducing initial development effort, their reliance on probabilistic language models introduces ethical risks, bias-related concerns, and accountability challenges. These limitations underscore the continued need for human oversight, transparent system design, and responsible AI practices to ensure that generated interfaces are reliable, inclusive, and suitable for production use [8]. The key limitations identified in generative no-code UI systems are summarized in

Table 10. Summary of limitations identified in generative no-code UI systems.

Limitation Category	Description	Representative Studies
Functional & Structural Errors	Missing UI elements, layout distortion, incomplete interaction logic	Zhou T. [15], Wu F. [16], Wan Y. [17]
Non-Determinism & Inconsistency	Variability across runs and tools; lack of reproducibility	Leung A. [8], Chen Z. [9]
Platform Constraints	Limited customization, scalability, and maintainability in LC/NC platforms	Velasquez A. P. [4], Cui J. [22], Naqvi B. [21]
Accessibility Limitations	Incomplete WCAG compliance; manual correction required	Zhang L. [11], Lu Y. [20], Feng S. [49]
Bias & Ethical Concerns	Dataset bias, design homogenization, accountability gaps	Sumit S. A. [10], Lu Y. [20]

.

As shown in Table 10, limitations span both technical and ethical dimensions, with consistency and functional correctness emerging as the most frequently reported challenges. These findings indicate that while generative no-code tools reduce development effort, their output remains insufficiently reliable for autonomous production use.

6. Discussion

The findings reveal recurring patterns in how generative no-code systems construct interfaces and where their limitations arise. Across studies, these systems consistently generate structurally plausible user interfaces, yet they also demonstrate variability, limited transparency in decision-making, and incomplete adherence to accessibility and usability principles. The discussion interprets these patterns to explain how generative UI design currently functions and what challenges must be addressed for reliable adoption.

6.1. Design Decision Patterns in Generative No-Code Tools

The reviewed literature suggests that generative no-code tools do not function as deterministic translators of prompts but instead behave as learned design agents. Rather than applying explicit rule-based design principles, systems infer layouts using patterns embedded in training data and previously observed interface structures. This results in convergence toward familiar arrangements such as header–content–control structures while allowing stylistic variation across outputs.

Because learned conventions guide generation, design decisions appear stable at the structural level yet variable at the stylistic level. The literature therefore indicates that these systems encode implicit design priors: they reliably reproduce common interface paradigms but lack transparent reasoning about why particular design choices are appropriate in context.

This distinction explains why generated interfaces often appear coherent while still requiring refinement. Current generative UI systems approximate acceptable solutions rather than reason about optimal ones, reflecting statistical regularities of prior designs rather than intentional design planning.

Figure 2 synthesizes these recurring design decision patterns and illustrates how core structural, aesthetic, and interactional dimensions manifest and evolve across tools and generations.

6.2. Variability and Reproducibility

Across studies, identical prompts frequently produce different layouts, styling decisions, and interaction structures. This variability arises from probabilistic inference rather than deterministic specification. As a result, generative no-code tools generate multiple plausible interpretations of user intent instead of a single fixed implementation.

The literature identifies two forms of variability. Cross-system variability occurs because models encode different training distributions and representation strategies. Intra-system variability occurs because repeated inference produces alternative outcomes for the same prompt. Together, these behaviors position generative no-code tools closer to collaborative ideation systems than traditional development environments.

This has practical implications for development workflows. Testing becomes iterative rather than deterministic, refinement replaces specification, and convergence toward a desired interface requires repeated prompting. Consequently, generative UI workflows shift effort from manual construction toward validation and correction rather than eliminating human involvement.

6.3. Usability and Accessibility as Emergent Properties

The reviewed literature consistently reports that generated interfaces achieve baseline readability and usability but frequently fail to satisfy comprehensive accessibility and interaction requirements. Across studies, accessibility appears to emerge indirectly from common interface templates rather than from explicit constraint enforcement.

Because systems rely on prevalent design patterns, they naturally produce readable typography, recognizable controls, and basic visual hierarchy. However, deeper requirements—such as semantic structure, keyboard navigation, and feedback transparency—require contextual reasoning that current models do not reliably perform.

This helps explain the reported gap between apparent usability and production readiness. Generated interfaces may appear functional and visually polished, yet still require expert review to ensure accessibility compliance. Generative no-code systems therefore support interface drafting rather than final interface validation.

To synthesise recurring patterns described across multiple studies, Figure 3 presents a conceptual summary of design trade-offs reported in generated interfaces. Rather than depicting results from a specific system, the figure abstracts common shifts in interaction design and content presentation documented in the literature when prompts are interpreted iteratively by generative no-code tools.

As illustrated in Figure 3, studies frequently report shifts from recognition-based interactions toward recall-based mechanisms, such as replacing visible keyword chips with free-text input fields. Similarly, efforts to reduce visual density often result in truncated content and removal of expandable elements, prioritizing aesthetic calmness over complete information access. These reports suggest that design refinement in generative no-code tools is not neutral but guided by implicit preferences for minimalism and immediacy.

Treating accessibility as a secondary concern in generative no-code systems has significant implications for real-world adoption and inclusivity. While these tools are capable of producing visually polished and structurally coherent interfaces, accessibility is often addressed only insofar as it aligns with dominant visual conventions. As a result, inclusivity emerges as a by-product of conventional UI patterns rather than as a primary design objective. To illustrate how these recurring behaviors relate to accessibility outcomes, Figure 4 presents a conceptual model synthesizing relationships discussed across prior studies.

As illustrated in Figure 4, one implication is the limitation this creates for autonomous production. Although generated interfaces frequently appear professional and usable at a surface level, prior research indicates that they often fall short of deeper accessibility requirements, such as consistent keyboard interaction or robust semantic support. These gaps necessitate human intervention to audit and repair generated outputs before deployment, particularly in contexts where legal or institutional accessibility standards apply. Consequently, the promise of fully automated, “no-code” interface production is constrained by the need for expert oversight, especially when accessibility compliance is required.

A second implication concerns the recurring trade-off between aesthetic calmness and perceivability. Across reported systems, design refinement often prioritizes reduced visual density through truncation of content, removal of explicit affordances, or consolidation of controls. While these changes produce cleaner and more contemporary interfaces, studies report that they frequently shift interaction from recognition-based mechanisms toward recall-based ones. This increases cognitive demand and disproportionately affects users who rely on visible cues, detailed descriptions, or predictable interaction structures. From an inclusive design perspective, such refinements risk privileging visual elegance over equitable access to information.

The literature also suggests a broader risk of design homogenization. Generative systems are trained predominantly on existing web interfaces, many of which do not fully adhere to accessibility best practices. As a result, reported outputs tend to replicate statistically common design patterns that accommodate mainstream users while marginalizing those with less typical access needs [10]. Prior work describes this effect as a form of “accessibility handcuffs,” where reliance on standardized templates limits the ability to meaningfully adapt interfaces for underrepresented or specialized user groups [32].

Importantly, studies indicate that accessibility cannot be reliably enforced through prompt-based intent alone. Explicitly requesting accessible design does not consistently produce more inclusive outputs, suggesting that current model architectures lack a contextual understanding of accessibility as a multidimensional and situational design requirement. Instead, accessibility remains dependent on iterative human intervention, reinforcing the view that inclusive design cannot yet be delegated to a single natural-language instruction [33].

These limitations pose particular risks for non-technical or “citizen” developers, who may lack the expertise to identify accessibility shortcomings in generated interfaces. Without awareness of deeper accessibility requirements, such users may inadvertently deploy systems that exclude portions of their audience, introducing compliance risks, technical debt, and costly redesign efforts later in the development lifecycle [52].

Taken together, these implications highlight a fundamental constraint of current generative no-code tools: while they excel at reproducing visually acceptable and conventionally structured interfaces, they struggle to support inclusive design as a first-class objective. Accessibility is treated as optional, emergent, and visually bounded rather than as an integral design dimension. This reinforces the need for human oversight and motivates consideration of how future tool design may address these limitations.

6.4. Implications for Human-AI Collaboration

The results indicate that generative no-code tools are best integrated as collaborative components within the design process rather than as autonomous development systems. Their value lies in rapid exploration of alternative interface configurations, while humans remain responsible for intent specification, evaluation, and final validation.

This shifts development from construction-oriented workflows to decision-oriented workflows. Instead of manually assembling interfaces, designers increasingly curate, compare, and refine candidate outputs. Consequently, productivity gains depend less on automation of implementation and more on the efficiency of evaluating alternatives.

Effective collaboration therefore requires interaction mechanisms that support guided exploration. Systems should enable users to iteratively narrow the design space, preserve preferred properties across generations, and prevent regression during refinement. Without such mechanisms, iteration cost may offset the speed advantages of generation.

6.5. Implications for Human-Computer Interaction Research

The findings suggest that user experience in generative environments depends on managing uncertainty rather than operating predictable controls. Interaction design must therefore support comprehension of system behavior rather than only interface manipulation.

For HCI research, the primary usability problem becomes interaction with the generator, not only the generated interface. Future work should investigate:

• how users form mental models of generative behavior
• how interfaces communicate degrees of confidence or stability
• how users constrain exploration without over-specifying solutions
• how iterative refinement affects trust and perceived control

In this context, prompting functions as an ongoing negotiation process. Interfaces that expose alternatives, preserve state across iterations, and communicate change boundaries may improve user confidence and reduce corrective interaction cycles.

6.6. Implications for Software Engineering Research

Generative interface development alters the nature of software artifacts from fixed implementations to variable outputs produced by a generation process. As a result, engineering practices must evaluate reliability of the process rather than correctness of a single instance.

Quality assurance therefore shifts toward:

• managing prompt and model configurations as versioned development inputs
• defining acceptable ranges of variation rather than exact outputs
• validating stability across multiple generations
• detecting undesirable drift during iterative refinement

This perspective treats generation as a build pipeline with probabilistic behavior. Engineering effort consequently moves from implementation verification to generation governance, including monitoring, configuration control, and reproducibility management.

6.7. Implications for Future Tool Design

To support reliable development workflows, generative no-code environments should provide explicit mechanisms for controlling and stabilizing outputs. Three capabilities emerge as central requirements:

• Transparency: communicating the constraints, assumptions, and preserved properties guiding each generation
• Controllability: enabling users to lock structural decisions, bound stylistic variation, and maintain consistency across iterations
• Reproducibility: allowing regeneration of equivalent interfaces across sessions, collaborators, and deployment stages

Together, these capabilities transform generative systems from exploratory prototyping tools into dependable development platforms suitable for collaborative and professional use.

7. Threats to Validity

As with any systematic literature review, the findings are subject to limitations related to study identification, interpretation, and generalizability. The main potential threats and mitigation strategies are summarized below.

7.1. Study Identification and Selection Validity

The review relied on IEEE Xplore, ACM Digital Library, and Google Scholar. Although these sources cover a substantial portion of HCI and software engineering literature, relevant studies in industrial reports, preprints, or proprietary evaluations may not have been captured. Additionally, inconsistent terminology in generative UI research may have caused some relevant studies to be missed during keyword-based retrieval.

To mitigate this risk, broad search expressions were used across multiple databases and screening was conducted in two stages (title/abstract and full-text) using predefined inclusion criteria. Nevertheless, publication bias remains possible because peer-reviewed literature tends to emphasize positive results while underreporting failures in real-world deployments.

7.2. Data Extraction and Interpretation Validity

The reviewed studies employed heterogeneous evaluation methods, including usability testing, metric-based evaluation, and qualitative analysis. Because standardized benchmarks for generative UI systems are not yet established, synthesizing findings required interpretive categorization across different reporting styles.

To reduce bias, extraction categories were defined prior to synthesis and applied consistently across studies. However, thematic grouping inherently involves researcher judgment, and the results therefore represent recurring patterns rather than precise quantitative comparisons between specific tools.

7.3. Generalizability and Temporal Validity

Many included studies evaluated prototypes or controlled scenarios rather than deployed production systems. Consequently, the conclusions may not fully generalize to all real-world generative no-code platforms.

Furthermore, generative AI models evolve rapidly. The findings therefore reflect the state of research during the reviewed period and should be interpreted as characterizing current behavior trends rather than permanent properties of future systems.

8. Conclusions

This study synthesized existing research to examine how generative AI–based no-code tools translate natural-language prompts into user interface designs, focusing on design decisions, variability, usability, and accessibility outcomes. Across studies, generative no-code systems produce structurally plausible interfaces by reproducing learned design patterns rather than applying explicit design reasoning. Outputs appear coherent but vary across executions and often require human refinement. While baseline usability is commonly achieved, accessibility and semantic interaction quality remain inconsistent and typically depend on expert oversight.

The primary contribution of this work is conceptual. The findings indicate that generative no-code tools act as probabilistic design agents that interpret user intent rather than deterministic mechanisms that execute specifications. This perspective explains persistent reproducibility issues, stylistic variability, and incomplete accessibility compliance across platforms. Practically, the results suggest that current generative no-code tools are well suited to ideation and prototyping but not yet reliable for autonomous production use. Reliable deployment requires reproducible generation, transparent design reasoning, and user-directed constraints.

Future research should therefore focus on stabilizing generative behavior, communicating model decisions to users, and enforcing human-centered design requirements during generation. Addressing these challenges will be essential for transforming generative no-code environments from exploratory assistants into dependable software development tools.