Skills Flutter

Instructions for adding a new validation rule and CLI flag to dart_skills_lint.

Use this skill when the user asks to create a new CatalogItem, data class, and/or widget class based on a JSON Schema definition in an application that uses…

Prefer using multi-line strings ( ''' ) over concatenating strings with + and \n , especially for large blocks of text like SQL queries, HTML, or PEM-encoded keys. This improves readability and avoids lines_longer_than_80_chars lint errors by allowing natural line breaks.

To find candidates for migration, use the following search strategies:

Keep the contents of your entrypoint file (e.g., bin/my_app.dart ) minimal. This improves testability by decoupling logic from the process runner.

To find documentation issues:

Parse failures from Dart and Flutter test logs.

To find lines that exceed the limit:

To find candidates for improving matcher usage, search for suboptimal patterns:

To find candidates for modernization:

Guidelines for maintaining Dart packages in alignment with Dart team best practices.

Use the dart_skills_lint CLI to validate skills. Choose the appropriate workflow based on your environment:

Guidelines for running and interpreting test coverage in Dart packages.

To find candidates for improving test structure:

Mandatory checks to run before completing any task that touches md files or dart code in this repository.

A skill to find the lowest Dart and Flutter release containing a given commit. Use this skill whenever users ask about when a commit landed in Flutter or Dart…

Implement WCAG 2 and EN 301 549 accessibility standards and adaptive layouts in Flutter apps. Enforces semantic annotations, tap target sizes (48x48 dp minimum), and text contrast ratios (4.5:1 for small text, 3:1 for large) across mobile, web, and desktop platforms Provides decision logic for web semantics initialization, interactive widget wrapping, screen-size-based layout switching, and keyboard/mouse input handling Includes focus traversal management via FocusTraversalGroup and...

Triggers an accessibility scan through the widget_inspector and automatically adds Semantics widgets or missing labels to the source code.

Configures Flutter Driver for app interaction and converts MCP actions into permanent integration tests. Use when adding integration testing to a project,…

Adds interactive widget previews to the project using the previews.dart system. Use when creating new UI components or updating existing screens to ensure…

Implement a component-level test using `WidgetTester` to verify UI rendering and user interactions (tapping, scrolling, entering text). Use when validating…

Add home screen widgets to Flutter apps for Android and iOS with native UI and shared data synchronization. Flutter communicates with native widgets via shared local storage (UserDefaults on iOS, SharedPreferences on Android) using the home_widget package; data flows from Flutter writes to native widget reads on OS trigger. iOS implementation uses Xcode, SwiftUI, and Widget Extension targets with App Groups capability; Android uses Android Studio with AppWidgetProvider, XML layouts, and...

Visual feedback, transitions, and physics-based motion for Flutter apps using the Animation framework. Four animation strategies: implicit animations for simple property changes, explicit animations with playback control, Hero transitions for shared elements between routes, and physics-based animations for gesture-driven natural motion Core typed Animation system with AnimationController , Tween , and Curve classes; always dispose controllers to prevent memory leaks Staggered animations...

Select and implement the optimal Flutter animation strategy for your UI requirement. Includes a decision tree to choose between implicit animations, explicit tweens, physics-based motion, hero transitions, staggered sequences, and page route transitions Provides complete code examples for each animation type, from simple AnimatedContainer to complex staggered multi-tween setups Enforces strict memory management with mandatory AnimationController disposal and performance best practices using...

Measure and optimize Flutter app bundle, APK, or IPA size with platform-specific analysis and reduction strategies. Supports Android (APK/AppBundle), iOS (IPA), and desktop platforms (Linux, macOS, Windows) with platform-specific measurement workflows Generates code size analysis JSON files via flutter build --analyze-size and integrates with Dart DevTools App Size Tool for component breakdown visualization Implements size reduction through debug info splitting, asset compression, and...

Architects a Flutter application using the recommended layered approach (UI, Logic, Data). Use when structuring a new project or refactoring for scalability.

Layered architecture framework for scalable Flutter apps with strict separation of concerns. Enforces three-layer structure (UI, Logic, Data) with unidirectional data flow and a single source of truth in the Data layer UI layer contains lean Views and ViewModels that transform domain models into presentation state; Logic layer (optional) handles complex business orchestration; Data layer divides strictly into stateless Services and caching Repositories Provides step-by-step feature...

MVVM architecture for Flutter apps with unidirectional data flow and strict layer separation. Implements three-layer architecture: Data Layer (Services and Repositories), Domain Layer (UseCases for complex logic), and UI Layer (ViewModels and Views) Uses provider for dependency injection and ListenableBuilder for reactive UI updates with the Command pattern for user interactions Enforces unidirectional data flow: data flows down from Repositories to ViewModels to Views; events flow up...

Use `LayoutBuilder`, `MediaQuery`, or `Expanded/Flexible` to create a layout that adapts to different screen sizes. Use when you need the UI to look good on…

Validated Flutter forms with field-level error handling and submission workflows. Requires StatefulWidget hosting with a persistent GlobalKey<FormState> to manage form state and validation across rebuilds Use TextFormField widgets with validator() callbacks that return error strings on failure or null on success Call _formKey.currentState!.validate() on submit to trigger all validators and automatically display error messages below fields Includes complete code example demonstrating username...

Master Flutter's constraint system to build responsive, overflow-free layouts efficiently. Core principle: constraints flow down, sizes flow up, parents set position. Never pass unbounded constraints in flex boxes or scrollable regions. Use Row / Column for linear layouts, Expanded / Flexible for space distribution, Stack for overlapping elements, and SizedBox for tight constraints. Apply LayoutBuilder for responsive sizing or conditional rendering for adaptive layouts across mobile, tablet,...

Scaffold and implement cross-platform Flutter plugins with native interop for Android, iOS, Windows, and web. Supports both standard plugins (Method Channels for platform APIs) and FFI plugins (C/C++ native libraries); choose based on whether you need platform-specific SDK access or direct native code binding Federated plugin architecture splits API across app-facing, platform interface, and independent platform implementation packages for team-based development Includes step-by-step...

Comprehensive caching and performance optimization for Flutter apps across multiple data types and platforms. Provides decision logic to select appropriate caching mechanisms: in-memory, shared_preferences for key-value pairs, SQLite for relational data, file system for large blobs, and image caching for network images Includes stream-based offline-first repository pattern that yields cached data first, then fetches and updates from the network Covers Android FlutterEngine pre-warming and...

Local data caching and offline-first synchronization patterns for Flutter apps. Covers five caching strategies: shared_preferences for UI state, SQLite/Hive for structured data, file system for binary media, state restoration for navigation, and FlutterEngine pre-warming on Android Implements offline-first repositories using streams for reads (yield local, fetch remote, update cache) and dual write strategies (online-only vs. offline-first with background sync) Optimizes image caching with...

Background JSON parsing and state management for jank-free Flutter UI rendering. Provides decision tree for choosing between manual serialization ( dart:convert ) and code generation ( json_serializable ) based on model complexity Supports three concurrency strategies: main-thread async/await for small payloads, short-lived Isolate.run() for heavy one-off computations, and long-lived isolates with ReceivePort / SendPort for continuous two-way communication Includes platform-aware fallback:...

MVVM-compliant data layer for Flutter with Repository pattern, stateless Services, and intelligent local caching strategies. Guides selection of persistence technology (shared_preferences, sqflite, drift, hive_ce, isar_community, or file I/O) based on data type, size, and relational complexity Implements Repository as single source of truth, isolating DatabaseService and ApiClient as private stateless dependencies Provides complete code examples for domain models, SQLite operations, and...

Embed native Android, iOS, or macOS views and web content directly into Flutter applications. Supports two Android composition modes (Hybrid and Texture Layer) with distinct performance and fidelity tradeoffs; iOS and macOS use Hybrid Composition exclusively Includes step-by-step workflows for implementing platform views on Android and iOS, with validation and troubleshooting guidance Enables embedding Flutter into existing web applications via Full Page or Multi-view (Embedded) mode, with...

Linux environment setup for Flutter desktop development with OS detection and toolchain validation. Automatically detects Debian/Ubuntu or ChromeOS and halts with instructions for non-apt systems Installs core dependencies (curl, git, unzip, libglu1-mesa) and Linux desktop toolchain (clang, cmake, ninja-build, GTK libraries) Prompts for optional IDE setup (VS Code or Android Studio via snap) Runs flutter doctor -v and flutter devices to validate the environment, automatically installing...

Automated macOS Flutter development environment setup with dependency validation and diagnostic fixes. Verifies Flutter installation, Xcode availability, and CocoaPods presence; stops with clear instructions if any prerequisite is missing Guides users through Xcode command-line tool configuration and license acceptance with required sudo commands Runs iterative flutter doctor validation loops to identify and resolve remaining toolchain issues until the Xcode section passes completely...

Automated Windows Flutter development environment setup with platform-specific toolchain configuration. Configures Flutter SDK paths, Visual Studio C++ toolchain installation, and platform-specific settings via interactive prompts for Windows Desktop, Android, or both targets Handles Android Studio setup, device/emulator configuration, and USB driver installation when Android is selected Generates self-signed MSIX certificates using OpenSSL for local Windows app packaging and deployment...

Fixes Flutter layout errors (overflows, unbounded constraints) using Dart and Flutter MCP tools. Use when addressing "RenderFlex overflowed", "Vertical…

Build a form with validation

Offload CPU-intensive tasks to background isolates while keeping Flutter UIs responsive. Provides three concurrency patterns: async / await for I/O-bound work, Isolate.run() for one-off heavy computations, and Isolate.spawn() with message passing for persistent background workers Includes a decision matrix to choose between async operations and isolates based on task type (I/O vs. CPU-bound) and execution frequency Covers three complete workflows with step-by-step task checklists: standard...

HTTP requests and JSON serialization for Flutter REST API integration and data parsing. Covers three HTTP methods (GET, POST, PUT, DELETE) with proper status code validation, HTTPS enforcement, and safe URI construction using Uri.https() . Offers two serialization strategies: manual fromJson / toJson for simple models, and code generation with json_serializable for complex nested structures. Includes background parsing with compute() to prevent UI jank when processing large JSON payloads...

Native home screen widgets for Flutter apps on iOS and Android with cross-platform data sharing. Establishes data sharing between Dart and native platforms via App Groups (iOS) and SharedPreferences (Android), enabling widget updates from your Flutter app Supports simple text-based widgets and complex Flutter UI rendered as static images for native display Requires native setup in Xcode (Widget Extension target with Swift TimelineProvider) and Android Studio (AppWidgetProvider with XML...

Secure HTTP networking and JSON handling for Flutter apps with background parsing support. Implements CRUD operations (GET, POST, PUT, DELETE) using the http package with safe URL construction via Uri.https() and strict status code validation Provides strongly typed JSON serialization and deserialization using Dart 3 pattern matching with factory constructors and toJson() methods Offloads large JSON parsing to background isolates via compute() to prevent UI jank on payloads exceeding 16ms...

Create model classes with `fromJson` and `toJson` methods using `dart:convert`. Use when manually mapping JSON keys to class properties for simple data…

Imperative and declarative routing patterns for Flutter screen transitions and deep linking. Covers both Navigator (imperative, stack-based) and Router (declarative, URL-synchronized) approaches with guidance on when to use each Supports deep linking on iOS, Android, and Web; includes data passing via constructors, route arguments, and return values Implements nested navigation for multi-step flows (e.g., setup wizards) with independent sub-navigators and back-button interception Provides...

Configure Flutter apps for assistive technologies including screen readers and keyboard navigation. Covers UI design fundamentals: font scaling, color contrast (4.5:1 for normal text, 3:1 for large), and 48x48 pixel minimum tap targets Provides semantic annotation patterns using Semantics , MergeSemantics , and ExcludeSemantics widgets to expose widget tree structure to assistive tools Includes web-specific guidance on enabling the semantics layer (disabled by default for performance) and...

Access device-specific native APIs on Android, iOS, and web from Flutter code. Supports three integration approaches: FFI for direct C/C++ binding, Platform Channels (with Pigeon for type safety) for calling Kotlin/Swift/Objective-C, and Platform Views for embedding native UI components FFI uses dart:ffi with automatic build compilation via build.dart hooks; requires extern "C" symbols and package:ffigen for Dart binding generation Platform Channels provide asynchronous messaging between...

Build responsive Flutter layouts by composing widgets, managing constraints, and adapting to screen sizes. Provides a decision tree for selecting the right base layout widget (Row, Column, Stack, ListView, GridView, CustomScrollView) based on content dimensionality, overlap, scrolling, and responsiveness needs Enforces Flutter's core constraint system: constraints flow down, sizes flow up, parents set position; includes ConstrainedBox patterns for forcing specific dimensions Implements...

Configure Flutter apps to support multiple languages and locales with proper i18n setup. Manages dependency injection ( flutter_localizations , intl ), code generation configuration ( l10n.yaml ), and .arb translation file creation with support for placeholders, plurals, and regional variants Configures root widget delegates ( MaterialApp , CupertinoApp , or WidgetsApp ) and handles isolated widgets like TextField and CupertinoTabBar that require explicit Localizations wrapping Supports...

Multi-language support for Flutter apps using ARB files and code generation. Configure pubspec.yaml with flutter_localizations and intl , then define an l10n.yaml file to enable the gen-l10n code generator Store localized strings in Application Resource Bundle ( .arb ) JSON files; the template file defines all keys, and locale-specific files provide translations Integrate localizations into MaterialApp or CupertinoApp by adding AppLocalizations.delegate and platform-specific delegates to...

Manage ephemeral and app-level state in Flutter using StatefulWidget, MVVM, and Provider. Distinguishes between ephemeral state (single widget, managed with setState() ) and app state (shared across widgets, managed with MVVM and provider package) Implements unidirectional data flow with a single source of truth: Models handle data, ViewModels manage UI state via ChangeNotifier , Views consume and display state Provides sequential workflow for MVVM implementation: define Repository, create...

Cross-platform native interoperability for Flutter apps on Android, iOS, and Web. Provides decision logic to select the optimal integration strategy: FFI for C/C++ code, Platform Channels for OS-specific APIs, Platform Views for native UI components, and JS Interop for web Implements modern FFI architecture using build hooks (Flutter 3.38+) with native toolchain compilation and Dart bindings Supports asynchronous Platform Channels (MethodChannel) with complete Kotlin and Swift...

Identifies and eliminates performance bottlenecks in Flutter apps through systematic profiling and targeted optimization. Provides a decision tree to diagnose jank on UI thread, Raster (GPU) thread, or both, with specific fixes for each Includes integration test templates using traceAction and TimelineSummary to establish performance baselines and measure frame budgets Covers UI optimization (localizing state, const constructors, StringBuffer usage) and Raster optimization (replacing Opacity...

Embed native views and web content into Flutter apps across Android, iOS, macOS, and web platforms. Supports Android Hybrid Composition (native fidelity) and Texture Layer (Flutter performance), iOS/macOS Hybrid Composition, and web full-page or embedded multi-view modes Provides complete Dart and native code templates (Kotlin for Android, Swift for iOS/macOS, JavaScript for web) with factory registration patterns Requires decision tree upfront to determine target platform and embedding...

Scaffolds Flutter plugins with native interop, method channels, FFI integration, and federated architectures. Generates standard plugins, FFI plugins, or federated multi-package architectures based on native code requirements and team structure Configures Android v2 embedding lifecycle interfaces, platform-specific native environments (Kotlin/Java, Swift/Objective-C), and method channel registration Implements package-separated federated plugins with app-facing and platform-specific...

Find failing checks on a Flutter PR and locate the corresponding LUCI log URLs.

Measure and optimize Flutter app bundle size across platforms with analysis tools and reduction strategies. Generates detailed size analysis JSON files via --analyze-size flag to identify large packages, libraries, and assets contributing to bloat Visualize and compare builds using DevTools app size tool with treemap inspection and diff functionality to track optimization progress Supports Android (APK/AAB), iOS, and desktop platforms with platform-specific workflows, including iOS app...

Navigate between screens, handle deep linking, and manage data passing in Flutter applications. Evaluates app requirements to select the optimal routing strategy: imperative Navigator for simple flows, declarative Router / go_router for deep linking and web support, or nested Navigator for independent sub-flows Supports data passing between routes via constructor arguments (preferred) or RouteSettings with type-safe argument extraction Implements named routes with MaterialApp.routes or...

Automates Linux environment setup for Flutter desktop development with dependency installation and validation workflows. Covers three core workflows: installing system dependencies (build tools, GTK libraries, C/C++ toolchain), validating the environment with flutter doctor , and preparing Snap packages for distribution Provides ready-to-run commands for Debian/Ubuntu systems and includes conditional setup for ChromeOS Linux containers Includes a baseline snapcraft.yaml template for...

Automated macOS environment configuration for Flutter development with Xcode and CocoaPods setup. Guides installation and linking of Xcode command-line tools, acceptance of developer licenses, and CocoaPods dependency management Includes validation workflow using flutter doctor and flutter devices to confirm proper environment setup and macOS desktop recognition Provides troubleshooting steps for common issues including missing command-line tools, CocoaPods path problems, and desktop support...

Automated Windows environment setup for Flutter development with SDK, tooling, and platform configuration. Guides SDK installation, PATH configuration, and dependency validation via flutter doctor Covers Visual Studio C++ workload setup for Windows desktop compilation and Android emulator/device configuration Includes workflows for building release binaries, packaging distributable archives with required DLLs, and generating self-signed certificates for MSIX deployment Provides step-by-step...

Configure `MaterialApp.router` using a package like `go_router` for advanced URL-based navigation. Use when developing web applications or mobile apps that…

Add `flutter_localizations` and `intl` dependencies, enable "generate true" in `pubspec.yaml`, and create an `l10n.yaml` configuration file. Use when…

Implement MVVM and Unidirectional Data Flow patterns for Flutter state management. Provides decision logic to differentiate between ephemeral state (local UI state via setState ) and app state (shared state via MVVM and provider package) Enforces strict separation of concerns: data layer (Repository as Single Source of Truth), logic layer (ViewModel extending ChangeNotifier ), and UI layer (pure functions of immutable state) Includes complete code examples for implementing the MVVM pattern...

Generates unit, widget, integration, and plugin tests for Flutter applications with architectural awareness. Analyzes target code to determine appropriate test type (unit for logic, widget for UI, integration for end-to-end, plugin for native code) Provides decision tree and step-by-step implementation patterns for each test category, including fake/mock setup and assertion strategies Includes ready-to-use code templates for ViewModels, Repositories, widgets, and full app flows with proper...

Comprehensive testing framework for Flutter apps across unit, widget, and integration test layers. Covers three test categories: unit tests for isolated logic, widget tests for UI components, and integration tests for end-to-end flows on real devices or emulators Provides architectural testing patterns for ViewModels, Repositories, Services, and Views, with emphasis on Fake implementations over mocks for cleaner test design Includes plugin testing guidelines combining Dart tests with native...

Migrate Flutter apps from Material 2 to Material 3 with automated component and theme updates. Identifies and replaces deprecated Material 2 components (FlatButton, RaisedButton, BottomNavigationBar, Drawer) with their Material 3 equivalents using a decision tree Converts legacy theme properties to Material 3 ColorScheme and removes deprecated accent color references (accentColor, accentColorBrightness, etc.) Normalizes all component themes to use *ThemeData classes and ensures useMaterial3:...

Global styling and adaptive design patterns for Flutter apps using Material 3 theming. Covers Material 3 color schemes, typography, elevation, and modern component replacements (NavigationBar, FilledButton, SegmentedButton) Includes component theme normalization using *ThemeData classes and deprecation guidance for legacy properties like accentColor and AppBarTheme.color Provides platform-specific adaptive patterns: scrollbar visibility, selectable text, button order (Windows vs....

Use the `http` package to execute GET, POST, PUT, or DELETE requests. Use when you need to fetch from or send data to a REST API.

SQLite and offline-first data layer architecture for Flutter apps with structured local persistence. Separates data layer into stateless Services (raw data wrappers) and business-logic Repositories (single source of truth per domain entity) Implements offline-first synchronization: reads yield cached local data immediately then fetch remote updates; writes save locally first, then attempt API sync with background queue fallback Covers SQLite setup with safe parameterized queries, Domain...

This skill provides workflows and best practices specific to the genui repository.

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to…

Use this skill when the user asks to integrate the genui package and get a simple conversation going with Firebase AI Logic.

Proofreads Markdown files against Google guidelines.

Rebuilds the Flutter tool and CLI. Use when a user asks to compile, update, regenerate, or rebuild the Flutter tool or CLI.

Before committing changes or reviewing a PR locally, it is important to stage the site and ensure everything works correctly. Follow these steps to stage the site:

Use when implementing any feature or bugfix, before writing implementation code

Update and maintain the llms.txt file. Use when the user wants to add sections, add links, correct information, or review the llms.txt file.

Upgrade browser versions (Chrome or Firefox) in the Flutter Web Engine and/or Framework tests. Use when asked to roll or upgrade Chrome or Firefox to a newer…

Ensure that any changed code excerpts are properly run and synced to the Markdown files: