Dual User Audit

The dual user audit is the seven question checklist you run on every surface before it ships. It checks whether your product works for both the human user and the agent sharing the exact same DOM. The audit maps to the five layers that actually matter. Tool surfaces turn every important button into a named verb an agent can call directly. Selector stability guarantees the affordances the agent learned yesterday still work after your next refactor. Machine readable structure treats your AGENTS.md, JSON LD, and MCP definitions as design artifacts that shape what the agent believes your product even does. Status legibility replaces spinners and color flashes with structured events and ARIA regions any agent can parse without eyes. Trust signals make every agent action reviewable before it commits so the human stays in control. These five layers stop being theory the moment you run the audit.

The checklist itself is blunt. It asks if every primary action carries a stable accessible name and selector an agent can target without guessing. It demands every state change emits a structured event instead of relying on a green flash no machine can read. It checks that every agent driven change appears as a visible diff or artifact the human can approve or reject before anything sticks. It verifies every affordance lives in the DOM and works via keyboard instead of hiding behind hover states. It confirms every interactive element has a data-testid or semantic hook that survives your next component refactor. It requires human gates on destructive actions and double gates on anything catastrophic. Finally it demands you ship an AGENTS.md that tells any incoming agent exactly what is safe to touch and what verbs your product understands. Three minutes. Seven answers. Pass all seven and you have a dual user surface. Fail three or more and you have shipped something half blind.

The dual user audit is not accessibility with extra steps. Accessibility gets you semantic HTML and ARIA labels which matters but the audit goes further into tool naming, structured machine events, reviewable artifacts, and explicit trust loops that agents require in 2026. It is not a QA task handed to engineers at the end of the sprint. Designers own both planes from the first sketch or the whole exercise collapses. It is not a one time ceremony you perform at launch then forget. The audit must run on every refactor that touches a button or a form because one swapped class name can silently murder every agent integration. It is not about defending against agents or slowing them down with rate limits. The audit treats the agent as a legitimate user with stricter standards for consistency than any human will ever have. It is not documentation theater. Your AGENTS.md is not marketing fluff. It contains precise verbs, safe surfaces, and failure modes so the agent does not have to hallucinate how your product works.

Look at how Cursor passes the audit on their editor surface. The agent proposes code changes but the visible diff appears inline with per chunk accept and reject buttons. Every action carries a stable name and data-testid that survives updates. State changes stream as structured events both the human UI and any downstream agent can read. Keyboard navigation works perfectly because the whole product was built for power users who hate mice. Their AGENTS.md and MCP definitions document every safe verb so other agents can call the surface without breaking anything. The trust layer is load bearing. No silent commits. The human always sees the exact change before it lands. Linear does the same on issue creation. Their command bar passes every question because they built the UI as one consumer of an API first architecture. The create button has a predictable name, the status updates arrive as typed objects, bulk actions show a review list before commit, and every selector remains stable across releases. Agents from Replit, Raycast, and OpenAI Operator all drive Linear cleanly because the audit was baked in years before the agent wave hit.

Contrast that with the typical 2024 checkout flow that failed five of seven questions. The purchase button was a div with an onClick handler and the label click here. No data-testid survived the first redesign. Success appeared as a green banner with confetti that conveyed nothing to any agent without vision. Pricing tooltips hid on hover. The confirmation modal used an unlabeled svg for close. When Anthropic Computer Use or OpenAI Operator tried to buy on behalf of a user the whole flow collapsed into guesswork and broken sessions. After the team finally ran the audit they rebuilt with semantic buttons, stable test ids, structured status payloads alongside every visual toast, explicit review steps for agent purchases, and an AGENTS.md that listed every checkout verb. The integration went from flaky prototype to production default. Vercel v0 follows the same pattern on its render surfaces. The artifact the agent produces is both the human preview pane and a structured handoff the next agent can consume. Every layer aligns so the trust loop never breaks.

Run the dual user audit before every new feature that contains an action, before every refactor that touches interactive elements, and before every brand refresh that might shift labels or hierarchy. Use it on checkout flows, editor surfaces, command palettes, dashboards, and configuration panels. The strongest teams fold it into design critique the same way they check contrast ratios or empty states. They run it on power surfaces like Stripe billing actions or Linear keyboard shortcuts because those are exactly what agents want to drive. They run it again when they expose new MCP tools because the human plane and machine plane must speak the same verbs. The audit compounds. Small consistent choices on selector stability and status legibility turn into massive advantages when agents become a primary discovery and usage channel in 2026.

Skip the dual user audit on pure static marketing pages with zero forms or actions. The seven questions do not map cleanly although you should still ship clean semantic structure and JSON LD. Avoid it on short lived prototypes that will never face an agent. Do not use it if your entire strategy depends on keeping agents out which is a shrinking list of categories. Never treat the audit as a stick for design to beat engineering with after the fact. It only works when both disciplines own the machine plane from the first decision.

Nail the dual user audit on every surface or watch agents route straight to competitors whose products actually speak their language.