Member-only story AI UX debt: A new bottleneck The illusion of completion and the birth of the ghost Zeeshan Khalid Follow 10 min read · 1 day ago 78 Press enter or click to view image in full size Photo by Julie Ricard on Unsplash In the quiet, early hours of the morning, a solo founder or an exhausted software engineer sits before a glowing screen. The room is silent except for the frantic clatter of a keyboard typing a single, unconstrained natural-language prompt into an AI browser interface. Within seconds, hundreds of lines of code stream across the terminal like rain. A fully styled, functional web application materialises from nothing — complete with modern buttons, glassmorphic dashboards, and glowing status indicators. The developer clicks through the interface, watches the transitions glide, and feels an overwhelming rush of creation. The process is intoxicating, carrying the intense, addictive dopamine release of pulling a slot machine handle and winning on every spin. This is the peak of “vibe coding,” a software development practice coined by computer scientist Andrej Karpathy, where developers describe intent, let an AI assistant generate code, iterate rapidly, and ship immediately. By 2026, the industry has watched this paradigm mature into “agentic engineering” A discipline where the default state is that humans do not write code directly 99% of the time, but instead orchestrate spiky, stochastic agents who execute the labor. Yet, as the code base grows at the speed of thought, an unsettling presence begins to haunt the application. A visually polished screen is designed, but the polished mockup creates a dangerous illusion of completeness. Underneath the futuristic aesthetics, the interface is structurally decaying. The user experience is broken, navigation is cluttered, input fields reject standard keyboard focus, and accessibility is entirely absent. This is “vibe-coded UX debt” — the silent, invisible residue of hyper-accelerated speed. Classic UX debt is the accumulated cost of conscious design compromises and neglected user feedback. In the vibe coding era, however, this debt is no longer hand-crafted. It is manufactured at an industrial scale. When speed is prioritised, the developer or designer accepts the AI’s first plausible suggestion. Because the interface looks complete, the team moves to the next ticket. This practice results in a disjointed, chaotic “Frankenstein’s monster” of an interface that users will quietly grow to resent, locking the enterprise into a hidden liability of support costs, lost conversions, and user churn. Why the vibe era generates accidental debt The sudden emergence of this bottleneck is not a failure of AI’s technical capability. Instead, it is a psychological and structural pathology born of how humans collaborate with these statistical systems. Three distinct systemic forces drive this silent accumulation of debt: 1. Cognitive trap of automation bias and risk homeostasis The primary psychological driver of vibe-coded UX debt is automation bias, The human tendency to over-rely on automated systems, accepting their suggestions while ignoring contradictory evidence or failing to search for confirmatory proof. In high-pressure development pipelines, human operators seek the path of least cognitive effort. When an AI assistant presents a highly polished, fluent user interface, the developer’s critical evaluation is bypassed. This complacency is governed by risk homeostasis, a cognitive theory suggesting that, Individuals adjust their behaviour based on their perceived level of risk. If a technology system introduces a high perceived level of accuracy or aesthetic polish, the practitioner feels safe. They fail to execute manual audits, skipping accessibility checks, input validation, and edge-case testing because the visual completeness of the interface masks the underlying instability. The developer assumes that because “it works” on their local machine, the foundation is solid. Press enter or click to view image in full size Homeostatic mechanism 2. Context rot and the collapse of architecture Large language models suffer from a fundamental technical constraint: the finite limits of their context windows. As a developer continues a long, iterative chat session to build a feature, the conversation suffers from “context rot”. The AI assistant begins to lose track of early architectural rules, design tokens, and structural logic. Press enter or click to view image in full size Claude Sonnet 4, GPT-4.1, Qwen3–32B, and Gemini 2.5 Flash on Repeated Words Task To satisfy a new prompt, the agent takes the shortest physical path to make the change work. It begins placing logic wherever it fits. Handlers start performing validation, persistence, domain decisions, and external API mapping in a single, tangled module. Changing a simple business rule suddenly requires editing database code and UI logic together. One module uses raw environment variables, another utilises a configuration dictionary, and a third introduces an entirely new wrapper, transforming the code base into a fragile house of cards. 3. Chasm of Norman’s Gulfs in generative interfaces In cognitive design, Donald Norman formulated the interaction loop through the twin concepts of the Gulf of Execution and the Gulf of Evaluation. The Gulf of Execution is the psychological gap between a user’s intention and the actions the interface makes available. The Gulf of Evaluation is the gap between the system’s physical change and the user’s ability to interpret and understand what happened. Press enter or click to view image in full size Gulf of Execution and the Gulf of Evaluation In generative, vibe-coded interfaces, these gulfs have widened into dangerous chasms. Press enter or click to view image in full size Bridging Gulfs in UI Generation through Semantic Guidance Traditional direct-manipulation interfaces rely on visual signifiers — such as a clearly labeled button — to narrow the Gulf of Execution, as the path to take action is obvious. Vibe coding replaces this deterministic model with an open, linguistic input: the prompt. Because human intention is formed top-down before actions are selected, practitioners struggle to translate nuanced, highly subjective design standards into precise text prompts. They rely on vague, ambiguous modifiers like “make it cleaner” or “more modern,” creating a massive translation cost. Once the AI processes this prompt, it instantly delivers thousands of lines of complex UI code. The human is then confronted with an insurmountable Gulf of Evaluation. Because the AI’s underlying rationale is hidden in a black box, the developer cannot easily trace why the system laid out components in a specific configuration. The cognitive effort has not been removed; it has merely been shifted from execution to verification. The developer must spend hours debugging, refactoring, and verifying that the generated UI aligns with team patterns, nullifying the speed gains of the prompt. Calculating the devastating ROI of “Debt-on-Arrival” To the executive eye, the early stages of vibe coding look like a miracle of productivity. Velocity charts are high, and code bases expand rapidly. However, this speed is a dangerous financial illusion. When a team skips user research, system design, and architectural validation, they are borrowing capital at an astronomical interest rate. The Lovable, Bolt.new, and V0 benchmark To understand the hidden economics of this trend, an empirical study tracked 20 prototype-to-production engagements where organisations arrived with functional prototypes built using popular generative tools like Lovable, Bolt.new, and v0. The data exposed the true structural state of these code bases upon arrival. Press enter or click to view image in full size Lovable → production the real cost The rebuild metric: On average, 59% of the original AI-generated code base had to be completely rewritten during the production hardening phase. The complexity cliff: For simple projects, the rebuild rate was 27%. However, as the application scaled to medium and complex tiers (such as multi-sided marketplaces, regulated platforms, or systems with nine or more data entities), the rebuild rate reached 76% to 85%. At high complexity, the original AI code became a visual specification rather than reusable software. Survival dynamics: The study discovered that the long-term survival of the product was entirely decoupled from the percentage of code rebuilt. Survival was a function of product-market fit, meaning the expensive engineering pass to rewrite the code was a mandatory tax to keep the validated product alive. Press enter or click to view image in full size Engagement cost vs %age of code rewritten To normalise this structural decay across varying project classes, the study established the Tech-Debt-on-Arrival Index (TBI): PCM = Production engagement cost ÷ AI-tool spend during prototype phase (Where the Complexity Coefficient is mapped as: Simple = $0.4$, Medium = $0.7$, Complex = $1.0$). A TBI score exceeding 100 indicates that the prototype was merely a visual mockup masquerading as functional software. The financial impact of this transition is measured by the Prototype-to-Production Cost Multiplier (PCM): TBI = Rebuild percentage ÷ Complexity coefficient At typical AI subscription rates of $20 to $50 per month, a basic production engagement of $3,500 yields a PCM of 70× to 175×. For complex, regulated platforms costing $22,000, the PCM scales to 440× to 1,100×. The AI tool subscription is a rounding error; the true financial driver is the human engineering labor required to clean up the structural omissions left in the AI’s wake. The cost of delay and rework By allowing AI agents to generate code without strict design and architectural boundaries, teams trigger the exponential cost-of-change curve analysed by Dr. Barry Boehm. Press enter or click to view image in full size Average cost to make a change If a requirements or design defect is caught during the initial definition phase, the relative cost to resolve it is $1 \ times$. If that same defect is allowed to slip through an automated coding generator and caught only in production, the cost of resolution skyrockets to 30x, 100x, or up to 1,500x the initial cost. Software projects spend 40% to 50% of their total engineering budget on avoidable rework, primarily driven by misunderstood requirements and incomplete conceptual models. This financial waste is amplified by severe user-experience costs: The reputation trap: Launching an unstable or confusing design damages market share permanently. If a user’s first experience with an interface is frustrating, they will abandon the application and refuse to return, regardless of whether the team later fixes the bugs. Habituation resistance: If users are exposed to a broken layout for an extended period, they construct cognitive workarounds and mental habits. When the design team finally attempts to clean up the UX debt, the users will resist the clean design because it forces them to break their established habits. Museum fatigue in digital layouts: For 110 years, museums have documented “museum fatigue” — the rapid onset of cognitive exhaustion in visitors caused by Dim lighting, hard flooring, and highly repetitive visual layouts. When AI tools generate screens, they rely on high-frequency internet patterns, producing highly repetitive, templated layouts. This visual monotony and poor layout hierarchy induce a digital form of museum fatigue, driving cognitive strain and forcing users to abandon the application within minutes. Systematic frameworks to reclaim intention The solution is not to return to the slow, manual coding cycles of the past. The extraordinary leverage of generative AI is a valuable strategic asset if managed with intent. To prevent vibe coding from becoming a debt-creation factory, organisations must establish rigorous guardrails. Transitioning to systemic UX debt management To manage design debt, organisations must abandon flat, disconnected backlog spreadsheets and treat UX debt as a living, relational database. Within delivery tools like Jira and Miro, UX debt must be structured hierarchically to maintain traceability : Epic (User goal / Job-to-be-Done): Establishes what the user is trying to achieve (e.g., “As a researcher, I want to export my structured bibliography without losing formatting” ). Story (User problem): Documents what is currently blocking the user (e.g., “The export modal has no keyboard focus loop, making it impossible for screen readers to select format options” ). Subtask (Hypothesis): A bounded, testable bet of how the engineering team intends to solve the problem. To prioritise this debt effectively, teams utilise a standardised T-shirt sizing model for estimation : S (Small): Simple layout or colour modifications requiring no user research. M (Medium): Standard flow changes involving one to two development teams, utilizing existing UI design tokens. L (Large): High-impact structural changes requiring cross-team coordination and focused user testing. XL (Extra Large): Highly complex, cross-functional architectural redesigns that impact core product flows and database schemas. By tracking these items visibly across a unified Kanban board, the product team tracks their progression across a structured lifecycle: Insight > Problem framing > Hypothesis development > Design > Delivery > Tracking & resolution The card is never closed upon code deployment; it remains open until user analytics, site intercepts, and session replays verify that the user friction has been completely eliminated. Path to agentic maturity The current era of “vibe coding” represents a profound transition in the history of human-computer interaction. We have successfully automated the act of typing code, but in doing so, we have inadvertently outsourced the act of thinking about the software we build. The result — a graveyard of polished, unusable, and structurally compromised interfaces — is not an indictment of AI itself, but a critique of our current passive relationship with it. The illusion of completion is a powerful drug. It creates the sensation of progress while hiding the reality of decay. If left unchecked, the “vibe coding” movement risks turning our digital infrastructure into a fragile, unmaintainable house of cards, where the cost of “technical debt-on-arrival” eventually exceeds the value of the products being shipped. However, we are not destined to succumb to this bottleneck. By shifting from passive prompting to active architectural orchestration, we can transform AI from a source of chaos into a force multiplier. The goal is to move beyond the dopamine loop of the “generate-and-forget” cycle and toward a model of Human-in-the-Loop Architecture, where the AI performs the heavy lifting of code generation while the human retains absolute sovereignty over the system’s design, intent, and long-term viability.