Agent-Mediated Software
When an agent — not a human — is the direct user of your software, the agent becomes a middle layer between the person and the product, and that layer is what finally makes software personal. The observation comes from someone who shipped both GUI web apps and skills and could compare them: the web apps drew a daily flood of complaints (couldn't find a button, didn't like a feature); the skill barely draws any. The reason is structural, not quality — a human isn't operating the skill directly, an agent is. If a skill's template defaults to something a user doesn't want (say, navigation dots), they don't file feedback and wait for the author; they just tell the agent to remove it, and it's gone. The output can therefore be different for every single person, so the one-size-fits-all compromise that generates GUI complaints dissolves.
Two consequences follow. First, distribution flips: instead of the user going to find the software, a capability wrapped as a skill comes to them inside the tool they already live in — no new app to install, no new interface to learn (the video predicts small productivity apps, mobile and web, get replaced by skills for this reason). Second, a design mandate: because a growing share of what we build will be consumed by agents rather than humans, product people must learn to design for agents. This is distinct from Agent-Computer Interface (ACI) (how an agent wields tools to act on the world); agent-mediated software is about the agent standing between a person and a product on that person's behalf.
Claims
- When an agent is the direct consumer of software, output personalizes per user and the one-size-fits-all complaint loop collapses — the user adjusts the software by instructing their agent, not by filing feedback. principle — durable: it follows from who operates the software; a mediating agent can tailor the same capability to each person, removing the shared-UI compromise that generates complaints. The web-app-vs-skill complaint asymmetry is the source's evidence.
- The agent is the middle layer between the person and the software, and that layer is what makes software truly personal. principle — durable framing of the mechanism above: personalization lives in the mediation, not in the product.
- Design for agents, not only humans, because much of what we build will be used by agents on behalf of users. best practice — context: product/design work under the premise that "everyone eventually has their own agent"; contingent on that adoption, and on the product being the kind an agent can drive.
- Capability wrapped as a skill comes to the user inside the tool they already use — no new app or interface — so skills replace small productivity apps ("the software comes to you"). observation — the distribution prediction; groundable over time, asserted here as the video's claim, not a settled outcome. Contrast the "zombie apps" you never reopen.
Related
- Agent-Computer Interface (ACI) — the complement, and the boundary: ACI is the agent→tools interface (acting on the world); agent-mediated software is the agent sitting between a person and a product for that person. Both say "the model is now a first-class user," aimed at different seams.
- Agentic Distribution — the producer-side plumbing that makes "the software comes to you" real: skills synced/installed so an agent can call a capability in place.
- Public Skill Adoption — the consumer-side mechanic: the capability arrives as a cloned/installed skill the agent invokes on the user's behalf.
- Execution Commoditization — why the mediating layer matters: with models converged, the value is in the method and the personalization the agent layer provides, not the raw execution.
- Knowledge Work as Code — the broader thesis this personalization serves: software as agent-run code that reshapes itself per user.
- Distillate: Stop Making PowerPoints: Vibe-Coding HTML Slides as a Skill