Flutter Expert

flutter core rules

When reviewing or writing code, apply these guidelines:

• Adapt to existing project architecture while maintaining clean code principles.
• Use Flutter 3.x features and Material 3 design.
• Implement proper null safety practices.
• Follow proper naming conventions.
• Use proper widget composition.
• Keep widgets small and focused.
• Use const constructors when possible.
• Implement proper widget keys.
• Follow proper layout principles.

flutter feature rules

When reviewing or writing code, apply these guidelines:

• Adapt to existing project architecture while maintaining clean code principles.
• Use Flutter 3.x features and Material 3 design.
• Implement clean architecture with BLoC pattern.
• Follow proper state management principles.
• Use proper dependency injection.
• Implement proper error handling.
• Follow proper state management with BLoC.
• Implement proper dependency injection using GetIt.

flutter general best practices

When reviewing or writing code, apply these guidelines:

• Adapt to existing project architecture while maintaining clean code principles.
• Use Flutter 3.x features and Material 3 design.
• Implement clean architecture with BLoC pattern.
• Follow proper state management principles.
• Use proper dependency injection.
• Implement proper error handling.
• Follow platform-specific design guidelines.
• Use proper localization techniques.

flutter performance rules

When reviewing or writing code, apply these guidelines:

• Use proper image caching.
• Implement proper list view optimization.
• Use proper build methods optimization.
• Follow proper state management patterns.
• Implement proper memory management.
• Use proper platform channels when needed.
• Follow proper compilation optimization techniques.

flutter presentation rules

When reviewing or writing code, apply these guidelines:

• Adapt to existing project architecture while maintaining clean code principles.
• Use Flutter 3.x features and

Consolidated Skills

This expert skill consolidates 1 individual skills:

• flutter-expert

Iron Laws

1. ALWAYS use const constructors for widgets that don't depend on mutable state — non-const widgets rebuild on every parent rebuild, causing unnecessary repaints and dropped frames.
2. NEVER perform async operations directly in build() — async calls in build() fire on every rebuild, causing duplicate network requests, race conditions, and unpredictable UI state.
3. ALWAYS separate business logic from UI using BLoC, Riverpod, or an equivalent state management pattern — mixing logic in widgets makes code untestable and tightly coupled to the widget tree.
4. NEVER use setState for shared state that spans multiple widgets — setState only rebuilds the local widget subtree; shared state must be lifted to a state management layer.
5. ALWAYS implement null safety fully (no ! force-unwraps on user or network data) — unchecked null dereferences crash the app at runtime with no error boundary.

Anti-Patterns

Anti-Pattern	Why It Fails	Correct Approach
Non-const stateless widgets	Rebuilt on every parent setState; wastes frame budget	Add const to all stateless widget constructors and their instantiation
Calling Future in build()	Re-fires on every rebuild; duplicates API calls and causes flickering	Use FutureBuilder with a stored Future field initialized in initState
Business logic in widgets	Untestable; coupled to widget lifecycle; duplicated across screens	Move logic to BLoC/Cubit or Riverpod providers; widgets observe state only
setState for cross-widget state	Only rebuilds local subtree; sibling widgets stay stale	Use InheritedWidget, Provider, or BLoC streams for shared state
Force-unwrapping nullable API data	Runtime null crash with no recovery path	Use null-aware operators (?., ??) and handle null states explicitly in UI

Memory Protocol (MANDATORY)

Before starting:

cat .claude/context/memory/learnings.md

After completing: Record any new patterns or exceptions discovered.

ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.