rule-docker-flutter-architecture

Enforce Flutter architectural separation across UI, state, and data layers.

Updated Nov 7, 2025
One-click install
npx skills add https://github.com/belluga/delphi-ai --skill rule-docker-flutter-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rule-docker-flutter-architecture
Source: https://github.com/belluga/delphi-ai/tree/main/.cline/skills/rule-docker-flutter-architecture
Command: npx skills add https://github.com/belluga/delphi-ai --skill rule-docker-flutter-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This rule ensures Flutter projects adhere to a consistent architectural model, preventing drift between UI, business logic, and data layers.

Core Features & Use Cases

  • Enforce separation of concerns by keeping widgets pure and routing governed by AutoRoute with proper guards.
  • Standardize DI/ownership boundaries, DTO → Domain → Projection flows, and canonical state ownership.
  • Apply to new features and modules across tenant screens, ensuring consistent feature-first structure and maintainable codebases.

Quick Start

Apply this rule to enforce Flutter architectural tenets across all tasks.

Frequently Asked Questions about rule-docker-flutter-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce clean architecture and separation of concerns in a Flutter project?

To enforce clean architecture in a Flutter project, apply rules that mandate strict separation between UI, state, and data layers. This prevents architectural drift and keeps widgets pure by governing routing, dependency injection, and state ownership.

What is the proper flow for mapping DTOs to domain models in Flutter?

The proper flow for DTOs in Flutter architecture requires mapping DTOs to Domain models and then to Projections. This standardized data flow ensures clear boundaries between data transfer, business logic, and UI presentation layers.

How do I standardize dependency injection boundaries and routing in Flutter?

Standardize dependency injection boundaries and routing in Flutter by codifying ownership rules and using AutoRoute with proper guards. This ensures consistent feature-first structure and governs how controllers, services, and repositories interact.

Can I use automated analysis checks to maintain Flutter code quality across modules?

Yes, you can maintain Flutter code quality across modules using automated analysis checks. These checks ensure compliance with architectural tenets, verifying proper DI boundaries, routing, and DTO to Domain to Projection flows across tenant screens.

Why does my Flutter feature architecture drift between UI and business logic layers?

Flutter feature architecture drifts when there are no enforced boundaries between UI, state, and data layers. Applying codified architectural rules for canonical state ownership and feature-first structure prevents this drift and maintains maintainable codebases.

Does this architectural rule apply to both new features and existing Flutter modules?

Yes, this architectural rule applies to new features and existing Flutter modules alike. It enforces consistent feature-first structure, routing guards, and DI ownership boundaries across tenant screens to guide controllers, services, and repositories uniformly.