How AI Explores Your App (Explained Simply)
Rihario uses AI to explore your app like a curious user would. The AI looks at pages, understands what's there, decides what to interact with, and notices when something looks wrong. No scripts, no selectors - just intelligent exploration.
The Exploration Process
When you start an exploration, the AI goes through these steps:
1. Understanding the Page
First, the AI analyzes what's on the page:
- What elements exist - Buttons, forms, links, images, text
- What's interactive - Which elements can be clicked, typed into, or interacted with
- Page structure - Navigation, headers, content areas, footers
- What looks important - Primary actions vs secondary, key content vs decorative
The AI uses computer vision and DOM analysis to understand the page structure. It's not just reading HTML - it's seeing what the page actually looks like.
2. Making Decisions
Based on what it sees, the AI decides what to do next:
- Which button to click - Focuses on primary actions first (Sign Up, Buy Now, etc.)
- What fields to fill - Identifies forms and understands what data they need
- When to navigate - Decides if links should be followed
- When to take screenshots - Captures important states
The AI makes these decisions based on:
- Your instructions (if provided) - "check the checkout flow"
- Page context - What elements are visible and important
- Common user flows - How people typically use apps
- Previous exploration - What it's already checked
3. Interacting Naturally
The AI interacts with elements like a human would:
- Clicks buttons - Uses mouse clicks, not just programmatic clicks
- Types in fields - Generates realistic test data and types character by character
- Scrolls pages - Scrolls to see content below the fold
- Waits for loads - Waits for pages to load, elements to appear, animations to finish
This natural interaction is important because it catches issues that programmatic testing might miss - like click handlers that don't fire properly or form validation that breaks.
4. Detecting Issues
While exploring, the AI constantly watches for problems:
- Visual issues - Broken layouts, overlapping elements, missing styles
- Console errors - JavaScript errors logged to the browser console
- Network errors - Failed requests, 404s, timeouts
- Accessibility issues - Missing alt text, unlabeled inputs, contrast problems
- Performance issues - Slow page loads, large bundles
When an issue is detected, the AI:
- Captures evidence (screenshot, logs, DOM snapshot)
- Classifies the issue (visual, console, network, etc.)
- Estimates severity (high, medium, low)
- Records where it was found (which step, which page)
5. Adapting to Changes
If your app changes, the AI adapts automatically:
- New button text - Finds the button by visual appearance, not just text
- Different layout - Understands the new structure and adapts
- Updated selectors - Doesn't rely on fixed selectors, finds elements dynamically
- New features - Discovers and explores new elements automatically
This is the key advantage over scripted tests - no maintenance required when your UI changes.
How AI Makes Decisions
The AI uses several techniques to decide what to do:
Computer Vision
The AI "sees" the page like a human would:
- Recognizes buttons by appearance (not just HTML)
- Understands visual hierarchy (what's prominent vs secondary)
- Detects layout issues (overlapping elements, broken CSS)
- Reads text content (even if it's in images)
DOM Analysis
The AI also analyzes the HTML structure:
- Identifies semantic elements (forms, buttons, links)
- Reads ARIA labels and accessibility attributes
- Understands element relationships (form fields to labels)
- Analyzes class names and IDs (if helpful)
Heuristics and Patterns
The AI uses learned patterns:
- Common UI patterns (login forms, checkout flows, navigation menus)
- User behavior patterns (people typically click primary buttons first)
- Error patterns (what broken layouts usually look like)
- Flow patterns (common paths through apps)
Instructions from You
If you provide instructions like "check the checkout flow", the AI:
- Prioritizes actions related to your instructions
- Still checks for general issues
- Focuses exploration on relevant areas
What This Means in Practice
No Selectors to Maintain
Traditional testing requires selectors like #submit-button or .checkout-form. If those change, tests break. Rihario doesn't rely on selectors - it finds elements by understanding what they are and what they do.
Adapts to UI Changes
If you redesign your login form, move buttons around, or change CSS, Rihario adapts automatically. The same exploration continues working because the AI understands the page structure, not just fixed selectors.
Finds Unexpected Issues
Because the AI explores like a human, it might find issues you didn't think to test for:
- Buttons that look clickable but aren't
- Forms that break when typed into
- Layout issues on certain screen sizes
- Errors that only appear under specific conditions
Limitations
AI exploration has limitations:
- Not exhaustive - Explores what it finds, doesn't test every possible scenario
- Probabilistic - Same exploration might take different paths
- Requires human judgment - Not everything it flags is a real problem
- Can miss edge cases - Focuses on common flows, not unusual scenarios
- May false positive - Sometimes flags non-issues as problems
This is why it's optimized for confidence, not coverage.