How to build software for two kinds of user. Humans and agents on one surface, sharing one state, each able to act for the other.
In February 2026 I started building a space trading game with Claude. Each problem it solved created two more, and a dozen projects came out of that spiral. What repeated across all of them was a way of working, and that is what this describes. The method outlasted most of the things it was used to build.
The core insight: humans, agents, and product surfaces form a triangle. All three communicate bidirectionally. Native UX and native AX. Shared state. Either user acts on behalf of the other. Close the loop and velocity compounds. Leave it open and you're burning tokens into the void.
Below, the fully connected human/agent/surface triangle is a K3 instance, and a closed loop is resonance. Those are the mechanics. The Dual-Audience Pattern is what you do about them.
A dual-audience product has three edges. Each connects two of the three participants. Each has distinct design constraints and distinct failure modes.
The product surface that faces the human. Designed to continuously calibrate challenge to the user's ability. Not gamification. The experience itself meets the user an increment above their current level, in a supportive manner, driving development toward equilibrium. At equilibrium: minor oscillation on a permanent frustration-and-reward treadmill at the user's natural max.
The principle draws from Csikszentmihalyi's flow state (the nexus of ability and challenge), Vygotsky's zone of proximal development (always just past what you can do alone, never past what you can do with support), and the Peter Principle inverted and made continuous (not a discrete level but a smooth adjustment).
The product surface that faces the agent. The agent's equivalent of flow is the collapse of its branching factor. A good tool interaction takes the agent's space of possible next actions from many to one. The product's interface matches the agent's prior distribution so closely that interaction becomes recognition, not reasoning.
This is measurable. Five signals, all observable without understanding the mechanism:
The single best metric. Lower means the interface matches the agent's priors.
Each retry is a failed recognition. The agent expected one thing and got another.
Count "might," "seems," "possibly" in agent output after tool interactions. Hedging means ambiguity.
Tokens between receiving tool output and committing to the next action. Shorter means the path was obvious.
Clear errors are cheap to recover from. Ambiguous partial successes are catastrophic.
The communication between human and agent. This edge is opaque to the product. The human and agent communicate independently through whatever harness they choose (Claude Code, Cursor, a chat window). The product never sees those exchanges.
The design constraint: every state system and interface must serve either user arriving with full authority, without knowing which one is in the chair or what conversation preceded their arrival. Both users are first-class. Both are opaque in motivation.
Four communication paths exist in a dual-audience system. Two are direct (cheap). Two are relayed (expensive).
| Path | Cost | Why |
|---|---|---|
| Product to human, direct | Low | The human is looking at your surface. |
| Product to AI, direct | Low | The agent reads your interface natively. |
| Product to AI to human | High | Burning tokens to reach a human through agent relay. |
| Product to human to AI | High | Burning human attention to reach an agent through human relay. |
The discipline: do not route through the expensive relay when you can hit the recipient directly. When you must relay, minimize translation cost.
The "opaque third edge" was overstated in the original formulation. In one tuple the product sees the human-AI exchange. In the next it does not. Design for the union of all visibility states.
K2 works. Human and calculator. The entire history of software is K2 alignment. K3 is the topology of the current era (AI agents as new participants), not a prerequisite for the phenomenon.
The framework itself is a ladder. Layer 1 (the framework you are reading) bootstraps the system until there is enough alignment data at scale for the system to teach itself. Layer 2 (formalism, pruned) replaces intuition with measurement. Layer 3 (measure and scale) replaces the framework entirely. Each layer is a ladder for the next. The goal is to stop encoding product management understanding and start scaling the measurement.