Agent skill

flutter-enterprise

Lightweight Flutter enterprise development skill focused on feature-based clean architecture. Use when user asks to: (1) Build enterprise Flutter apps with clean architecture, (2) Implement feature-based modular structure, (3) Set up scalable Flutter project organization, (4) Create maintainable enterprise codebase. Triggers: Flutter enterprise app, clean architecture Flutter, feature-based Flutter, enterprise Flutter structure, modular Flutter architecture

View SKILL.md on GitHub Repository
Stars 1
Forks 0

Install this agent skill to your Project

npx add-skill https://github.com/ajianaz/skills-collection/tree/main/skills/flutter-enterprise

SKILL.md

Flutter Enterprise - Feature-Based Clean Architecture

Lightweight Flutter development skill for building enterprise applications using feature-based clean architecture patterns.

Core Philosophy

"Feature-first, testable, maintainable enterprise code" - Focus on:

Priority Area Purpose
1 Feature-Based Structure Modular, scalable code organization
2 Clean Architecture Separation of concerns and testability
3 Dependency Injection Loose coupling and maintainability
4 Enterprise Patterns Proven enterprise development practices
5 Code Generation Boilerplate reduction and consistency

Development Workflow

Execute phases sequentially. Complete each before proceeding.

Phase 1: Analyze Requirements

  1. Feature identification - Identify distinct business features
  2. Data flow analysis - Map data dependencies between features
  3. Integration points - Define external service integrations
  4. Scalability requirements - Plan for future feature additions

Output: Feature breakdown with dependency mapping.

Phase 2: Design Feature Architecture

  1. Feature boundary definition - Define clear feature boundaries
  2. Data layer planning - Design repositories and data sources
  3. Domain modeling - Create entities and use cases
  4. Presentation layer design - Plan UI components and state management

Output: Feature architecture diagram and data contracts.

Phase 3: Implement Core Structure

  1. Project setup - Create feature-based directory structure
  2. Dependency injection - Set up service locator or DI container
  3. Core utilities - Create shared utilities and constants
  4. Navigation setup - Implement routing structure

Feature Structure Pattern:

lib/
├── core/
│   ├── constants/
│   ├── errors/
│   ├── network/
│   ├── utils/
│   └── widgets/
├── features/
│   ├── feature_name/
│   │   ├── data/
│   │   │   ├── datasources/
│   │   │   ├── models/
│   │   │   └── repositories/
│   │   ├── domain/
│   │   │   ├── entities/
│   │   │   ├── repositories/
│   │   │   └── usecases/
│   │   └── presentation/
│   │       ├── pages/
│   │       ├── widgets/
│   │       └── providers/
│   └── ...
└── main.dart

Phase 4: Implement Feature Modules

  1. Data layer - Implement repositories and data sources
  2. Domain layer - Create business logic and use cases
  3. Presentation layer - Build UI components and state management
  4. Feature integration - Connect feature to main app

Clean Architecture Implementation:

dart
// Domain Layer - Entity
class User {
  final String id;
  final String name;
  final String email;

  User({required this.id, required this.name, required this.email});
}

// Domain Layer - Repository (Abstract)
abstract class UserRepository {
  Future<List<User>> getUsers();
  Future<User> getUserById(String id);
}

// Domain Layer - Use Case
class GetUsersUseCase {
  final UserRepository repository;

  GetUsersUseCase(this.repository);

  Future<List<User>> call() async {
    return await repository.getUsers();
  }
}

// Data Layer - Repository Implementation
class UserRepositoryImpl implements UserRepository {
  final RemoteDataSource remoteDataSource;

  UserRepositoryImpl(this.remoteDataSource);

  @override
  Future<List<User>> getUsers() async {
    final userModels = await remoteDataSource.getUsers();
    return userModels.map((model) => model.toEntity()).toList();
  }
}

Phase 5: Setup Testing Structure

  1. Unit tests - Test domain layer and use cases
  2. Integration tests - Test data layer and repositories
  3. Widget tests - Test presentation layer components
  4. Test utilities - Create mock objects and test helpers

Quick Reference

Feature-Based Architecture Patterns

Layer Responsibility Key Components
Presentation UI and State Management Pages, Widgets, Providers/Bloc
Domain Business Logic Entities, Use Cases, Repository Interfaces
Data Data Implementation Models, Data Sources, Repository Implementations

Dependency Injection Setup

dart
// main.dart
void main() {
  // Initialize dependencies
  final serviceLocator = GetIt.instance;

  // Data sources
  serviceLocator.registerLazySingleton<RemoteDataSource>(
    () => RemoteDataSourceImpl(httpClient: serviceLocator()));

  // Repositories
  serviceLocator.registerLazySingleton<UserRepository>(
    () => UserRepositoryImpl(serviceLocator()));

  // Use cases
  serviceLocator.registerFactory<GetUsersUseCase>(
    () => GetUsersUseCase(serviceLocator()));

  runApp(MyApp());
}

State Management Patterns

This skill now supports state management neutrality with equivalent implementations for all four major approaches:

Provider Pattern

dart
// Presentation Layer - Provider
class UserProvider extends ChangeNotifier {
  final GetUsersUseCase getUsersUseCase;

  List<User> _users = [];
  bool _isLoading = false;

  UserProvider({required this.getUsersUseCase});

  List<User> get users => _users;
  bool get isLoading => _isLoading;

  Future<void> loadUsers() async {
    _isLoading = true;
    notifyListeners();

    try {
      _users = await getUsersUseCase();
    } catch (e) {
      // Handle error
    } finally {
      _isLoading = false;
      notifyListeners();
    }
  }
}

Bloc Pattern

dart
// Presentation Layer - Bloc
abstract class UserEvent extends Equatable {}
class LoadUsers extends UserEvent {}

abstract class UserState extends Equatable {}
class UserLoading extends UserState {}
class UserLoaded extends UserState {
  final List<User> users;
  UserLoaded(this.users);
  @override
  List<Object> get props => [users];
}

class UserBloc extends Bloc<UserEvent, UserState> {
  final GetUsersUseCase getUsersUseCase;

  UserBloc({required this.getUsersUseCase}) : super(UserInitial()) {
    on<LoadUsers>(_onLoadUsers);
  }

  Future<void> _onLoadUsers(LoadUsers event, Emitter<UserState> emit) async {
    emit(UserLoading());
    try {
      final users = await getUsersUseCase();
      emit(UserLoaded(users));
    } catch (e) {
      // Handle error
    }
  }
}

Riverpod Pattern

dart
// Presentation Layer - Riverpod
class UserNotifier extends StateNotifier<AsyncValue<List<User>>> {
  final GetUsersUseCase getUsersUseCase;

  UserNotifier({required this.getUsersUseCase}) : super(const AsyncValue.loading());

  Future<void> loadUsers() async {
    state = const AsyncValue.loading();
    try {
      final users = await getUsersUseCase();
      state = AsyncValue.data(users);
    } catch (e, stackTrace) {
      state = AsyncValue.error(e, stackTrace);
    }
  }
}

final userProvider = StateNotifierProvider<UserNotifier, AsyncValue<List<User>>>((ref) {
  return UserNotifier(getUsersUseCase: ref.watch(getUsersUseCaseProvider));
});

GetX Pattern

dart
// Presentation Layer - GetX
class UserController extends GetxController {
  final GetUsersUseCase getUsersUseCase;

  UserController({required this.getUsersUseCase});

  final RxList<User> _users = <User>[].obs;
  final RxBool _isLoading = false.obs;

  List<User> get users => _users;
  bool get isLoading => _isLoading.value;

  Future<void> loadUsers() async {
    _isLoading.value = true;
    try {
      final userList = await getUsersUseCase();
      _users.assignAll(userList);
    } catch (e) {
      // Handle error
    } finally {
      _isLoading.value = false;
    }
  }
}

// Page Example with GetX
class UserListPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GetBuilder<UserController>(
      init: UserController(getUsersUseCase: Get.find()),
      builder: (controller) {
        return Scaffold(
          appBar: AppBar(title: Text('Users')),
          body: Obx(() {
            if (controller.isLoading.value) {
              return Center(child: CircularProgressIndicator());
            }

            return ListView.builder(
              itemCount: controller.users.length,
              itemBuilder: (context, index) {
                final user = controller.users[index];
                return UserTile(user: user);
              },
            );
          }),
        );
      },
    );
  }
}

Resources

  • Architecture patterns: See references/clean-architecture.md
  • Feature templates: See references/feature-templates.md
  • Testing patterns: See references/testing-patterns.md
  • Code generation: See references/code-generation.md

Technical Stack

  • Architecture: Clean Architecture with feature-based structure
  • State Management: Provider/Bloc/Riverpod/GetX (state management neutral - all four approaches fully supported with equivalent examples)
  • Dependency Injection: GetIt/Injectable
  • Code Generation: build_runner, json_annotation, freezed
  • Testing: mockito, bloc_test, widget testing

Best Practices

  • Feature Independence: Each feature should be self-contained
  • Dependency Rule: Dependencies point inward (Presentation → Domain ← Data)
  • Interface Segregation: Keep interfaces small and focused
  • Single Responsibility: Each class has one reason to change
  • Test Coverage: Aim for 80%+ coverage on domain and data layers

This Flutter enterprise skill transforms complex enterprise app development into a systematic process that ensures maintainable, scalable, and testable applications using feature-based clean architecture.

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

ajianaz/skills-collection

task-planner

Generate structured task lists from specs or requirements. IMPORTANT: After completing ANY spec via ExitSpecMode, ALWAYS ask the user: "Would you like me to generate a task list for this spec?" Use when user confirms or explicitly requests task generation from a plan/spec/PRD.

1 0
Explore
ajianaz/skills-collection

security-auth

Comprehensive security and authentication workflow that orchestrates security architecture, identity management, access control, and compliance implementation. Handles everything from authentication system design and authorization frameworks to security auditing and threat protection.

1 0
Explore
ajianaz/skills-collection

shadcn-svelte-management

Manage UI components using MCP tools with primary focus on Svelte ecosystem. Specialized in Svelte component libraries including shadcn-svelte, Skeleton UI, and Melt UI. Use when user needs to: (1) Add new Svelte UI components to a project (2) Build complex UI features requiring multiple components (3) Research component implementations and examples (4) Get component installation commands (5) Choose appropriate Svelte component library Triggers: "add components", "UI components", "build UI", "install component", "create form", "create dialog", "svelte components", "shadcn-svelte", "skeleton ui"

1 0
Explore
ajianaz/skills-collection

svelte-ui-animator

Analyze and implement purposeful UI animations for Svelte/SvelteKit + Tailwind projects. Specialized in Svelte transitions, actions, and animation patterns. Use when user asks to add animations, enhance UI motion, animate pages/components, or improve visual feedback. Triggers on "add animations", "animate UI", "motion design", "hover effects", "scroll animations", "page transitions", "micro-interactions".

1 0
Explore
ajianaz/skills-collection

mobile-devops

Comprehensive mobile DevOps workflow that orchestrates mobile application development, CI/CD for mobile, app store deployment, and mobile device testing. Handles everything from mobile app build automation and testing to app store submission, monitoring, and mobile-specific DevOps practices.

1 0
Explore
ajianaz/skills-collection

svelte-design

Create distinctive, production-grade frontend interfaces with high design quality. Specialized in Svelte/SvelteKit applications with full-stack capabilities. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

1 0
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results