Shipping got easier. Polish may be the advantage now.

Launching got easier. Polishing did not.

I think almost anyone can put a working website online in a weekend now, and I think that is a good thing. It also seems to me that there is more software than ever, and that more of it feels unfinished: every page looks right on its own, and then buttons go nowhere and a sequence stops partway. I have not measured that. It is a thing I keep noticing.

Something like it is not new. In a sample of news webpages checked as of October 2023, Pew Research found that 23%, nearly one in four, contained at least one broken link.

Pew counted links that did not work when they were checked. It did not ask why any failed, and it says nothing about how those pages were built. I bring it up only because a broken link has the same shape as what I am describing: the page opens, the route out of it does not.

These paths are also easy to miss. Tractinsky, Katz and Ikar reported that people who rated a layout as more attractive also tended to rate it as easier to use.

That is a finding about judgements. It says nothing about whether anyone can tell a finished product from an unfinished one. What it does suggest is that how attractive something looks and how usable people judge it to be are tangled together, which is a reason not to trust a first impression, including my own.

So I do not think the coding tools made software worse. I think they moved where the difficulty sits. In my own use they draft whatever screen I ask for, but they have never told me which screens deserve to exist, and never noticed when one of them led nowhere. Building got cheap. Polishing did not, and polishing is mostly two jobs: joining the parts you built, and refusing the parts you should not.

The first job: joining the parts you built

I build Curio, an app that shows short knowledge cards one at a time. We added a way to pin a chosen card to the top of every reader's stack. The half that lives online worked. That half is the server: the computer we run, which decides which cards to send and in what order. Ask it for a batch and the pinned card came back first, so we wrote down that the feature was verified.

No reader ever saw it.

Two separate breaks sat between the server and a phone. One step dropped the marker that says a card is pinned. Another re-sorted a pool of 200 cards on the phone itself, throwing away the order the server had sent.

The server had a test and it passed. The phone had its own tests and they passed. Nothing tested the two together, which is where the feature actually lived.

Both were ordinary bugs. What interests me is where they sat: in the joins between the parts, which nobody was responsible for checking. The rule we keep now is that the test proving a feature works has to run on the screen a person actually uses.

The second job: deciding what it will never do

The clearest case I have is Sense, which I designed for Curio. It watches how a person taps and reads, on their own phone, to cut down accidental touches. Almost none of the work was the watching. Nearly all of it was me writing down what it must never do.

If a change is big enough for a reader to notice, Sense has to ask first and wait for a yes. I gave it no way to make that kind of change on its own. I assumed a returning reader has learned where everything is, and that this familiarity is worth more than any improvement I could make.

An interface that quietly rearranges itself is worse than one that never adapts, so the only changes it may make on its own are ones nobody can see: a tappable area made a little wider, a stray touch ignored.

I also put some screens out of its reach entirely, including the paywall and anything to do with cancelling. A system that learns when you are most likely to say yes, and shows you the paywall exactly then, is manipulation whatever the intent behind it.

And I barred it from increasing how long people spend in the app. There is a button that asks an AI writing system to explain a card at more length, and suppressing accidental taps means that button gets opened less. Measured by app usage, fewer opens looks like a worse result. Sense exists to cut mistaken taps, so it accepts looking worse by that measure.

Anyone can ship. My guess is that polish stays scarce.

Being able to build and launch a thing used to separate the people who could make a product from the people who could only describe one. I do not think it does that now, though that is a reading rather than anything I have counted.

Neither example was technically hard. The pinned card needed its test moved to the phone, and Sense needed a list of screens it must never touch. Both jobs were slow because someone had to sit and decide, and in neither case did I find a way to hand the deciding to a tool.

So my guess is that getting something launched will matter less than whether it feels intended the whole way through. That is made of unglamorous habits: deciding which features should not exist, and going back over the ones that do until nothing in the sequence is left half-joined. Neither habit produces anything you can show off. I have spent months on exactly those two habits, so I would like the guess to be true, and that is the reason to distrust it.