31 prompts that make a vibe-coded app fast

Audit this app for speed. Check every item below, tell me which ones are already handled, which ones are problems, and where in the code each problem is. Don't change anything yet. Rank the problems by how much faster the app would feel once fixed.

Skeleton screens while loading · WebP/AVIF images · duplicate API calls · debounced search inputs · paginated API results · static files on a CDN · slow work in a background job queue · N+1 database queries · Brotli or gzip compression · caching hot data (Redis) · unused dependencies · timeouts on external API calls · streaming AI responses · optimistic UI updates · lazy-loaded images · parallel independent requests · database indexes for common queries · tracing slow requests (OpenTelemetry) · server close to the database · server or build-time rendering · third-party scripts loaded after the page · JavaScript split per page · virtualized long lists · selecting only needed columns · database connection pooling · unnecessary re-renders · browser caching headers for static files · load balancing across instances · self-hosted fonts with fewer weights · real-user speed monitoring · testing on slow phones and networks.

Make this app feel faster on screen:
1. Replace blank screens and spinners with skeleton screens shaped like the real content.
2. Stream AI responses to the UI token by token instead of waiting for the full answer.
3. Use optimistic updates for likes, saves and edits: update the UI first, roll back if the server fails.
4. Lazy load images and heavy components that start below the fold.
5. Render pages on the server or at build time where the content allows it.
6. Find components that re-render without their data changing and stop it (memoization, stable props, splitting state).
Show me each change and why it helps.

Cut what the browser has to download:
1. Serve images as WebP or AVIF with the right size per screen, with a fallback.
2. Serve static files through a CDN.
3. Turn on Brotli compression, with gzip as the fallback.
4. Find and remove dependencies nothing imports, and show the bundle size before and after.
5. Load third-party scripts (chat, analytics, ads) after the page is interactive.
6. Split the JavaScript per page or route so each page loads only its own code.
7. Set long cache headers on versioned static files.
8. Self-host the fonts and keep only the weights the design uses.

Fix how this app talks to its APIs:
1. Find places where the same request fires more than once and dedupe them (shared fetch, request caching or a data library).
2. Debounce search and autocomplete inputs so they don't query on every keystroke.
3. Paginate API results instead of returning everything.
4. Give every call to an outside API a timeout and a fallback.
5. Run requests that don't depend on each other in parallel.

Speed up the backend:
1. Move slow work (PDFs, emails, image processing, AI calls that the user doesn't wait on) to a background job queue.
2. Cache frequently read data in Redis with sensible expiry and invalidation.
3. Add OpenTelemetry tracing so we can see which part of a slow request takes the time.
4. Check that the app server and the database run in the same region, and tell me if they don't.
5. Make the app safe to run as several instances behind a load balancer (no in-memory sessions or local files it depends on).

Speed up the database work:
1. Find N+1 queries (a query inside a loop) and replace them with joins or batched queries.
2. Add indexes for the queries the app runs most, and show me the query plan before and after.
3. Select only the columns each query needs instead of SELECT *.
4. Use connection pooling, sized for where the app runs (serverless needs a pooler).

Set up a way to know if the app is actually fast:
1. Add real-user monitoring for Core Web Vitals (LCP, INP, CLS) from real visitors, not my laptop.
2. Give me the steps to test on a slow phone and slow network: Chrome DevTools CPU throttling and a slow 4G profile.