Every App Becomes an API in the Age of Personal Agents

Pete Koomen, Group Partner at Y Combinator, recently laid out five observations about building software right now. Peter Steinberger, creator of OpenClaw, distilled the same argument even further: all apps will become APIs or disappear. Both are pointing at the same structural shift. The primary consumer of software is no longer the human sitting at the screen.

Five Realities of Building Software Now

Pete Koomen’s observations are deceptively simple, and each one compounds the last.

AI coding tools have collapsed the time between idea and implementation. A feature that once took a sprint now takes an afternoon. The uncomfortable corollary is that every competing team has access to the same tools, so speed is no longer a moat.

The third observation is the one most product teams are slow to accept: users are builders now. They can spin up competing tools, custom scripts, and personal workflows faster than your product team ships updates. The fourth follows directly from that: if a workflow takes more than a few clicks, an agent can do it better than a human clicking through screens. The fifth is where it gets uncomfortable for anyone who has invested years in UI polish. People increasingly want to tell their agent what to do and let the agent navigate the interface for them.

When everyone writes code fast, competitive advantage shifts away from execution speed toward something else: how well your product serves agents as its primary users. That transition is not guaranteed to go smoothly, and most products are not ready for it.

Apps Become APIs or Disappear

Peter Steinberger pushes this logic to its endpoint. If agents are the consumers, visual interfaces become optional. What matters is the API surface: structured, predictable, machine-readable interactions.

His argument breaks into two predictions. Apps that survive will be games or sensor-heavy experiences that fundamentally require human perception, things like real-time visuals, physical input, and spatial awareness. A game needs a screen. A fitness tracker needs a body. Everything else becomes a candidate for agent consumption.

For everything else, your agent, not you, will be the primary consumer. The booking app, the email client, the project management tool: your agent will interact with these on your behalf. The UI becomes a debugging surface for when the agent gets stuck, not the main interaction point.

OpenClaw already demonstrates the pattern: a personal agent running on your machine, reachable via iMessage or Telegram, executing terminal commands, managing files, and browsing the web. The human gives high-level intent. The agent handles the implementation. Where this breaks down is edge cases: ambiguous intent, unexpected UI states, services that don’t expose clean APIs. Agents fail on these more often than their demos suggest.

The Inversion of Software Design

If agents are the primary consumers, the design questions change. The old question was how to make a workflow intuitive for a human. The new question is how to expose a capability so an agent can use it reliably.

That means APIs need to be self-describing. Error messages need to be parseable, not just human-readable. Authentication needs to support agent delegation. Rate limiting needs to account for automated consumption patterns. None of this is trivial to retrofit onto existing products.

The winners won’t be companies with the best dashboards. They’ll be companies with the cleanest, most composable APIs: the ones an agent can discover, authenticate against, and orchestrate without human intervention.

What This Means for Developers

API-first is no longer a best practice. It’s a survival condition. If your product can’t be consumed programmatically, agents will route around it to competitors that can.

Multi-step UIs have become a liability. Every wizard, every multi-page form, every workflow that requires sequential human clicks is friction that agents will eliminate, by using a competitor’s API instead. That’s a brutal selection pressure for products built around complex onboarding flows.

Your users’ agents are your new users. Document your APIs as though your product depends on it, because it does. And expect that competitive moats will shift further toward proprietary data, network effects, and deep integrations. When code is cheap to write and UIs are bypassed by agents, those are the defensible assets.

The Real Question for Every Builder

Pete and Peter are describing the same inflection point from different angles. Pete sees it from the builder’s side: the tools have leveled the playing field, and users have become builders. Peter sees it from the product’s side: if software is not agent-accessible, it is dead software.

The question for every software team is whether your product can be consumed by an agent today, not in some future release. For most products, the honest answer is no, and that gap is closing faster than most roadmaps account for.