You're building products for an audience that's about to become the minority.

We talk about AI like it's the new junior developer. A faster pair of hands. A tool that helps us ship features quicker, write code cleaner, build products better.

For humans.

That last part is the assumption nobody questions. And I think it's wrong.

The Kitchen You Never See

Here's what I've been noticing. As AI agents get better at executing complex tasks, they increasingly need to talk to each other. And when agents talk to each other, they don't need buttons. They don't need dropdown menus. They don't need onboarding flows or tooltips or responsive layouts.

They need capabilities. Endpoints. Functions. The raw machinery of getting things done, without the wrapper we built for human fingers and human eyes.

Think about what happens when you order food at a restaurant. You tell the server what you want. Maybe you say "something light, not too spicy." You don't walk into the kitchen. You don't pick which pan to use. You don't decide the order of operations.

The kitchen has its own tools, its own workflows, its own language. You never see any of it. You just eat.

That's where a lot of software is heading. You express what you want. Agents figure out how. And the "software" they use to get there, the functions, the data transformations, the integrations, is built for them, by them. Some of it already exists. Some of it gets created on the fly, used once, and discarded.

You're already watching this happen if you use Claude Code, Codex, or any AI coding tool. The agent writes a script, runs it, learns from the output, throws the script away. That intermediate code was never meant for you. It was software built by an agent, for an agent, in service of your goal.

You never see the kitchen.

The Internet Already Knows This

Here's the part that should make this feel less speculative: most internet traffic is already machine-to-machine. Over 60% of all dynamic web traffic is API-based, and it's growing twice as fast as traditional browsing.¹ The human-facing web, the pages we actually look at, is already the smaller half.

We just don't think about it because we only see our slice.

Software is following the same trajectory. Right now, most software has a user interface because most software is used by humans. As agents become the primary executors of tasks, the balance flips. Most software will be consumed by agents. The human-facing layer becomes the thin crust on top of a deep machine-to-machine stack.

Ephemeral by Design

This is where it gets interesting. When software is built by agents for agents, permanence stops being a virtue.

Today, we treat code as an asset. We maintain it, version it, refactor it, write tests for it, build teams around it.

When the marginal cost of generating code approaches zero, and the "user" is an agent that can read raw functions as easily as you read a menu, software becomes disposable. An agent needs a specific data transformation? It writes one, runs it, discards it. Like a napkin sketch that serves its purpose and goes in the bin.

Fly.io is already building infrastructure for ephemeral machines that spin up in milliseconds and die when they're done. The pieces are falling into place.

No login screen, no user manual, no name. But it's software.

What Humans Actually Do

So if agents are building and using most of the software, what's left for us?

The interesting answer: we become the desire layer.

Not the execution layer. Not the implementation layer. The layer that says what should exist and why it matters. The chef who says "something light, not too spicy," and the line cook figures out the rest.

This sounds like a demotion. It's actually a promotion.

Right now, most of the work in software, the coding, the debugging, the infrastructure, the deployment, is implementation. Translating human intent into machine behavior, one keystroke at a time. That translation layer is what agents are absorbing.

What remains is the part machines can't do: knowing what's worth building. Having taste. Understanding what a person actually needs when they say something vague. The judgment calls. The priorities. The this matters more than that.

The Test That Tells You Where This Is Going

Here's a quick way to see this shift in real time. Look at any piece of software you use daily and ask: could an agent bypass this interface entirely and still get the job done?

Your calendar? An agent doesn't need the UI. It needs the API.

Your project management tool? An agent doesn't need the kanban board. It needs the data model.

Your email client? An agent doesn't need the inbox view. It needs the message stream.

For most of the software you use, the answer is yes. The interface is for you. The capability underneath is for anyone, or anything, that can call it.

Where it breaks down is revealing. Spotify? An agent could pick your music, but listening is the point. Your group chat? An agent could summarize every message, but that kills the experience of actually being in the conversation. A musical instrument, a sketchpad, a poem you're writing? The doing is the value. Software where the human experience of using it is the whole point stays human-facing. Everything else is up for grabs.

Now imagine a world where most "callers" are agents. The interface becomes the exception.

Behind the Wall

If you're building software right now, this probably creates some anxiety. If most future software is agent-to-agent, what happens to the products you're shipping today?

Human-facing software won't disappear. People will always want interfaces for creative work, entertainment, social connection. The places where the experience of using is the point.

But the utility software? The tools that exist purely to get a job done? Those are the kitchen. And the kitchen is going behind the wall.

You can already see the pressure building. When agents need access to software that only offers a human interface, they don't wait politely. They spin up invisible browsers and emulate human clicks, typing, scrolling. They pretend to be you just to get the job done. It works, but it's absurd. Like sending a carrier pigeon to the person sitting across the table.

The builders who thrive will be the ones who stop thinking of their software as a product only humans use and start thinking of it as a capability agents consume. APIs over UIs. Functions over features. Outcomes over experiences.

We keep asking how AI will change software development. The bigger question is how AI changes who software is for.

The answer, increasingly, is: not us.

  1. Cloudflare's "Landscape of API Traffic" from 2022-01-26 API traffic report tracks this across their global network, which handles a significant share of all internet traffic.

Rabbit Hole

If this made you think, you might also enjoy:

  1. Every Action Is an Agent. What happens when every button click becomes an autonomous agent?
  2. Software Companies Are Becoming Staffing Agencies. The business model shift when you're renting out agents instead of selling seats.
  3. You're Building a Stone Cathedral Out of Concrete. Why treating AI like an old material guarantees you'll miss what it actually makes possible.