Every app you learned to use is going to become unnecessary. A better one won't replace it. "An app you have to learn" was always a design failure.

The internet is getting its Unix moment. The answer runs every computer you've touched and has for 50 years. We never applied it to the web.

What Agents Actually Are

Strip away the press releases. LLM agents do two things: predict code and predict language.

You describe what you want and show them what the interface looks like. They generate the right commands. The model doesn't need to understand your platform. It needs to understand structure.

Agents don't need custom APIs. They don't need SDKs with 400 methods, OAuth flows, webhooks, rate limit documentation. They need a directory structure that makes sense and a file explaining what's in it.

The entire MCP ecosystem exists because apps expose themselves one way and agents consume them another. Integration platforms, middleware, the whole category. It's all bridge code. What if apps stopped being complex?

The Unix Prophecy

Unix gave us one organizing principle: everything is a file.

Processes, devices, sockets, configuration, data. All files in a directory tree. Navigate with cd. Read with cat. Pipe. Three-letter commands. Unchanged since the 70s.

Every OS that deviated came back. Windows added a filesystem. macOS is Unix. Android, iOS, every Linux distribution. Turned out the filesystem was the best abstraction for managing complexity. Nothing else stuck.

The internet got apps instead. Thousands of them. Each with its own interface, its own API, its own onboarding. Every platform reimplementing the same handful of operations under a different brand name. Move data, read it, copy it, search it, filter it, transform it. Same shit, new product.

That fragmentation lasted 30 years because nothing forced a correction. Now something does.

The Complexity Tax

To let an agent book a flight right now, you need an API key, REST docs, auth handling, pagination, error codes, rate limits, and a custom tool definition before you write a single line of logic. Just to talk to one service.

Multiply by every service. That's why the integration economy is worth billions. We papered over a design mistake and called it an industry.

Or you could have a directory:

skyscanner/
  flights/
    JFK-LAX/
      return/
        2026-03-02/

Interact with it the same way you interact with everything else:

cat skyscanner/flights/JFK-LAX/return/ | grep "03.02.2026" | sort -n price | head -5

A complicated MCP server collapses into a directory and a README. Every app is a subdirectory. Code files, a markdown explaining the interface. No SDK. No integration. No middleware. The agent already knows what to do. It's been doing it since Unix.

Every App Is a Directory

# Tomorrow's weather
cat weather/nyc/2026-05-16 | jq '.temperature.high'

# Download an Instagram post
cp instagram/user/johndoe/post_123/images/* ~/downloads/

# GitHub repos by stars
ls -la github/search/javascript/ | sort -k5 -rn | head -20

# Migrate Spotify library to Apple Music
cp -r spotify/me/playlists/* apple_music/me/import/

This is the interface when you stop pretending apps need to be opaque services. Apps were always data with behavior attached. The opacity was a choice.

The agent doesn't need to know how Spotify works. It knows how filesystems work. Everyone who's touched a computer knows how filesystems work. The universal interface was sitting there the whole time while we built walls in front of it.

The Spotify-to-Apple-Music migration used to require a third-party service, a subscription, an afternoon. Now it's one line. The lock-in that made switching costs real just evaporated. Power shifted.

The Multi-Platform Post

Posting one photo to Instagram, Twitter, Facebook, and TikTok means opening four apps, uploading four times, writing the same caption four times, tapping post four times. Platform designers call this engagement. It's friction wearing a product label.

Filesystem internet:

echo "Vacation photo" > /tmp/caption
cat ~/vacation.jpg | tee instagram/me/posts/new \
                        twitter/me/media/upload \
                        facebook/me/photos/add \
                        tiktok/me/videos/create | \
  xargs -I {} cp /tmp/caption {}/caption

One command. The image pipes to four platforms. The caption follows. Done.

Platforms stop being destinations and become directories. You write to them instead of visiting them. The entire attention economy, the dark patterns, the feed algorithms, the compulsive loops. All of it rests on the assumption that you have to open the app to do the thing. You never did. The app just made sure you thought you did.

The Blooming

Proprietary lock-in dies. Every platform spent a decade digging a moat. Hard exports, impossible migrations, APIs that serve their interests over yours. None of it survives a cp command. Your data was always yours. The filesystem makes that true in practice.

Platform-specific knowledge dies alongside it. The hours learning Notion's block system. The muscle memory in Figma. Your mental model of Twitter's draft UI. It all becomes overhead the moment an agent navigates platforms through a directory structure. Platforms that expose clean structures survive. Those burying data in opaque APIs become friction. Users won't feel it. Their agents route around it.

You never learn to use an app again. Apps don't get simpler. The agent already knows how to use any app that follows the standard. The commands haven't changed in 50 years. The internet hasn't caught up yet.

This is the blooming. The web has been frozen in awkward adolescence since the first dot-com boom, powerful underneath, needlessly complicated on the surface. The principle that fixed operating systems is about to fix the internet. It took 50 years and agents to build the pressure, but the answer never changed. Unix got it right in 1973: make it a file.