Android UI Verification Skill

SkillDev tools

This skill is an Android UI verification tool that lets an AI agent run end-to-end UI tests on an Android emulator using ADB. It guides the agent through calibrating the screen, dumping the UI layout to find element positions, tapping or swiping, and verifying results with screenshots and logcat output. It is intended for checking UI changes in React Native or native Android apps and for autonomous debugging of layout or interaction bugs.

Use Android UI Verification Skill in Claude, ChatGPT or Ahel Desktop

Free. Sign in, add Android UI Verification Skill and connect your AI. About a minute.

Also: Claude Code · Cursor · Codex

Then ask your AI: use the Android UI Verification Skill skill

Details

Instructions available. Your AI can read the instructions. Execution depends on the setup they require.

Have an Android emulator running and adb installed and available in PATH.

Android UI Verification SkillStart free

What your AI can do with it

  • Calibrate screen resolution with adb shell wm size
  • Dump UI layout with uiautomator to find element bounds
  • Tap, swipe, input text, and send key events via adb shell input
  • Capture screenshots with screencap and pull them to artifacts
  • Monitor ReactNativeJS logs with adb logcat and grep

Getting started

  1. Have an Android emulator running and adb installed and available in PATH.
  2. Ensure the application under test is in debug mode so logcat access works.
  3. Run adb shell wm size to verify the screen resolution before calculating tap coordinates.
  4. Use adb shell uiautomator dump to save the view hierarchy and pull it to artifacts/view.xml.
  5. After each interaction, wait briefly, then capture a screenshot or check logcat to verify the result.

What this skill tells your AI

The instructions your AI receives, as published by sickn33/agentic-awesome-skills in skills/android_ui_verification/SKILL.md and read by ahel’s review.

This skill provides a systematic approach to testing React Native applications on an Android emulator using ADB commands. It allows for autonomous interaction, state verification, and visual regression checking.

When to Use

  • Verifying UI changes in React Native or Native Android apps.
  • Autonomous debugging of layout issues or interaction bugs.
  • Ensuring feature functionality when manual testing is too slow.
  • Capturing automated screenshots for PR documentation.

🛠 Prerequisites

  • Android Emulator running.
  • adb installed and in PATH.
  • Application in debug mode for logcat access.

🚀 Workflow

1. Device Calibration

Before interacting, always verify the screen resolution to ensure tap coordinates are accurate.

adb shell wm size

Note: Layouts are often scaled. Use the physical size returned as the base for coordinate calculations.

2. UI Inspection (State Discovery)

Use the uiautomator dump to find the exact bounds of UI elements (buttons, inputs).

adb shell uiautomator dump /sdcard/view.xml && adb pull /sdcard/view.xml ./artifacts/view.xml

Search the view.xml for text, content-desc, or resource-id. The bounds attribute [x1,y1][x2,y2] defines the clickable area.

3. Interaction Commands

  • Tap: adb shell input tap <x> <y> (Use the center of the element bounds).
  • Swipe: adb shell input swipe <x1> <y1> <x2> <y2> <duration_ms> (Used for scrolling).
  • Text Input: adb shell input text "<message>" (Note: Limited support for special characters).
  • Key Events: adb shell input keyevent <code_id> (e.g., 66 for Enter).

4. Verification & Reporting

Visual Verification

Capture a screenshot after interaction to confirm UI changes.

adb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png ./artifacts/test_result.png
Analytical Verification

Monitor the JS console logs in real-time to detect errors or log successes.

adb logcat -d | grep "ReactNativeJS" | tail -n 20
Cleanup

Always store generated files in the artifacts/ folder to satisfy project organization rules.

💡 Best Practices

  • Wait for Animations: Always add a short sleep (e.g., 1-2s) between interaction and verification.
  • Center Taps: Calculate the arithmetic mean of [x1,y1][x2,y2] for the most reliable tap target.
  • Log Markers: Use distinct log messages in the code (e.g., ✅ Action Successful) to make grep verification easy.
  • Fail Fast: If a uiautomator dump fails or doesn't find the expected text, stop and troubleshoot rather than blind-tapping.

Limitations

  • Use this skill only when the task clearly matches the scope described above.
  • Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
  • Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

Signals

GitHub stars
47k
Forks
7k
Last commit
Sep 2026

Questions

What is this skill for?
It provides a systematic approach to testing React Native applications on an Android emulator using ADB commands, allowing autonomous interaction, state verification, and visual regression checking.
What are the prerequisites?
An Android emulator running, adb installed and in PATH, and the application in debug mode for logcat access.
What are the limitations?
Use this skill only when the task clearly matches the scope described above. Do not treat the output as a substitute for environment-specific validation.
Advanced
Item type
skill
Key
android-ui-verification-sickn33
Source
github.com/sickn33/agentic-awesome-skills