← Back to directory

Flutter Skill

Community

Give any AI agent eyes and hands inside your running app — E2E testing across 10 platforms via MCP

GitHub source repository ↗

★ 360 Stars Category · Dev Tools Very popular Source revision de1a0081c298

54FMRS · D

Reliability

8/20

Security and permissions

7/20

Maintenance

12/20

Documentation

14/20

Setup experience

13/20

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.

Read the FMRS scoring method →

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.

Tools

page_summary

Returns a compact semantic summary of the current page/screen (~200 tokens) instead of a screenshot

explore_actions

Batches multiple exploratory actions (fill, tap, etc.) into a single call

boundary_test

Runs boundary/security test payloads against input fields

explore_report

Summarizes findings and issues from an AI autonomous exploration run

launch_app

Launches the app under test with a specified flavor

scan_and_connect

Auto-discovers and connects to a running app instance

connect_cdp

Connects to an already-open browser via Chrome DevTools Protocol

hot_reload

Triggers a hot reload of the app

hot_restart

Triggers a hot restart of the app

list_sessions

Lists all currently connected sessions

switch_session

Switches the active connected session

close_session

Closes a specific session

disconnect

Disconnects from the target app or browser

stop_app

Stops the app process under test

screenshot

Captures the current screen or page

screenshot_region

Captures a specific region of the screen

screenshot_element

Captures a screenshot of a single element

native_screenshot

Captures a screenshot using the platform's native mechanism

inspect

Retrieves element information for the current screen/page

inspect_interactive

Lists all tappable/typeable elements with semantic refs

snapshot

Returns an accessibility-tree structural snapshot at far lower token cost than a screenshot

get_widget_tree

Retrieves the full widget/control tree

find_by_type

Finds elements by control type

get_text_content

Reads the text content of an element

get_visible_text

Reads all visible text on the current screen

tap

Taps a specified element

double_tap

Double-taps a specified element

long_press

Long-presses a specified element

enter_text

Types text into an input field

set_text

Directly sets the text value of an input field

clear_text

Clears an input field

swipe

Performs a swipe gesture on the screen

scroll_to

Scrolls to a specified element or position

drag

Performs a drag gesture

go_back

Navigates back to the previous screen/page

press_key

Presses a key, optionally with a modifier

type_text

Types text via the keyboard

hover

Hovers the pointer over an element

fill

Fills a form field

select_option

Selects an option in a dropdown/select control

set_checkbox

Sets a checkbox's checked state

focus

Gives focus to an element

blur

Removes focus from an element

native_tap

Taps an element using the platform's native mechanism

native_input_text

Enters text using the platform's native mechanism

native_swipe

Swipes using the platform's native mechanism

smart_tap

Self-healing tap with fuzzy matching, tolerant of UI changes

smart_enter_text

Self-healing text entry with fuzzy matching

smart_assert

Self-healing assertion with fuzzy matching

assert_text

Asserts an element's text content

assert_visible

Asserts an element is visible

assert_not_visible

Asserts an element is not visible

assert_element_count

Asserts the number of matching elements

assert_batch

Runs multiple assertions in a single call

wait_for_element

Waits for an element to appear

wait_for_gone

Waits for an element to disappear

wait_for_idle

Waits for the app/page to become idle

wait_for_stable

Waits for the UI to finish rendering and stabilize

wait_for_url

Waits for the page URL to match a condition

wait_for_text

Waits for specified text to appear

wait_for_element_count

Waits for a matching element count

visual_baseline_save

Saves a visual regression baseline screenshot

visual_baseline_compare

Compares the current screenshot against the baseline

visual_baseline_update

Updates the visual regression baseline

visual_regression_report

Generates a visual regression test report

visual_verify

Verifies the visual appearance of the UI

visual_diff

Computes the diff between two screenshots

compare_screenshot

Compares two screenshots for equality

mock_api

Sets a network mock response for a given endpoint

mock_clear

Clears configured network mocks

record_network

Records network request traffic

replay_network

Replays previously recorded network requests

intercept_requests

Intercepts network requests

clear_interceptions

Clears configured request interceptions

block_urls

Blocks network requests to specified URLs

http_request

Sends a raw HTTP request

api_request

Sends an API test request

api_assert

Asserts against an API response

coverage_start

Starts collecting test coverage

coverage_stop

Stops collecting test coverage

coverage_report

Generates a coverage report

coverage_gaps

Identifies uncovered functionality

retry_on_fail

Automatically retries a step on failure per a policy

stability_check

Checks whether test results are stable or flaky

test_with_data

Runs a test driven by a data set

generate_test_data

Generates test data

multi_connect

Connects to multiple devices/instances simultaneously

multi_action

Runs the same action synchronously across connected devices

multi_compare

Compares execution results across devices

multi_disconnect

Disconnects all multi-device sessions

parallel_snapshot

Captures snapshots across devices in parallel

parallel_tap

Taps across multiple devices in parallel

accessibility_audit

Runs an accessibility audit

a11y_full_audit

Runs a full accessibility audit

a11y_tab_order

Checks tab-key traversal order

a11y_color_contrast

Checks whether color contrast meets requirements

a11y_screen_reader

Simulates a screen reader for checks

set_locale

Switches the app's language/locale

verify_translations

Verifies translated UI copy

i18n_snapshot

Captures a UI snapshot for a given locale

Setup

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"]}}}

Generate and validate client config

Fit and risk

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

Troubleshooting

Confirm `flutter-skill` is installed globally (`npm install -g flutter-skill` or the equivalent package manager command) and the executable is on PATH
Verify the AI client's MCP config file path and JSON are correct, and restart the client to pick up the change
Confirm the app under test has the correct platform SDK integrated (e.g. Flutter's `FlutterSkillBinding.ensureInitialized()`) and is running in debug mode
Use `flutter-skill tools` to list available tools and `flutter-skill call <tool> [json]` to invoke a tool directly for troubleshooting connectivity
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

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 DesktopFull support

CursorFull support

WindsurfFull support

VSCode CopilotFull support

ClineFull support

Continue.devFull support

OpenClawPartial support

Related MCP servers

Compare with other MCP servers