Performance & Efficiency rules

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.