How to Test Your Product for AI Agent Users

The Problem Nobody's Talking About

Here's something I've noticed: AI agents are already using your product right now. OpenAI's Operator, Claude's computer use, MCP clients, browser automation frameworks, they're all signing up for accounts, working through checkout flows, navigating multi-step wizards. Your product wasn't designed with them in mind, and unlike human users their experience is breaking silently.

When a customer is frustrated, they tell you. Humans have a natural bias to feel small negative experiences far more than positive ones.

The agent just fails and moves on, or your rate limits get hammered, or you lose a potential customer who wasn't even human. That's a missed opportunity: you're incompatible with a growing category of users that's already here.

The challenge is that AI agents interact with products differently than humans do. They can't skip the confusing parts, they can't guess, they can't call support. They need clear, unambiguous, interfaces: actually, all users do.

Where Products Break for AI Agents

Let's talk about the specific failure modes. These are the places where products silently fail when an AI agent tries to use them.

Unlabelled or Poorly Labelled Form Inputs

An agent encounters a form with five input fields. Three of them have no <label> elements and no aria-label attributes. The agent has to guess what each field is for based on nearby text, context, or placeholder attributes. Sometimes it guesses right. Often it doesn't.

<!-- Bad: agent has to guess -->
<input type="text" placeholder="Name..." />

<!-- Good: agent knows exactly what this is -->
<label for="name">Full Name</label>
<input type="text" id="name" name="name" placeholder="E.g., Jane Smith" />

Ambiguous Buttons

Your form has three buttons: "Submit", "Continue", "Next". To a human, context makes it obvious which one to click. To an agent trying to complete a task, they all sound similar. Which one advances to the next step? Which one submits the form? If the button labels aren't unique and descriptive, the agent might click the wrong one.

Unexpected Modals, Popups, and Cookie Banners

A user opens your website. A modal appears: "Subscribe to our newsletter!" The modal isn't modal from the agent's perspective, it's just another element on the page. The agent tries to click on form fields behind the modal and fails. Or it gets stuck trying to close a banner that wasn't properly marked up.

CAPTCHAs and Bot Detection

Your product has perfectly reasonable bot protection. From a human's perspective, it's fine. But if an agent-assisted user is trying to sign up, they hit a CAPTCHA and can't proceed. You've just locked out a legitimate user category.

Multi-Step Flows with No Clear Progress

Your onboarding has six steps: account setup → profile → preferences → billing → integration → done. A human sees visual progress indicators and knows they're halfway through. An agent has to infer from page content whether it's on step 2 or step 4. Clearer labelling helps the agent understand the journey.

Dynamic Content That Loads After Initial Render

You're using a modern SPA. The page renders a skeleton, then populates content via JavaScript. An agent that takes a screenshot and tries to interact with the page might see empty fields or missing buttons. The agent needs to wait for the page to fully load before it can act.

Iframes and Shadow DOM Elements

Your payment processor lives in an iframe. Your dropdown component uses shadow DOM. Some agents can't access these elements. The agent tries to fill in a credit card field or select an option and can't find the element.

Why Traditional Testing Misses These Issues

You might be thinking: "We test our product with Selenium and Playwright. Why haven't we found these issues?"

Good question. Here's why traditional test automation misses the problem:

Selenium and Playwright test what you tell them to test. You write a script: "Click button with ID 'submit'". The script clicks that button. It doesn't encounter the real problem: figuring out which button to click without knowing the ID.

Manual testing doesn't scale. A human can work through your product and find a couple of pain points. But humans are expensive and slow. You can't manually test every possible journey, edge case, and combination of inputs.

Neither approach tests "can an AI figure out what to do here?" That's the actual failure mode. An agent doesn't have access to your design specs or implementation details. It only sees the rendered page. If the page isn't clear to an AI reading the HTML and screenshots, you have a problem.

This is why testing with an actual AI agent, not just an automated test suite, is essential. The agent encounters the same friction a real agent-assisted user would encounter.

The Practical Checklist: Audit Your Flows for Agent Compatibility

Here's how to find out where your product breaks for AI agents. This checklist is designed to be run through manually, but you can also use tools to automate parts of it.

1. Test Your Key Flows with an AI Agent

Start with your most important user journeys:

• Sign up and onboarding
• Product discovery or search
• Purchase or conversion
• Account settings

Open Claude's computer use or OpenAI's Operator. Give it a realistic task like "Sign up for a free account" or "Complete checkout with a test card". Watch where the agent gets stuck. Note the exact failure point.

2. Audit All Form Inputs for Proper Labelling

Every <input>, <textarea>, and <select> should have one of these:

• A <label> element with a matching for attribute
• An aria-label attribute
• An aria-labelledby attribute pointing to a descriptive element

Run this in the browser console to find unlabelled inputs:

document.querySelectorAll('input, textarea, select').forEach((el) => {
  const hasLabel = document.querySelector(`label[for="${el.id}"]`);
  const hasAriaLabel = el.getAttribute('aria-label');
  const hasAriaLabelledby = el.getAttribute('aria-labelledby');

  if (!hasLabel && !hasAriaLabel && !hasAriaLabelledby) {
    console.warn('Unlabelled input:', el);
  }
});

3. Ensure All Buttons Have Unique, Descriptive Text

Every button should have a clear, unique label that describes what it does. Don't use generic text like "Submit" or "OK" without context.

Instead of:

• "Submit"
• "Continue"
• "Next"

Use:

• "Create account"
• "Review order"
• "Add another item"

4. Test with JavaScript Disabled

Disable JavaScript in your browser (Chrome DevTools, then Settings, then Disable JavaScript, or use an extension). Navigate through your product. If critical content is missing or buttons don't work, you've got a problem.

Agents with limited JavaScript support might encounter the same issues.

5. Check That Key Information Isn't Locked in Images or Canvases

If your product displays important information in images without alt text, or in canvas elements without fallback text, an agent can't read it.

Look for:

• Product information in images without alt attributes
• Charts or graphs rendered to canvas with no text alternative
• Icons without aria-label or nearby text labels

6. Verify Error Messages Are Clear and Machine-Readable

When something goes wrong, what does the user see?

Bad: "Error 422" Better: "This email is already registered. Try logging in instead, or use a different email."

Error messages should:

• Be displayed clearly on the page (not hidden in console logs)
• Explain what went wrong
• Suggest how to fix it
• Be associated with the relevant form field

7. Test Your Auth Flow Without JavaScript-Heavy CAPTCHAs

If you're using a CAPTCHA that requires human interaction (clicking images, solving puzzles), you're blocking agents. Consider:

• Risk-based authentication (step up only when necessary)
• Passwordless methods (magic links, passkeys)
• Delegating CAPTCHA to your auth provider (they handle it better than you will)

8. Audit Your Cookie Consent Flow

Does your cookie banner block access to the page until dismissed? Does it have a clear "Reject all" button?

Test this flow:

1. Open your site
2. Try to interact with the main page without accepting cookies
3. Is there a way to reject cookies without accepting tracking?

If consent is required to proceed, make sure there's a straightforward way to deny it.

How to Act on What You Find

You don't need to fix everything at once. Prioritise by impact.

1. Start with critical path issues. If agents can't sign up or complete checkout, tackle those first.
2. Then tackle common failure points. Unlabelled inputs and ambiguous buttons affect many flows, so they're worth fixing early.
3. Re-test after changes. Once you've made fixes, run the agent test again to confirm it worked.

How Stunt Double Automates This

If you want to run continuous testing without manually opening every flow, Stunt Double deploys realistic AI actors that navigate your product end-to-end. Each actor logs exactly where they got stuck and why. You can trigger tests from Claude via MCP, and findings flow straight into Linear or GitHub. It's like having an always-on QA team that never sleeps.

But honestly? Even without tools, running through this checklist once will reveal 80% of your agent compatibility issues. Start there.

The Bottom Line

AI agents aren't coming, they're already here. Your product works for them, or it doesn't. The sooner you know which, the sooner you can act.

Start by testing with an agent, work through the checklist, and watch for failure points. Fix the obvious ones first. You don't need to be perfect, but you do need to be usable.

The future is agent-assisted users, and it's worth making sure your product is ready for them.