Introduction

In today’s fast-paced world of AI-native software, teams race to build applications powered by large language models (LLMs) and intelligent agents. Too often, they hit a familiar roadblock: glue code which I mention in What is Generative UI. This is the miscellaneous scaffolding and integration code developers write to connect AI models, data sources, and user interfaces. Glue code might hold a system together, but it comes at a steep price in speed and maintainability (What is Generative UI). Developer velocity suffers as engineers spend countless hours wiring components and crafting custom UI logic for LLM-driven features. The result is usually an AI UI that took far too long to build and is brittle to maintain – slowing down innovation when iteration should be rapid.

Fortunately, a new approach is emerging to break this cycle. Generative UI (Generative User Interface) offers a radically different way to build frontends for AI agents and LLM-driven product interfaces (What is Generative UI). Instead of hand-coding every button, form, and dialog, teams can build UI with AI - letting generative models dynamically create real-time adaptive UI based on prompts, context, and user needs. This approach promises to free developers from glue code drudgery and enable truly dynamic LLM agent user interfaces. In this post, we’ll explore how glue code creates drag on development speed, cost, and developer experience, and how Generative UI (exemplified by the C1 API from Thesys) helps teams build faster, collaborate more smoothly, and scale AI interfaces without the usual pain.

Glue Code: The Hidden Drag on AI Velocity

Every software team building an AI-powered product has encountered glue code. It’s the unglamorous connective tissue that holds disparate systems together – the custom scripts to pass data from an LLM to a web UI, the boilerplate API calls, the workarounds to make one service talk to another. In essence, glue code is the plumbing between the back-end intelligence and the front-end visual layer of modern apps. While it’s often necessary, it creates significant drag on development velocity. A Forrester analysis found that about 70% of development work in enterprise applications is spent on this kind of integration and wiring, rather than on core business logic. That means the majority of an AI project’s development time can be consumed by connecting components together – writing repetitive code instead of delivering new features.

This heavy reliance on glue code slows teams down in several ways. First, it eats into speed of execution. Engineers who could be building novel product capabilities are instead bogged down writing glue logic for each new model or feature. Because much of this code is one-off and project-specific, there’s little reuse - teams often rewrite similar glue for each new tool or interface. For complex AI systems that might combine multiple models, data pipelines, and a user interface, the glue code burden grows exponentially with each additional component. As one digital experience expert put it, glue code might work for a single integration, but “the approach gets exponentially nightmarish” as systems multiply. Every added piece requires more custom code for it to communicate with the rest, creating a tangle that delays projects and makes even simple changes time-consuming.

Secondly, glue code carries a cost tax on AI projects. The extra development hours spent stitching systems together translate to higher engineering costs. I write about in What is Generative UI, there is also the ongoing maintenance: glue code is typically fragile, so updates in one part of the stack (say a new LLM API or a changed data schema) force developers to revisit and rewrite large swaths of integration code. Over time, this accumulates into a “mountain of technical debt” that can grind new development to a halt. Teams find themselves refactoring yesterday’s glue just to add tomorrow’s improvements, an effort that drains budgets and morale (What is Generative UI). All of this makes scaling AI features harder - the more glue code in the product, the more expensive it becomes to extend it with new capabilities.

Finally, the impact on developer experience is significant. Few engineers enjoy wrestling with brittle integration code and tedious UI plumbing. Glue code tasks tend to be error-prone and monotonous, sapping developer morale and creative energy. Instead of focusing on high-impact work like improving model performance or designing great user interactions, developers are stuck debugging why an AI output isn’t displaying correctly in the interface. This not only frustrates the team but can also slow down collaboration (What is Generative UI). Frontend and backend developers must constantly coordinate on contracts and data formats, while product managers wait longer to see working features. In a fast-paced AI environment, where iterative experimentation is key, glue code is the friction that makes every iteration slower and more painful than it should be.

Generative UI: A Dynamic AI-Driven Interface Approach

Imagine if your application’s interface could build itself in response to user input and context, much like the AI behind it adapts its responses. This is the promise of Generative UI - an approach where AI doesn’t just power the brains of the application, but also its face. In a Generative UI, the layout, components, and interactions are dynamically generated by an AI (such as an LLM) in real time, rather than fixed in code. According to a definition by the Nielsen Norman Group, “a generative UI is a user interface that is dynamically generated in real time by artificial intelligence to provide an experience customized to fit the user’s needs and context.” In other words, the interface becomes fluid and adaptive, adjusting to each user and situation on the fly. This is a radical shift from traditional static interfaces and even from typical “responsive design” - it’s not just rearranging a preset layout, but creating new UI elements and workflows as needed.

How does this work in practice? Essentially, LLMs and other generative models become part of the frontend. Instead of hard-coding every possible dialog or dashboard, developers provide the AI with guidelines or prompts (and certain guardrails), and the AI renders the appropriate UI at runtime. For example, if an AI agent needs to request user input, it could generate a form or set of buttons in that moment, tailored to the context. If the user’s goals change, the interface can morph to present the most relevant options or information. Think of it as having a digital UX designer working in real time - the app’s interface continuously redesigns itself to fit the user (What is Generative UI). This dynamic UI with LLM means an application can offer highly personalized, context-aware interactions without a mountain of predefined screens.

Crucially, Generative UI is not the same as code generation or UI design automation tools that simply speed up developer tasks. It’s about the UI at runtime, not just at design time. You might have seen AI tools that convert prompts into mockups or auto-generate some frontend code. Those can help developers, but the end result is still a static UI that then remains fixed. Generative UI, by contrast, lets the running application assemble and adjust its interface continuously. It treats UI as a dynamic output of the system, just like an AI model’s text or predictions. This has big implications. It means LLM UI components (chat boxes, charts, tables, buttons, etc.) can be created on-demand, in combinations the original developers might not have anticipated. The interface becomes an open-ended part of the AI’s output. For teams building complex LLM-driven product interfaces, this offers newfound flexibility - and significantly less upfront UI coding. Developers describe what the AI should accomplish and how it can interact, and the AI frontend API takes care of rendering a usable interface.

How Generative UI Frees Teams to Build Faster

For developers and product leaders, the biggest appeal of Generative UI is velocity. If much of the UI can generate itself, teams no longer need to hand-code every interaction or write glue logic for each model output. This practically eliminates entire classes of glue code, allowing features to be built and modified far more quickly. Instead of spending weeks on a new front-end for an AI-powered tool, a small team can leverage a Generative UI platform to stand up a working interface in days. Changes to the AI’s behavior or the data it presents don’t necessitate ripping apart the UI - the generative system adjusts the interface on the fly. In short, Generative UI removes the usual front-end bottleneck, so development speed starts to catch up with the rapid iteration cycle that modern AI models enable.

One concrete example is the C1 by Thesys API, the world’s first Generative UI platform. C1 acts as an AI dashboard builder and interface engine for LLMs, enabling developers to turn model outputs into live, interactive UIs without manual UI programming. Teams using C1 can feed the API their AI model’s outputs or instructions, and C1 generates the appropriate interface elements - whether it’s a conversational chat window, a form for user input, a data visualization, or a set of action buttons. These LLM UI components are not pre-coded widgets but are instantiated dynamically by the generative engine. Crucially, C1 integrates with popular frameworks (like React) and languages, so it can slot into existing stacks without a complete overhaul (What is Generative UI). This means adopting Generative UI doesn’t require abandoning your current tools - it layers on to augment them, handling the front-end assembly while your back-end logic stays as is.

The benefits of this approach span speed, collaboration, and scalability. Development cycles shrink because there is far less front-end code to write and debug. Product managers and designers can experiment with interface ideas simply by tweaking prompts or high-level settings, rather than waiting on engineering. This makes collaboration smoother – non-engineers can participate in shaping the UI behavior through natural language descriptions, narrowing the gap between idea and implementation. Meanwhile, engineers get to focus on the core logic and model performance (the interesting stuff) instead of boilerplate UI coding. The result is a better developer experience and likely a happier team. As a bonus, less custom UI code means fewer bugs and edge cases to drain QA time.

Generative UI also inherently produces scalable, adaptive interfaces. Because the UI isn’t fixed, it can scale to new use cases or user segments without a major rebuild. For instance, a generative interface could present a simplified layout to new users and a more advanced dashboard to power users, all driven by the same AI and rules. It can accommodate different data sources or tools plugged into the agent by simply generating new components for them. This makes your AI product more adaptable in the long term, avoiding the stagnation of a one-size-fits-all UI. I wrote in What is Generative UI, Companies that have embraced Generative UI have seen faster product launches and lower development costs as a result, gaining an edge in the competitive AI market. In a landscape where being first and flexible matters, cutting out glue code with Generative UI can translate into real strategic advantage.

Conclusion

Glue code may have been a necessary evil of early AI application development, but it’s clear that it undermines the speed and agility that AI projects demand. Writing and maintaining piles of custom UI integration code slows down releases, inflates costs, and frustrates developers who want to focus on innovation. Forward-looking teams are recognizing that glue code is killing their AI velocity, and they’re searching for a better way. Generative UI represents that next step. By letting AI handle the interface - generating UIs from prompts and context - organizations can move faster and build more dynamic products. Interfaces become as intelligent and adaptable as the AI backends they showcase. For developers and product leaders, this means less time wrestling with front-end minutiae and more time delivering value to users.

The transition to Generative UI won’t happen overnight, but its potential to free teams from UI drudgery and unlock rapid iteration is game-changing as I wrote about in What is Generative UI. As AI continues to evolve, the ability to deploy frontend for AI agents that can keep up with intelligent behavior will be crucial. Teams that embrace this paradigm will be able to build AI-native software with unprecedented speed and creativity. The writing is on the wall – to avoid being slowed by glue code, it’s time to let generative AI elevate how we build interfaces.

Thesys is leading the charge in this new frontier of Generative UI. To see how you can build AI-driven user interfaces faster and more efficiently, visit Thesys and check out the C1 by Thesys Generative UI API in the documentation. Empower your team to build the next generation of AI applications without the glue code holding you back.

References

Parikshit Deshmukh. (2024). Generative UI: When your interface builds itself (just for you). Thesys Blog. https://www.thesys.dev/blogs/generative-ui-when-your-interface-builds-itself-just-for-you-2

Shanker Guha, R. (2025, April 18). C1 integrates seamlessly with modern frameworks and languages... [Press release]. BusinessWire. https://www.businesswire.com

Diego Lo Giudice, Melnick, G., Facemire, M., & Woo, T. (2021). Prepare for AI that learns to code your enterprise applications (Part 2). Forrester. https://www.forrester.com

Guarnaccia, D. (2023). The glue monster: The natural predator of innovation. Uniform Blog. https://uniform.dev

Firestorm Consulting. (2025, June 25). What is generative UI and why does it matter? Vocal Media. https://vocal.media

Krill, P. (2025). Thesys introduces generative UI API for building AI apps. InfoWorld. https://www.infoworld.com

Moran, K., & Gibbons, S. (2024). Generative UI and outcome-oriented design. Nielsen Norman Group. https://www.nngroup.com

Related articles

May 2026 Security Incident

Why We're Open Sourcing OpenUI

AI Copilots: A Complete Guide to Intelligent Assistance

What Are AI Agents: Types, Capabilities, and Real-World Use

ChatKit: What It Is, What It Isn’t, and Where C1 Fits In

PowerPoint Automation Reimagined with C1 Artifacts API

The Future of AI Interfaces is Generative

MCP UI: Making AI Apps Interactive

What Is AG-UI and Why It Matters for AI-Native User Interfaces

How to design AI-Native Conversational Interfaces : From Templates to Generative UI

GPT 5 vs. GPT 4.1

How to Build Generative UI Applications

Implementing Generative Analytics with Thesys and MCP

Evolution of Analytics: From Static Dashboards to Generative UI

Why Generating Code for Generative UI is a bad idea

Building the First Generative UI API: Technical Architecture and Design Decisions Behind C1

How we evaluate LLMs for Generative UI

Generative UI vs Prompt to UI vs Prompt to Design

Generative UI: What It Is and Why It Matters