Argent Test Ui Flow
Run autonomous iOS or Android UI tests with Argent MCP using screenshot, describe, gesture, and verify loops.
Overview
Argent test UI flow is an agent skill most often used in Ship (also Validate prototype, Build frontend) that runs autonomous interact-screenshot-verify loops on iOS or Android via Argent MCP.
Install
npx skills add https://github.com/software-mansion/argent --skill argent-test-ui-flowWhat is this skill?
- Platform-agnostic MCP tools (`gesture-tap`, `gesture-swipe`, `describe`, `screenshot`, `launch-app`) dispatched by `udid
- Documented interact-screenshot-verify loop starting from a baseline screenshot.
- Device selection via `list-devices` with per-platform setup skills for iOS and Android.
- Supports login, navigation, and full scenario E2E checks without platform-specific tool names.
- Requires emulator or simulator readiness before the workflow starts.
- Core loop: baseline screenshot, discover target, interact, verify—documented as section 1 workflow.
- Single tool surface for iOS and Android (identical MCP tool names).
Adoption & trust: 1.9k installs on skills.sh; 1.2k GitHub stars; 1/3 security scanners passed (skills.sh audits).
What problem does it solve?
You need to confirm a mobile UI flow works on device but manual tapping does not scale and your agent lacks a repeatable visual test ritual.
Who is it for?
Indie mobile teams already on Argent MCP who want agent-driven regression on login, navigation, or critical paths before ship.
Skip if: Backend-only APIs, desktop web-only apps, or runs without first completing the platform-specific Argent emulator or simulator setup skill.
When should I use this skill?
Testing a UI flow, verifying login works, testing navigation, or running an end-to-end UI test scenario.
What do I get? / Deliverables
Your agent executes an end-to-end UI scenario with baselined screenshots and verified post-interaction state on the chosen simulator or emulator.
- Completed E2E UI scenario with before/after screenshots
- Documented pass/fail judgment on the target flow
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
End-to-end UI verification is canonically a Ship concern even when you first exercise flows during Validate or Build. The skill implements structured E2E UI testing—baseline screenshot, element discovery, interact, re-screenshot—not emulator provisioning.
Where it fits
Walk through a stub login screen on emulator to confirm the prototype flow before full build.
Re-run navigation after a UI refactor using describe plus gesture-tap without manual device babysitting.
Execute a full E2E checkout or settings path with screenshot verification before store submission.
Regression-test a hotfixed screen on the same Argent device serial after a production bug report.
How it compares
Structured MCP UI loops instead of one-off screenshot guesses in chat.
Common Questions / FAQ
Who is argent-test-ui-flow for?
Solo and indie mobile developers using Claude Code, Cursor, or similar agents with Argent to validate real device UI behavior.
When should I use argent-test-ui-flow?
When testing a UI flow, verifying login, checking navigation, or running E2E scenarios—during Validate on prototypes, Build while iterating screens, and Ship before launch.
Is argent-test-ui-flow safe to install?
Check the Security Audits panel on this Prism page; the skill drives real apps and device automation, so align permissions with your security review.
Workflow Chain
Requires first: argent android emulator setup
SKILL.md
READMESKILL.md - Argent Test Ui Flow
## Platform-agnostic The interaction tool names are identical on iOS and Android — `gesture-tap`, `gesture-swipe`, `describe`, `screenshot`, `launch-app`, etc. — and the tool-server auto-dispatches based on the `udid` you pass (UUID-shape → iOS, adb serial → Android). **Before testing, resolve which device to test on.** Call `list-devices` and follow `<device_selection_rule>`: prefer a running device on any platform; Once a platform is chosen, the per-platform setup skill takes over: | Platform | Setup skill | Find devices with | | -------- | ------------------------------- | ----------------------------------------------------------- | | iOS | `argent-ios-simulator-setup` | `list-devices` → `boot-device` with `udid` if none booted | | Android | `argent-android-emulator-setup` | `list-devices` → `boot-device` with `avdName` if none ready | ## 1. Workflow All interactions go through argent MCP tools. Ensure the simulator/emulator is ready before starting. 1. **Baseline screenshot**: Call `screenshot` to see the current UI state. 2. **Find target**: Before tapping, use a discovery tool to get element coordinates: - **React Native apps**: use `debugger-component-tree` — it returns component names with (tap: x,y) coordinates. This is the preferred tool for RN apps on either platform. To use it, resolve the `argent-react-native-app-workflow` skill for setup; on Android you must also run `adb -s <serial> reverse tcp:8081 tcp:8081` so Metro is reachable from the device. - **Standard app screens and in-app modals**: use `describe`. On iOS this returns the AX tree (falls back to native-devtools when AX is empty); on Android it returns the uiautomator tree in the same DescribeNode shape. - **Permission prompts / system modal overlays**: try `describe` first. Fall back to `screenshot` only if the overlay is not exposed reliably. - **Fallback**: use `screenshot` to estimate where the desired component is, then verify immediately after the action. 3. **Interact**: Perform the action (`gesture-tap`, `gesture-swipe`, `keyboard`, `button`, ...) — you receive a screenshot automatically. 4. **Verify**: Check the returned screenshot for expected results. If it shows a loading/transitional state, retake with `screenshot`. 5. **Repeat** for each step in the flow. ## 2. Template ``` Goal: Test [feature name] Steps: 1. screenshot → see current state (baseline) 2. [Navigate / tap / type to reach starting point] → verify auto-screenshot 3. [Perform the action to test] → verify auto-screenshot 4. Report: pass / fail with details ``` ## 3. Examples ### Login flow ``` 1. screenshot → see login screen 2. gesture-tap { x: 0.5, y: 0.4 } → tap email field 3. paste { text: "user@example.com" } 4. gesture-tap { x: 0.5, y: 0.55 } → tap password field 5. paste { text: "password123" } 6. gesture-tap { x: 0.5, y: 0.7 } → tap Login button 7. screenshot → verify home screen appeared ``` ### Scroll and navigation ``` 1. screenshot → see list at top 2. gesture-swipe { fromY: 0.7, toY: 0.3 } → scroll down 3. gesture-tap item at visible position → verify auto-screenshot 4. screenshot → verify detail view opened 5. button { button: "back" } 6. screenshot → verify returned to list ``` --- ## 4. Recovery Pattern - If screenshot shows loading/transition: wait 500ms, retake with `screenshot`. - If tap misses target: re-run discovery tool (`describe` / `debugger-component-tree`), retry once with new coordinates. - If a permission dialog or modal is visible: re-run `describe` first. Stay in screenshot-driven navigation only when the overlay is not exposed reliably, then switch back to `describe` / `debug