It never happened, because every website at the time would have had to label its pages for machines. That was a lot of work, so almost nobody bothered.

As MIT Technology Review's "The agentic web is here" (opens in a new tab) explains, language models skipped that cumbersome step.

Agents such as Meta's Muse and OpenAI's Dots now book, buy and sort inboxes for people.

The dream came true. And then, almost at once, everyone started building walls around it.

The first wall keeps agents out

Companies such as Yelp openly say they admit them only if they pay for its data. Delta in the US stops them from booking tickets. JPMorgan Chase and Schwab keep them out of accounts. Amazon blocked Muse recently, and (surprise!) Amazon happens to promote a shopping agent of its own. Where agents are welcome at all, they're only welcome if they pay, or if they belong to the house.

The second wall keeps users in

Meta says "turning away a personal agent means turning away the customer behind it," which sounds like a defense of the open web. But it only really looks like that Meta's own networks (and businesses that pay to be featured) will be favoured by Muse.

“An agent that could take you anywhere... would probably take you back into Meta's walled garden.”

The third wall decides who counts

Visa and Mastercard are building registries of approved agents that sign each request. A signed agent beats one pretending to be Chrome. But a registry needs an owner, and an owner can charge admission. Microsoft economist David Rothschild expects companies to "build barriers in order to maintain the consumer base that they have."

Some walls are important, because they are about our own safety. But most walls also protect a business model, and safety seems to be a convenient name for a moat.

We've seen this before. The move to mobile apps left people without phones locked out of many services that were designed to be mobile-first, and if agents become the normal way to book, buy and apply, whoever owns the walls decides who gets served.

The web was built so you didn't need anyone's permission to link to a page. The agentic web is being built so you need permission for everything. A web where a handful of companies decide who's allowed in isn't the open web with better security. It isn’t what Berners-Lee dreamed of either. It's an exclusive members' club.

Let the agents roam. The web never had a bouncer. It doesn’t need one now.

That quote from npm co-founder Laurie Voss's slides sums up what I find exciting about where software engineering is going these days!

AI writes the code. So... what's left for engineers? Voss argues that they need to understand the business well enough to make good product decisions. That means spending time with the people who will use what you build.

If you love the act of programming, being told you'll soon spend less time doing it is a weird sales pitch... But I think Voss is right about the direction. AI making code cheap to produce exposes the review bottleneck (anyone keen on reviewing those 10,000-line PRs?), which will also get automated at some point.

And automating more of the code review itself exposes the next bottleneck; bringing us closer to a job centered on deciding what to build and what good looks like.

I think that brings product and engineering much closer together. The market is already hiring for the combination: Forward Deployed Engineers, for example, are expected to understand customer workflows and build production applications.

I still think there's something beautiful about crafting software. I also like the possibility of spending more time making it delightful to use. That takes attention to the person using it; and the baker can tell us plenty that we won't learn by staring at the code!

Check out Voss's talk on Youtube (opens in a new tab).

The biggest shift on my side hasn’t been “AI writes all the code now.” It’s been realizing that the valuable part of building software is moving up a level.

For me, what matters most now is: Understanding the problem. Designing the system. Making good product and technical decisions. Knowing what to delegate, what to inspect, what to question, and when to steer the agents when you realize they are confidently heading in the wrong direction 🤖

I’ve spent years getting better at writing code. More recently, I’ve been learning how much more I can build, when code itself stops being the bottleneck.

That requires a different skill set; and, in some ways, a broader one.

“Software maker” is actually a pretty darn good way of putting it!

P.S. If this topic resonates, I’d also recommend DHH’s recent conversation with Lex Fridman (opens in a new tab) on the future of programming, AI, agentic engineering and Linux.

The original DHH post I refer to (opens in a new tab), with the Rails World 2026 Opening Keynote (opens in a new tab).