Workflow-Net: Toward Understanding Designer Workflows in Generative AI-Driven Systems through Comparing Node-and Prompt-Based Interfaces

2. 1. Interface Frameworks for Generative AI-Driven Design Support Systems

The interface is the primary space where designers communicate their intent with generative AI. While recent HCI surveys broadly categorize these interface frameworks into Conversational and Canvas User Interfaces (UIs) (Luera et al., 2024), distinct sub-framework structures these interactions in fundamentally different ways, significantly shaping the designer’s workflow and sense of agency. We conceptualized the two UIs as three distinct frameworks—an Agentic Prompt-based (AB) interface, a Programming Node-based (PB) interface, and a Creative Node-based (CB) interface. Our rationale for this classification is as follows.

2. 2. Creative Design Process Workflow Analysis

To understand how these interface frameworks influence behavior, we must look beyond static outputs and analyze the design process workflow itself. While existing methods are valuable, they present distinct limitations in capturing high-level design action intent.

Micro-Level vs. Macro-Level Analysis. Linkography (Goldschmidt, 2014; Hatcher et al., 2018) is a foundational method for analyzing moment-to-moment evolution of the thought process, mapping the links between design moves. However, its strength is also its limitation; it focuses on tracing micro-level connections between the individual words, sentences, or concepts (Hatcher et al., 2018). While effective for isolated design case studies, this granularity makes it difficult to systematically capture the high-level actions that represent designers’ underlying intent, such as “verifying a design’s feasibility”, “refining a design feature form”, or “branching into variating designs”. Furthermore, this approach makes it challenging to aggregate workflows across multiple users or identify common behavioral or interface-specific patterns (Smith et al., 2025).

Artifact-Centric vs. Action-Centric Analysis. To address aggregation, W-graphs (Chang et al., 2020; Hyun & Jang, 2025; Jang & Hyun, 2024) captures the overall sequence and collective patterns across multiple designers’ design process by clustering intermediate states based on the geometric similarity of the 3D output. While effective for revealing ‘what was made’, this artifact-centric approach fails to capture and distinguish the context of the user’s action intents and behavioral patterns regarding ‘why it was done that way’. For instance, “refining a curve” and “correcting an error” might produce similar geometric changes but represent fundamentally different creative behaviors.

Bridging the Gap with LLMs. To overcome these limitations, recent studies demonstrate that LLMs can effectively group detailed work data (e.g., event logs) into semantic units and label them automatically (Fani Sani et al., 2023; Vaarandi & Bahşi, 2025). These studies are significant in that they can translate raw records into contextually understandable explanations for humans. Moreover, recent research has also proposed methods for semantic-based clustering using LLMs on various data (e.g., news articles, short texts, conversation logs) (Miller & Alexander, 2025; Tarekegn, 2024), demonstrating the possibility to derive common patterns that reflect contextual meaning, rather than just listing data.

Building on this, the current study proposes an action-centric approach. By leveraging LLMs to cluster structured protocols based on semantic intent rather than just geometric output or keywords, we map meaningful, high-level design action behaviors. Validated by Clustering Stability (CLS) metrics (von Luxburg, 2010), this method constructs a comprehensive multi-user workflow graph that reveals how different interface frameworks systematically shape the creative design process beyond the constraints of artifact-centric and individual, micro-level analyses.

Figure 1

Overview of our Workflow-Net framework

3. 1. Overview

The proposed method aims to empirically compare how distinct generative AI-driven interface frameworks shape the behaviors of the creative design process workflows. The research methodology undergoes the following stages: 1) Modeling Interface Frameworks: Development of the distinct AB, PB, and CB interaction models to serve as the comparative apparatus. 2) Workflow-Net Analysis: Our evaluation pipeline that captures high-level design intent through deductive protocol analysis approach (Ericsson, 2017) followed by LLM-assisted in-context clustering (Fu et al., 2025) to aggregate multi-user data. 3) Graph Construction: The transformation of multi-user sequences into a comprehensive, weighted directed graph to visualize collective behavioral patterns and state transitions. 4) Quantitative Evaluation: The derivation of behavioral metrics from the analysis to empirically measure the impact of interface frameworks on the creative design process workflows.

3. 2. Modeling Generative AI-Driven Interface Frameworks

To investigate how interaction modalities shape design workflows, we developed three web-based generative AI-driven design support interfaces connected to a unified backend architecture (Figure 5). To ensure a rigorous, controlled comparison, this backend exposes a consistent suite of generative agents to all three frontends: text-to-text, image-to-text, text-to-image, image-to-image, text-to-3D, and image-to-3D. As detailed in Section 3.2.2, this parity ensures that while the interaction framework (AB, PB, and CB) vary, the underlying generative power remains constant, allowing us to isolate the impact of the interface itself on the creative process.

3. 2. 1. Frontend User Interface Implementations

AB interface: Modeled after conversational UIs, this interface features a chat panel where users input natural language prompts and optional attachments (Figure 2). The system parses text input and places automatically generated assets as cards onto the canvas, prioritizing dialogue over direct manipulation to articulate design goals. The goal of this interface is to allow users a fluid, iterative workflow based on natural language, minimizing the need to learn complex controls:

Figure 2

Frontend UI of our developed Agentic Prompt-based (AB) Interface - Sample of P5’s cup design task

• • The user types a command into the chat panel such as ‘@image a vintage wooden chair’ or ‘@3d minimalist urban mug cup’.
• • The user can optionally attach images to their chat prompts or select existing asset cards on the canvas to provide multimodal context.
• • The agent parses the text for commands and context, packages the multimodal inputs, and executes the relevant generative task.
• • Upon completion, the newly generated asset (image or 3d model) is automatically placed as cards onto the canvas space, allowing for immediate user-led manipulation and spatial organization.

PB interface: Modeled after visual scripting environments, this interface requires users to manually construct DAGs (Figure 3) (Xue et al., 2025) by connecting logic nodes (inputs, parameters, outputs). This interface framework grants the designer explicit, granular control over the entire generative workflow by requiring them to construct a complete workflow of operations. The goal of this interface is to allow users precision, repeatability, and a clear visualization of the data flow in the generative process. The workflow is structured around the construction of DAG, which visually represents the entire computational pipeline:

Figure 3

Frontend UI of our developed Programming Node-based (PB) Interface - Sample of P3’s ceiling lamp design task

• • The user populates the canvas with various nodes from a sidebar representing specific operations.
• • They configure each node’s internal parameters and draw explicit connections between the output and input sockets to define the data flow.
• • A global ‘compile’ button triggers the execution of the workflow when clicked; the system traverses the completed workflow, from the terminal output node backwards to assemble and run the full chain of operations.

As noted in prior work, users must manually create these workflows, which can be laborious and time-consuming (Xue et al., 2025).

CB interface: This interface streamlines interaction by automating connections through more direct, selection-based interaction (Figure 4), lowering the cognitive load of visual programming. When a user acts on a content node, the system automatically generates a new linked node, creating a visual history tree without requiring manual logic wiring:

Figure 4

Frontend UI of our developed Creative Node-based (CB) Interface - Sample of P2’s chair design task

• • The user populates the canvas with self-contained content nodes (e.g., text, image).
• • To generate new content, the user selects one or more existing nodes that serve as inputs.
• • They then click a direct action button (e.g., Generate Image, Generate 3D Model), which the system immediately creates a new output node on the canvas and automatically draws connections back to the input nodes that were used for its content generation.

This interface, by automating the creation of connections, visually documents the designer’s complete generative design process history, enabling process traceability.

3. 2. 2. Backend Technical Implementations

To ensure a controlled comparison, all three interfaces were connected to a single backend system built on a scalable serverless architecture that functions as an orchestration layer, utilizing a unified API gateway to receive and process requests from the frontend interfaces (Figure 5). The gateway parses a set of parameters (Table 1) to dynamically route tasks to the appropriate generative agent.

Figure 5

Frontend to backend architecture framework for the generative AI capabilities

Table 1

List of key parameters and descriptions required by the backend endpoint

Generative AI Functionalities. The backend architecture was engineered to provide six distinct generative AI functions, which were made equally available to all our three interfaces through the unified API endpoint. The logic for invoking these functions followed a consistent pattern of parameterization and data handling defined by the backend’s orchestration layer:

• 1. Text-to-Text Generation: this facilitates general-purpose textual queries. When a request is made with an output_type of text_only and operation_type of generate, the backend routes the user’s prompt to Google’s Gemini (Google, n.d.). The interfaces are equipped to handle both standard JSON responses and real-time streaming of text, allowing for immediate feedback during longer text generations.
• 2. Text-to-Image Generation: this is responsible for creating images from textual descriptions. The interface sends a request with an output_type of image and an operation_type of generate. The backend orchestrator forwards the prompt to a text-to-image model. The interface utilizes OpenAI’s DALL-E 3 model (OpenAI, 2025) for high-quality generation, with Google’s Gemini model (Google, n.d.) as an alternative. To ensure stylistic consistency, the interface’s logic was designed to append a string to user prompts (e.g., “Please generate a professional product photograph of a single product with a clean white background. The product should be positioned at a three-quarter view. Ensure the lighting is even and the focus is sharp.”) before sending the request. The backend returns the final image as a base64 string.
• 3. Text-to-3D Generation: this exclusively utilizes the Meshy API (Meshy, n.d.) (ai_type: ‘meshy’) with an output_type of model3d and operation_type of generate. Due to the extended processing time, it relies on the aforementioned backend’s asynchronous workflow. The interface sends the user’s prompt along with numerous Meshy-specific parameters (e.g., art_style, enable_pbr, target_polycount). The backend initiates the task with Meshy and immediately returns a taskId. The interface then periodically polls the API using this taskId to fetch status updates until the generation is complete and download links for the 3D model files (.glb, .fbx) are available.
• 4. Image-to-Text Analysis: to enable the analysis of visual content, this is invoked when the output_type is text_only and the operation_type is analyze. The interface transmits a POST request containing the image as an image_base64 string in the request body. The backend then passes this image data, along with an optional guiding prompt (provided by the user via the chat panel or a connected text node), to Google’s Gemini model (Google, n.d.). If no text is provided, the model utilizes its native vision capabilities to return a general textual description; otherwise, it returns an answer to a specific query about its visual content.
• 5. Image-to-image Generation: this encompasses more complex visual transformations and was implemented through a multi-step process orchestrated by the interface system logic:
  • • Variation: for generating a variation of a single source image, the operation_type is set to variation. The interface ensures the input image is converted to a compatible RGBA PNG format before sending it to OpenAI’s DALL-E model (OpenAI, 2025). This specific operation is text-free; the model utilizes the input image’s visual embedding as the sole conditioning signal to generate a stylistically and structurally similar output.
  • • Edit: when a user provides a source image and a textual modification prompt (e.g., “add a handle”), the interface initiates a three-step pipeline:
    • A. Background removal: the original image is first sent to the PhotoRoom (Photoroom, n.d.). This isolates the main subject of the image.
    • B. Mask creation: the interface then processes the background-removed image from PhotoRoom to create a precise, opaque mask (mask_base64). This mask defines the exact area of the original image that DALL-E is allowed to modify.
    • C. Image Generation: Finally, the interface sends the original source image (converted to RGBA format), the newly created mask, and the user’s textual prompt to OpenAI’s DALL-E (OpenAI, 2025) editing endpoint. This ensures that modifications are applied only to the intended areas, preserving the rest of the image.
• 6. Image-to-3D Generation: Similar to text-to-3D, this process is powered by the Meshy API (Meshy, n.d.), with the interface configured to use the Meshy-5 model (ai_model: ‘meshy-5’) by default. The function is invoked with an output_type of model3d and an operation_type of image_to_3d, requiring an image_base64 payload. Similar to the variation operation, this process does not require a text prompt; the Meshy-5 model infers the 3D geometry and texture directly from the provided 2D visual data. It follows the same asynchronous taskId-based workflow, where the interface tracks the task’s status and retrieves the final 3D model files upon completion.

3. 3. Workflow-Net: Multi-user Action-centric Analysis

We developed a multi-step methodology (Figure 6) to evaluate and quantify designers’ behaviors by mapping high-level design action data into a comprehensive graph.

Figure 6

Illustration of our multi-step Workflow-Net framework: 1) Protocol Analysis & Dataset Construction, 2) LLM-Assisted Translation & Clustering, 3) Workflow-Net Graph Visualization.

Step 1. Protocol Analysis and Dataset Construction. To capture the high-level intent behind design moves, we employed deductive protocol analysis (Ericsson, 2017; Ericsson & Simon, 1980). Researchers systematically coded designers’ think-aloud verbalizations and observations against a predefined coding schema containing six high-level design action moves (create, branch, modify, combine, verify, ask) and eight contextual parameters (e.g., User, Referent, Referent property, Inspiration Source, Design Idea).

Our predefined coded scheme labels were developed by synthesizing and adapting established frameworks from foundational design research. The main category, ‘design action move’ is justified by its functional role in the creative process as identified in prior HCI and design studies (Lee et al., 2024; Shen et al., 2025; You et al., 2025). Furthermore, to provide a richer understanding of the designer’s intent, each design action move is contextualized by several other observable parameters, including the Referent, Referent Property, Inspiration Source (self-creativity vs. AI-inspiration) (X. Lin et al., 2025), Design Idea Input Number and Output Number, and Design Stage. While these parameter categories were predetermined by our schema, the specific labels assigned to them were dynamically extracted based on the unique, real-time context of each user’s actions. As a result, our protocol coding scheme enables the sequential mapping of each designer’s intended actions into a structured dataset (Figure 6-1). Unlike purely inductive methods, this ensures actions are mapped to functional roles grounded in design theory.

This coding scheme was applied by the experiment moderators who systematically reviewed each participant’s think-aloud transcriptions and screen recordings. During this manual process, moderators extracted the relevant labels for every observed action. Critically, this phase also involved inferring the user’s underlying motivation (Action Motive) for each design move sequence, a judgment grounded in direct evidence from the qualitative data. This procedure served as our primary human validation stage, ensuring the final structured dataset was an accurate representation of the design process and formed a reliable foundation for the subsequent analysis.

Step 2. LLM-Assisted Translation and Clustering. To aggregate individual workflows, we developed a pipeline (Figure 6-2) to convert these labeled codes into a unified workflow.

While our protocol analysis produced a validated, structured dataset, the coded labels are not inherently suitable for nuanced, LLM-driven workflow analysis. To address this, we developed a process to translate the structured data into rich, natural language descriptions that preserve the original, human-validated context.

We evaluated two distinct prompt engineering strategies to perform this translation. The first was an unconstrained approach, where the LLM was instructed to generate a natural language summary from the data points. The second was a template-based approach, which required the model to populate a predefined sentence structure. To validate the output of both methods, we implemented two verification processes. We conducted a rule-based automated check on the entire translated dataset. This sanity check systematically verified that all key data parameters from each source row were present in the corresponding output sentence. For any translations that failed this check, moderators then performed manual spot-checks to diagnose those errors.

Our evaluation revealed that the unconstrained approach consistently failed both the automated and manual checks, frequently omitting critical labels from the final translation. In contrast, the template-based approach achieved 100% accuracy on both the automated validation and manual spot-checks, successfully including all labels in every instance. Therefore, we exclusively adopted the template-based method for our final data translation. The selected technique involved systematically presenting each row of the coded dataset to the GPT-4o model (OpenAI, n.d.). The model was instructed to synthesize the discrete data points into a coherent narrative sentence based on a predefined template.

Following the high-fidelity translation of coded labels into natural language, we then employed LLM-assisted in-context clustering (Fu et al., 2025) to group design actions from multiple users based on semantic intent. This aggregation step is designed to overcome the limitations of prior methods by enabling the systematic comparison of cross-user behavioral patterns based on high-level design action moves. The clustering logic prioritized design moves and design idea relations while enforcing hard constraints against mixing different design stages. To ensure the method’s clustered outputs were not arbitrary but consistently reproducible, we conducted a rigorous stability analysis.

The validation process involved setting the model’s decoding temperature to 0.5, a value chosen to balance determinism with semantic flexibility, and executing the clustering process five times on each identical input datasets. The consistency of the five resulting partitions per interface (AB, PB, CB) was then assessed using the Clustering Stability (CLS) method (von Luxburg, 2010), with detailed results presented in Table 2.

Table 2

Clustering Stability Scores for AB, PB, and CB Interfaces

The analysis demonstrated a high degree of stability across all three interfaces (AB=0.81(σ=0.05), PB=0.82(σ=0.07), CB=0.88(σ=0.07)). This outcome validates our methodology as a robust tool for this analytical task, confirming our methodology’s reliability for cross-user analysis.

Step 3. Graph Construction. To model the sequential dynamics, we utilized NetworkX (Hagberg et al., 2007) to construct a directed graph of the aggregated workflow of multiple users, where nodes represent semantic action clusters and edges represent sequential transitions (Figures 10 to 12). The weight w(u, v) of an edge is calculated as the total frequency of transitions from state u to an action state v across all designer sessions D, formally expressed as:

$$ w(u,v)=\sum _{L\in D} \sum _{l=1}^{\left|L\right|-1} I\left(s\left(a_l\right)=u\wedge s\left(a_{l+1}\right)=v\right)$$

where L is a single designer’s sequence, s(a_l) maps an action to its corresponding state, and I(·) is the indicator function. This topology reveals the mapping of the dominant behavioral patterns and cognitive flow across interfaces.

3. 4. Quantifying Behavioral Metrics using Workflow-Net

To empirically compare the interfaces, we derived four metrics from the graph topology, targeting specific dimensions of the creative process:

• 1. Design Action Move Variety: Serves as a quantitative proxy for the breadth of exploration within the solution space. The variety of design action moves measures the diversity of cognitive and operational strategies employed during ideation (Shah et al., 2003). High variety suggests a comprehensive use of cognitive and operational strategies, while low variety indicates a constrained process dominated by a single action type (Wadinambiarachchi et al., 2024). This is quantified by calculating the ratio of each unique action label (e.g., Create, Modify, Branch) relative to the total number of actions performed.
• 2. Majority Agreement: An inverse measure of behavioral variety that quantifies consensus among designers at any given sequence in the workflow. High agreement signals convergence on a shared strategy, while low agreement indicates divergent activity. It is calculated as the ratio of the most frequent action to the total actions at each discrete sequence step, averaged across design stages.
• 3. Branching Rate: Characterizes the complexity and degree of divergence in the creative process (Chang et al., 2020; Liu et al., 2017). A high branching rate indicates the active generation of parallel conceptual pathways. This is operationalized as the percentage of all actions labeled as a “branch” move within each design stage.
• 4. Idea Switch Ratio: Evaluates the balance between deep, iterative elaboration on a single idea versus broad exploration across multiple concepts (Dow et al., 2010). It quantifies the design idea continuity by calculating the ratio of moves labeled as a “switch” to a new design idea versus those continuing the “same” design idea. A high switch ratio is a behavioral signature of parallel prototyping, which has been shown to improve design outcomes (Dow et al., 2011).

Collectively, these four metrics transform the sequential behavioral data captured by Workflow-Net into a robust quantitative framework. This enables the nuanced, action-centric cross-interface comparisons essential for understanding the efficacy of different design support systems.

5. 1. AB Interface as a Design Support Tool for Open-ended Initial Design Stage Exploration

The utility of the AB interface was largely confined to the open-ended, initial stages of the design process. Our Workflow-Net analysis revealed a process that lacked both strong divergence for exploration and effective convergence for refinement. While “modify” was the most frequent action, it constituted only 47% of all moves which was significantly lower than the focused activity observed in the PB interface (71%), indicating an inability to effectively iterate on design details (Table 4). Consequently, the AB interface received the lowest scores for creativity support (CSI: M=48.77, SD=24.40) and usability (SUS: M=67.50, SD=22.47), alongside a moderately high workload (NASA-TLX: M=36.11, SD=21.87) (Table 6).

Table 4

Workflow-Net Behavioral Analysis Metrics: Design Action Move Variety

This limitation became pronounced as designers transitioned into the design development stage, where the AB interface induced significantly more struggle compared to the other interface frameworks. General satisfaction ratings reflected this friction (Figure 9), with participants reporting the highest levels of struggle in developing (Q3: M=4.78, SD=1.30) and finalizing (Q4: M=4.00, SD=1.66) their concepts. Designers found text-only interaction to be a bottleneck for conveying complex visual concepts, resulting in consistently low ratings for user Agency (Q1: M=3.56, SD=1.33) (Figure 9). Qualitative feedback illuminated a profound sense of disconnect; as ideas became more concrete, the interface framework felt “uncontrollable” (P9), forcing designers to abandon their design ideas. Participants noted the frustration of a system that “wouldn’t listen” (P9), with P4 stating, “I gave up on my ideas... it felt like the AI was the designer and I was the assistant”.

Figure 9

Subjective Evaluation Metrics: Agency and General Satisfaction

Figure 10

Aggregated workflow graph visualization of AB nterface framework

These findings align with existing literature regarding the abstraction gap of text-only interaction (Dang et al., 2022; Liu et al., 2023; Masson et al., 2024), where users struggle to articulate nuanced visual intent through language alone. Ultimately, the AB interface framework proved effective only for simple, open-ended ideation, as user agency proved fragile once the design process demanded precision and refinement.

5. 2. PB Interface as a High-control Tool for Convergent Refinement Process

Figure 11

Aggregated workflow graph visualization of PB interface framework

The PB interface enforced a highly convergent and linear workflow centered on iterative refinement. Workflow-Net analysis revealed an overwhelming dominance of the “modify” action, which accounted for 71% of all moves (Table 4). This rigid focus led designers to elaborate deeply on a single concept rather than exploring alternatives, as evidenced by idea switch ratio decreasing from 13% during ideation to 0% by the finalization stage (Table 5). Moreover, divergent thinking was inhibited as the process progressed; the branching rate plummeted from 11% during ideation to 0% in the final stage. This linear trajectory resulted in highly similar behavior across participants, with the PB interface yielding the highest Majority Agreement scores, peaking at 84% during the design idea development stage.

Table 5

Workflow-Net Behavioral Analysis Metrics: Majority Agreement, Idea Switch Ratio, and Branch Rate

While designers valued the granular control While designers valued the granular control which was reflected in moderate CSI (M=65.68, SD=12.93) and SUS scores (M=69.17, SD=14.95) (Table 6), this precision came at a significant cost. Despite the high degree of procedural control, the interface yielded only a moderate sense of Agency (Q1: M=5.11, SD=1.10) (Figure 9), suggesting that manual technical management does not linearly translate to creative empowerment. Quantitative measures of struggle were lower than AB but remained present (Figure 9), particularly in the development phase (Q3: M=3.56, SD=1.67), though participants found it easier to finalize designs (Q4: M=2.78, SD=0.97) once the pipeline was established. As shown in Table 6, PB demonstrated the highest overall workload (NASA-TLX: M=37.35, SD=12.66), confirming the “stressful and slow” nature of manual pipeline construction. Specifically, results showed that the PB interface imposed a higher physical demand than the CB interface framework. Participant 6 captured this trade-off, noting that while “connecting the nodes was really annoying,” it remained “effective for refinement”.

Table 6

Subjective Evaluation Metrics: Creativity Support Index (CSI), System Usability Scale (SUS), and NASA-TLX

These findings align with literature identifying manual pipeline construction as a notable usability barrier (Jiang, 2023). Furthermore, the observed paradox of control where rigid mechanics hinder creative exploration demonstrates how such interfaces force designers to expend significant effort translating emergent ideas into structured workflows (Angert et al., 2023). This highlights that high procedural control can actually diminish creative agency when the interface’s logic restricts the natural, fluid progression of the design.

5. 3. CB Interface as a Fluidic Design Partner Balancing Exploration and Refinement

Figure 12

Aggregated workflow graph visualization of CB interface framework

In contrast to the other interface frameworks, the CB interface emerged as the most effective model, successfully balancing broad exploration with intuitive refinement. Our Workflow-Net analysis revealed a uniquely divergent and non-linear process, characterized by the highest variety of design action moves. This versatility was reflected in the lowest average Majority Agreement (53%), indicating a more personalized design process for each participant (Table 5). The interface actively encouraged divergent thinking, sustaining the highest Branching Rate (18% in ideation, 16% in development) and a design Idea Switch Ratio (32.67%) more than five times higher than the PB interface (Table 5).

This fluid, parallel workflow translated into superior subjective ratings across all primary metrics (Table 6). The CB interface achieved the highest creativity support (CSI: M=76.54, SD=21.09) and usability (SUS: M=86.94, SD=13.85) scores while maintaining the lowest workload (NASA-TLX: M=21.30, SD=14.89). General Satisfaction scores (Figure 9) across all questions were the most favorable in this condition, with the lowest reported struggle in creation (Q2: M=2.00, SD=1.00), development (Q3: M=2.33, SD=1.58), and finalization (Q4: M=2.22, SD=1.20). Qualitative feedback revealed that this success was rooted in the system’s ability to act as a creative stimulant; P7 noted that the system allowed for more “design experiments and tests” than anticipated, generating results that “exceeded expectations”.

However, the powerful generative capacity of CB interface presented a minor challenge; P9 found the sheer volume of information in the canvas space “a bit chaotic,” highlighting a need for future mechanisms to prevent choice overload. Despite this, the CB interface, by empowering designers with a strong sense of agency without imposing a heavy workload, stood out as the most holistic and successful design partner among the three interface frameworks.

Crucially, this exploratory power did not hinder refinement. By automatically visualizing workflow history, the CB interface framework provided essential process traceability, allowing designers to “see their thought process” at a glance (P3) without the manual labor required by the PB interface. This seamless integration created the highest sense of Agency (Q1: M=5.89, SD=1.54) (Figure 9), with participants feeling they were leading the process. P3 described “the AI not as a director, but as a supportive assistant providing a guideline to efficiently produce 60–70% of the design for the designer to finalize”.

6. 1. Balancing Fluidity and Precision through Hybrid Architectures

While the AB interface framework is effective for initial ideation, its abstraction gap makes it a bottleneck for refinement. Conversely, the PB interface framework’s procedural control is valuable for detail, but its rigidity inhibits the fluid exploration essential to creativity. Future systems should synthesize these strengths by utilizing an infinite canvas as the primary workspace for non-linear exploration, while integrating procedural nodes as an optional, on-demand layer. Tools should allow designers to transition seamlessly from low-fidelity conversational ideation (AB) to high-fidelity procedural tuning (PB) within a single canvas-based environment. This allows the system to support the entire design lifecycle—from broad divergence to structured convergence—without forcing the user to switch tools or sacrifice creative flow.

6. 2. Mitigating Cognitive Load via Agent-Assisted Automation

A primary barrier observed in the PB interface was the usability wall created by manual pipeline construction. To lower this barrier, future systems must move away from manual wiring toward intent-based automation. Instead of requiring users to connect every node, generative AI should act as a technical intermediary that intelligently suggests design actions or auto-generates procedural pipelines based on high-level designer intent. Implementing an intelligent agent that can suggest next design moves or an automated workflow pipeline construction features enables reproducibility and granular control without the physical and cognitive overhead of manual node management. By automating the labor of the design process, the interface allows the designer to remain focused in the strategy phase of the workflow.

6. 3. Fostering Agency through Process Traceability and Prompt Archiving

Our results indicate that user agency is fragile and closely tied to a designer’s ability to visually trace their thought process. The success of the CB interface framework was largely due to its inherent process traceability. Future tools should treat the workflow history as a primary design asset. Systems should implement ‘Prompt Archives’ that visualize the linguistic and procedural evolution of a design. By preserving the exchange of interactions (e.g., conversation prompts) between the designer and AI, the interface supports reflection and iterative reuse.

Real-time node traceability ensures that users can backtrack, branch, and experiment without manual overhead, reinforcing the role of the AI as a supportive assistant rather than a “black-box” director. This shift ensures the system remains designer-led, upholding creative agency even as the AI’s generative power increases.