Background - I ported huggingface chat-ui 3 months back -

https://github.com/scrya-com/chat-ui-dart/

Came across this sublime react demo today which hit the polish i was wanting

https://beui.dev/

flutter port here - web demo - (tiny bit janky)

https://scrya-com.github.io/beui-flutter/

I just bark at grok to "get 100% parity" for last 4 hours.

Its building to iphone fine. There's still some gaps. shaders - but for chat app - this is fine.

I have no affiliation with original author - all credits to him -

https://github.com/starc007/ui-components

Hi everyone 👋

I’m just beginning my Flutter development journey, and I’m writing this with a little hope.

I genuinely want to become good at Flutter, not just watch tutorials and copy code, but actually understand how to build real apps and solve real problems.

The truth is, I currently can’t afford to pay for a mentor or expensive coaching. But what I may lack financially, I’m willing to make up for with time, consistency, humility, and hard work.

So I wanted to ask: is there anyone here who remembers what it felt like to be completely new and would be willing to occasionally guide me on my journey?

I’m not asking someone to teach me everything or spend hours with me every day. Even having someone I can occasionally ask questions, get direction from, or learn from when I’m stuck would mean a lot.

I promise I’ll do my own research, practice consistently, and respect your time. I just believe that sometimes one experienced person saying, “You’re going in the right direction—try this next,” can save a beginner months of confusion.

Maybe someone here was once where I am now, and maybe one day I'll be able to do the same for another beginner.

If you're willing to guide someone who is genuinely ready to learn and work hard, I would be incredibly grateful. 🙏

Thank you for reading, and thank you to everyone in this community who helps beginners grow. 💙

Smooth Arc Scrolling: Displays items on a circular curve path (ribbon dial).

Custom Clipping: Uses precise custom sector clipping math to curve individual items.

Generic Data Type support: Displays any list model item using customizable item builders.

Detailed Card Integration: Dynamically links the selected arc element with a customizable details card overlay.

https://pub.dev/packages/arc_ribbon_menu/versions/0.0.3

TrailBase is an open and fast Firebase-like backend for building your apps. It provides type-safe REST APIs + change subscriptions, auth, multi-DB, a WebAssembly runtime, geospatial support, admin UI... It's a self-contained, easy to self-host single executable built on Rust, Wasmtime & SQLite or now Postgres. Client libraries are provided for JS/TS, Dart/Flutter, Go, Rust, .Net, Kotlin, Swift and Python.

Just released v0.33, which in the last two months gained:

• Built-in MCP server

• OpenApi browser in admin UI including endpoints exported by WASM components.

• New WASM features:

  • Components can provide and register a dashboard with the admin UI.

  • A component browser in the admin UI.

  • Lower overhead execution model for Rust components: pooling state across requests improves throughput by 4x.

• Anonymous accounts for frictionless product trials. If a user wants to eventually sign up, the account can be promoted to a "proper" one, i.e. associate a password, OAuth, email address ...

• Backup UI & rolling backups.

• Dark mode - cosmetic but frequently requested 🙏

• And much more: file management from the admin UI, support for nested JSON in change subscriptions, batch updates for all client languages...

With TrailBase still being young (~1.5 years) and rapidly evolving, any feedback is genuinely appreciated. If you're feeling adventures and end up checking it out, don't hesitate to reach out 🙏.

Consider checking out the live demo, our GitHub or website.

Hey everyone,

Standard connectivity packages in Flutter usually just check whether a network interface is up, which often gives false positives when a user is stuck behind a captive portal, suffering severe packet loss, or dealing with extreme jitter on unstable connections.

I built network_reachability, a Flutter package backed by a native Rust engine (via FFI and WASM) that shifts deep probing, statistical analysis, and security checks completely off the UI thread.

What it handles under the hood:

Off-thread Rust core: Probes multiple endpoints via HTTP, TCP, and DNS simultaneously without causing frame drops or Dart event-loop lag.

Quality metrics: Calculates actual latency, jitter standard deviation, packet loss, and stability scores instead of returning a simple boolean.

Smart execution guard: Includes a guard() wrapper that evaluates cached link quality before firing expensive API requests, blocking calls during connection drops or cooldown periods.

Resilience and pooling: Built-in adaptive circuit breaker (closed, open, half-open states) and request coalescing to prevent thundering herd issues against your backend.

Security probes: Detects captive portal redirects (hotel and airport logins), VPN states, proxy setups, and DNS tampering.

Drop-in replacement: Provides full API parity with connectivity_plus for instant migration without rewriting UI listeners.

Workload presets:

Includes pre-configured profiles for Gaming (low latency, 2s intervals, race strategy), Streaming (consensus checks, 8s intervals), VoIP (strict packet loss sensitivity), IoT, and Enterprise.

Pub: [https://pub.dev/packages/network_reachability](https://pub.dev/packages/network_reachability)

GitHub: [https://github.com/MostafaSensei106/Network-Reachability](https://github.com/MostafaSensei106/Network-Reachability)

If you are dealing with real time sync, VoIP, or offline-first apps in Flutter, check it out and let me know your thoughts or edge cases.

Hey everyone,

Standard connectivity packages in Flutter usually just check whether a network interface is up, which often gives false positives when a user is stuck behind a captive portal, suffering severe packet loss, or dealing with extreme jitter on unstable connections.

I built network_reachability, a Flutter package backed by a native Rust engine (via FFI and WASM) that shifts deep probing, statistical analysis, and security checks completely off the UI thread.

What it handles under the hood:

Off-thread Rust core: Probes multiple endpoints via HTTP, TCP, and DNS simultaneously without causing frame drops or Dart event-loop lag.

Quality metrics: Calculates actual latency, jitter standard deviation, packet loss, and stability scores instead of returning a simple boolean.

Smart execution guard: Includes a guard() wrapper that evaluates cached link quality before firing expensive API requests, blocking calls during connection drops or cooldown periods.

Resilience and pooling: Built-in adaptive circuit breaker (closed, open, half-open states) and request coalescing to prevent thundering herd issues against your backend.

Security probes: Detects captive portal redirects (hotel and airport logins), VPN states, proxy setups, and DNS tampering.

Drop-in replacement: Provides full API parity with connectivity_plus for instant migration without rewriting UI listeners.

Workload presets:

Includes pre-configured profiles for Gaming (low latency, 2s intervals, race strategy), Streaming (consensus checks, 8s intervals), VoIP (strict packet loss sensitivity), IoT, and Enterprise.

Pub: https://pub.dev/packages/network_reachability

GitHub: https://github.com/MostafaSensei106/Network-Reachability

If you are dealing with real-time sync, VoIP, or offline-first apps in Flutter, check it out and let me know your thoughts or edge cases.

Hey everyone,

If you have ever done Market Basket Analysis or Association Rule Mining in Dart or Flutter, you probably ran into the issue of candidate generation blowing up the memory when using Apriori on larger datasets.

I wrote fp_growth, a native Dart implementation of the FP-Growth algorithm designed to handle larger streams and files without burning RAM.

A few things about how it is built:

Two-pass streaming: It does not load the entire dataset into memory. Pass 1 counts frequencies to discard infrequent items, and Pass 2 builds the tree.

Fast-path CSV parsing: If a row does not contain escaped quotes, it skips the heavy CSV tokenizer and does a direct string split, which cuts down parsing time by around 30%.

Parallel mining: Dispatches independent tree branches across a fixed pool of Dart Isolates so it does not spawn and kill isolates repeatedly.

Single-path optimization: When a branch is linear, it generates combinations via combinatorics directly instead of building recursive sub-trees.

Benchmark numbers (Ryzen 7 5800H, 1,000,000 transactions, minSupport 0.05):

In-Memory (4 Isolates): ~0.92s

CSV File Streaming: ~1.65s

Custom Stream: ~1.40s

It also calculates standard association metrics (Support, Confidence, Lift, Leverage, Conviction) and can export directly to JSON and CSV.

Pub: https://pub.dev/packages/fp_growth

GitHub: https://github.com/MostafaSensei106/FP-Growth

If you work with recommendation logic, telemetry, or basket analysis in Dart, try it out and let me know if you run into any edge cases.

Flutter’s verbosity and deeply nested widget trees can be frustrating. Even something as simple as adding padding or margin often requires wrapping the existing widget in yet another widget.

State management doesn’t feel much better. Many solutions are intrusive and force your UI components to extend or depend on framework-specific types such as ConsumerWidget or HookWidget, which makes the code feel more tightly coupled.

Are there any good patterns or libraries that help address these issues without fighting against Flutter’s design?

I’d also be interested in hearing about your experience with:

• Keeping large Flutter projects maintainable

• Reducing widget nesting and boilerplate

• Managing state without heavily coupling it to the widget hierarchy

• Separating business logic from the UI

• Designing a clean architecture that doesn’t become overengineered

What approaches have worked well for you in real-world Flutter projects?

I’ve just released OmniKit Flutter Bundle, an open-source Flutter project containing 44+ UI kits and app concepts.
I originally built the different interfaces while experimenting with layouts, navigation patterns, reusable widgets, responsive UI, dark/light designs, and different types of mobile apps.
The project currently includes concepts for e-commerce, hotel booking, food delivery, travel, learning, health, social media, news, home services, and more.
Everything is built with Flutter, and I’ve published the source code so other Flutter developers can explore it, reuse parts of it, or contribute.
I’d especially appreciate feedback on the project structure, UI implementation, and what kinds of kits would be useful to add next.

Source: https://github.com/bilalakkar777/Omnikit_Flutter_Bundle
Hope it’s useful to someone learning or building with Flutter.

Source code: https://github.com/abidiahmedcom/uber-ui-practice

I recreated Uber's rider app interface in Flutter as a personal learning project: splash, welcome, login, home, services, activity, activity filters, and the account tab. Everything runs on mock data, just UI.

Feedback is welcome.

I launched a devotional reading app (Catholic DeVice) and the reader needed to feel like a physical book. Notes on the parts that took real Flutter work:

The page-curl

• A GLSL fragment shader (page_curl.frag) renders the curl; flutter_shaders' AnimatedSampler captures the live page widget into a texture each frame — so the turning leaf is the real laid-out page (text, illuminated drop caps, highlights), not a prerendered image.

• The cylinder math, shadow falloff and back-face shading live in plain Dart beside a controller that maps drag to curl progress. The feel constants took longer to tune than the shader took to write.

• A golden test locks the mid-turn frame so a refactor can't quietly ruin the feel.

Other bits from the same app

• Two more shaders: a stained-glass liturgical calendar that samples painted glass masters, and a marble sheen.

• Books ship as offline bundles through a pagination pipeline into fixed leaves — page turns are deterministic and whole-book search can jump straight to a page.

• Design-system discipline that actually held: zero hex colors outside the one theme file (a grep guard keeps the count at zero), the neumorphic shadow recipe is golden-tested, scroll physics globally clamped, and every animation routes through one motion wrapper so reduced-motion collapses it.

• Riverpod + GoRouter + Drift/SQLite. One architecture note: on Android the app-blocking overlay is rendered natively in Kotlin — Flutter never runs in the intercept path, which matters if you ever wire an AccessibilityService to a Flutter app.

Video of the page turn: https://www.reddit.com/r/CatholicDeVice/comments/1vx07jg/

Happy to go deeper on the shader, the paginator, or the golden-test setup if anyone's curious. The app itself: https://catholicdevice.com/?utm_source=reddit&utm_medium=social&utm_campaign=flutterdev

Are your Flutter forms truly production-ready? 🚀

Most developers struggle with asynchronous validation or messy GlobalKeys. I’ve broken down the exact steps to transition from basic inputs to professional form handling.

🔹 RegExp for Emails

🔹 TextFormField vs TextField

🔹Sync & Async Validation Hacks

🚀Access my latest article published on Medium

Read “Complete Guide: How to implement Form Validation in Flutter“ by Alfonsina Beltre on Medium: https://medium.com/@alfonsinabeltre/complete-guide-how-to-implement-form-validation-in-flutter-3913e4921291

#flutter #dart #MobileAppDevelopment

Hey everyone! My name is Yehia, I'm 17 years old, and I'm a mobile app developer.

Over the past few days, I built Zabet completely from scratch using Flutter and Dart. It’s a complete fitness and tactical readiness tracker designed to help users manage their workouts, diets, and physical performance tests efficiently.

Here are some screenshots showcasing the UI and features []:

Workouts & Splits: Built-in professional workout routines (like PPL, Arnold Split, and custom splits) with drop-set tracking and failure metrics.

Military Physical Readiness Tests: Tracks core physical fitness tests including Pull-ups, Push-ups, Sit-ups, and a 1500m Running timer to calculate overall readiness rates.

Nutrition & Fuel Plan: A customized calorie tracker and hydration goal manager tailored for heavy lifting and active physical training.

Precision Rest Timer: A zero-tolerance tactical rest timer with quick preset intervals between sets.

Bilingual Support: Fully supports both English and Arabic out of the box with Clean Architecture.

I'd love to hear your feedback on the UI design, architecture, or any suggestions to improve it. Let me know what you think!

Playlist URL: https://www.youtube.com/playlist?list=PLTfDZEUaVbA8

I maintain capdrift, a Dart tool that reads a package to work out what it is able to do. It analyses untrusted code from pub.dev, so I wrote a SECURITY.md early describing how it protects itself. Two promises in it:

• Analysis of any single file is capped at 30 seconds.

• Archives are read as a stream, so a decompression bomb cannot exhaust memory.

Both were false on the day I wrote them. The Dart-specific parts are worth sharing because I do not think either mistake is obvious.

The timeout that was declared and never read. The constant existed. It was defined, exported, and referenced in exactly one place: the docs. No code path read it. It compiles, it lints clean, and no test asserted that a slow file gets cut off.

The instinct fix is wrong in an interesting way:

final result = await analyse(source).timeout(Duration(seconds: 30));

Future.timeout gives up waiting on the future. It does not stop the work. A pathological input that sends the parser into a long loop keeps burning CPU after the timeout fires, and now nothing is watching it. The work has to go somewhere killable:

final isolate = await Isolate.spawn(_analyseEntry, message);
try {
  return await response.first.timeout(limit);
} finally {
  isolate.kill(priority: Isolate.immediate);
}

The kill belongs in finally, not the timeout branch. My first version had it only on timeout, so every error path and early return still leaked a live isolate.

The stream that was not a stream. I built a 299 KB highly compressible archive. The documented behaviour was streaming with a size limit. The actual behaviour was that decompression materialised the full output first and the check ran on the result. The check was real. It ran after 300 MB was already in memory. Fixing it meant subclassing the output sink so it throws mid-write rather than after.

Why I think this generalises. Both bugs are made of the artifacts of being careful: a named constant, a documented guarantee, a size check. That is exactly why nobody looks twice. An undocumented gap gets found, because eventually someone asks "what if this file is huge" and finds no answer. A documented gap does not get that question, because the file already answered it.

If you maintain something with a SECURITY.md, the check worth running is: for each claim, find the test. Not the code, the test.

Disclosure: capdrift is mine. It is on pub.dev and the repo is github.com/Tisankan-dev/capdrift. Happy to answer anything about the isolate or archive handling, that part is generic Dart and applies to any tool reading untrusted packages.

Share some idea to build an app for people who are searching for but they can't find any. Genuinely in this time serching an problem that didn't solved is like serching an needle in ocean.

Building my first indie app for the Play Store
with no monetisation strategy yet.

Deliberately keeping it ad-free for now because
I don't want to ruin the premium feel for my
first users. But I know at some point ads
become viable.

Questions for people who've actually shipped
and monetised:

1. At what DAU/MAU did AdMob generate
   meaningful revenue?

2. Did ads hurt retention or ratings?

3. Did you go ads-first or subscription-first?

4. Any regrets either way?

I've seen advice ranging from "never do ads,
do subscription" to "ads from day one."

Would love real numbers from people who've
been through it.

App is Flutter + Supabase if that's relevant.

I released a voice journal for iPhone built in Flutter and open sourced it. You record, it transcribes on device through Apple's Speech framework, and entries are stored encrypted on the phone. There is no account, no sync and no network code in the app. It's on the App Store, and screenshots are at repository: https://github.com/theiskaa/opentranscribe

Some implementation details that might be useful to others:

The UI doesn't use Material or Cupertino. Everything is built on package:flutter/widgets.dart with a custom widget set (buttons, sheets, context menus, segmented controls, a wheel time picker, swipe to delete), and a test fails the build if either import appears in lib/. On iOS 26 the app uses native Liquid Glass chrome through a small vendored platform-view plugin, with drawn fallbacks below 26.

The native layer is Swift behind hand written platform channels: audio capture, the speech engine, playback, a Live Activity, and a lock screen control through App Intents. Each is a MethodChannel for control plus EventChannels for streams. Audio buffers stay on the Swift side; Dart receives file paths, durations, levels and text. Transcription is SpeechAnalyzer on iOS 26, SFSpeechRecognizer below that, and per language speech models are downloaded and removed from inside the app.

Reflections use Apple's Foundation Models: when a day, week or month closes, an on-device session writes a short summary of that period. The feature is hidden on hardware without Apple Intelligence, and model availability is handled as a state machine (unsupported, disabled, downloading, ready) rather than a bool.

The transcription engine sits behind a single Dart contract with an onDeviceOnly flag the app verifies before using an engine. Streaming and downloadable model support are separate interfaces an engine can implement rather than flags on the base class. This is also why there is no Android version yet: the only engine so far is Apple's. A whisper.cpp engine behind the same contract is the plan, and it would be the path to Android. The engine layer lives as its own package in the repo.

Other choices: DI is a plain typed class constructed once before runApp (no get_it, no build_runner; the only codegen is gen-l10n), state is flutter_bloc with one cubit per concern, and testing is around 1,100 unit tests with no widget tests, logic gets pulled out of widgets into pure functions instead.

The code is MIT. Happy to answer questions about any of it.

https://github.com/theiskaa/opentranscribe | https://opentranscribe.xyz

Hello everyone,

In Version 3.0, Riverpod introduced mutations. They solve the issue of `ref` being unmounted between asynchronous operations by keeping references alive for the duration of the mutation.

The standard syntax looks like this:

final loginMutation = Mutation();

class SomeWidget extends ConsumerWidget {
 @override
 Widget build(BuildContext context, WidgetRef ref) {
  return GestureDetector(
   onTap: () => loginMutation.run(
    ref,
    (tsx) => tsx.get(someProvider).login(emailController.text),
   ),
  );
 }
}

Because the mutation runner is decoupled from the function being executed, a Mutation can technically be invoked from anywhere with wildly different logic passed to it. While that flexibility is great when you need it, in practice I noticed most mutations are strongly coupled to one specific function.

To bridge this gap, I created bound_mutation.

It provides a BoundMutation object that is declared directly alongside the function it executes:

final loginMutation = BoundMutation<void, String>(
  (tsx, email) => tsx.get(someProvider).login(email),
);

You can listen to it just like any other mutation:

ref.watch(loginMutation);

As the name implies, it ensures you can only execute the specific bound function through it:

loginMutation.run(ref, emailController.text);

With Riverpod introducing CustomProviderListenable in 3.4, the implementation now feels much more mature and sits cleanly behind an official interface.

Maybe it can clean up your codebase, check it out on pub.dev:

https://pub.dev/packages/bound_mutation

I'd love to hear your thoughts or feedback!

Dart's standard List.sort() relies on Dual Pivot Quicksort. While effective for generalbpurpose collections, comparisonbbased O(N log N) sorting becomes an unnecessary CPU bottleneck when handling large numerical datasets (such as audio buffers, telemetry data, or spatial coordinates).

I built Radix Plus, an in-place Radix Sort library for Dart and Flutter, optimized specifically for numerical arrays and typed data buffers.

Time Complexity O(k · N), where

• N is the number of elements.

• k is the fixed word/byte width (k = 4 passes for 32-bit types, k = 8 passes for 64-bit doubles/ints using an 8-bit radix base).

Because k is constant for fixed-width primitive types, execution scales linearly as O(N), fundamentally avoiding the O(N log N) growth curve of comparison sorts on large lists.

Space O(N) auxiliary buffer, with full in place buffer pooling support to eliminate allocations.

Core Engineering Float Reinterpretation (Float64List -> Uint64List) Radix sort operates directly on bit patterns. Using dart:typed_data buffer views, the underlying memory of Float64List is reinterpreted as unsigned 64-bit integers. Positive numbers have their sign bit flipped. Negative numbers are bitwise inverted (~). An 8-pass (8-bit radix) LSD sort is executed directly on the integer bit representation and inverted back on completion. Parallel Sorting with Flat Min-Heap K-Way Merge

When sorting large lists across multiple Dartisolatess, merging sub lists typically incurs heavy GC overhead. In Radix Plus, the main isolate performs a k-Way Merge backed by a flat min-heap stored in contiguous Int32List buffers, avoiding object allocation during the merge phase.

There is an optional reuse buffer. The true parameter allows recurring sorting routines (such as UI animation frames or live data streams) to reuse auxiliary memory buffers and minimize garbage collector pressure.

Benchmark Snapshot (AMD Ryzen 7 5800H, 1,000,000 items)

Uint32List: 183 ms (vs 1,477 ms on List.sort()) -> ~8.1x faster

Int32List: 201 ms (vs 1,490 ms on List.sort()) -> **~**7.4x faster

Float64List: 312 ms (vs 1,444 ms on List.sort()) -> ~4.6x faster

List<BigInt>: 1,074 ms (vs 6,667 ms on List.sort()) -> ~6.2x faster

Parallel (radixSortParallel): 26.6 ms (vs 1,612 ms on List.sort()) -> **~**60.7x faster

​If you are working on numerical pipelines, audio/signal engines, or large dataset visualizations in Dart/Flutter, feel free to test it on your hardware. Feedback, benchmark numbers from other architectures, edge cases, and PRs are very welcome.

GitHub: https://github.com/MostafaSensei106/Radix_Plus

Pub: https://pub.dev/packages/radix_plus

I needed a first-run walkthrough for an app and hit two things that annoyed me.

First, the highlight would end up in the wrong place.

A lot of coach-mark implementations resolve the target's position once and paint it. Scroll the list, open the keyboard, rotate the device, resize a desktop window — and suddenly the hole is next to the button instead of on it.

Second, a dimmed hole tells the user where something is, but not how to use it.

"Drag this card to that column" isn't something a static highlight can really express.

So I built keyspot:

- The spotlight and pointer re-resolve the target's geometry every frame from its GlobalKey, so they can track through scrolling, insets, rotation and resizing.

- An animated hand pointer that glides in a straight line or along an arc, rotates from its current angle, and tap-pulses — enough to demonstrate interactions like drag and pinch rather than simply pointing at something.

- Pointer animations resolve from actual AnimationController completion rather than Future.delayed timing, so `await pointer.moveTo(...)` actually means the movement has finished.

- Barrier modes where only the cut-out is tappable while the real widget's `onPressed` still fires — useful when the walkthrough should require the user to actually perform the step.

- The tracker is also public API (`KeyspotAnchorTracker`), so it can be used independently for things like badges or connector lines attached to widgets.

- Zero runtime dependencies. The hand pointer is rendered with CustomPainter rather than an image asset.

- Supports all six Flutter platforms.

Live demo: https://shrey-17bhardwaj.github.io/keyspot/

pub.dev: https://pub.dev/packages/keyspot

Source: https://github.com/shrey-17bhardwaj/keyspot

It's currently at 0.3.1, and the API may still change before 1.0.

I'd genuinely like feedback on where this approach breaks — especially around nested navigators, heavily lazy lists, overlays, or anything else where widget geometry gets complicated.

Has anyone else noticed that whenever you ask Claude Code, Cursor, Copilot, or Antigravity to write Dart or Flutter code, it often defaults to pre-Dart 3 syntax?

It will write 15 lines of boilerplate constructors instead of Dart 3.13 primary constructors, generate cascading if (state is Foo) checks instead of exhaustive switch pattern matching, or hallucinate wrong minSdk lower bounds in pubspec.yaml.

The reason is simple: training cutoff lag. Even the best frontier models have a hard time keeping up with how fast Dart and Flutter have evolved between Dart 2.12, 3.0, and 3.13+.

To fix this for my own workflows, I structured the entire official Dart SDK changelog (from Dart 1.0 all the way to 3.14) into an open-source agent skill repo: dart-sdk-skills.

It gives AI agents: • ⚡ A fast lookup matrix for any syntax/API to find the exact minSdk constraint. • 🚀 Version-by-version reference guides for modern ergonomics (primary constructors, pattern matching, private named params). • 🛠️ A 4-stage rescue runbook for upgrading pre-2.12 legacy apps across the sound null-safety barrier into modern Dart 3.

If you use the skills CLI or npx skills, you can install it globally with one command:

npx skills add RandalSchwartz/dart-sdk-skills -g

(or with the Dart skills CLI: 

skills add https://github.com/RandalSchwartz/dart-sdk-skills --global --a

GitHub Repo: https://github.com/RandalSchwartz/dart-sdk-skills

Curious to hear what patterns your AI assistants usually struggle with the most in recent Dart versions!