AI-in-the-Loop Ideate-Prototyping Process

• AI-in-the-loop ideate-prototyping is a workflow that fuses human framing and evaluative control with AI-driven generation of intermediate artifacts like sketches and blueprints.
• The process emphasizes editable representations and bidirectional feedback loops, enabling iterative revisions that cascade across linked design stages.
• Human creativity remains central as experts guide problem framing, selection, and refinement, while AI handles repetitive transformations and structural generation.

Searching arXiv for the cited papers and closely related work to ground the article. Taken together, these works suggest that an AI-in-the-loop ideate-prototyping process is a design and development workflow in which humans frame problems, set intent, choose examples, and judge outcomes, while AI systems generate, translate, structure, or evaluate intermediate artifacts so that ideation and prototyping remain tightly coupled rather than separated into long sequential stages. Across the literature, the process is characterized by editable intermediate representations, repeated human review, and iterative movement between divergent exploration and convergent refinement, rather than one-shot generation or opaque end-to-end automation (Pandian et al., 2020, Suh et al., 5 Aug 2025, Lin et al., 30 Jan 2025, Liang et al., 6 Oct 2025).

1. Conceptual scope and process logic

A recurring claim in this literature is that AI should not replace designers or other domain experts at the ideation-to-prototype boundary. In BlackBox Toolkit, AI is explicitly framed as an intelligent assistant or collaborator, “more like an apprentice than an autonomous generator,” with the designer retaining “creative intent, detailed judgment, and iterative refinement” while AI absorbs repetitive, mechanical, and structurally inferable work across fidelity transitions (Pandian et al., 2020). This establishes a foundational distinction between assistive transformation and autonomous authorship.

StoryEnsemble extends that logic from user-interface design to a broader design-process model spanning personas, problem framing, solution ideation, and storyboards. Its central claim is that design processes are iterative in theory but often become linear in practice because revisiting earlier stages is expensive. The system therefore introduces “forward propagation” and “backward propagation” so that revising one artifact can selectively cascade through linked upstream or downstream artifacts, making iteration multi-directional rather than stage-locked (Suh et al., 5 Aug 2025). This suggests that AI-in-the-loop prototyping is not only about faster generation, but also about maintaining coherence across interdependent representations.

Chaehan So’s Human-in-the-Learning-Loop (HILL) Design Cycles places the same idea inside a sprint-based product process. HILL preserves the design-thinking loop but operationalizes it through repeated prototype creation, online psychometric measurement, ML updating, and sprint planning. Its distinctive move is to replace or structurally supplement small-sample qualitative testing with a quantitative design-perception instrument organized around the dimensions of novelty, energy, simplicity, and tool, and to route those signals into subsequent implementation priorities (So, 2020).

In a different domain, policy prototyping for LLMs imports prototyping logic into pluralistic alignment. Stakeholders do not merely submit values or rules once; they collaboratively draft policy, inspect policy-informed model behavior, discuss unintended consequences, revise the policy, and repeat. The paper characterizes this process with four guiding principles: direct experimentation with tight feedback loops, synchronous collaboration, lower-fidelity prototyping, and scenario-centered discussion (Feng et al., 2024). A plausible implication is that AI-in-the-loop ideate-prototyping is best understood as a general process family, not a UI-specific technique.

2. Process architectures and intermediate representations

The strongest implementations in this literature rely on explicit intermediate representations rather than direct input-to-final-output jumps. BlackBox Toolkit organizes UI design around fidelity transitions. One path begins with a low-fidelity sketch; MetaMorph, a fine-tuned RetinaNet detector, recognizes UI element categories and positions, converts the sketch into a medium-fidelity representation, and supports progression toward high-fidelity Android XML through the Eve workbench. A second path begins with a screenshot; Blu extracts UI element categories, positions, grouping information, and layout, then produces a blueprint and a layout tree (Pandian et al., 2020). The process architecture is therefore representation-transformative rather than purely generative.

StoryEnsemble uses a node-link workspace as its central process representation. Persona, Problem, Solution, Storyboard, and Context nodes externalize design artifacts, while links encode dependencies that can be operationalized through update, forward propagation, or backward propagation. The storyboard pipeline is especially explicit: persona, problem, and solution inputs are used to generate a storyboard outline and captions; visual character descriptions are generated for consistency; image prompts are then created for all frames in a single invocation; finally, images are generated in parallel (Suh et al., 5 Aug 2025). The important architectural point is that prototypes remain linked to upstream reasoning instead of becoming terminal deliverables.

Inkspire makes the same architectural commitment in sketch-based product design. It couples an analogical inspiration mechanism with a closed sketch-to-design-to-sketch loop. A user starts from an abstract concept and a subject, receives concrete analogical inspirations from domains such as nature, architecture, or fashion, sketches minimally, receives AI-generated designs conditioned on sketch and analogy, and then works against a scaffold derived from the generated design. The scaffold is computed as

$Scaffolding = Boundary(Seg(D)) \cap SoftEdge(D)$

where $D$ is the generated design (Lin et al., 30 Jan 2025). This makes the AI’s current state legible in sketch form and returns the process to the user’s native representational medium.

AgentBuilder applies a similar principle to interface agents. Its Workflow tab represents behavior as a directed graph with nodes such as Start, End, UI Actions, Plan, Message, Interact, and Confirmation, while the Prompt interface decomposes specification into Workflow Prompt, Agent Capabilities Prompt, User Information Prompt, and Other Instructions. The system supports bidirectional movement between these representations: workflow paths are searched depth-first from the Start node and expanded into text, while prompt edits plus workflow JSON are given to an LLM to update the graph specification (Liang et al., 6 Oct 2025). This suggests that AI-in-the-loop prototyping benefits from dual representations: one structural, one linguistic.

3. Human and AI roles in co-creative prototyping

The division of labor is unusually explicit across this body of work. In BlackBox Toolkit, the human designer is responsible for user-centered reasoning, ideation, choosing what to sketch, selecting examples, evaluating alternatives, and controlling styling and detail; the AI is responsible for recognition, structural extraction, blueprint generation, and fidelity transition support (Pandian et al., 2020). The choreography systems make the same assignment in a different medium. In DanceGen, the choreographer provides text or video input, selects among alternatives, chooses edits, and decides what to save or export, while the AI provides movement variations, style control, partial-body editing, blending, and extension within a digital prototyping loop (Liu et al., 2024).

In the related choreography-support system built around MDM, CLIP, and VIBE, this turn-taking is even more concrete. Text input produces three candidate dance sequences per request, each up to 10 seconds; generated or uploaded sequences can be extended by up to 5 seconds per extension; style control supports six explicit styles; and users can constrain upper body, lower body, arms, or legs. The paper characterizes this not as autonomous choreography generation, but as a “human-steered exploration loop” that supports divergent ideation, convergent refinement, branching, and reuse (Liu et al., 2024). This suggests that “AI-in-the-loop” often means human-led exploration over AI-generated state spaces.

In user-centered design with generative UIs, the human role remains primary in understanding context of use, eliciting needs, and formulating design goals, while AI is inserted between design goals and design solutions to generate design ideas and transform low-fidelity visuals into interactive prototypes. The reported case study emphasizes that AI-generated prototypes function as “ready-for-interaction design artifacts” that enrich conversation with domain experts rather than eliminate the need for UX judgment (Li et al., 28 Jul 2025). No-code AutoML frameworks assign the same pattern at the product level: non-experts frame use cases, inspect data, review metrics, and make viability, feasibility, usability, and desirability judgments, while AutoML automates algorithm selection, model training, validation, and optimization (Truss et al., 2024).

Some papers make the governance layer itself a human role. HILL identifies a quality engineer as the human in the loop who filters invalid survey responses before they enter model training, thereby protecting the integrity of the feedback signal (So, 2020). The embedded-AI HMI paper makes a related argument at runtime: AI remains the “working horse,” but when it is unsure whether its inference is correct or detects a safety- or security-critical situation, it should query the user through a minimal HMI rather than proceed autonomously (Schöning et al., 2023). A plausible implication is that the most robust AI-in-the-loop processes assign humans not only creative authority but also escalation authority.

4. Evaluation, propagation, and evidence of process utility

The literature varies sharply in empirical maturity, but several systems report concrete process evidence. StoryEnsemble combines a formative study with 15 participants and a user study with 10 participants. In the user study, overall CSI was 72.0 (SD 15.7), SUS averaged 84.8 (SD 10.8), participants created on average $16.\overline{3}$ ideas, and most participants used forward propagation and backward propagation multiple times, with forward propagation averaging $3.\overline{2}$ uses and backward propagation $1.\overline{2}$ (Suh et al., 5 Aug 2025). The study also reports three workflow styles—bottom-up, top-down, and hybrid—supporting the claim that the system functions as a workspace rather than a strict pipeline.

BlackBox Toolkit reports the clearest model-centric metric. Because no large-scale low-fidelity sketch detection dataset existed, the authors collected UISketch, containing 5,917 sketches of 19 UI elements from 350 participants, then created Syn, a synthetic dataset of 125,000 low-fidelity sketches for training detection. MetaMorph was trained on Syn and evaluated on 200 low-fidelity sketches, reaching 63.5% mAP (Pandian et al., 2020). Blu, by contrast, is supported more by system demonstrations and dataset preparation around RICO than by end-to-end user evidence.

The adult-learning LLM workflow evaluates blueprint quality before expensive production. The LLM generated course outline, objectives, course text, video scripts, interactive activities, and assessments within a blueprint template, after which five expert raters evaluated 20 content elements and sections for accuracy and clarity. The AI-assisted course scored 86.3% on accuracy and 88.0% on clarity, compared with 91.3% and 82.3% for the control, with differences reported as not statistically significant ($p=.16$ and $p=.09$, respectively). Inter-rater agreement was high, with Kendall’s $W$ values of .93 and .91 for the experimental course on accuracy and clarity (Leiker et al., 2023). This suggests that prototype-stage expert review can function as a quality gate even when AI performs most drafting labor.

HILL evaluates process utility through its psychometric backbone rather than through a comparative organizational deployment. Its 12-item instrument, derived from evaluations of 1,955 design works, organizes user feedback into novelty, energy, simplicity, and tool; each factor showed reliability around Cronbach’s alpha $\approx 0.80$, and together they explain 74% of the variance. The process then maps the lowest-scoring dimension into the highest-priority sprint category (So, 2020). This makes user feedback machine-readable and backlog-relevant, which is a distinct form of AI-in-the-loop evaluation.

5. Failure modes, controversies, and common misconceptions

A major misconception in this area is that repeated human feedback automatically yields convergence. “The Human in the Infinite Loop” directly challenges that assumption. In a field deployment with two 3D artists over three months, 549 evaluation sequences were recorded; 134 involved actual sequential preference ratings, and only 16 of those 134 optimized sequences—11.9%—produced a satisfactory outcome. In a lab study with $N=20$, 200 evaluation sequences were collected and only 97 sequences—48.5%—terminated satisfactorily (Ou et al., 2022). The paper attributes these failures to two interacting facts: preference-based optimization lacks mechanisms for inconsistent and contradictory human judgments, and machine outcomes influence future user choices through heuristic biases and loss aversion. This suggests that preference loops should not be treated as clean optimization channels.

BlackBox Toolkit exposes a different class of limitation. The paper does not report a formal user study of designers using the toolkit end to end, does not provide comparative time-on-task evidence, and does not operationalize explanation interfaces, confidence displays, or explicit correction loops. MetaMorph’s 63.5% mAP leaves substantial room for recognition error, and Blu’s layout detection problem remains open enough that the authors explicitly state there is “no algorithmic way yet to automate layout using Gestalt law” (Pandian et al., 2020). The conceptual promise of designer control therefore exceeds the degree of control formally instrumented in the current system.

Generative prototyping with LLMs and motion models introduces additional risks. In rapid UI prototyping with vibe coding, generated code can be buggy, brittle, insecure, and misleadingly polished, and repeated prompting inside one session can create cumulative errors and integration breakdown (Li et al., 28 Jul 2025). In DanceGen, participants reported unrealistic or glitch-like motions, mismatches between prompts and outputs, and a persistent gap between digital prototypes and embodied dance qualities such as emotion, energy, and effort (Liu et al., 2024). These cases complicate the common claim that faster generation straightforwardly improves prototyping.

Policy prototyping surfaces a further tension between participation and scale. Synchronous collaborative workshops appear effective for disagreement resolution and nuanced discussion, but they are costlier and less scalable than linear elicitation pipelines. The paper also notes that general-purpose collaborative documents do not support direct testing of a policy-informed model, scenario integration, or clause-level comparison well enough for the proposed process (Feng et al., 2024). A plausible implication is that pluralistic AI-in-the-loop design becomes harder, not easier, as one moves from small expert groups to large publics.

6. Broader significance and emerging directions

Several transferable design principles recur across otherwise distant domains. Inkspire shows that early-stage co-creation benefits when AI returns outputs in the user’s native representational medium, not only as polished renderings (Lin et al., 30 Jan 2025). Protosampling generalizes that claim by collapsing sampling and prototyping into a shared canvas where references, generated outputs, decomposed assets, and provenance traces coexist; Atelier’s “easels,” lineage DAG, history, trails, heatmap, collections, and exhibit gallery are all designed to let creators “navigate emergence” rather than merely produce more images (Guo et al., 8 Jan 2026). StoryEnsemble adds a complementary principle: prototypes should remain connected to upstream reasoning through linked artifacts and bidirectional propagation rather than being treated as terminal deliverables (Suh et al., 5 Aug 2025).

Embodied and spatial domains push the same logic into deployment contexts. Vibe Coding XR argues that natural-language-to-prototype workflows become viable only when a domain exposes high-level, human-centered primitives; XR Blocks therefore provides a Reality Model organized around user, world, peers, agents, context, interface, and Script, while Gemini translates prompts into executable XR Blocks scripts that can be previewed in desktop simulated reality or deployed on Android XR. On VCXR60, pass@1 reached 95.5% for gemini-3.1-pro with High thinking, though the corresponding median latency was 86.02 seconds rather than below one minute (Du et al., 25 Mar 2026). Cloud2Edge Elastic AI makes the same point from the opposite direction: effective AI prototyping in autonomous vehicles requires a data-driven V-Model in which prototyping happens as Software-in-the-Loop in the cloud and deployment-grade validation happens as Hardware-in-the-Loop on ECUs, with logged results fed back into retraining (Grigorescu et al., 2020).

The most explicit recent statement on scaffolds comes from rapid visual-analytics prototyping with ATWL. There, the Artifact–Transform Workflow Language served as a scaffold that fixed artifacts, flow, three refinement loops, and a feedback path in minutes, and helped produce a running prototype in a few hours. Yet the paper is equally clear that the scaffold alone was not enough: the first implementation was “only average,” and expert knowledge injection was needed to reach state-of-the-art quality. It further reports that a language definition and a library of examples support different aspects of the task, that providing both at once reduces quality because template following displaces creative content, and that scaffolds work best when introduced after an initial unconstrained design pass (Andrienko et al., 30 Jun 2026). This suggests a broader conclusion: AI-in-the-loop ideate-prototyping is not simply a matter of adding generation to a workflow; it depends on when structure is introduced, how intermediate representations are made inspectable, and how human expertise is injected back into the loop.