Build High-Performance Flutter Apps

Flutter Expert is a specialist skill for Flutter 3.x and Dart 3.x multi-platform development across mobile, web, desktop and embedded targets. Its capability areas include: core Flutter mastery (widget composition, the Impeller rendering engine replacing Skia, custom render objects, Material Design 3 and Cupertino, accessibility-first widgets); Dart language features (patterns, records, sealed classes, null safety, Future/Stream/Isolate concurrency, FFI for C/C++ integration); state management across Riverpod 2.x, Bloc/Cubit, GetX, Provider, Stacked, MobX and Redux; architecture patterns including Clean Architecture, feature-driven organization, MVVM/MVP/MVI, the repository pattern and dependency injection with GetIt, Injectable or Riverpod; platform integration for iOS (Swift channels), Android (Kotlin channels), web (PWA), desktop and embedded systems; performance work on widget rebuilds, memory profiling with DevTools, image caching, Sliver-based list virtualization and isolate offloading; UI/UX with AnimationController, Hero transitions, Rive/Lottie and custom painters; testing with mockito, testWidgets, golden files, and Patrol integration tests; data persistence with SQLite, Hive, ObjectBox and Drift; DevOps with Codemagic, GitHub Actions and Bitrise; and security work including certificate pinning, local_auth biometrics and code obfuscation.

Its bundled resources/implementation-playbook.md gives concrete, adaptable patterns for Flutter 3.x/Dart 3.x with null safety, all under a feature-first, clean-layered lib/ structure (core/, features/<feature>/{data,domain,presentation}) where domain imports nothing from Flutter and stays testable without a widget tree. It recommends Riverpod 2.x with code generation as the default state-management choice, wrapping repository calls in AsyncValue.guard and rendering the UI's loading, error and data states explicitly rather than assuming data is ready. Network errors are mapped to a typed sealed Failure class in the repository layer so the UI never handles a raw DioException. For performance, it recommends const constructors wherever inputs are compile-time constants so Flutter can skip rebuilds entirely, illustrated with a good/bad pair:

// Good: const stops this subtree from rebuilding on parent changes.
const _Header(title: 'Products');

// Bad: rebuilding a giant Column holds every child in memory.
Column(children: products.map(ProductTile.new).toList());

It also covers ListView.builder/Slivers for long lists instead of mapping into a Column, profiling with Flutter DevTools' rebuild-count overlay, widget and golden-file testing (flutter test --update-goldens to create a baseline PNG committed for CI regression checks), and offloading CPU-bound work such as large JSON parsing to a background isolate with compute() rather than blocking the UI isolate.

Four recurring problems, with fixes: a setState call after dispose throws a mounted exception, fixed by guarding with if (!mounted) return; after any await; rebuilding the whole screen on every keystroke, fixed by isolating the changing widget or using a select on the provider; memory leaks from uncancelled StreamSubscriptions or controllers, fixed by canceling in dispose() or, with Riverpod, ref.onDispose; and blocking the UI thread with synchronous file or JSON work, fixed by moving it to an isolate via compute. Its pre-ship checklist covers a clean flutter analyze, passing flutter test including golden tests, const and builder/sliver usage, handled loading/error/empty states, disposed controllers and subscriptions, testing on a real iOS and Android device, and accessibility semantic labels with adequate contrast.

Use it for architecting a Flutter app with clean architecture and Riverpod, implementing complex animations, building responsive layouts across mobile/tablet/desktop, optimizing Flutter web for production, integrating native iOS/Android features through platform channels, setting up golden-file testing, implementing offline-first sync, or building accessible Material Design 3 widgets. Do not use it for tasks unrelated to Flutter expert work, or when a different domain or tool fits better. The rule is to always use null safety with Dart 3 features and include comprehensive error handling, loading states and accessibility annotations.

Output includes platform-optimized Dart/Flutter code (controllers, repositories, widgets), a recommended state-management approach chosen for the task's complexity, comprehensive test coverage (unit, widget and golden), and deployment guidance across app stores.

Named integrations include Riverpod, Bloc, GetX, Dio, Firebase, AWS and Google Cloud for backend/storage, GraphQL via Ferry or Artemis, TensorFlow Lite, ARCore/ARKit, and CI/CD via Codemagic, GitHub Actions or Bitrise.

It suits Flutter developers building or reviewing production multi-platform apps who need architecture guidance, a concrete state-management pattern, performance-aware widget code, and a real testing and deployment path rather than a toy example.