Flutter Error Handling für die KI-Ära

Das Problem

Wir alle kennen es: Du arbeitest mit einem Coding Assistant — Claude, Copilot, Cursor — und die KI generiert Code. Du führst ihn aus. Crash.

Jetzt beginnt der Tanz:

Screenshot machen vom Error Screen
Terminal öffnen, Log Output kopieren
Stack Trace irgendwo rauskratzen
Prompt formulieren: "Dieser Fehler tritt auf wenn..."
Alles zusammenkopieren und an die KI schicken
Hoffen, dass genug Kontext dabei ist

Fünf Minuten für einen Roundtrip. Bei komplexen Bugs: Dutzende Roundtrips. Stunden verschwenden mit Copy-Paste-Gymnastik.

Die Lösung: Ein Button

Was wäre, wenn du einfach einen Knopf drückst und der Coding Assistant sofort versteht, was schiefgelaufen ist?

Das war die Idee hinter moinsen_runapp.

import 'package:moinsen_runapp/moinsen_runapp.dart';

void main() {
  moinsenRunApp(child: const MyApp());
}

Eine Zeile. Deine App hat jetzt:

Three-Layer Error Catching — nichts entkommt
Error Deduplication — keine "1000 identische Fehler in 3 Sekunden"
Beautiful Error Screens — Debug und Release
"Copy All" Button — strukturierter Markdown Bug Report

Der Game Changer: Copy All

Hier ist, was der "Copy All" Button generiert:

## Error Report

**Runtime Type:** FormatException
**Message:** Invalid JSON at position 42
**Source:** zone (uncaught async)
**Count:** 3 occurrences
**First seen:** 2026-02-10 14:23:01
**Last seen:** 2026-02-10 14:23:04

### Stack Trace (App-filtered)
lib/services/api_client.dart:127 - parseResponse
lib/screens/home_screen.dart:45 - _loadData
lib/main.dart:23 - main

### Flutter Diagnostics
Flutter 3.19.0 • Dart 3.3.0
Device: iPhone 15 Pro (iOS 17.2)
Mode: debug

### Framework Context
[... relevant Flutter framework trace ...]

Das ist kein Screenshot. Das ist strukturierter Kontext, den jede KI sofort versteht.

Workflow: Vorher vs. Nachher

Vorher (5+ Minuten pro Bug)

Error → Screenshot → Terminal → Copy → 
"Der Fehler ist..." → Paste → Hoffen → 
"Mehr Kontext?" → Nochmal Screenshot → ...

Nachher (30 Sekunden)

Error → "Copy All" → Paste → Fix

Ich nutze das jetzt seit Wochen in allen meinen Projekten. Der Unterschied ist dramatisch.

Warum Three-Layer Catching?

Flutter's Standard-Error-Handling hat Löcher:

Error-Typ	Flutter Standard	moinsen_runapp
Widget Build Error	Red Screen of Death	✅ Gefangen
Uncaught Async Error	App Crash	✅ Gefangen
Platform Dispatcher Error	Stillschweigend ignoriert	✅ Gefangen
Init Failure	App startet nicht	✅ App startet trotzdem

┌─────────────────────────────────────────────────┐
│ runZonedGuarded (Layer 3: Zone Catch-All)       │
│ ┌───────────────────────────────────────────┐   │
│ │ PlatformDispatcher.onError (Layer 2)      │   │
│ │ ┌─────────────────────────────────────┐   │   │
│ │ │ FlutterError.onError (Layer 1)      │   │   │
│ │ │ ┌───────────────────────────────┐   │   │   │
│ │ │ │         Your App              │   │   │   │
│ │ │ └───────────────────────────────┘   │   │   │
│ │ └─────────────────────────────────────┘   │   │
│ └───────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘

Drei Netze. Nichts entkommt.

Error Deduplication

Kennst du das?

[ERROR] FormatException: Invalid JSON
[ERROR] FormatException: Invalid JSON
[ERROR] FormatException: Invalid JSON
[ERROR] FormatException: Invalid JSON
... (x 1000)

Deine Console ist Müll. Dein Log File ist Müll. Du scrollst ewig, um den echten ersten Fehler zu finden.

moinsen_runapp dedupliziert automatisch:

[ERROR] FormatException: Invalid JSON (3x in 2.1s)

Konfigurierbar via deduplicationWindow. Default: 2 Sekunden.

Release Error Screens

In Production willst du keine Stack Traces zeigen. moinsen_runapp hat drei eingebaute Varianten:

Variant	Style
`friendly`	Wackelnde Animation, "Oops!" Message, warm und freundlich
`minimal`	Clean, Error Icon, Retry Button, keine Animation
`illustrated`	Full-Screen CustomPainter, floating broken-link Motif

Alle mit automatischem Dark/Light Mode Support.

Oder bau deinen eigenen:

moinsenRunApp(
  config: RunAppConfig(
    releaseScreenBuilder: (context, errors) {
      return YourBrandedErrorScreen(errors: errors);
    },
  ),
  child: const MyApp(),
);

Integration mit Sentry/Crashlytics

moinsenRunApp(
  onError: (error, stackTrace) {
    Sentry.captureException(error, stackTrace: stackTrace);
  },
  child: const MyApp(),
);

Der onError Callback feuert für jeden Error — auch Duplikate — damit dein externes Monitoring das vollständige Bild hat.

Installation

dependencies:
  moinsen_runapp: ^0.1.0

Oder via Git:

dependencies:
  moinsen_runapp:
    git:
      url: https://github.com/moinsen-dev/moinsen_runapp.git
      ref: main

Fazit

Das Package ist simpel. Ein runApp() Replacement. Aber der Impact auf den KI-Coding-Workflow ist enorm.

Drück ein Knopf, fertig.

Kein Screenshot. Kein Terminal-Scrollen. Kein Prompt-Formulieren.

Error → Copy All → Paste → Fix.

So sollte Debugging in der KI-Ära funktionieren.