Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
ajianaz avatar

Flutter Enterprise

ajianaz/skills-collection

  • 19 installs
  • 4 repo stars
  • Updated December 6, 2025
  • ajianaz/skills-collection

flutter-enterprise is a skill for building enterprise Flutter apps with feature-based clean architecture, dependency injection, and code generation.

About

flutter-enterprise is a skill for building enterprise Flutter applications using feature-based clean architecture. A developer uses it to set up a modular, scalable project structure with dependency injection and code generation for maintainability. It runs a sequential, phased workflow beginning with requirements analysis.

  • Feature-based clean architecture for enterprise Flutter apps
  • Modular structure with dependency injection and code generation
  • Sequential phased workflow starting from requirements analysis

Flutter Enterprise by the numbers

  • 19 all-time installs (skills.sh)
  • Ranked #770 of 1,039 Mobile Development skills by installs in the Skillselion catalog
  • Data as of Jul 28, 2026 (Skillselion catalog sync)
At a glance

flutter-enterprise capabilities & compatibility

Capabilities
frontend · ui design
Use cases
frontend · ui design
Pricing
Free
From the docs

What flutter-enterprise says it does

Lightweight Flutter development skill for building enterprise applications using feature-based clean architecture patterns.
SKILL.md
"Feature-first, testable, maintainable enterprise code"
SKILL.md
npx skills add https://github.com/ajianaz/skills-collection --skill flutter-enterprise

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs19
repo stars★ 4
Last updatedDecember 6, 2025
Repositoryajianaz/skills-collection ↗

What it does

Structure an enterprise Flutter app with feature-based clean architecture, DI, and code generation.

Who is it for?

Setting up a scalable, maintainable enterprise Flutter codebase with clean architecture.

Skip if: Simple prototype apps or non-Flutter mobile frameworks.

When should I use this skill?

You want to build an enterprise Flutter app with feature-based modular clean architecture.

What you get

A feature-based, clean-architecture Flutter codebase with DI and code generation ready to scale.

  • Feature-based project structure
  • Clean architecture layers
  • Dependency injection setup

By the numbers

  • 5 prioritized architecture areas

Files

SKILL.mdMarkdownGitHub ↗

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:

PriorityAreaPurpose
1Feature-Based StructureModular, scalable code organization
2Clean ArchitectureSeparation of concerns and testability
3Dependency InjectionLoose coupling and maintainability
4Enterprise PatternsProven enterprise development practices
5Code GenerationBoilerplate 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:

// 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

LayerResponsibilityKey Components
PresentationUI and State ManagementPages, Widgets, Providers/Bloc
DomainBusiness LogicEntities, Use Cases, Repository Interfaces
DataData ImplementationModels, Data Sources, Repository Implementations

Dependency Injection Setup

// 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
// 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
// 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
// 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
// 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.

Related skills

firebaseXcode Project SetupAutomatically create and configure a new Xcode project with Swift Package Manager dependencies for iOS or macOS agent projects.74.7k392expoExpo Tailwind SetupInstantly configure Tailwind CSS v4 with NativeWind v5 and react-native-css inside an Expo project for universal styling.46.7k2.3kexpoExpo Dev ClientCreate custom development clients for Expo React Native apps that need native modules or Apple-specific targets.45.9k2.3kavdleeSwiftui Expert SkillGet expert guidance when writing, reviewing, or refactoring SwiftUI views, state, performance, and modern iOS/macOS APIs.27.6k3.3kflutterFlutter Apply Architecture Best PracticesEnforce clean layered architecture when creating or refactoring a Flutter mobile application.25.4k2.7kexpoExpo ModuleCreate custom config plugins that safely modify native Android and iOS projects generated by Expo prebuild.25k2.3k

FAQ

What architecture does flutter-enterprise use?

Feature-based clean architecture with dependency injection and code generation for maintainable enterprise apps.

When should I use it?

When building or organizing a scalable enterprise Flutter app that must stay testable and maintainable.

Mobile Developmentfrontend
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.