Skip to content
Get packs

Guide · Agent skill

How to use the Android UI Verification agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The android_ui_verification skill lets an AI agent drive an Android emulator through ADB (Android Debug Bridge, a developer command-line tool) so it can check whether a UI change actually works, not just whether the code looks right. It is written for React Native and Android developers who want quick visual evidence of a screen. After this guide you will know what the skill does, how to install it, how to ask for it in plain language, and what to check before trusting its output.

Android UI Verificationsickn33/agentic-awesome-skills · MIT

Quick start

  1. 1Install the Android platform tools. Install Android SDK platform tools so that adb is available on your PATH.
  2. 2Start an emulator. Run an Android emulator and note its serial, which you can list with adb devices -l.
  3. 3Install the skill. Unzip the downloaded ZIP into ~/.claude/skills/ or a project's .claude/skills/ folder, or upload it under Settings → Capabilities → Skills.
  4. 4Build your app in debug mode. Use a debug build so that JS logs appear in logcat.
  5. 5Ask for the check in plain language. Describe the screen, the action and the expected result you want verified.
  6. 6Run the helper or the ADB commands. Use ANDROID_SERIAL with scripts/verify_ui.sh or the ADB commands to capture the layout, a screenshot and logs.
  7. 7Inspect the artifacts. Compare the artifacts folder contents with the expected UI yourself, because the skill does not decide pass or fail.

What is an agent skill, and what does this one do?

An agent skill is a folder of instructions and optional scripts that an AI agent can load when a task matches its description. This one is defined in a file called SKILL.md and comes with a helper script.

Once the skill is active, the agent can read the emulator's screen layout, tap, swipe and type, take screenshots, and read the app's JavaScript console logs. Those abilities let it test a UI change on the device rather than only reading the code.

  • Reads the screen layout to find buttons and inputs by text, content description or resource ID.
  • Taps, swipes, types text and sends key events such as Enter.
  • Captures screenshots after an interaction.
  • Reads recent ReactNativeJS log lines from logcat.

Check the requirements before you install

The skill assumes a specific setup. Confirm you have each item below before you start, because the skill will not work around a missing piece.

  • Android SDK platform tools with adb installed and on your PATH.
  • A running Android emulator. If you have several devices, the serial is set with ANDROID_SERIAL.
  • A debug build of your app, so that JS logs appear in logcat.
  • A bash shell to run scripts/verify_ui.sh.

How do you install the skill?

Download the ZIP from the skill page and unzip it. Then place the folder in one of two locations.

For a personal install available across your projects, put it in ~/.claude/skills/. To limit it to one project, put it in that project's .claude/skills/ folder.

If you use the Claude apps instead, open Settings, go to Capabilities, and upload the skill under Skills.

  • Personal: ~/.claude/skills/
  • Single project: .claude/skills/ inside the project
  • Claude apps: Settings → Capabilities → Skills

How do you trigger the skill with a natural request?

You do not need a special command. Describe the task in plain language that matches the skill's scope, such as checking a UI change on the emulator or capturing a screenshot for a pull request. The agent should pick up the skill from the description.

Be specific about the screen and the expected result. The skill is most useful when you name what should appear after an action, because the agent needs a success criterion to check against.

  • "Use the android UI verification skill to check that the login button opens the settings screen on my emulator."
  • "Take a screenshot of the checkout screen on the emulator for the PR description."
  • "My new list row looks misaligned on the emulator. Dump the layout and tell me the tap bounds of the row button."

What do the core ADB commands look like?

The skill's workflow uses standard ADB commands. Select the emulator first, then inspect the screen before tapping. If several devices are connected, add -s SERIAL to every command.

Coordinates come from the layout dump, not from guesses. The bounds attribute [x1,y1][x2,y2] marks the clickable area, and the centre of that box is the most reliable tap target.

  • Tap: adb shell input tap <x> <y>
  • Swipe (for scrolling): adb shell input swipe <x1> <y1> <x2> <y2> <duration_ms>
  • Text: adb shell input text "<message>" (special characters have limited support)
  • Key event: adb shell input keyevent <code_id>, for example 66 for Enter
adb devices -l adb shell wm size adb shell uiautomator dump /sdcard/view.xml && adb pull /sdcard/view.xml ./artifacts/view.xml

How do you run the bundled helper script?

From the skill's directory, select the emulator you have verified and run the helper with a name for the screen you are checking. Replace the example serial with your own device's serial.

The helper captures artifacts/view.xml, artifacts/login-screen.png and recent JS logs. It does not decide whether the test passed. You still need to compare the captured state with the expected UI.

ANDROID_SERIAL=emulator-5554 bash scripts/verify_ui.sh login-screen

How do you check that a result is real?

Take a screenshot after each interaction and read the layout dump to confirm the expected text or resource ID is present. For logs, the skill suggests printing a distinct marker in your code and grepping for it, so the check is repeatable.

Wait for the expected state with a bounded timeout rather than a fixed delay. A fixed sleep only pauses; it does not verify anything. If the layout dump fails or does not show the expected text, the skill says to stop and troubleshoot rather than tap blindly.

  • Poll for the expected UI state with a timeout.
  • Use log markers such as a success message, then grep for it.
  • Stop if uiautomator dump fails or the expected text is missing.
adb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png ./artifacts/test_result.png adb logcat -d | grep "ReactNativeJS" | tail -n 20

Safety notes: scripts, network and personal data

The skill runs scripts, so review scripts/verify_ui.sh before you run it. The skill does not use the network. The helper is described as inert and non-executable, but treat that as the skill's own description and check the file yourself.

Screenshots and logs can contain personal information. Keep the artifacts/ folder private when it holds personal data, and do not use the skill on physical phones or production devices with real user data. The skill assumes an emulator.

  • Review the script before running it.
  • The skill does not use the network.
  • Keep artifacts private if they contain personal data.
  • Use it on emulators, not production devices.

What people use it for

  • Smoke-testing a React Native UI change on an emulator before opening a pull request.
  • Capturing a screenshot of a screen for PR documentation.
  • Finding the exact bounds of a button that is hard to tap to debug a layout issue.
  • Collecting recent ReactNativeJS log lines alongside a screenshot when an interaction misbehaves.

Frequently asked questions

Is the android_ui_verification skill free?

The skill is released under the MIT licence, as listed on the item page. Check the licence file in the downloaded package for the full terms.

What do I need to run the android UI verification skill?

You need Android SDK platform tools with adb on your PATH, a running Android emulator, a debug build of your app so JS logs appear in logcat, and a bash shell to run scripts/verify_ui.sh.

Where do I install an agent skill like this one?

Put the unzipped folder in ~/.claude/skills/ for personal use or in a project's .claude/skills/ folder for one project. In the Claude apps, upload it under Settings → Capabilities → Skills.

Can this skill test an iOS app?

No. The skill uses ADB, which controls Android devices and emulators only, so it cannot drive iOS.

Can I use it on a physical phone?

The skill assumes an emulator. It is not intended for physical phones or production devices with real user data, because screenshots and logs may contain personal information.

Does the skill tell me whether my test passed?

No. The helper collects a layout dump, a screenshot and recent logs, but it does not assert outcomes. You or the agent must inspect the results against the expected UI.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you are a React Native or Android developer who wants an agent to smoke-test a UI change on an emulator, or who needs screenshots and layout evidence for a pull request. Pick something else if you need formal pass/fail regression suites, iOS testing, or testing on physical phones with real user data.

Download the skill