Designing for Invisible Effort

A few weeks ago I ran out of credits on one of my Claude accounts and had to step down a model. I had been working with Opus and moved to Sonnet: the highest one, but Sonnet. The first thing I noticed wasn't a failure, it was my own expectation. I read every answer waiting for it to taste thin. I assumed it would be narrower, simpler, less able to hold the depth I was asking for, and I read looking for confirmation of that. When I finally sat down to compare the two models seriously, I found they differed on a fairly specific set of tasks, none of which was what I was doing. My distrust didn't come from the results. It came from an idea I had formed about how much effort each model puts into thinking: how many resources it spends understanding the context before answering me, how long it lingers on what I ask. The cost was only the visible form of that idea.

That scene interests me because there is nothing exceptional about it. The interface all of this passes through is a text box: probably the simplest UI we've designed in twenty years. And yet, inside that simplicity, the entire experience plays out in a territory that appears in no flow diagram. How much I know about the model I'm using. What I imagine is on the other side. How much technical information I'm missing, and what I fill that gap with when I am. Almost always, I fill it with something that isn't information.

In my first essay I wrote that trust in an AI system isn't built through perfection but through legibility: a system that communicates its uncertainty well ends up more trustworthy than one that performs certainty. I still think that. But that is the rational half of the matter, the half a designer can intervene in. There is another half that operates earlier, faster, and on less evidence, and that decides big things: which tool we choose, which one we believe, which one we abandon, and which one we keep paying for reasons we couldn't quite defend out loud.

The effort you can't see

To trust work, we first need to be able to read it. And for most of history that was relatively easy, because effort left visible traces: the hours someone sat there, the corrections in the margin, the texture of something made by hand, the folder of earlier attempts. Work showed itself in its result and also in its remains. We could estimate what something cost to make, and that estimate was a good part of our judgment about its worth.

With AI that reading breaks down. The work happens somewhere else, at a scale we don't perceive, and all we receive is the finished result. No drafts, no signs of fatigue, no marks of process. So we do what we always do when direct information is missing: we look for indirect signals. The price of the plan. The model's name and its position in the brand's hierarchy. How long it takes to answer. Whether it says it's thinking. How long and elaborate the response is. None of those things is the work. All of them get read as if they were.

Biology has an elegant explanation for why we trust expensive signals. The biologist Amotz Zahavi proposed that certain signals are credible precisely because they are costly to produce: a peacock's tail is an enormous burden, and that is exactly what makes it an honest proof of health, since a weak individual couldn't afford one. The cost is what makes the signal trustworthy. It's a deep mechanism and a fairly reasonable one, and it explains why my mind linked "uses more resources" to "thinks better" without hesitating.

The problem is that this mechanism breaks when the signal comes loose from what it was signaling. A model's price reflects compute, architecture, and business decisions; it doesn't reflect how well that model fits the question I happen to be asking. A costly signal stays costly even after it has stopped informing us about the thing we care about. And that's where I ended up: reading perfectly good answers with suspicion already in place, not because of what they said, but because of what I believed they had cost.

From our own effort to someone else's

Something caught me off guard when I saw it. In my previous essay I argued that there is effort we shouldn't delegate, because that is exactly where understanding forms: the friction of sitting down to read and comprehend what the machine produced, without which we delegate without participating. There, the effort was ours, and the argument was to protect it.

Here I'm running the same operation, only outward. I judge the machine by the effort I imagine it makes. And both versions share an identical problem: in both cases the effort is invisible. Mine happens inside my head and no one sees it; its own happens in a data center and no one sees that either. In both cases we end up judging by signals rather than substance.

That isn't new, though AI sharpens it. We spent an entire century designing workplaces around a single question: how do we make effort visible. Open offices, logged hours, presence as proof, availability as a synonym for contribution. All of those are signals of work, not work. And we all know how easily they can be produced with nothing behind them. Now we're beginning to do the same with machines, and it's worth looking at early, because we already know how that story goes.

Borrowed trust

The other half of this isn't calculation. It's history.

The first AI tool I ever used was ChatGPT. Then Claude appeared and I moved over almost entirely for work, but I never cancelled the first one: I kept using it for personal things. And for quite a while I did that for no reason I could have defended technically. I did it because I had more experience with it, because I felt it understood me better, because somehow it already knew me. Today I have rational reasons to keep both, but it would be dishonest not to say that the attachment came first and the arguments came later.

What's interesting is that the attachment isn't entirely irrational. Familiarity is real information: I know how to talk to a tool I've used a thousand times, I know its failure modes, I've learned to correct it without thinking. That's genuine knowledge and it has value. The problem is that it gets confused with quality. I end up attributing to the model a virtue that is actually mine: the skill I developed by using it.

On top of that sits something the industry still doesn't discuss enough: the trust an AI system inherits from the brand that hosts it. If I trust the company, I trust the model, and the model emits no signal of doubt to correct that transfer. It's borrowed trust, arriving from outside, received by a system that did nothing to earn it. With a person, trust is built in the encounter and adjusted with every exchange. With these tools it arrives before the first exchange, fully formed, and afterwards it is surprisingly hard to move.

Designing the signal

Here the design problem appears, and it's uncomfortable.

If a user's perception forms from signals rather than substance, then designing those signals is part of the job. We're already doing it. The indicator saying the system is thinking, the text appearing gradually as if it were being typed, the intermediate steps showing reasoning in progress: all of these are design decisions about how an otherwise invisible effort is perceived. Some are honest, because they genuinely correspond to something happening and they help calibrate expectations. Others are pure theater of work, the digital version of an employee who looks busy.

The distinction matters enormously and it isn't easy to draw. A signal is honest when it corresponds to something real and helps you decide better: how much to verify, how much to trust, when to doubt. It's theater when it was manufactured to produce a confidence you have no grounds for. And the genuinely uncomfortable part is that from the outside they look nearly identical. A system that shows its process because it wants you to understand and one that shows it because it wants you to be impressed produce, on screen, exactly the same image.

That ambiguity is, I think, the ethical heart of AI design today. It isn't in the grand debates about autonomy and control. It's in tiny decisions about what we show someone regarding work they cannot see.

The dose, again

And yet, after all of this, something forces me to complicate my own argument.

Effort guarantees nothing. There are extraordinarily well-resolved things that cost almost nothing: the elegant solution that arrives all at once, the right word on the first try, the obvious design no one had seen that becomes inevitable afterwards. We all know the opposite too, the work that took months and came out mediocre. If effort were a good indicator of quality, elegance wouldn't exist—and elegance is precisely the art of achieving a lot with little.

It works the same way with AI. A great many of the tasks I hand over don't need the most powerful model, and some do. The skill isn't in always choosing more: it's in knowing how much is needed. And that requires two different kinds of knowledge we almost never cultivate together. Knowing the tools for real, beyond the brand's hierarchy, understanding what each one does well. And knowing yourself well enough to recognize what kind of task you have in your hands: whether it calls for depth or only needs to be done, whether it's a moment to delegate or a moment to think.

It's the same question of dose that keeps following me. In the previous essay it was how much friction to keep. Here it's how much effort to ask for. And in both cases the answer isn't a number but a capacity: the capacity to calibrate. Which is, when I think about it, a rather particular form of judgment. Not judging the content of a task, but how much judgment that task deserves. Deciding where it's worth placing attention—ours, and the machine's.

Maybe that's what we should be designing for now, and what each of us would do well to practice. Not tools that appear to be trying hard, nor users who always pick the most expensive model just in case, but the ability to know what we're asking for. Because in the end the question isn't how much effort the machine made. It's whether we knew how much effort was needed.