I Think I Became the Middleware

I have spent a surprising amount of time lately copying small pieces of text from one system and pasting them into another. API keys, authentication codes, webhook URLs, IP addresses, environment variables, project IDs.

None of this is particularly difficult. What started bothering me was something else: why am I involved at all?

The machines on either side are extraordinarily capable. One can deploy software globally in seconds. Another can manage infrastructure, customers, content or payments. Yet between them is often a person carrying a string from one browser tab to another.

At some point I realized that I had become the middleware.

The switchboard moved into the browser

There is something strangely familiar about this arrangement. Telephone switchboard operators once connected different parts of a network by physically moving cables. We removed the cables, built vastly more sophisticated networks, distributed our software across the planet, and somehow kept the operator.

Now the switchboard is a collection of rectangles on a screen.

I decide that a domain should point to an application. That is the actual decision. What follows is a procedure: open one service, find the right value, open another, create a record, go back, copy something else, return, paste, verify.

I decide that one system should be allowed to use another. Again, the intent is simple. What follows may involve credentials, permissions, dashboards, secrets, confirmation emails and authentication codes.

The software is not asking me to make another meaningful decision. It is asking me to transport the consequences of a decision I have already made.

We tend to describe this as operating software. Sometimes it feels like the relationship has quietly reversed. The software knows its procedure and tells me where to go, what to copy, where to paste it and what to click next.

In those moments, the software is operating me.

Human middleware

I wrote about a broader version of this in I’m Trying to Build Myself Out of the Loop. That piece was about the way people become part of the infrastructure around work because they carry context, catch exceptions and keep disconnected parts moving.

I have been exploring the organizational version more deeply in The Executable Company. In Your Company Is Not Integrated. Your Best People Are., I use human middleware to describe companies that look integrated because people quietly provide the transport, synchronization, memory and translation that the systems themselves cannot carry.

What has been bothering me lately is a more literal version of the same problem.

Copy and paste is only the visible symptom. The deeper issue is that state is fragmented across machines while the intent remains with me. One system knows the credential. Another knows where it needs to go. Another knows the current state. I know why any of it is happening.

So my attention becomes the place where the system comes together.

That seems like a poor use of a human. Not because I want humans removed from the system. I would rather spend my attention deciding what should happen, whether it should happen, what tradeoffs I am willing to make and whether the result is any good. I am less interested in using that attention as a transport layer.

There is an important limit to this argument. Some manual steps are there for good reasons. An authentication code can be a deliberate security boundary. An approval can preserve authority or responsibility. A system asking me to confirm a consequential action may be doing exactly what it should.

The point is not to eliminate every handoff. It is to distinguish the moments when a human is actually making a decision from the moments when a human is simply carrying information because the surrounding systems cannot.

From procedure to intent

For most of computing history, there was a good reason for this arrangement. Software could execute instructions, but it could not really understand intent. We had to translate what we wanted into the exact procedure a machine could perform. Interfaces were part of that translation.

If I wanted to publish something, the software did not understand "publish this." It understood the sequence of screens, fields and commands that eventually resulted in something being published.

That constraint is starting to change. Software can increasingly understand ordinary language, inspect context, use tools, call APIs, execute several steps and check what happened afterward.

This is why I am not particularly interested in replacing every dashboard with a chat box. If I tell an AI what I want and it responds by telling me which website to open, which API key to copy and where to paste it, the interface changed but my job did not. I am still the middleware.

The more interesting shift is from telling humans how to operate software to allowing them to express what they intend to happen.

There is a meaningful difference between "here are the six steps you need to perform" and "this is the outcome I want; carry it through, stay within these boundaries, tell me what changed and come back when you actually need a decision from me."

That is a different relationship with software.

Maybe I am in the wrong loop

I wrote recently that I was trying to build myself out of the loop. I still believe in that instinct, but I think I may have described it too broadly.

I do not want to be outside every loop. I want to make decisions, exercise judgment, change my mind, bring taste to something, notice when the result feels wrong and remain responsible for what happens.

What I want to leave is the loop where I translate intent into procedure and then carry the procedure between machines.

Perhaps the goal is not to remove the human from the loop, but to move the human up a layer. From transporting information to directing systems. From executing procedures to defining intent. From operating every piece of software involved to deciding where human attention actually belongs.

There is probably something recursive about this. Every time technology absorbs one layer of work, we eventually discover that we have become middleware at another. We may build systems that carry today's integration work and then find ourselves coordinating agents, goals or decisions at a higher layer.

That is fine. I do not need a world in which humans sit outside the system while machines do everything. I just want to become more deliberate about where I put myself inside it.

So when I find myself opening another tab and carrying another piece of information from one machine to another, I have started asking a simple question: why am I the one carrying this?

If my judgment, responsibility, taste or relationship genuinely belongs there, I want to remain involved. If I am there because two machines still need a person to connect them, I increasingly want out of that particular job.

I still want to be in the loop. I just don't want to be the wire.