The Kludge Economy

The Last Interface—Essay II

“Let’s just pretend the animation worked right there.”

I said that, or something like that, so many times, grimly. Practiced and completely automatic—the kind of recovery that takes years to develop and about four nanoseconds to perform. Stakeholders nodded. The presentation continued. Nobody mentions the broken prototype, the detached component, the click event that dissolved into a blank screen at the worst possible moment.

We move on.

The crazy thing is nobody is surprised. Everyone in the room has been in that room before, on both sides of the table. The unspoken agreement is immediate and total: we see you, we’ve been you, let’s all get through this together. The more unsettling moment would have been if the prototype actually worked perfectly—then the questions start. How did you build that? Can we see it on mobile? What happens if I click this? A flawless Figma prototype in a live presentation is suspicious. A slightly broken one is just Tuesday.

That shared commiseration—the collective wince, the knowing nod—is not a failure of craft. It’s the symptom of a process that put the wrong thing at the center for too long.

Let’s Just Pretend the Animation Worked

Figma started as liberation.

Get design closer to code. Collapse the translation gap. Put something real in front of a human before the engineers had to build it. For a while, it delivered on every promise. The shared canvas alone changed how teams communicated. Real acceleration. Real value.

Then it kept going and growing and groaning.

Auto-layout. Variables. Booleans. Interactive components with conditional logic that rivals a developer’s first project — except it can’t be deployed, can’t survive real conditions, and collapses if someone sneezes on a nested frame. Figma is designed to articulate spatial coordinates and visual properties to simulate software rather than building it. A flight simulator that looks exactly like a cockpit but never leaves the runway.

The prototype became the trap. Not because prototypes are wrong—because this kind requires a specialist to build, hours to maintain, and a specific prayer before every live presentation. One detached component. One unsynced variable. One boolean that flipped when nobody was watching. And suddenly you’re standing in front of a room full of decision-makers doing your best Clint Eastwood—The Good, The Bad and The Ugly playing out in real time, except you’re all three simultaneously, improvising the score as you go.

Here’s the thing about the code a designer generates with AI tools now: it’s spaghetti. Glorious, honest, functional spaghetti. It breaks in real ways, under real conditions, with real error messages that point to real problems. It doesn’t perform stably—it either works or it doesn’t, and when it doesn’t, everyone learns something true. Compare that to a Figma prototype that performs confidence while concealing every constraint, every compromise, every technical debt hiding behind a beautifully kerned button that will never behave this way in production.

AI didn’t kill the Figma prototype. It just made the performance too expensive to keep staging.

The Kludge Economy

There’s a TED Talk nobody gives. The working title would be How To Never Fix Anything, Keep Everyone Reasonably Happy, And Call It A Roadmap.

It goes something like this.

Designers feel it first

—in the gut, the moment the engineer says we can’t fix the real problem with the time and resources we have. Not a shock. More like recognizing a familiar intersection you’ve driven through a hundred times, knowing the light timing is wrong, knowing someone will eventually get hurt, turning left anyway because you’re already late.

The PM needs the metric to move. The engineer needs the sprint to close. The roadmap has commitments nobody wants to revisit. And the designer—who has been living inside the user’s frustration for weeks, who can feel exactly where the experience splinters—gets handed a UI bandaid and asked to make the laceration look like a design decision.

So we do. Because what’s the alternative?

This is the Kludge Economy. No villains. No conspiracy. Everyone is rational. Everyone is optimizing for something real — velocity, sustainability, relationships, quarterly numbers. The system produces bad outcomes from individually reasonable decisions, and the whole thing runs on one phrase, delivered with genuine intention every single time:

“We’ll go back and solve it right later.”

It is not a lie. It is a shared and renewable delusion. Everyone believes it in the moment. The priority evaporates the instant the mediocrity metric is hit. The kludge becomes the baseline. The baseline becomes the product. The product becomes what the next designer inherits, works around, and eventually says we’ll fix it later.

This is how design debt becomes architectural debt becomes a platform migration that someone announces three years from now with a slide that says Investing In Our Foundation.

The Kludge Economy doesn’t run on bad intentions. It runs on a process that puts collaboration in the wrong place at the wrong time downstream, inside the tool, after the constraints are already load-bearing.

John Maeda put it cleanly: “Designers make obstacle courses. But AI with intent can teleport the user to the goal.” The obstacle courses aren’t accidents. They’re the accumulated geometry of every ‘we’ll fix it later’ that didn’t get fixed. Every bandaid that calcified into a feature. Every kludge that got a component built around it.

There is good news — the Kludge Economy runs on a specific inefficiency: the right solution used to cost more than the excuse. That math just changed.

The Builder Blueprint

Bauhaus Manifesto was released in 1919 with a declaration that had nothing to do with aesthetics and everything to do with construction: “The ultimate aim of all visual arts is the complete building.”

Not the drawing of the building. Not the presentation of the drawing. Not the stakeholder review of the presentation of the drawing. The ‘building’. The complete, inhabited, functioning thing.

He was describing something software forgot and construction never abandoned: the most consequential decisions happen before anyone picks up a tool.

Change your mind during design—cheap. Change your mind during framing—expensive. Change your mind after the foundation is poured—catastrophic.

The blueprint exists not to demonstrate that work is happening but to make the right decisions before the wrong ones become structural.

This is the Builder Blueprint.

Not a deliverable. Not a phase. A practice — the discipline of resolving the hard questions upstream, in planning and discovery and research, before a single tool is opened. Design, engineering, product management, and business strategy in the same room, arguing about the right problem before anyone has invested in a solution. The artifact—the code that ships, the experience the user actually touches—becomes the finish line. The evidence of decisions made well before the deadline arrived.

The old model put collaboration inside the design file. The Figma canvas became the negotiating table where scope got quietly trimmed, constraints got absorbed into components that pretended they didn’t exist, and metric pressure produced flows that nobody loved but everyone could survive. Every compromise lived in the file.

The Builder Blueprint flips it. The file is the finish line. Polish and precision are the output of upstream alignment—not the substitute for it.

Karl Koch at DuckDuckGo calls the operational balance *“build with vibes but ship with rigor.”* The vibes are the exploration—the fast, messy, AI-assisted navigation through incomplete thoughts and imperfect ideas. Rigor is the Builder Blueprint—the upstream clarity that makes the vibes mean something when they land.

Luis Ouriach at Figma sees the same thing from the systems side: *“The more we rely on a tool to create our code, the more we rely on a system to tell that tool what to code.” *The new system is a Builder Blueprint. It’s what turns AI velocity into something other than fast kludge.

One idea. Clear enough to fight for. That’s how things get done.

“It is much better to have just one idea, and if the idea is clear, then you can fight for it. That is how you can get things done.” — Mies van der Rohe

The Kludge Economy produces synthetic outcomes because the process never gave craft a fair fight. Bandaids that calcified into features. Prototypes that performed confidence. Roadmaps that promised what the sprint couldn’t deliver.

Nobody planned it that way. It emerged.

Here’s the exit ramp.

Before a single automobile reaches a customer, it exists as one perfect prototype that every discipline touched—designers, engineers, strategists, safety teams—all of them fighting over the same object until it earns the right to be reproduced. The prototype isn’t a simulation of the car. It is the car. And only when it’s right does it go into production.

Software forgot this. The product that reaches the user should be the thing everyone agreed was worth building — not the thing that survived the process.

Kris Puckett calls the quality that emerges from that kind of process soul. The residue of a cross-functional fight worth having. It registers the moment a user touches something and thinks—without knowing why—someone actually gave a damn about this.

The interface is a conversation now. Ambient. Personal. Assembled in the moment for the person in the moment. You cannot kludge a conversation. You either know what you’re trying to say or you don’t.

And the agent — fast, tireless, pattern-hungry — is only as honest as the intent behind the prompt.

Which means the most important work isn’t in the tool.

It never was.

Acknowledgments & Hat Tips

The Spaghetti Western analogy deserves a footnote. The Good, The Bad and The Ugly was filmed by an Italian director with a mostly European cast—cheap, brilliant, and completely uninterested in whether you noticed the shortcuts. Hollywood offshored the Western to cut costs and accidentally made art. Software did the same thing somewhere between Series B and the IPO roadshow, with considerably less Ennio Morricone. The difference is Leone knew he was making camp.

The Historical Record

Mies van der Rohe—Seagram Building, 1958. Seven months deciding where to put the columns. Worth every minute.

Marcel Breuer—Wassily Chair, 1925. Steel that looked like steel. Radical then. Obvious now. That’s how the right idea always works.

Film

The Good, The Bad and The Ugly Dir. Sergio Leone, 1966. Filmed in Spain. Dubbed in post. Somehow still perfect. The lesson is complicated.

The Phrase That Built An Economy

“We’ll go back and solve it right later.” — Author unknown. Repeated everywhere. Retirement date: TBD.