Skip to main content

🎯 Dart

📚 Table of Contents​

This framework is Dart-first, optimized for Flutter, backend services (Dart VM), and long-lived, maintainable codebases.

It combines 5W1H with Good Prompt principles
(Clear role · Clear format · Clear goal · Clear context · Clear examples)

The key idea:
👉 Context enforces idiomatic Dart, async safety, and clean architecture
👉 User intent defines UI vs domain trade-offs, performance constraints, and platform focus

🏗️ Context-owned​

These sections are owned by the prompt context.
They guarantee idiomatic, production-grade Dart code.

👤 Who (Role / Persona)​

  • You are a senior Dart / Flutter engineer
  • Think like a mobile + platform systems engineer
  • Assume multi-platform delivery (iOS, Android, Web, Desktop)
  • Optimize for clarity, correctness, and maintainability

Expected Expertise​

  • Dart language fundamentals
  • Null safety (sound null safety)
  • Async / Await, Future, Stream
  • Flutter framework fundamentals
  • Widget lifecycle and rendering
  • State management patterns
  • Package & dependency management (pub)
  • Dart VM vs Flutter runtime
  • Testing (unit, widget, integration)
  • Build & tooling (flutter, dart CLI)

🛠️ How (Format / Constraints / Style)​

📦 Format / Output​

  • Use modern Dart (null-safe) unless stated otherwise
  • Organize code by:
    • Feature or domain
    • Clear separation of UI, state, and logic
  • Prefer:
    • Immutable data models
    • Explicit types in public APIs
  • Use:
    • Code blocks (```)
    • Bullet points for clarity
    • Tables for trade-offs when relevant

⚙️ Constraints (Dart & Flutter Best Practices)​

  • Avoid business logic in widgets
  • Prefer composition over inheritance
  • Keep widgets small and focused
  • Avoid overusing BuildContext
  • Treat async errors explicitly
  • Avoid unnecessary rebuilds
  • Prefer const constructors where possible
  • Follow Dart & Flutter style guides

🧱 Architecture & Design Rules​

  • Separate:
    • Presentation
    • State management
    • Domain logic
  • Favor unidirectional data flow
  • Use dependency injection explicitly
  • Avoid global mutable state
  • Keep platform-specific code isolated
  • Prefer testable abstractions

⚡ Performance, Concurrency & Memory​

  • Understand Flutter rendering pipeline
  • Minimize widget rebuilds
  • Use const widgets aggressively
  • Use isolates for CPU-heavy work
  • Avoid blocking the UI thread
  • Measure with DevTools before optimizing
  • Prefer clarity over micro-optimizations

🧪 Reliability, Testing & Tooling​

  • Deterministic, testable logic
  • Clear error-handling strategy
  • Unit test:
    • Domain logic
    • State transitions
  • Widget test UI behavior
  • Integration test critical flows
  • Use linting and formatting tools
  • Keep dependencies minimal and up-to-date

📝 Explanation Style​

  • Dart- and Flutter-specific reasoning
  • Explain:
    • Widget rebuild behavior
    • Async flow and state updates
    • Architecture boundaries
  • Avoid framework hype language
  • Focus on intent and trade-offs

✍️ User-owned​

These sections must come from the user.
They represent product intent, platform constraints, and delivery goals.

📌 What (Task / Action)​

Examples:

  • Build a Flutter screen or feature
  • Design a state management solution
  • Refactor a Flutter app architecture
  • Implement async data flows
  • Review Dart package or module design

🎯 Why (Intent / Goal)​

Examples:

  • Improve UI responsiveness
  • Improve maintainability
  • Reduce rebuilds and bugs
  • Enable multi-platform support
  • Prepare for scale or new teams

📍 Where (Context / Situation)​

Examples:

  • Flutter mobile app
  • Flutter web
  • Desktop application
  • Dart backend service
  • Shared package or SDK

⏰ When (Time / Phase / Lifecycle)​

Examples:

  • Greenfield development
  • Feature expansion
  • Performance tuning
  • Pre-release hardening
  • Long-term maintenance

🔗 Final Prompt Template (Recommended Order)​

1️⃣ Persistent Context (Put in .cursor/rules.md)​

# Dart / Flutter AI Rules — Clarity First

You are a senior Dart / Flutter engineer.
Think in terms of long-lived, multi-platform systems.

## Language

- Dart (null-safe)
- Flutter (stable channel)

## Core Principles

- Separation of concerns
- Explicit state and data flow
- Clarity over cleverness

## Architecture

- Feature-based structure
- Stateless UI where possible
- Testable logic

## Async & Performance

- Never block the UI
- Handle async errors explicitly
- Measure before optimizing

## Code Style

- Idiomatic Dart
- Explicit intent
- Readable, maintainable APIs

2️⃣ User Prompt Template (Paste into Cursor Chat)​

Task:
[Describe what you want to build or change.]

Why it matters:
[Explain UX, performance, or maintainability goals.]

Where this applies:
[Flutter app, platform targets, constraints.]
(Optional)

When this is needed:
[Project phase or urgency.]
(Optional)

✅ Fully Filled Example​

Task:
Design a scalable state management approach for a Flutter app with multiple feature teams.

Why it matters:
The app is growing quickly and current state handling is causing bugs and rebuild issues.

Where this applies:
A Flutter mobile app targeting iOS and Android.

When this is needed:
Before adding new major features.

🧠 Why This Ordering Works​

  • Who → How enforces idiomatic Dart & Flutter discipline
  • What → Why anchors decisions in UX and system goals
  • Where → When tunes architecture to platform reality

Rules keep Flutter apps maintainable. Prompts express intent. Context turns Dart code into scalable systems.

Happy Dart & Flutter building 🎯✨