The Button Was Never Just a Button

There is an old joke in software that a manager looks at a feature and says: why does this take three weeks? It is just a button.

The joke works because the button is almost never just a button. It may sit on top of authentication, permissions, a database migration, analytics, payments, localization, accessibility, error handling, support processes, legal requirements, and a set of assumptions made years ago by people who no longer work there. The visible object is tiny. The work holding it up is not.

AI agents are turning this joke into a mass interaction pattern.

I can now ask a machine to research a market, redesign a page, debug a product, write a proposal, compare competitors, apply for jobs, or change a codebase. The request may fit into one sentence. Behind that sentence, several systems can begin working. They search, interpret, call tools, read files, modify code, test assumptions, hit dead ends, retry, and return with an answer.

From my side, the experience is extremely clean.

I want something. I ask. Something happens.

This feels powerful, but it also creates a new kind of ignorance.

Delegation used to come with friction

For most of history, getting complicated work done through other people required access to an organization. You needed employees, collaborators, money, authority, contracts, meetings, schedules, and some understanding of who could do what. Even a bad manager usually had to spend enough time around work to absorb a rough sense of its shape.

You learned that a website redesign could become a content migration. You learned that changing one policy could create work for finance, legal, operations, and support. You learned that the person who said something was difficult might not be resisting you. Sometimes the thing was simply difficult.

AI removes much of that apprenticeship.

A person can move directly from individual contributor to something that feels like executive power. One person can dispatch several agents in parallel. One can research while another codes, another checks, another writes, and another prepares the next task. The organizational chart appears before the organization does.

The ability to command work is growing faster than the ability to understand the work being commanded.

That creates a familiar character: the executive who has become detached from operations.

Except now the executive may be anyone with a subscription.

The interface teaches us the wrong lesson

Most software has spent decades trying to hide complexity. Good interfaces remove unnecessary steps, reduce cognitive load, and make difficult systems feel simple. This is usually a virtue.

Agent interfaces inherit the same instinct. The ideal experience is often presented as a blank box: say what you want and receive the result.

The cleaner this becomes, the easier it is to believe that the work itself became simple.

It did not.

The labor was compressed, automated, parallelized, and moved out of sight. Those are not the same thing as disappearing.

This matters because users learn from interfaces. If every request produces a polished result with no visible trace of difficulty, the interface teaches that complicated outcomes are naturally cheap, immediate, and reversible. When an agent takes longer, fails, asks a question, or reports uncertainty, the user experiences this as friction rather than information.

The machine starts to look incompetent precisely when it becomes more honest about reality.

Imagine two agents.

The first says: done.

The second says: this change touched authentication, onboarding, account recovery, the user table, and three existing tests. I tried two approaches. One would preserve the current data model but create a confusing merge case. The other is cleaner but requires a migration. I need you to choose which tradeoff matters more.

To an inexperienced user, the first agent feels magical.

The second feels annoying.

But the second may be doing something more valuable. It is teaching the user what kind of thing they asked for.

We do not need to see the terminal

The obvious response is to expose more activity. Show the commands. Show the files. Show the tool calls. Show every subagent. Show the logs.

That solves the wrong problem.

Raw activity is not understanding. A chief executive does not become operationally literate by staring at every Slack message in the company. A customer does not understand a hospital by watching every nurse walk through a corridor. Visibility without interpretation becomes surveillance or noise.

What is missing is not a live feed of labor. It is a model of consequence.

The interface should help me understand that a request which looks small crosses several systems. It should tell me that a dependency I cannot see is carrying most of the risk. It should show me where the agent is uncertain, where a decision is reversible, where it is expensive to reverse, and where my request conflicts with something I asked for earlier.

It should turn hidden work into managerial perception.

Not: 14 files changed.

But: the feature you thought was local changes the account model used by login, billing, and support.

Not: three agents are running.

But: one agent is blocked because your current requirement contradicts the way existing users are identified.

Not: 8,400 tokens used.

But: most of the work is not implementation. It is resolving ambiguity in what should happen to existing accounts.

That is a very different interface.

Every wrinkle has a cause

When I was learning to draw pillows, the useful lesson was that a wrinkle should not be copied as decoration. A fold appears because something pushed, pulled, sagged, compressed, or resisted. The visible line is evidence of an invisible force.

The same principle applies here.

A strange database constraint has a cause. A slow implementation has a cause. A brittle workflow has a cause. A decision that keeps reappearing has a cause. A form with one inexplicable field may contain the residue of fraud, regulation, an old sales process, or a customer complaint from five years ago.

AI is becoming extremely good at producing surfaces. It can generate the button, the page, the plan, the report, and the answer. But if the surface arrives without any trace of the forces beneath it, the human on the other side can become less capable of judging what they are looking at.

The wrinkle disappears, and with it, the clue.

This creates an interaction-design problem that feels almost opposite to traditional usability.

The goal is no longer simply to remove complexity from view.

The goal is to decide which complexity must remain visible so that the user can still develop judgment.

The new literacy is managerial

As agents improve, knowing how to perform every task personally may become less important for many kinds of work. But other skills become more valuable.

Can I tell whether the request is actually large?

Can I notice when the agent is solving the wrong problem very efficiently?

Can I distinguish a reversible experiment from a decision that changes the architecture?

Can I tell when five tasks that look separate are actually the same underlying problem?

Can I recognize when the agent is confidently smoothing over uncertainty?

Can I give a useful constraint instead of a vague preference?

Can I evaluate whether the result is good without knowing every step used to produce it?

These are management questions.

People using agents are becoming managers before they have managed anything, and executives before they have operated anything. The interface may need to compensate for that missing experience.

This does not mean recreating bureaucracy around AI. The point of agents is still to compress effort. I do not want a status meeting with my coding agent. I do not want to approve every file edit. I do not want a synthetic employee explaining its day to me.

I want the compression without losing the shape of reality.

A managerial interface for agents

I imagine a request arriving with something like a complexity map.

The agent says the task touches five systems. Two changes are local. One crosses authentication and user data. One assumption is uncertain. There is a decision that will be expensive to reverse later. Most implementation is straightforward, but one edge case contains nearly all of the risk.

As work continues, that map changes.

A dependency appears. The task becomes larger. The agent explains why. Another path is found and the blast radius shrinks. A human decision is requested only when it matters.

Over time, the user begins to learn.

They stop saying, why is this taking so long? It is just a button.

Not because they learned to code the button themselves, but because the system taught them to see what the button is connected to.

This may become one of the most important jobs of agentic interfaces.

AI should compress labor, but it should not erase our perception of complexity.

If it does, we may become extraordinarily powerful users and increasingly bad bosses at the same time.

Connected reading

• Every Wrinkle Has a Cause
• What Kind of Worker Is AI Allowed to Become?
• The Real Bottleneck Is Human Attention
• Every Coding Agent Needs a Regression Agent
• The AI Was Easy. Understanding the Company Was Hard

AI authorship note

This essay began with Kris Haamer's observation that people using AI agents are starting to behave like executives: they can ask for complicated outcomes and receive them without seeing how much work happened underneath. Kris identified the sharper Raw Drafts angle as the loss of operational intuition and connected it to the idea that every visible wrinkle has an invisible cause. AI supported development of the argument, drafting, editing, and implementation. Kris selected the framing, title, direction, and decision to publish.