← Back to directory
F

Flutter Skill

Community
Give any AI agent eyes and hands inside your running app — E2E testing across 10 platforms via MCP
Category
Dev Tools #199 of 438
Stars
★ 391 Very popular
Transport
stdio (local process)
Runtime
Node.js
Credentials
No credential needed
License
MIT
Last commit
Tools
100
54FMRS · D

flutter-skill is a broad, third-party MCP testing server that connects AI agents to running apps across 10 platforms (Flutter, React Native, iOS, Android, Web, Electron, Tauri, KMP, .NET MAUI) via roughly 253 self-described tools, emphasizing zero test code and low token usage through accessibility-tree snapshots. It requires granting the AI agent fairly broad control over the app/browser under test and the ability to alter network behavior (including arbitrary JS execution via eval), so it's best suited to trusted local development or CI environments. As a community-maintained, pre-1.0 project, evaluate its maturity and security boundaries before adopting it for sensitive or production-adjacent testing.

Strongest · Documentation 14/20 Weakest · Security and permissions 7/20

Reliability
8/20
Security and permissions
7/20
Maintenance
12/20
Documentation
14/20
Setup experience
13/20
Why each score
Reliability 8/20
The README claims 253 MCP tools, 10 platforms, and 656/664 (98.8%) passing tests, with suspiciously precise per-platform pass counts (e.g. 188/195, 75/75), but the supplied material contains no verifiable test files or CI artifacts — only a badge referencing a ci.yml workflow whose actual run status cannot be confirmed from source. The manifest only declares stdio transport plus npm package name/version, with no tool schemas, error-handling description, or dependency-control evidence. The discrepancy between 'server' mode (253 tools) and 'serve' mode (246, 'dynamic per page') is unexplained, adding uncertainty about whether declared behavior matches reality. Per the static calibration rule, without real CI + committed tests the score cannot exceed 12; set to 8 given the largely unverifiable self-reported benchmarks.
Security and permissions 7/20
The toolset includes eval (arbitrary JS execution), http_request/api_request, network interception and replay (mock_api, replay_network, intercept_requests, block_urls), and credential/session-related tools (auth_inject_session, auth_biometric, auth_otp, auth_deeplink) — a broad capability surface. Neither the README nor the manifest describes least-privilege scoping, confirmation prompts before dangerous actions, sandbox boundaries, or data-flow disclosure (e.g., where auth data originates, how it's handled or logged). The manifest's empty environmentVariables means no declared credential configuration, yet auth data can clearly flow through tool calls at runtime with no documented handling. No red-line evidence was found (no malware, no fabricated identity, no leaked secrets in examples), but the wide permission surface combined with the absence of confirmation/least-privilege design warrants 7.
Maintenance 12/20
The repo is MIT-licensed, not archived, has 343 stars and 8 open issues, and links CONTRIBUTING.md and CHANGELOG.md; the 0.9.36 version number suggests ongoing iteration. However, the supplied material lacks actual commit history, release cadence, or issue-response-time evidence, and there is no visible security-response channel (e.g., SECURITY.md). Based on the static evidence available, this reflects moderate activity, scored 12.
Documentation 14/20
The README is extensive, covering installation, quick start, setup instructions for 8 platforms, a CLI command reference, and a categorized list of the 253 tools, with links to deeper docs (docs/USAGE_GUIDE.md, docs/CLI_CLIENT.md). However, the most sensitive tools (auth_inject_session, auth_otp, auth_biometric, auth_deeplink) have no dedicated usage notes, scope, or risk disclosure, there is no dedicated troubleshooting section, and many performance/test-pass figures lack reproducible methodology or raw data links. Scored 14 overall.
Setup experience 13/20
The install path is clear: a single npm install -g command plus a few lines of MCP JSON config; the README gives concrete configuration examples for Cursor, Claude Desktop, Windsurf, VSCode Copilot, and Cline, plus alternative install methods (Homebrew, Scoop, Docker, pub.dev). Steps are simple and cross-platform coverage is broad. Per the static calibration rule, without verifiable execution evidence (real CI plus committed tests), setup cannot exceed 15, so it is scored 13.

Static review · not runListed 2026-08-26

Read the FMRS scoring method →

Fit and risk

What it can accessWrites / deletes local filesUses the networkControls a browser

Best for

  • Teams with a debuggable, running Flutter/React Native/Electron/Tauri/mobile/web app who want natural-language E2E testing instead of writing test scripts
  • Developers who want to drive exploratory testing directly from an MCP client like Claude Desktop, Cursor, Windsurf, or Copilot
  • Scenarios where low-token UI understanding (accessibility-tree snapshots instead of screenshots) matters for cost

Not for

  • Teams that require a tool maintained by an official upstream vendor (e.g. Flutter, Google, Anthropic) — this is a third-party project maintained by ai-dashboad
  • Restricted environments that cannot integrate a platform SDK into the app or cannot install local npm/CLI tooling
  • Situations requiring the production-proven maturity and community scale of established tools like Playwright or Appium

Required permissions

  • Local execution permission to launch and run the `flutter-skill` executable over stdio
  • Connection and control permissions over the app/browser instance under test (tap, type, screenshot, read widget tree, etc.)
  • Access to runtime data such as app logs, console messages, and network requests
  • Network port listening permission when using the HTTP `serve` mode (configurable via `--port`/`--host` or environment variables)

Risks and side effects

  • This is a third-party open-source implementation, not maintained by Flutter, Google, or Anthropic — the source material does not describe any audit, signing, or supply-chain security process
  • The tools can perform arbitrary interactions (tap, type, execute JavaScript via `eval`, inject login sessions, etc.); if driven by a malicious or manipulated prompt, they could take unintended or destructive actions against the app under test
  • Tools like `eval` execute arbitrary JavaScript in the page context, and `mock_api`/`intercept_requests` can alter network behavior — restrict use to trusted development/test environments
  • The manifest version (0.9.36) indicates the project is still pre-1.0 and its interface may change

Setup

Before you start

Runtime:Node.js

Other optional settings (2)
FS_PORT optional Optional port for HTTP serve mode (`flutter-skill serve`); can also be set via the `--port=N` flag.
FS_HOST optional Optional host for HTTP serve mode (`flutter-skill serve`); can also be set via the `--host=H` flag.

1) Install globally: npm install -g flutter-skill (Homebrew, Scoop, a Docker image, or dart pub global activate flutter_skill are also documented). 2) Add the install_config shown here to your AI client's MCP configuration (e.g. Cursor's .cursor/mcp.json, Claude Desktop's claude_desktop_config.json, Windsurf's ~/.codeium/windsurf/mcp_config.json, or VSCode's .vscode/mcp.json). 3) Add the matching SDK to the app under test — e.g. for Flutter, add the flutter_skill dependency and call FlutterSkillBinding.ensureInitialized() in main() under kDebugMode; separate SDK packages exist for React Native, Electron, iOS, Android, Tauri, KMP, and .NET MAUI. 4) Restart the AI client and issue natural-language test instructions, e.g. "launch my app and explore every screen".

claude_desktop_config.json
{"mcpServers":{"flutter-skill":{"command":"flutter-skill","args":["server"]}}}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "flutter-skill": {
      "command": "flutter-skill",
      "args": [
        "server"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add flutter-skill -- flutter-skill server

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

Run `npm install -g flutter-skill`, add the flutter-skill MCP config to your client and restart it, then confirm the `page_summary` and `screenshot` tools appear in the client's tool list. Alternatively run `flutter-skill tools` to list all available tools.

Troubleshooting

  1. Confirm `flutter-skill` is installed globally (`npm install -g flutter-skill` or the equivalent package manager command) and the executable is on PATH
  2. Verify the AI client's MCP config file path and JSON are correct, and restart the client to pick up the change
  3. Confirm the app under test has the correct platform SDK integrated (e.g. Flutter's `FlutterSkillBinding.ensureInitialized()`) and is running in debug mode
  4. Use `flutter-skill tools` to list available tools and `flutter-skill call <tool> [json]` to invoke a tool directly for troubleshooting connectivity
  5. If using HTTP `serve` mode, check whether the port/host is already in use, and adjust via `--port=N`, `--host=H`, or the `FS_PORT`/`FS_HOST` environment variables

Things to try

Once connected, you can ask your AI assistant things like:

  • Launch my app, explore every screen, and report any bugs
  • Test the checkout flow with an empty cart, then add 3 items and complete purchase
  • Fill the registration form with edge cases like emoji and long strings
  • Take a snapshot of the current page and list all buttons

Tools 100

page_summary read-only
Returns a compact semantic summary of the current page/screen (~200 tokens) instead of a screenshot
explore_actions read-only
Batches multiple exploratory actions (fill, tap, etc.) into a single call
boundary_test
Runs boundary/security test payloads against input fields
explore_report read-only
Summarizes findings and issues from an AI autonomous exploration run
launch_app writes
Launches the app under test with a specified flavor
scan_and_connect read-only
Auto-discovers and connects to a running app instance
connect_cdp read-only
Connects to an already-open browser via Chrome DevTools Protocol
hot_reload writes
Triggers a hot reload of the app
Show 92 more tools
hot_restart writes
Triggers a hot restart of the app
list_sessions read-only
Lists all currently connected sessions
switch_session writes
Switches the active connected session
close_session writes
Closes a specific session
disconnect writes
Disconnects from the target app or browser
stop_app writes
Stops the app process under test
screenshot read-only
Captures the current screen or page
screenshot_region read-only
Captures a specific region of the screen
screenshot_element read-only
Captures a screenshot of a single element
native_screenshot read-only
Captures a screenshot using the platform's native mechanism
inspect read-only
Retrieves element information for the current screen/page
inspect_interactive read-only
Lists all tappable/typeable elements with semantic refs
snapshot read-only
Returns an accessibility-tree structural snapshot at far lower token cost than a screenshot
get_widget_tree read-only
Retrieves the full widget/control tree
find_by_type read-only
Finds elements by control type
get_text_content read-only
Reads the text content of an element
get_visible_text read-only
Reads all visible text on the current screen
tap writes
Taps a specified element
double_tap writes
Double-taps a specified element
long_press writes
Long-presses a specified element
enter_text writes
Types text into an input field
set_text writes
Directly sets the text value of an input field
clear_text writes
Clears an input field
swipe writes
Performs a swipe gesture on the screen
scroll_to writes
Scrolls to a specified element or position
drag writes
Performs a drag gesture
go_back writes
Navigates back to the previous screen/page
press_key writes
Presses a key, optionally with a modifier
type_text writes
Types text via the keyboard
hover writes
Hovers the pointer over an element
fill writes
Fills a form field
select_option writes
Selects an option in a dropdown/select control
set_checkbox writes
Sets a checkbox's checked state
focus writes
Gives focus to an element
blur writes
Removes focus from an element
native_tap writes
Taps an element using the platform's native mechanism
native_input_text writes
Enters text using the platform's native mechanism
native_swipe writes
Swipes using the platform's native mechanism
smart_tap writes
Self-healing tap with fuzzy matching, tolerant of UI changes
smart_enter_text writes
Self-healing text entry with fuzzy matching
smart_assert read-only
Self-healing assertion with fuzzy matching
assert_text read-only
Asserts an element's text content
assert_visible read-only
Asserts an element is visible
assert_not_visible read-only
Asserts an element is not visible
assert_element_count read-only
Asserts the number of matching elements
assert_batch read-only
Runs multiple assertions in a single call
wait_for_element read-only
Waits for an element to appear
wait_for_gone read-only
Waits for an element to disappear
wait_for_idle read-only
Waits for the app/page to become idle
wait_for_stable read-only
Waits for the UI to finish rendering and stabilize
wait_for_url read-only
Waits for the page URL to match a condition
wait_for_text read-only
Waits for specified text to appear
wait_for_element_count read-only
Waits for a matching element count
visual_baseline_save writes
Saves a visual regression baseline screenshot
visual_baseline_compare read-only
Compares the current screenshot against the baseline
visual_baseline_update writes
Updates the visual regression baseline
visual_regression_report read-only
Generates a visual regression test report
visual_verify read-only
Verifies the visual appearance of the UI
visual_diff read-only
Computes the diff between two screenshots
compare_screenshot read-only
Compares two screenshots for equality
mock_api writes
Sets a network mock response for a given endpoint
mock_clear writes
Clears configured network mocks
record_network read-only
Records network request traffic
replay_network writes
Replays previously recorded network requests
intercept_requests writes
Intercepts network requests
clear_interceptions writes
Clears configured request interceptions
block_urls writes
Blocks network requests to specified URLs
http_request writes
Sends a raw HTTP request
api_request writes
Sends an API test request
api_assert read-only
Asserts against an API response
coverage_start writes
Starts collecting test coverage
coverage_stop writes
Stops collecting test coverage
coverage_report read-only
Generates a coverage report
coverage_gaps read-only
Identifies uncovered functionality
retry_on_fail writes
Automatically retries a step on failure per a policy
stability_check read-only
Checks whether test results are stable or flaky
test_with_data writes
Runs a test driven by a data set
generate_test_data read-only
Generates test data
multi_connect writes
Connects to multiple devices/instances simultaneously
multi_action writes
Runs the same action synchronously across connected devices
multi_compare read-only
Compares execution results across devices
multi_disconnect writes
Disconnects all multi-device sessions
parallel_snapshot read-only
Captures snapshots across devices in parallel
parallel_tap writes
Taps across multiple devices in parallel
accessibility_audit read-only
Runs an accessibility audit
a11y_full_audit read-only
Runs a full accessibility audit
a11y_tab_order read-only
Checks tab-key traversal order
a11y_color_contrast read-only
Checks whether color contrast meets requirements
a11y_screen_reader read-only
Simulates a screen reader for checks
set_locale writes
Switches the app's language/locale
verify_translations read-only
Verifies translated UI copy
i18n_snapshot read-only
Captures a UI snapshot for a given locale

Use cases

Driving an AI agent with natural language to run end-to-end tests against Flutter/React Native/Web/desktop apps
Letting an AI autonomously explore every screen of an app and report bugs it finds
Boundary-value and edge-case testing of flows like login or checkout
Comparing the same test flow's UI and results across platforms (e.g. iOS vs Android)
Visual regression, accessibility audits, i18n verification, and performance data collection

Supported clients

Claude Desktop
Cursor
Windsurf
VSCode Copilot
Cline
Continue
OpenClawPartial support

Listed from the project's documentation, not tested by this site.

Overview

flutter-skill is an open-source MCP server (npm package flutter-skill, Dart package flutter_skill) that connects AI agents such as Claude, Cursor, Windsurf, and Copilot directly to a running app over the Model Context Protocol. It exposes roughly 253 MCP tools for screenshots, accessibility-tree snapshots, taps, text entry, scrolling, assertions, visual regression, network mocking, coverage tracking, multi-device sync, accessibility audits, performance monitoring, and test recording/export, and claims support for 10 platforms — Flutter, React Native, iOS, Android, Web, Electron, Tauri, KMP, and .NET MAUI. It advertises zero test code and zero configuration, driven purely by natural language, and also ships a separate HTTP serve mode with a CLI client. The repository is MIT-licensed.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

Source revision c31a08ead80e Data synced 2026-10-19 Read the FMRS scoring method