Performance & Efficiency code review rules

Blocking async methods with `.Result` or `.Wait()` can cause deadlocks and prevent efficient asynchronous execution. Use `await` instead for proper async behavior.

All static JS/CSS/font/image files MUST use content-hashed filenames (e.g., app.9c1a7b.js) and be served with "Cache-Control: public, max-age=31536000, immutable". HTML and other non-fingerprinted documents MUST be served with "Cache-Control: no-cache" (or equivalent) to enable conditional revalidation.

Unit tests must stub or fake external HTTP/DB calls; allow real I/O only in integration/e2e tests tagged accordingly.

Detect uses of `re.sub()` where regular expressions are not needed. For simple string replacements, `str.replace()` is more efficient and should be used instead.

Ensure that offset-based string methods are used instead of creating unnecessary substring instances.

Ensure that `String.replace()` is used when a simple string replacement is needed instead of `String.replaceAll()`.

Verify that when extracting substrings, a start index is specified to avoid unnecessary memory allocations.

Define constructors for `@immutable` classes as `const` to ensure that instances are created efficiently and cannot be modified.

Index frequently filtered or joined columns and verify with query plans.

`DateTime.Now` is affected by daylight savings and system clock adjustments. Use `Stopwatch` for more accurate timing.

Never use `v-if` on the same element as `v-for`.

Ensure that React list items do not use array indexes as keys. This practice can cause reordering issues and unexpected behavior. Recommend using unique identifiers instead.

Ensure that objects are not created solely for calling `getClass()`. Use `ClassName.class` instead.

Ensure that logging arguments and preconditions do not require costly evaluations before method calls.

Remove unnecessary calls to `.toList()` when using the spread operator (`...`) as it is already designed to work with iterable collections.

Remove unnecessary `.toList()` calls when using the spread operator (`...`) to avoid redundant operations.

Detect the use of .bind() or inline arrow functions inside JSX props. These create new functions on every render, impacting performance. Suggest moving function definitions outside the render method.

Ensure that `File.deleteOnExit()` is not used, as it can cause memory and resource leaks.

Ensure that the `finalize()` method is not used. Use try-with-resources or explicit cleanup methods instead.

Serve text-based assets (JS, CSS, JSON, SVG) with Brotli (br) when the client sends "Accept-Encoding: br" and fallback to gzip. Always set "Vary: Accept-Encoding" and do NOT compress already-compressed formats (e.g., .png, .jpg, .woff2).

Apply debounce/throttle to handlers that trigger network calls or heavy computation on rapid input.

Flag patterns that issue network/database calls inside loops; recommend batching (Promise.all), joins, or aggregate endpoints.

Check if React components are defined inside other components. Nested components are recreated on every render, causing unnecessary re-renders. Suggest moving them outside the parent component.

Ensure that `StringBuilder` instances are converted to strings using `ToString()` before use to prevent memory wastage.

Ensure that `ThreadLocal` variables are cleaned using `.remove()` to avoid memory leaks.

Check that JSX list components have unique key properties. Missing keys can cause unnecessary re-renders and lead to state inconsistencies.

Check if React list keys are stable and unique. Using dynamic values like Math.random() or Date.now() can cause rendering issues. Recommend using unique IDs.

Check if resources such as files or database connections are properly closed in a `finally` block. This ensures resources are always released, even if an exception occurs.

Serve precompressed .br/.gz variants when the client sends Accept-Encoding, set "Vary: Accept-Encoding", and apply immutable caching for hashed assets; keep HTML revalidatable.

In Express, use serve-static with setHeaders to apply "Cache-Control: public, max-age=31536000, immutable" for files matching /\.[0-9a-f]{8,}\./ and "Cache-Control: no-cache" for HTML. Also set correct Content-Type.

Prefer Server Components for pages/layouts and move interactivity to small leaf Client Components. Only add 'use client' where browser APIs or event handlers are strictly necessary.

For dynamic data use { cache: 'no-store' } or file-level dynamic = 'force-dynamic'. For ISR use { next: { revalidate: N, tags: [...] } }.

Keep middleware fast and side-effect free (no DB writes). Narrow the matcher and skip static assets. Use Route Handlers for heavy logic.

Prefer JOINs/eager loading over per-row queries to avoid N+1 patterns.

Ensure LINQ queries translate to SQL efficiently (avoid client evaluation, use projections, defer ToList until needed).

Validate inputs and preconditions up-front and return early before issuing any database queries.

Use `for` elements inside map literals instead of `Map.fromIterable` to improve readability and allow better compiler optimizations.

Use `SizedBox` instead of `Container` when adding spacing in layouts to improve performance and avoid unnecessary rendering overhead.

Preload render-blocking WOFF2 fonts using <link rel="preload" as="font" type="font/woff2" crossorigin> and define @font-face with "font-display: swap". Only preload fonts used above the fold.

Ensure that `HashMap` and `HashSet` are initialized with appropriate capacity settings to optimize performance.

Do not send direct identifiers (email, CPF) to analytics. Use an HMAC-based pseudonymous ID derived from user ID and a rotating key; never reversible without server secret.

Identify cases where React Context values are being reassigned dynamically. Unstable context values trigger unnecessary re-renders. Use memoization to stabilize them.

Provide AVIF/WebP fallbacks via <img srcset> with width/height attributes, meaningful sizes, and "loading=lazy" plus "decoding=async". Avoid shipping oversized PNG/JPEG when AVIF/WebP is supported.

Every container must specify resources.requests and resources.limits for cpu and memory.

Ensure that `Arrays.stream(array)` is used instead of `Arrays.asList(T... a).stream()` for primitive arrays.

Ensure that all literal values passed to constructors of `@immutable` classes are marked as `const` to prevent unnecessary object creation.

Ensure that `entrySet()` is used instead of iterating over `keySet()` and calling `get(key)`, to optimize performance.

Detect code where resources (files, sockets, etc.) are not closed in a `finally` block. Using `finally` ensures that resources are released, even if an exception is raised.

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".

Apply memoization (functools.lru_cache) or explicit caches for pure, expensive computations keyed by inputs.

Cache frequently used, rarely changing query results in memory or an external cache with appropriate TTL/invalidations.

Do not recompute expensive values inside loops; compute once and reuse.

Hoist and reuse costly objects (Pattern, DateTimeFormatter) rather than re-creating per use.

Memoize expensive results (regex, serializers, tokens) and refresh on expiry using a thread-safe cache.

Hoist constant work out of loops and memoize expensive computations when inputs repeat.

If a single-stage image must build native deps, remove compilers/headers after install and clear package caches in the same layer.

Ensure that multiple loops over the same collection are combined into a single loop to improve efficiency.

Hoist constant Regex/Formatters/Collections into top-level vals or companion objects; avoid recreating in hot paths.

Include clear, testable success metrics or SLOs in ADRs (e.g., p95 latency < 120ms, error rate < 0.1%) under a 'Measures of Success' section.

Use next/dynamic with { ssr: false } for large client-only components (maps, editors) and provide a lightweight loading fallback.

Avoid using element selectors (e.g., `button {... }`) directly within `<style scoped>`. Prefer class selectors.

When a TS package depends on another workspace package, tsconfig.json must set "composite": true and include a "references" entry to the dependency; root must aggregate paths via tsconfig.base.json if used.

Encapsulate coroutine parallelization (map async/awaitAll, limited concurrency) into utilities.

Hoist constant work (e.g., RegExp, static JSON, config loads) out of loops and cache results by input when feasible.

By default, use unbuffered channels or a buffer size of one. Only use larger buffers when necessary and carefully considered. Unbuffered channels (size 0) or a size of 1 are the most common; a large buffer can hide synchronization issues or lead to memory bloat if misused.

Guard expensive debug log formatting behind level checks or lazy formatting.

For pure functions called repeatedly with the same inputs, memoize results; avoid recreating identical callbacks in hot paths.

Cache expensive pure results using memoization (`||=`) or request-scoped caches.

Lift loop-invariant computations (regex, formatters, lookups) out of loops and reuse.

Prefer a single pass when possible (e.g., reduce) over multiple filter/map chains on the same array.

Instantiate expensive clients (DB/HTTP/SDK) once and inject/reuse them; avoid per-call construction.

Use executemany/bulk operations and commit in sensible batches for large writes.

Copy and install dependencies before application sources; ensure .dockerignore excludes node_modules and build outputs.

Exit loops as soon as the goal is achieved using break/return or use any/find/count short-circuiting operations.

Combine filters/maps to minimize passes; avoid creating intermediate collections unnecessarily.

Use appropriate column types/lengths (e.g., NVARCHAR(128) vs NVARCHAR(MAX)) for fields with known bounds.

Ensure that the `read(byte[], int, int)` method is overridden in `InputStream` subclasses to improve efficiency.

Detect string formatting using `.format()` or `%`. These methods are less readable and slower than f-strings. Recommend converting string formatting to f-strings for better readability and performance.

Use <Link> from 'next/link' for internal routes; reserve <a> only for external URLs or downloadable assets.

Ensure that event listeners are removed when no longer needed. Not doing so can lead to memory leaks and unnecessary resource consumption.

Avoid re-checking loop-invariant conditions inside iterations; lift them out.

Avoid unnecessary AsQueryable/ToList/Where/Select chains that do nothing; keep pipelines minimal.

Set sensible timeouts for queries/transactions and avoid excessively long timeouts that mask problems.

Serve assets with accurate Content-Type (e.g., text/css, application/javascript, image/avif, image/webp, font/woff2, image/svg+xml) and include charset for text types. Do not default to text/plain or application/octet-stream.

Configure UseStaticFiles with OnPrepareResponse to set "Cache-Control: public, max-age=31536000, immutable" for hashed assets and "no-cache" for HTML; ensure correct Content-Type (e.g., "font/woff2", "text/css").

In turbo.json, each task must set dependsOn (e.g., "^build") and outputs (e.g., "dist/"). Require cache:true for build/test/lint pipelines unless explicitly justified.

Replace `static final` with `const` where applicable to enable compile-time evaluation and optimize performance.

`string.Equals()` for checking empty strings is inefficient. Use `string.IsNullOrEmpty()` instead for clarity and performance.

Use the time package's types for handling time. For example, represent instants as `time.Time` and durations or time intervals as `time.Duration` instead of raw numeric types (int, int64).

Prefer set-based SQL (DELETE/UPDATE with WHERE IN/JOIN) or chunked batches over per-row statements.

Compute expensive derived values once per input set and reuse them rather than recalculating in multiple places.

For frequent key lookups, use Dictionary/ConcurrentDictionary instead of repeated linear scans.

When statically prebuilding dynamic segments, implement generateStaticParams and validate params; fall back to notFound() for invalid slugs.

Use HashSet<T> for repeated contains checks on large collections.

Stream results (cursor/generator) or paginate instead of loading entire result sets into memory.

Prefer comprehensions over map/filter chains and avoid double-sorting or sorting inside loops.

Prefer direct Map access over linear scans when looking up by key.

Load fonts via next/font (google or local) and apply on html/body; avoid runtime <link> to fonts that cause FOUT/CLS.

For third-party scripts, use <Script> with an appropriate strategy and onLoad callbacks. Avoid dangerouslySetInnerHTML for scripts.

Combine ActiveRecord relations with `or` instead of materializing arrays or concatenating results.

For large sets, prefer a periodic sweep job rather than spawning one job/timer per item.

Extract repeated inline collections to unmodifiable static constants.

Use String#replace for literal substrings instead of replaceAll unless regex is required.

Use StringBuilder for many concatenations in loops or when building large strings.

Prefer Struct (or value objects) over OpenStruct for performance and type clarity.

Check for cases of string concatenation using +. Template literals improve readability and are less error-prone.

Ensure that resources such as streams or file handlers are managed using try-with-resources to avoid leaks.