Two people looked at the same thing this year and drew opposite conclusions. One said the skill that got more valuable is the one that decides what deserves to exist. The other watched a team spend two and a half years proving they'd lost it.
The contradiction is only apparent. Both are describing the same event from different ends. Judgment didn't get more valuable because teams got wiser about it. It got more valuable because the thing that used to enforce it for free just disappeared.
Start with the phone call. A company, two and a half years in, four rebuilds deep, on the line with an outside voice they'd brought in to help.
The engineering was, in places, genuinely beautiful. A working voice interface. A slick web app. A problem-solving engine underneath it smarter than most things you'd see after years in the AI space.
Forty minutes into the call, they still could not say who it was for.
One of their engineers said the thing out loud: a startup used to get one real shot at an idea, because building was slow enough and expensive enough that the budget only paid for one go. AI had cut that cost so far they'd taken multiple shots instead, and many iterations later they were no closer to a product anyone wanted.
Then he reached for a biotech analogy. They'd invented a molecule that might really cure something, and they had no manufacturing, no distribution, and no earthly idea who was sick.
Here is the part worth sitting with: these were not clumsy or ignorant people. That's the whole point. Building was never their bottleneck. Deciding was, and nothing forced them to do it.
For decades the industry treated "just because you can build something doesn't mean you should" as a virtue — a discipline good teams practiced and lazy ones neglected. That framing was always slightly wrong.
It wasn't a virtue. It was a tax, and slow, expensive building collected it automatically.
Chandler Thompson put the mechanism plainly: when writing code was the slow, deliberate step, the act of typing functioned as a tax on bad ideas. If a feature would take three days, you thought hard about whether it was worth three days. The friction killed marginal features before they were born.
Collapse the build to an afternoon and you don't just build the good features faster. You build all the marginal ones you'd previously have talked yourself out of.
His sharpest line names the exact substitution that happened: take the dread away, and "should we build this?" quietly collapses into "can we build this?" — and the answer to can we is now always yes, and always soon.
So AI didn't remove a bottleneck. It removed an enforcement mechanism. The judgment the tax used to buy you for free now has to be bought deliberately, with attention nobody has budgeted.
AI didn't remove a bottleneck. It removed an enforcement mechanism. The judgment the tax used to buy you for free now has to be bought deliberately.
That single failure is now wearing three different costumes. Once you see it's the same wound, the industry's separate panics stop looking separate.
The first costume is discovery debt: you skip asking whether the thing should exist at all.
Roberto Hortal names it directly — decisions about what to build, made without validated knowledge of why anyone would use it. Itamar Gilad calls the trigger code-first discovery: teams build a prototype first because building is now cheaper than the administrative overhead of a proper discovery process.
The prototype becomes the experiment. The experiment, if it performs, becomes the product. Discovery isn't happening; it's being skipped.
And it doesn't feel like debt. It feels like momentum — a demo, early-access signups, incomplete data, a shipping team, high velocity, every leading indicator green while the lagging ones haven't caught up.
The reason this stays invisible is structural, not moral. In a room where deadlines are real and stakeholders aren't patient, visible work wins every time. The shipped feature is legible. The conversation you didn't have, the user you didn't talk to — invisible. Invisible work loses.
The edtech case is the whole pattern in miniature. A team spent a big chunk of a cycle building an AI lesson-planning tool. Sales loved the demo, executives approved it, teachers looked at it and kept doing what they'd always done.
Not because they misunderstood it. Because it wasn't meaningfully better than a workflow they'd built over years. Meanwhile the features teachers had actually flagged sat unread, delayed a quarter, and someone else shipped the competitive one.
The second costume is UX debt: the code compiles, and the invisible interface decisions buried inside it fail the user anyway.
A user opens a signup form. Name, email, password. Twelve seconds later they close the tab and never come back.
You didn't lose them to a competitor's better product. You lost them to a password input that never told them why it got rejected.
Nothing threw an error. The code works. That gap — between "the code works" and "the person could use it" — is what UX actually is, and it's exactly the kind of judgment the old friction used to force into the open.
When building was slow, someone had time to notice the rejected password said nothing. When a service ships in an afternoon, the invisible decisions ship unexamined inside it, looking like working software.
The third costume is standards debt, and fragmentation is its telltale.
Every team building with AI right now believes it's working on a blank frontier — new interface, new rules, no map. That belief is wrong, and it's expensive: it shows up as rework, as users who never trust the tool, as products that age fast.
We've been here. Around 1997, Netscape and Internet Explorer and Opera each rendered the same page differently, each with its own proprietary tags. Netscape gave you a blink tag; Microsoft answered with a scrolling marquee.
A site built for one broke in the next, so designers rebuilt the same thing three times and called it a living.
The browsers have new names now: ChatGPT, Claude, Gemini, Copilot — each handling the same task its own way, its own conventions for showing reasoning, citing a source, asking permission before it acts. No shared standards, so the vendors are playing jazz, and every team reinvents the same interaction three times.
Jeffrey Zeldman is the name worth remembering here, and the reason he matters isn't a specification. He convinced an entire industry that shared conventions were worth fighting for. His real achievement was a belief held widely enough that building any other way started to feel embarrassing.
But notice why the fragmentation is happening at all. It's the same collapse. When each app is cheap to stand up, nobody feels the dread that used to make them ask whether the pattern already existed. Per-app reinvention is discovery debt and UX debt at the level of the ecosystem.
Three costumes, one wound: judgment that used to be forced now has to be re-imposed, and almost no team is doing it.
The bill is already arriving. Alex Turnbull estimates more than 8,000 startups built production apps with AI in 2025 and now need full or partial rebuilds — what he calls an incoming wave of rescue engineering.
The code itself shows the mechanism at scale. GitClear analyzed 211 million changed lines and found refactoring dropped by more than half between 2021 and 2024 while copy-pasted code climbed.
That's the tax being skipped, line by line. When the pressure to plan disappears, so does the pressure to restructure — and this shows up even in expert hands, which is the clearest sign it's about incentives, not skill.
Which brings us to the uncomfortable reframe.
Convergence toward shared conventions is not a nice-to-have designers might win by building a coalition. That framing makes it sound optional, a movement to join.
It isn't. Convergence is the market re-collecting the tax you skipped. Fragmentation is billed as rework. Unvalidated ideas are billed as flat retention and closed go-to-market windows. Invisible UX failures are billed as the tab that closes at twelve seconds.
The market is the one party at the table that can kill your product and never negotiates. It doesn't care how hard you worked, and it renders its verdict without explaining why.
So the only real question is when you pay. Deliberately, up front, as budgeted evaluation-and-decision time — or later, as rescue engineering, at the market's price and on the market's schedule.
The honest complication: cheap building is a genuine gift. Throwaway prototypes, spikes, three versions of an interaction so you can feel which is right — all nearly free now. Nobody should argue for artificial slowness.
But the gift only stays a gift if the throwaway gets thrown away. A prototype that ships is not a prototype; it's production code that skipped review.
The discipline AI demands was never typing slower. It's answering "do we want to own this for three years?" with a no, even when the demo took twenty minutes and looked great.
A month ago the open question was whether teams would formally budget for the new decision time AI creates. Here's the answer this evidence points to: they won't, not voluntarily.
Not because they're clumsy. Because the tax that used to force it is gone, and nobody bills you for what feels like momentum — until, quarters later, someone does.