AI für Progressive Web Apps

AI für Progressive Web Apps: Service Worker, Offline Support und App-ähnliche Erlebnisse mit ChatGPT & Claude. 10 Prompts für PWA-Entwicklung.

Einleitung

Progressive Web Apps verbinden das Beste aus Web und Native: Offline-Fähigkeit, Push Notifications, Installation auf dem Homescreen. AI hilft bei Service Worker, Caching-Strategien und Web APIs. Hier sind 10 Prompts für PWA-Entwicklung.

Prompt 1: PWA Grundlagen

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

Konvertiere meine Web App zu einer PWA:

Stack: [z.B. "Next.js" / "React (Vite)" / "Vue" / "Vanilla JS"]
Features: [z.B. "Offline-fähig, installierbar, Push Notifications"]

Erstelle die PWA Grundlagen:
1. **Web App Manifest**: name, icons, theme_color, display
2. **Service Worker**: Registration und Lifecycle
3. **HTTPS**: Pflicht für Service Worker
4. **Icons**: Alle benötigten Größen (192, 512, maskable)
5. **Meta Tags**: theme-color, apple-mobile-web-app-capable
6. **Lighthouse Audit**: PWA Checklist durchgehen
7. **next-pwa / vite-plugin-pwa**: Framework-Integration
8. **Scope**: Service Worker Scope korrekt konfigurieren
9. **Start URL**: Was öffnet sich beim App-Start?
10. **Display Mode**: standalone, fullscreen, minimal-ui

PWA Checklist:
- HTTPS ✅
- manifest.json verlinkt ✅
- Service Worker registriert ✅
- Icons (192 + 512) ✅
- Offline-Seite ✅
- Responsive ✅

Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.

Prompt 2: Service Worker

Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.

Implementiere einen Service Worker:

Framework: [z.B. "Vanilla / Workbox / next-pwa"]

Implementiere den Lifecycle:
1. **Registration**: navigator.serviceWorker.register()
2. **Install Event**: Precache wichtige Ressourcen
3. **Activate Event**: Alte Caches löschen
4. **Fetch Event**: Requests abfangen und Caching-Logik
5. **Update Flow**: Neuer SW wartet, bis alter weg ist
6. **skipWaiting**: Sofort aktivieren (Vorsicht!)
7. **Clients.claim**: Sofort alle Tabs übernehmen
8. **Error Handling**: SW Fehler graceful behandeln
9. **Unregister**: SW entfernen wenn nötig
10. **Debug**: chrome://serviceworker-internals

Workbox (empfohlen):
```javascript
import { precacheAndRoute } from 'workbox-precaching';
import { registerRoute } from 'workbox-routing';
import { StaleWhileRevalidate } from 'workbox-strategies';
```

Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.

Prompt 3: Caching-Strategien

Ebenso wichtig ist es, die Best Practices zu kennen.

Implementiere Caching-Strategien für meine PWA:

Ressourcen:
- HTML Seiten
- CSS/JS Bundles
- API Responses
- Bilder
- Fonts

Implementiere diese Strategien:
1. **Cache First**: Statische Assets (CSS, JS, Fonts)
2. **Network First**: API Calls (frische Daten bevorzugt)
3. **Stale While Revalidate**: Bilder (schnell anzeigen, im Hintergrund updaten)
4. **Network Only**: Auth Requests (niemals cachen!)
5. **Cache Only**: Precached App Shell
6. **Precaching**: Build-Artefakte beim Install cachen
7. **Runtime Caching**: Dynamische Ressourcen on-the-fly cachen
8. **Cache Expiration**: Max. Alter und Max. Anzahl
9. **Cache Versioning**: Alte Caches bei Update löschen
10. **Selective Caching**: Nur bestimmte API Routes cachen

Workbox Routing:
```javascript
registerRoute(
  ({request}) => request.destination === 'image',
  new StaleWhileRevalidate({ cacheName: 'images' })
);
```

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

Prompt 4: Offline-Fähigkeit

Natürlich gibt es dabei verschiedene Herangehensweisen.

Mache meine App vollständig offline-fähig:

App-Typ: [z.B. "News App" / "Todo App" / "Dashboard"]
Daten: [z.B. "API Daten die offline verfügbar sein sollen"]

Implementiere:
1. **Offline Page**: Custom Offline-Seite statt Chrome Dino
2. **App Shell**: UI-Grundstruktur immer verfügbar
3. **Daten-Caching**: Letzte API-Responses als Fallback
4. **IndexedDB**: Größere Datenmengen lokal speichern
5. **Offline Indicator**: Banner "Du bist offline"
6. **Offline Queue**: Aktionen speichern, bei Reconnect senden
7. **Optimistic UI**: Sofort in UI zeigen, später synchen
8. **Conflict Resolution**: Was wenn Online-Daten sich geändert haben?
9. **Storage Quota**: Verfügbaren Speicher prüfen
10. **Offline Analytics**: Events speichern, später senden

Offline-First Architektur:
- Immer zuerst lokale Daten zeigen
- Im Hintergrund synchronisieren
- Konflikte intelligent lösen (Last-Write-Wins oder Merge)

Prompt 5: Web App Manifest

Dabei spielen mehrere Faktoren eine wichtige Rolle.

Erstelle ein optimales Web App Manifest:

App Name: [z.B. "MyApp"]
Farben: [z.B. "Primary: #3B82F6, Background: #FFFFFF"]

Erstelle manifest.json mit:
1. **name / short_name**: Vollständig + kurz (max. 12 Zeichen)
2. **icons**: 192x192, 512x512, maskable Icons
3. **start_url**: "/?source=pwa" (für Tracking)
4. **display**: standalone (App-ähnlich, ohne Browser-Chrome)
5. **theme_color**: Toolbar-Farbe auf Android
6. **background_color**: Splash Screen Hintergrund
7. **orientation**: portrait, landscape, any
8. **scope**: Welche URLs gehören zur App?
9. **categories**: Für App Stores
10. **shortcuts**: Quick Actions im Long-Press Menü

Zusätzlich:
- Apple-spezifische Meta Tags (iOS Safari)
- Maskable Icons (Safe Zone beachten!)
- Splash Screen optimieren
- share_target: Web Share Target API

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

Prompt 6: Push Notifications

Dementsprechend solltest du die folgenden Aspekte kennen.

Implementiere Push Notifications für meine PWA:

Stack: [z.B. "Next.js, web-push, Service Worker"]

Implementiere:
1. **Permission Request**: Zur richtigen Zeit fragen (nicht sofort!)
2. **Subscription**: PushManager.subscribe() mit VAPID Keys
3. **Server-Side**: web-push Library, Subscription speichern
4. **Send Notification**: Payload mit Title, Body, Icon, Badge
5. **Click Handler**: Notification Klick → App öffnen, Seite navigieren
6. **Actions**: Buttons in der Notification (Antworten, Löschen)
7. **Badge**: App Badge mit Zähler aktualisieren
8. **Silent Push**: Daten im Hintergrund aktualisieren
9. **Notification Preferences**: User kann Typen wählen
10. **Analytics**: Delivery Rate, Click Rate, Dismiss Rate

Best Practices:
- Permission erst nach User-Aktion fragen
- Erklären WARUM Notifications nützlich sind
- Max. 2-3 pro Tag
- Personalisiert und relevant
- iOS: erst ab iOS 16.4 Support!

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

Prompt 7: Installation & Homescreen

Im Folgenden findest du alle wichtigen Details dazu.

Optimiere die PWA Installation Experience:

Implementiere:
1. **Install Banner**: beforeinstallprompt Event abfangen
2. **Custom Install Button**: Eigener "App installieren" Button
3. **Install Prompting**: Zum richtigen Zeitpunkt zeigen
4. **Install Analytics**: Track wer installiert (und wer dismisst)
5. **Post-Install**: Willkommens-Screen nach Installation
6. **iOS Anleitung**: Custom "Zum Home-Bildschirm" Anleitung
7. **Standalone Detection**: Erkennen ob App als PWA läuft
8. **In-App Install Promotion**: Banner/Toast mit Install-Hinweis
9. **TWA**: Trusted Web Activity für Google Play Store
10. **App Store Listing**: PWABuilder für Microsoft Store, Play Store

Install-Strategie:
- Nicht beim ersten Besuch fragen
- Nach positiver Interaktion (Task abgeschlossen, 3. Besuch)
- Erkläre den Vorteil: "Offline nutzen", "Schneller Zugriff"
- Dismiss respektieren (nicht 10x fragen)

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Prompt 8: Background Sync

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

Implementiere Background Sync für meine PWA:

Use Case: [z.B. "Formulardaten offline speichern und bei Reconnect senden"]

Implementiere:
1. **Background Sync API**: SyncManager.register('sync-data')
2. **Service Worker Sync Event**: Gespeicherte Daten senden
3. **IndexedDB Queue**: Offline-Aktionen in Queue speichern
4. **Retry Logic**: Bei Fehler automatisch nochmal versuchen
5. **Periodic Background Sync**: Regelmäßig Daten aktualisieren
6. **Sync Status**: UI zeigt "Wird synchronisiert..." / "Synced"
7. **Conflict Handling**: Server-Daten  vs. Offline-Änderungen
8. **Batch Sync**: Mehrere Änderungen auf einmal senden
9. **Priority Queue**: Wichtige Syncs zuerst
10. **Fallback**: Für Browser ohne Background Sync Support

Offline-First Pattern:
```javascript
async function saveData(data) {
  await db.pendingSync.add(data); // Lokal speichern
  if (navigator.onLine) {
    await syncToServer(); // Sofort senden
  } else {
    await registration.sync.register('sync-data'); // Später
  }
}
```

Prompt 9: PWA Performance

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

Optimiere die Performance meiner PWA:

Aktueller Lighthouse Score: [z.B. "Performance: 72, PWA: 85"]
Größte Probleme: [z.B. "LCP 4.2s, FID 200ms"]

Optimiere:
1. **App Shell**: Minimale HTML/CSS sofort laden
2. **Precaching**: Kritische Ressourcen beim Install cachen
3. **Navigation Preload**: Netzwerk-Request während SW Startup
4. **Code Splitting**: Nur Code für aktuelle Seite laden
5. **Image Caching**: Bilder im Service Worker cachen
6. **Font Caching**: Google Fonts offline verfügbar
7. **API Caching**: Stale-While-Revalidate für schnelle UIs
8. **Skeleton Screens**: Lade-Animation statt Spinner
9. **Resource Hints**: preconnect, prefetch, preload
10. **Bundle Analyze**: Was macht das Bundle so groß?

Performance Budget:
- JavaScript: < 200KB (gzipped)
- First Contentful Paint: < 1.8s
- Time to Interactive: < 3.8s
- Lighthouse Performance: > 90

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

Prompt 10: Update-Strategie

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

Implementiere eine Update-Strategie für meine PWA:

Anforderung: [z.B. "User soll neues Update sofort bekommen können"]

Implementiere:
1. **SW Update Detection**: navigator.serviceWorker.waiting
2. **Update Banner**: "Neue Version verfügbar! Jetzt aktualisieren"
3. **skipWaiting Message**: postMessage an neuen SW
4. **Page Reload**: Nach Update automatisch neu laden
5. **Version Check**: API Endpoint für aktuelle Version
6. **Force Update**: Bei kritischen Updates sofort erzwingen
7. **Cache Busting**: Alte Caches bei Update löschen
8. **Gradual Rollout**: Neuen SW nur für % der User
9. **Rollback**: Zurück zur alten Version bei Problemen
10. **Update Logging**: Welche Version hat der User?

Update Flow:
```
Neuer SW detected → Banner zeigen → User klickt "Update"
→ skipWaiting() → controllerchange → location.reload()
```

Wichtig: Nie skipWaiting() ohne User-Bestätigung
(sonst kann laufende Seite crashen!)

Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.

FAQ

PWA oder Native App?

Grundsätzlich gibt es dabei einige Punkte zu beachten.

PWA wenn: Budget limitiert, schneller Launch nötig, Web-Reichweite wichtig, keine speziellen Native APIs nötig. Native wenn: Bluetooth, NFC, Background Processing, App Store Sichtbarkeit essentiell. PWA als MVP starten, Native nachziehen wenn nötig.

Funktionieren PWAs auf iOS?

Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.

Ja, mit Einschränkungen: Installation über „Zum Home-Bildschirm“, Push Notifications ab iOS 16.4, kein Background Sync, 50MB Cache-Limit. Android bietet vollere PWA-Unterstützung. Für iOS-Heavy Audience eventuell React Native/Capacitor als Wrapper.

Kann AI eine PWA komplett generieren?

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

AI kann Service Worker, Manifest, Caching-Logik und Installation-Flow generieren. Workbox-Konfiguration, Push Notifications Setup und Offline-Strategien sind ideale AI-Aufgaben. Nutze next-pwa oder vite-plugin-pwa als Basis und lass AI die Konfiguration erstellen.

Verwandte Artikel:

Zuletzt aktualisiert: März 2026