A few days ago I asked Fable5 to do something fairly complicated, and it did it well. Better than I would have. I looked at the result, nodded, and moved on. Only later did an uncomfortable thought come to me: I had no idea how it got there. I couldn’t have retraced a single step. And what bothered me wasn’t the not-knowing — it was how comfortable the not-knowing felt. I hadn’t lost control by accident. I had handed it over, happily, because handing it over is easy.
We talk a lot about what these systems can do. We talk far less about how we talk to them — and almost never about what that conversation is quietly doing to us. Most of the debate about AI and work asks whether the machine will replace us. I think that’s the wrong question. The better one is about how we interact with them. The approach we’ve adopted — and the interfaces that run these systems — end up wearing down our own abilities, turning us, little by little, into spectators.
That word — spectator — is worth keeping in mind, because it’s the exact opposite of what a good interaction should make of us. So let’s start from that ideal. Whatever these tools become, one principle shouldn’t be negotiable: the person using them has to be able to see what is happening, understand it, and step in at any moment. A clear interface isn’t a nice-to-have. It’s what decides who is actually in charge. When an interface hides how it works, it isn’t making your life simpler — it’s quietly moving control from you to the system, and calling it convenience.
That’s the ideal. It sounds obvious. And yet almost everything about how we use these tools today works against it.
Here’s the uncomfortable part. We assume that as long as the controls are there — a stop button, an approval step, the option to step in — we stay in charge. But a control is only as real as your ability to use it. And the more we delegate, the more that ability quietly fades.
This isn’t new, and it isn’t really about AI. Engineers noticed it decades ago in every automated system we’ve built: the more reliable the automation, the less its human operator actually does, until the person is left standing outside the process — a supervisor on paper, a spectator in practice. Lisanne Bainbridge called them the ironies of automation back in 1983. The system runs beautifully, right up to the moment it can’t, and then it turns to a human who has spent months being kept out of the picture and no longer knows how to read it.
We already live in smaller versions of this. Ask yourself how well you can find your way around a city now that the map does it for you. How confidently you spell a word the autocorrect always fixes. These are small losses, and we accept them happily, because the trade is worth it almost all the time. But scale that same logic up to the systems we’re now handing our thinking to, and the trade stops being small. If I no longer follow how an answer was reached, I’m in no position to notice when it’s wrong. The stop button is still there. My finger is still on it. But I’ve lost the judgment that would tell me when to press it.
So the real question isn’t whether we have controls. It’s this: a control you no longer know how to use — is that still control? Or is it just a prop, something that lets us feel in charge while we quietly slip into the role of spectator?
So far this sounds like something we do to ourselves. But the interface isn’t innocent here — it actively pushes us into that role. Once you start looking, you notice how much of the “control” these interfaces give us is theater. The endless confirmation steps — are you sure? approve? continue? — feel like oversight, but they train the opposite habit. Click enough of them and you stop reading; you approve on autopilot, which is exactly the moment oversight becomes a rubber stamp. The same goes for transparency that shows you everything and lets you change nothing: a wall of detail is not the same as a handle you can actually grab.
And this fake control doesn’t only give us false comfort — it slows us down. Every empty confirmation, every panel of information you can’t act on, is friction that adds no safety.
So what would real control look like? For a start, “giving people control” is too vague to build anything on; a more concrete goal is designing so the work is easy to check. That means an interface that shows its sources, flags the parts it’s unsure about, and lets you spot-check what matters instead of re-doing everything just to trust it. It also means guarding an action as carefully as the risk deserves — no more, no less. A true confirmation makes sense for the few actions you genuinely can’t take back — sending the message, making the payment, deleting the thing.
But for everything else, the honest form of control isn’t asking permission over and over; it’s reaching a real understanding between the two of you. I get how it works — the way it reasons, and what it has actually taken from what I asked. And it, in turn, gets me: my needs, my intentions, the way I think a problem through. When that understanding is there, the wrong outcome rarely even comes up. And the way we hold this conversation today — a whole exchange forced through a single line of text — works against exactly that.
The text box is a poor instrument. It’s a narrow opening: you pack an intention into a paragraph, send it, and then you’re on the outside — watching the system act on its own reading of your words, which you can’t see or change. When it drifts from what you meant, fixing it midway is almost impossible, because the system only ever showed you the finished result, never its thinking while it worked. So you wait, get something slightly off, rewrite the whole request, and try again. We call this efficiency. It’s a huge waste of time and attention, and we’ve simply gotten used to it.
What would it mean to design for the opposite — for an interaction that keeps us inside the process instead of outside it? Not smarter models, but richer ways of talking to them: being able to reach in while the work is still happening, to nudge and redirect in real time, to see the reasoning taking shape before it turns into a final answer, and to really understand what it’s doing. Interfaces built not to impress us with how much they can do on their own, but to keep us awake and able. That, to me, is the design problem of the next few years — and the one we’re paying the least attention to.
Predicting the future of AI is very hard, and we’re not getting better at it. But not knowing where this goes isn’t a reason to give up — it’s exactly the reason to act. Since we can’t know what these systems will become, the safest bet, whatever happens, is to build them so a person can still watch, understand, and step in — and is still able to actually do it.
And it isn’t only a private worry: regulators are starting to take this on, too — though they’re mostly focused on safety and data, which matters enormously. The quieter question of how we actually interact with these tools gets much less attention, even though it counts just as much. Regulation will shape the tool, but not the person behind it — and that part is still ours.
So I keep coming back to that small, uncomfortable thought from the other day. The system did the work well, I understood none of it, and I didn’t mind. The question I can’t shake isn’t whether the machine will take my place. It’s whether, one small handover at a time, I’ll give it away myself — and be too comfortable to notice.
