Performance & Efficiency rules

Calling synchronous methods inside async code can block execution and reduce performance. Use awaitable methods to ensure proper async execution.

Process large tables with find_in_batches and avoid loading entire datasets.

Iterate large ActiveRecord sets with find_each/find_in_batches to stream records in batches.

Always use the Next.js Image component for images with width/height (or fill) and meaningful alt text. Avoid plain <img> for app assets.

Prefer thenCompose/thenCombine over blocking get/join; propagate async results end-to-end.

Use try-with-resources for Closeable/AutoCloseable objects to guarantee deterministic cleanup.

When callbacks/validations are not required, prefer a single UPDATE statement via update_all over iterating records and calling update.

Wrap IDisposable resources in using/await using to ensure deterministic disposal.

Ensure that value types (structs) implement `IEquatable<T>` for efficient equality comparisons, avoiding boxing and reflection.

Enable content versioning and long-lived caching via ResourceChain with VersionResourceResolver and set Cache-Control to public, max-age=31536000 for static locations; keep HTML templates non-immutable.

If a PR changes an API endpoint/controller/route, assess current production health before adding heavier logic. - If a monitoring MCP is available (Datadog/Grafana): query current p95 latency and error rate for that endpoint. - If the endpoint is already degraded, warn against adding heavy queries, blocking I/O, or complex synchronous logic; require performance evidence or a safe rollout plan. To enable this check, the PR should reference the endpoint path (e.g., `POST /api/payments`) or the controller/action name.

Run blocking I/O and CPU-intensive work inside withContext(Dispatchers.IO) or Dispatchers.Default respectively. Never block the main thread.

Mark compile-time constants and constant widgets with `const` to reduce rebuild cost and GC pressure.

Identify hot lookups/joins/sorts and add appropriate single/compound indexes in migrations.

Ensure that resources such as files, sockets, or database connections are managed using the `with` statement. Code that explicitly calls `.close()` without `with` should be refactored to use context managers for automatic resource cleanup.

Do not put complex logic or long-running tasks in package `init()` functions. Keep `init()` minimal (if you use it at all), such as simple registration of types or default variable initialization. Perform real setup in explicit functions (like in `main` or a setup function called by main).

Detect floating-point numbers with excessive precision. Overly precise numeric literals can cause rounding errors and unexpected behavior in calculations.

Animate transform/opacity; avoid top/left/width/box-shadow on large elements.

Be c sem areful when slicing out a small portion of a large slice or array. The resulting slice still references the entire original array. If you only need the small portion long-term, copy that data into a new slice to avoid keeping the large array in memory.

Do not perform multiple DB queries inside a loop for data you could fetch in one query. Instead, consolidate using IN clauses or JOINs to retrieve all needed data at once.

Never use a pointer to an interface type. Pass interfaces as values, since an interface already provides reference semantics to the underlying data.

Do not use pointers to slice or map types. Slices and maps are already reference types that point to underlying data, so they can be passed by value and still allow modifications to the contents.

Don't place a defer inside a loop that iterates many times (especially if the loop is performance-critical). Defer calls won't run until the function returns and each call has a small overhead; instead, perform the operation directly in the loop when possible.

In Kotlin Ktor, install CachingHeaders and Compression. Set immutable caching for hashed resources and no-cache for HTML; include "Vary: Accept-Encoding".