expo-skill-eval
Evaluate Expo skills in this repo end-to-end - trigger accuracy, generated code quality, and runtime screenshots on iOS simulator and Android emulator via Expo Go (web optional)
Install / Use
npx skills add expo/skills --skill expo-skill-evalInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of expo-skill-eval
expo-skill-eval scores 86/100 on our quality scale, 2372nd of 4,698 Development & Engineering skills we index.
Its SKILL.md is 47 KB long, well organised into 16 sections with 7 code examples: long enough that it reads more like full documentation than a focused instruction file, which agents can find harder to follow.
With 2,602 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so expo-skill-eval is actively maintained.
- Our last check on 2026-11-03 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found 3 patterns worth reviewing before you install expo-skill-eval. An AI review judged it risky: The skill instructs the agent to pass `--dangerously-skip-permissions` to `claude -p` subprocesses and defaults to/recommends this option (lines 77, 159).
- mediumDisables the agent's permission promptsline 77
…with `AskUserQuestion` whether they may run with `--dangerously-skip-permissions`, then apply the same answer to every subprocess this run (… - mediumDisables the agent's permission promptsline 79
- **Skip permissions (recommended)** — pass `--dangerously-skip-permissions`. Each subprocess runs unattended inside a throwaway fixture und… - mediumDisables the agent's permission promptsline 159
…n" can make the subprocess write files, and with `--dangerously-skip-permissions` those writes would otherwise land in the skills repo. Trig…
AI review: risky
- The skill instructs the agent to pass `--dangerously-skip-permissions` to `claude -p` subprocesses and defaults to/recommends this option (lines 77, 159).
- It tells the agent to bake the chosen permission flag into generated orchestrator scripts and apply it to every subprocess run.
- While it asks user confirmation up front, the default/recommended choice disables permission prompts, which meaningfully weakens safeguards for the eval run.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-29. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
expo-skill-eval compared with similar skills
All 4 of these similar skills score higher than expo-skill-eval; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| expo-skill-eval (this skill)by expo | 86 | 2.6k | 53d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install expo-skill-eval?
- Run
npx skills add expo/skills --skill expo-skill-eval. The install tabs above show the steps for each supported agent. - Which AI agents does expo-skill-eval work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is expo-skill-eval safe to use?
- Our scan of the whole file found 3 patterns worth reviewing before you install expo-skill-eval. An AI review judged it risky: The skill instructs the agent to pass
--dangerously-skip-permissionstoclaude -psubprocesses and defaults to/recommends this option (lines 77, 159). It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand. - Is expo-skill-eval still maintained?
- The repository was last updated about 2 months ago, so expo-skill-eval is actively maintained.
Skill content
View source on GitHubname: expo-skill-eval description: Evaluate Expo skills in this repo end-to-end - trigger accuracy, generated code quality, and runtime screenshots on iOS simulator and Android emulator via Expo Go (web optional). Use when the user wants to eval an Expo skill, test that a skill produces working code, benchmark a skill with device screenshots, or verify a skill's output renders correctly. version: 1.0.0 license: MIT allowed-tools: "Read(~/.cache/expo-skill-eval/), Read(/tmp/expo-skill-eval-*/), Read(/private/tmp/expo-skill-eval-/**), Write(/tmp/expo-skill-eval-/), Write(/private/tmp/expo-skill-eval-*/), Edit(/tmp/expo-skill-eval-/**), Edit(/private/tmp/expo-skill-eval-/**), Bash(python3 /tmp/expo-skill-eval-), Bash(python3 /private/tmp/expo-skill-eval-), Bash(python3 expo-skill-eval/scripts/), Bash(tee /tmp/expo-skill-eval-), Bash(tee /private/tmp/expo-skill-eval-), Bash(bash expo-skill-eval/scripts/)"
Expo Skill Eval
Evaluates skills in plugins/expo/skills/ for trigger accuracy, generated code quality, and/or runtime rendering in Expo Go.
Requirements: macOS with Xcode (iOS simulators), Android SDK with at least one AVD, and bun. No other device tooling is assumed.
Workspace root: /private/tmp/expo-skill-eval-<skill-name>/iteration-N/ (e.g. /private/tmp/expo-skill-eval-expo-ui/iteration-4/).
Before starting — clarify scope
Confirm all of the following up front, before any pipeline work — don't skip any (only skip a given item if the request already states that choice). Batch them into AskUserQuestion calls of ≤4 questions each, in this order:
- Which skill to eval (if not clear from the request).
- Prompts — which prompts drive the eval. Built-in prompts (from the skill's eval cases) are pre-selected all; drop any, add a custom text prompt, or build from an uploaded screenshot (a target UI the skill must reproduce). See Prompts below.
- What to verify — one multi-select of three options: Runtime + screenshots / Trigger accuracy / Code checks (no device). See What to verify below.
- Expo SDK — latest (default, auto-detected) or a pinned version.
- Runner — Expo Go (default) or development build.
- Platforms — iOS / Android / web (always offer all three).
- Permission flag for
claude -p— skip-permissions (default) or accept-edits. - Viewer delivery — local only (default) or publish a shareable Artifact.
- If trigger accuracy is selected — confirm the published
expoplugin is disabled (or not installed).
Each is detailed below. Items 4–6 (SDK, runner, platforms) fit naturally in one AskUserQuestion call.
If the skill to eval is not clear from the request, list available skills from plugins/expo/skills/ and ask which one to evaluate.
How the skill under test is loaded — two mechanisms, one per phase (don't pick one globally): executor runs reference it by file path (SKILL_PATH = plugins/expo/skills/<skill>/SKILL.md, read explicitly), while the trigger eval loads it as a plugin (--plugin-dir plugins/expo, so the model can auto-select it from its description). Both point at the local, in-repo version — that's what you're evaluating. You do not need any special flag to launch the harness session itself (the harness finds the skill by repo path); the mechanisms apply to the claude -p subprocesses it spawns. See steps 1 and 3 for why each phase differs. One pre-run check (required when the trigger eval is in scope): if the published expo plugin is installed/enabled, disable it (via /plugin) before launching the harness and re-enable after. A single disable is a global-config change that both this session and the spawned claude -p subprocesses inherit. Why it's required for the trigger eval: that phase loads the local skill via --plugin-dir, and a second installed expo collides with it — the model may trigger the published expo:expo-ui, and since detection only sees the tool-call name you'd silently score the published description instead of your local edits (the collision could also just error). The executor / runtime / static phases are not affected — they read the skill under test by its local SKILL_PATH with no --plugin-dir — so a run with no trigger eval can skip the disable. Disabling expo does not disable expo-skill-eval (a standalone project skill, not part of the expo plugin), so the harness stays available.
Surface this to the user as an explicit up-front confirmation — the same way you confirm which skill to eval. When the trigger eval is in scope, ask the user to confirm the published expo plugin is disabled (or not installed) before you start step 1; if it's still enabled, pause and have them disable it via /plugin. Don't run the trigger eval until they confirm — the harness can't reliably detect installed plugins on its own (reading the global plugin config or claude plugin list would prompt), so this is a manual confirmation, not an auto-check.
Pick the prompts — built-in, custom, or a target screenshot. The prompts are the inputs that drive the executor (with-skill and without-skill); they are separate from what you verify. Confirm them with AskUserQuestion (skip if the request already names a prompt):
- Built-in prompts — representative prompts you generate by reading the skill under test (its
SKILL.md+references/) andreferences/runtime-matrix.md, covering the skill's standard use cases. (If the skill already ships eval cases underevals/evals.json, fold theirpromptfields in too — but most skills don't, so you usually derive them.) Pre-select all so the default run exercises the skill's standard cases; let the user deselect any. - Custom text prompt — a one-off prompt the user types. Don't spend a dedicated option slot on this:
AskUserQuestionauto-adds a "Type something" / Other entry, and anything typed there becomes a custom text case. - Build from an uploaded screenshot — the user gives the path to a target screenshot (a UI to reproduce). The executor is told to open it —
claude -preads PNGs with its Read tool — and build an app matching it; the case records the path asreference_image, and grading compares the generated app to that target (step 6). This is the strongest visual test for a UI skill: "build this."
Respect AskUserQuestion's 4-option-per-question cap with this priority (the bug to avoid: the upload option silently dropped once the four slots fill up):
- Always reserve a slot for "Build from an uploaded screenshot." It's the whole point of the visual eval and must never be the option that gets dropped.
- Don't add an explicit "Custom text prompt" option — the auto "Type something" / Other entry already covers it.
- Fill the remaining ≤3 slots with the built-in/representative prompts, pre-selected. If there are more than 3, collapse them into one pre-selected "All built-in prompts (default)" option and offer subset-picking in a short follow-up, so the upload option still fits.
Present it as a multi-select. When "Build from an uploaded screenshot" is picked, ask for the target image path in a follow-up. Each selected prompt (built-in, typed, or image) becomes one eval case (run with-skill and without-skill).
Always confirm what to verify unless the request makes it unambiguous. Present these options and let the user pick one or more (defaults in bold based on the skill's references/runtime-matrix.md entry):
| Option | What it does | When to suggest as default |
|--------|-------------|---------------------------|
| Runtime + screenshots | Full pipeline: fixture → executor → static gate → run the app on iOS/Android and screenshot it. The runner (Expo Go or dev build) is a separate question — don't name it here. | Default for any skill that renders an app screen (the expo-go/dev-build rows in references/runtime-matrix.md). Requires a booted simulator/emulator. |
| Trigger accuracy | Run realistic prompts via claude -p, check whether the skill is read. Measures recall (should-trigger queries only). | Always useful as a standalone check. |
| Code checks (no device) | tsc --noEmit + diff-aware lint + expo export, plus the grader checks the generated code against any custom expectations you provide. No device. | Default for static-only and n/a skills, and whenever you want to verify code patterns (correct import path, a Host wrapper, …) without running the app. |
Present these as ONE multi-select question — "What do you want to verify?" These are grading dimensions (how to judge what gets built) — distinct from the Prompts phase (what to build). The user may pick any combination. When a prompt is an uploaded screenshot (see Prompts), include "Runtime + screenshots" so the harness captures the generated app and the grader can score it against the target.
Read references/runtime-matrix.md to find the skill's default mode before suggesting. If the request already specifies a mode (e.g. "just check if it triggers", "run it on device"), skip the question and proceed.
Pick the Expo SDK version — once, up front. Detect the latest with bash /abs/path/expo-skill-eval/scripts/latest-sdk.sh (it prints the major, e.g. 56; internally it uses bun to run npm view expo dist-tags --json and read the major via JSON.parse/semver, and it's covered by the bash-scripts rule — so don't run the registry query inline yourself, which would prompt). Then confirm with AskUserQuestion: default to that latest SDK, or let the user pin an older one (e.g. to reproduce a version-specific issue). Use the chosen version everywhere the fixture is built — pass it as the <sdk> arg to make-fixture.sh and write it into each eval case's runtime.sdk. If the request already names a version ("eval on SDK 54"), skip detection and use it.
Default to the latest — it stays compatible with the Expo Go that expo start installs on the device. Pinning an SDK older than the device's installed Expo Go makes expo start try to prompt "Install the recommended Expo Go version?"; with no TTY (the snapshot scripts read stdin from /dev/null) it dies with Input is required, but 'npx expo' is in non-interactive mode and every snapshot fails. So only pin an older SDK when you also pre-install a matching Expo Go on the simulator/emulator — otherwise stick with latest.
Pick the runner — Expo Go (default) or a development build. Ask with AskUserQuestion (skip if the request already says which):
- Expo Go (default) — the snapshot scripts run the app with
expo start --ios/expo start --androidas-is. Fast (no native compile), and it runs anything Expo Go bundles (including@expo/uion SDK 56+). Cannot run custom native code (expo-modules, config plugins, native deps not in Expo Go). - Development build — the snapshot scripts run
expo run:ios/expo run:androidinstead, compiling a native dev client per fixture. Use this for skills whose output needs custom native code (the cases that would otherwise bestatic-only). Much slower —expo runprebuilds and natively compiles each fixture (minutes, especially the first), and needs the full iOS/Android build toolchain — so only choose it when the skill actually requires native code. Disk-heavy: each fixture's native build is multi-GB. The snapshot phase runsclean-fixture.shafter each fixture to keep peak usage to ~one build, but still prefer fewer eval cases and a single platform for dev-build runs, and keep a few GB free.clean-fixture.shremoves the per-fixture build output (node_modules,ios,android,.expo,dist, and the fixture's iOS DerivedData) and keeps the app source + git. The lever for dev-build disk is fewer eval cases + one platform — it only reclaims per-fixture build output and never touches s
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6k🤯 LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
