Coding Rules Library

Rules Hub

Coding Rules Library

Quick stacks

Model a binary state as a boolean/enum, not a nullable

When a value is inherently two-state (connected/disconnected, on/off), model it as a boolean or a two-case enum, not `T?`/nullable. A third `null` state that can never legitimately occur forces meaningless null handling everywhere and hides bugs behind an impossible case.

modelingnull-safetytypes

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Kotlin

frontend ruleP2

Centralize user-facing strings in a single constants module

Collect repeated user-facing strings (error/success messages, labels, locale codes) into one `as const` object or enum instead of scattering literals across code and tests. A single source keeps wording consistent, makes it reusable in assertions, and is the first step toward i18n.

constantsi18nmaintainability

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026TypeScript

mobile ruleP1

Own observable objects with @StateObject, inject them with @ObservedObject

Use `@StateObject` in the view that creates and owns an observable object's lifecycle; use `@ObservedObject` (or `@EnvironmentObject`) in views that receive one created elsewhere. Re-declaring an injected object as `@StateObject` gives it a second, view-local lifecycle and detaches it from the real source of truth.

swiftuistatelifecycle

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026SwiftUI

mobile ruleP2

Decompose complex SwiftUI view bodies with @ViewBuilder members

Break a large SwiftUI `body` into small `@ViewBuilder` computed properties or subviews (often in a private extension). Deeply nested single-expression bodies overwhelm the type-checker, which then reports errors at the wrong line or fails to compile; smaller pieces also read better and localize errors.

swiftuireadabilitycompiler

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026SwiftUI

mobile ruleP2

Use named arguments for non-obvious call sites

Pass named arguments when a call has several parameters, booleans, or same-typed values whose meaning isn't obvious from position (DI wiring, constructors, config). Names make the call self-documenting and guard against silently swapping two positional args of the same type.

kotlinreadability

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Kotlin

mobile ruleP2

Register repositories as singletons in the DI container

Bind repositories (and other stateless, shared-resource services) as singletons rather than factory/new-per-injection. They wrap a shared data source and hold no per-caller state, so a new instance per injection wastes allocations and can duplicate caches/connections.

dependency-injectionkotlinkoin

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Kotlin

mobile ruleP1

Keep UI-state types out of use cases and domain logic

A use case encapsulates business logic and must not depend on UI-layer types (snackbar/toast models, view state). Return a domain result (`Result<Domain, Error>`) and let the view model translate it into UI state. Mixing the layers couples business logic to the UI and blocks reuse/testing.

clean-architectureseparation-of-concernskotlin

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Kotlin

mobile ruleP2

Don't create pass-through use cases

Skip a use-case/interactor class when it only forwards to a repository with no added business logic. A one-line delegator is indirection without value; introduce a use case only when it encapsulates real logic (validation, orchestration, mapping). Call the repository directly otherwise.

clean-architecturekotlinabstraction

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Kotlin

backend ruleP2

Don't put validation decorators on response DTOs

Class-validator decorators only run through the validation pipe on incoming request payloads. Adding them to response/output DTOs does nothing but implies a guarantee that isn't enforced. Keep response DTOs as plain shape/serialization types.

nestjsdtovalidation

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026NestJS

backend ruleP2

Type an ORM schema/model with its generic instead of casting

Pass the domain type as the schema/model's type argument (e.g. `new Schema<Applicant>()`) so queries return typed results, instead of returning loose objects and sprinkling `as T` casts at the call sites. The generic gives real type-checking; the cast only silences the compiler.

typescriptormtyping

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026TypeScript

backend ruleP1

Reuse a single database connection, don't reconnect per call

Create the DB connection/pool once and share it, rather than instantiating a new client on each operation or script step. Repeated connections exhaust the connection limit, add latency, and defeat pooling.

databaseconnectionperformance

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Node.js

backend ruleP1

Handle the null result of a single-record lookup

A `findOne`/`findByPk`/`find` that matches nothing returns null/undefined, not an error. Guard the not-found case (throw a named error or return early) before dereferencing, or the next property access throws a generic runtime error.

ormnull-safetyerror-handling

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Node.js

backend ruleP0

Scope data queries to the authenticated user

Always constrain read/update/delete queries for user-owned resources by the current user's id (or verify ownership before mutating). Filtering only by resource id lets any authenticated user access or modify another user's records — a broken-object-level-authorization (IDOR) vulnerability.

securityauthorizationidor

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Node.js

frontend ruleP2

Render static content on the server, not as a client island

In island/hybrid frameworks (Astro, RSC), keep purely static, non-interactive content as server-rendered markup rather than shipping it as a client component. Client islands add JS and hydration cost and can hide content from crawlers for no benefit when there's no interactivity.

astrossrseoperformance

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Astro

frontend ruleP2

Eager/priority-load only above-the-fold images

Mark only images visible in the initial viewport as eager/`priority`; let everything below the fold lazy-load (the default). Eager-loading off-screen images competes with the LCP image for bandwidth and hurts initial load performance.

performanceimageslcp

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026React

frontend ruleP1

Scope CSS-module selectors under a class

In a CSS/SCSS module, start every rule with a locally-scoped class. Bare tag selectors and `*` are not localized by the module and leak globally to the whole document. Nest global-ish resets under the component's root class.

css-modulesscopingbug

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026CSS Modules

frontend ruleP2

Avoid the universal selector; target explicit classes

Prefer explicit class selectors over `*` or `& > *`. The universal selector is opaque about what it styles, applies broadly, and is easy to leak or mis-scope; a named class documents intent and limits the blast radius.

cssselectorsmaintainability

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026CSS

frontend ruleP2

Omit the unit on a zero length in CSS

Write `0`, not `0px`/`0rem`/`0em`, for zero lengths. Zero is unitless in CSS and the unit adds noise. (Keep the unit only where a unit is required, e.g. some `calc()` operands and angle/time zeros.)

cssstylenitpick

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026CSS

frontend ruleP2

Define palette colors as opaque hex, not rgba

Store design-system/theme colors as solid hex values, not `rgba()` with baked-in alpha. A translucent token renders differently over every background, so it can't be a reliable single source of truth; apply opacity only where a specific overlay effect is actually intended.

cssdesign-systemcolor

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026CSS

testing ruleP2

Write failure and validation tests before the happy path

Order a test suite so error, validation and edge cases come before the success case. Tests run top-to-bottom in the order the code evaluates guards, so leading with failures verifies the guards actually fire before the happy path is reached, and reads as a spec of what the code rejects.

testingstructure

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Testing

backend ruleP2

Read env vars and constants once, not inside hot functions

Resolve `process.env` values and other invariant constants once at module load / class construction, not on every function call. Env values never change during a process lifetime, so re-reading and re-deriving them per invocation is wasted work and scatters magic strings.

performanceconfigconstants

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026Node.js

frontend ruleP2

Trim and normalize free-text user input before using it

Trim (and normalize, e.g. strip formatting separators) text the user types or pastes before validating, comparing or sending it. Pasted values routinely carry leading/trailing whitespace and formatting characters that make an otherwise-valid input fail.

formsinputvalidation

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026JavaScript

frontend ruleP2

Format currency and numbers with Intl.NumberFormat

Use `Intl.NumberFormat` (a shared, memoized instance) for currency, decimals and locale-aware number formatting instead of hand-rolled string concatenation. It handles locale separators, currency symbols and rounding correctly. Constructing a formatter per call is slow, so reuse one.

i18nformattingmoney

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026JavaScript

backend ruleP1

Never use floating-point numbers for money

Represent monetary amounts as integer minor units (cents) or a decimal type, and only format to a float for display. JS `number` is IEEE-754 binary floating point, so arithmetic like 0.1 + 0.2 drifts and rounding errors accumulate in totals.

moneyprecisioncorrectness

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026JavaScript

backend ruleP1

Match errors by type, not by message string

Branch on `instanceof` a known error class (or a discriminant field), never on `error.message.includes(...)`. Message text is unstable, locale-dependent and owned by third-party libs, so string matching silently breaks and misclassifies unrelated errors.

error-handlingrobustness

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026JavaScript

backend ruleP2

Use constructor parameter properties instead of manual field assignment

When a class field is just assigned from a constructor argument, declare it inline with an access modifier on the parameter. It removes the duplicated field declaration + assignment and keeps the class shorter.

typescriptoopreadability

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026TypeScript

frontend ruleP2

Use type-only imports for types

Import types with `import type` (or an inline `type` specifier). Under verbatimModuleSyntax/isolatedModules a value-style import of a type is not erased and can pull runtime code in or fail the build. It also documents intent: this symbol is only used for typing.

typescriptimportsbuild

profico-org-corpus batch2 (all stacks/products)

Jul 26, 2026TypeScript

backend ruleP2

Don't repeat the resource or an action verb in a REST route path

Routes in routes/user.js are already under /user, and an /update segment is redundant when the method is PUT/PATCH; let the mount point and HTTP method carry that meaning.

restroutingapi-designhttp

profico-mining-2026-06

Jul 26, 2026node

fullstack ruleP1

Add a tiebreaker so sorts are deterministic on equal keys

When the sort key can repeat (name, count), rows with equal keys can come back in any order across queries; add a stable secondary key (e.g. id) so order is deterministic.

sqlsortingdeterminismpaginationbug

profico-mining-2026-06

Jul 26, 2026sql

frontend ruleP2

Transition specific properties, not `all`

`transition: all` forces the browser to watch every property for changes; list the exact properties you animate (and pull duration/easing into variables).

csstransitionperformance

profico-mining-2026-06

Jul 26, 2026css

frontend ruleP2

Use @use instead of @import in SCSS

@import is deprecated in Sass and dumps everything into the global namespace; use @use (with a namespace) so partials are scoped and loaded once.

scsssassmodulesnamespace

profico-mining-2026-06

Jul 26, 2026css

fullstack ruleP1

Respect architecture layer boundaries — don't reach across them

Keep data-layer types out of the domain layer and application-level decisions out of pure business use-cases; each layer depends only inward, through its defined interfaces.

architectureclean-architecturelayeringseparation-of-concerns

profico-mining-2026-06

Jul 26, 2026universal

mobile ruleP1

Inject coroutine dispatchers instead of referencing them directly

Depend on an injected dispatcher (from a DispatcherModule) rather than hardcoding Dispatchers.IO/Default, so coroutines are testable with a test dispatcher.

kotlincoroutinesdispatcherstestabilitydi

profico-mining-2026-06

Jul 26, 2026kotlin

mobile ruleP2

Order @Preview before @Composable on preview functions

For preview functions, put @Preview above @Composable so previews are consistently annotated.

androidcomposepreviewconvention

profico-mining-2026-06

Jul 26, 2026android

mobile ruleP2

Put modifier: Modifier first among a composable's parameters

Follow the Compose convention of the optional `modifier: Modifier = Modifier` being the first parameter (after required ones) for consistency and readability.

androidcomposeconventionmodifier

profico-mining-2026-06

Jul 26, 2026android

backend ruleP2

Use the ORM's built-in create/update methods instead of hand-rolling

Reach for Model.create / Model.update / findOneAndUpdate rather than manually composing the steps they already encapsulate — it's less code and fewer bugs.

ormsequelizemongoosedry

profico-mining-2026-06

Jul 26, 2026node

backend ruleP1

Define explicit column types, table name and primary key in ORM models

Don't leave an ORM model relying on inference; declare the table name, primary key, and each column's DB data type explicitly.

ormsequelizemodelschema

profico-mining-2026-06

Jul 26, 2026node

backend ruleP0

Never leave ORM auto-synchronize on for production

Set synchronize:false (TypeORM/Sequelize) and manage schema via migrations; auto-sync can drop or alter production tables. Keep DB credentials in env, not code.

ormtypeormsequelizemigrationsproductionsecurity

profico-mining-2026-06

Jul 26, 2026node

backend ruleP1

Give NestJS DTO members access modifiers, validators, and @ApiProperty

Every DTO property should have an explicit access modifier, a class-validator decorator (required/optional), and an @ApiProperty for Swagger docs.

nestjsdtovalidationswaggertypescript

profico-mining-2026-06

Jul 26, 2026node

backend ruleP2

Use the null-conditional operator instead of a ternary null check

Replace `x != null ? x.Y : null` with `x?.Y` — the null-conditional operator is shorter and expresses the same intent.

csharpnull-safetyreadabilitydotnet

profico-mining-2026-06

Jul 26, 2026csharp

fullstack ruleP2

Don't compute the same expensive test output twice

When multiple suites assert against the same expensive result (a rendered page, a built artifact), merge the assertions into one test or share the computed value instead of recomputing it per suite.

testingperformancestructure

FCK-3307 Improve the order of <head> elements

Jul 16, 2026testing

fullstack ruleP2

Keep test-only helpers in a test directory

Test utilities must not sit next to production source where they read as app code; place them under test/ (or a __tests__/ folder co-located with their specs).

project-structuretestingconventions

FCK-3307 Improve the order of <head> elements

Jul 16, 2026testing

fullstack ruleP1

Register runtime-read files as watch dependencies in tests

When a test reads or renders files at runtime (templates, fixtures) instead of importing them, watch mode never reruns on their changes; register them as module dependencies (e.g. Vite's import.meta.glob with eager + ?url) and derive the test list from those keys.

vitestvitewatch-modefixtures

FCK-3307 Improve the order of <head> elements

Jul 16, 2026testing

frontend ruleP2

Prefer firstElementChild over children[0]

Use semantic DOM accessors (firstElementChild, lastElementChild) instead of positional indexing into children; they state intent and are typed with null in the contract.

domreadability

FCK-3307 Improve the order of <head> elements

Jul 16, 2026typescript

frontend ruleP2

Use document.head/document.body instead of querying singleton elements

The document object exposes head and body directly and always defined; querySelector('head') plus a null guard is redundant noise.

domreadabilitytesting

FCK-3307 Improve the order of <head> elements

Jul 16, 2026typescript

api-design ruleP1

Verify no external consumers before renaming or removing an API endpoint

Before renaming or deleting an HTTP endpoint, search beyond the current repo for its route string: sibling repos, org-wide code search, and native/mobile apps. Raw fetch URL strings are invisible to typecheck and build, so grep for the literal path. If an external caller exists, migrate it in the same change or defer the rename with an alias — never ship a dangling rename.

apiendpointsrenamebreaking-changecross-repo

FCK-3218 rename watchlist to portfolio (hegnar-forum-web)

Jul 16, 2026any

testing ruleP2

Pass import() to vi.mock instead of a bare module string

Mock modules with vi.mock(import('path/to/module')) rather than vi.mock('path/to/module'). The import() form is type-checked: the module path is validated by TypeScript, and the factory/mocked result is typed to the real module's shape, so typos, moved files, and drifted mock shapes fail at compile time instead of silently.

vitestmockingtype-safetytests

FCK-3218 rename watchlist to portfolio (hegnar-forum-web)

Jul 16, 2026vitest

testing ruleP2

Assert element presence with retryable accessibility locators, not document.querySelector

In component/browser-mode tests, check for an element's presence or absence with a retryable accessibility locator (`await expect.element(page.getByRole(...)).toBeInTheDocument()` / `.not.toBeInTheDocument()`) instead of a one-shot `document.querySelector(...)` read. The role query mirrors how users and assistive tech find elements, and the awaited matcher waits for the DOM to settle. Only reach for a more specific query (e.g. getByRole with a name, or includeHidden) when several elements share the same role.

testingbrowser-modeaccessibilityqueryselectorvitest

silvenon PR review FCK-3150 (zephr-components)

Jul 13, 2026typescript

correctness ruleP1

Propagate a lookup's not-found result instead of forwarding it into unconditional dereferencing code

If a lookup can return null/undefined for "not found", check for that at the call site and return early — don't pass the possibly-missing result into a helper that unconditionally spreads or reads properties off it, since that turns a normal "not found" case into an uncaught runtime throw.

null-safetyerror-handlingcorrectness

startsiden/hegnar-journalist-boost#548

Jul 13, 2026TypeScript

readability ruleP2

Consolidate duplicate/adjacent doc comments left over from a refactor

When renaming or splitting a function, merge any leftover JSDoc block with the new one you add — two consecutive doc blocks above the same declaration duplicate or contradict each other and make the header harder to read.

documentationrefactoringreadability

startsiden/hegnar-journalist-boost#548

Jul 13, 2026TypeScript

reliability ruleP1

Handle pre-existing pooled resources when patching via a "new resource" event

A listener on a pool's "new connection/resource" event only fires for instances created *after* the listener is registered. Resources opened earlier (e.g. during startup migrations, before your bootstrap phase runs) must be patched explicitly — don't rely on a single one-off call happening to catch the only pre-existing instance.

concurrencystartupconnection-poolreliability

startsiden/hegnar-user-ws#211

Jul 13, 2026Node.js

type-safety ruleP2

Type loosely-shaped upstream data as unknown and validate before use

When a field comes from an upstream type that's only loosely typed (e.g. `{ [key: string]: any }`), accept it as `unknown` in the function that reads it and runtime-check each value before use, instead of trusting the declared shape.

typesvalidationexternal-data

startsiden/hegnar-web#4554

Jul 13, 2026TypeScript

readability ruleP2

Name a helper after everything it does, not just its primary transform

If a function does more than its name implies (e.g. also normalizes a protocol prefix on top of converting to absolute), rename it to reflect the full behavior — a narrow name hides intent from the next reader deciding whether it's safe to reuse.

namingreadabilitymaintainability

startsiden/hegnar-web#4554

Jul 13, 2026TypeScript / Node.js

readability ruleP2

Name computed values after their standardized platform meaning, not an ad hoc synonym

When a variable represents a well-known concept (e.g. protocol + host), use the platform-standard name for it (`origin`) instead of inventing a new name (`baseUrl`) — otherwise every reader has to relearn what the custom name means.

namingreadabilityconventions

startsiden/hegnar-web#4566

Jul 13, 2026TypeScript / Node.js

testing ruleP2

Write component and client-side tests in Browser Mode, not happy-dom/jsdom

Test components and client-side code in a real browser (Vitest Browser Mode via Playwright) rather than a simulated DOM (happy-dom/jsdom). Simulated environments miss real layout, events, and browser behaviour; treat existing happy-dom component tests as legacy to phase out.

testingvitestbrowser-modehappy-domjsdom

silvenon PR review FCK-3150

Jul 10, 2026typescript

correctness ruleP2

Match a known-position marker with startsWith/endsWith, not includes

When checking for a marker that must sit at a specific position (a prefix or suffix), use startsWith/endsWith rather than includes. includes matches the substring anywhere, which risks false positives when the same characters legitimately appear elsewhere in the value.

stringsstartswithincludesfalse-positives

silvenon PR review FCK-3150

Jul 10, 2026General

clean-code ruleP2

Prefer plain truthiness over the !! double-negation

In boolean contexts (if conditions, `&&` chains feeding a ternary or JSX), rely on the value's own truthiness (`value && ...`) instead of coercing with `!!value`. The double negation is noise; reach for `!!` only when a real boolean is genuinely required (a boolean-typed prop, state, or return).

typescriptbooleanreadabilityclean-code

silvenon PR review FCK-3150

Jul 10, 2026typescript

correctness ruleP1

Preserve empty-string-as-absent when replacing a truthiness check

When refactoring a truthiness guard (`value ?` / `if (value)`) into a more explicit condition, keep a truthiness check (`!!value` / `value && ...`) rather than switching to `value != null` / `!== undefined`. Otherwise an empty string passes as 'present' and leaks through as an empty src/href/label.

correctnessempty-stringguardsrefactoring

Pre-PR review FCK-3150

Jul 10, 2026General

type-safety ruleP1

Don't rely on Boolean() to narrow a possibly-undefined value

Boolean(x) is not a type guard in TypeScript: after `Boolean(x) && ...` the value is still possibly undefined, so calling a method on it fails strict null checks (TS18048). Narrow with a truthiness guard (`x && ...` / `!!x && ...`) or an explicit null check before dereferencing.

typescriptnarrowingstrict-null-checksundefined

Pre-PR review FCK-3150

Jul 10, 2026typescript

workflow ruleP2

A passing test run doesn't prove the code type-checks

Test runners (Vitest/Jest via esbuild/swc) transpile by stripping types without checking them, so a green test suite can hide type errors. Run the project's typecheck (tsc) separately before treating a change as done.

testingtypechecktscworkflow

Pre-PR review FCK-3150 (self-review findings)

Jul 10, 2026typescript

clean-code ruleP1

Don't add code comments unless truly necessary

Do not add explanatory code comments by default. Write self-documenting code (clear names, small functions) instead. Only add a comment when the code genuinely cannot express something on its own — a non-obvious 'why', a workaround, or a real gotcha.

commentsclean-codereadabilityself-documenting

User directive 2026-07-10

Jul 10, 2026General

communication ruleP1

State which repository the changes were made in

When reporting completed work or edits, always explicitly name the repository the changes landed in (and the branch when relevant), so it is never ambiguous which repo was touched.

communicationworkflowreportingrepository

User directive 2026-07-10

Jul 10, 2026General

code-review ruleP1

Fetch the branch and latest master locally before reviewing a PR

Before reviewing any pull request, branch, or commit, fetch the target branch AND the latest master locally, then diff the branch against master (three-dot) to review the complete change set in the context of the current codebase. Never review only the raw PR patch: without the master baseline you cannot see how the branch diverges from live master, whether the branch is stale/behind, or what the surrounding code looks like now — which is exactly what tells you whether the change is correct and whether it could have been done better. Prefer diffing origin/master...origin/<branch> over switching the working tree, so the reviewer's own checked-out branch is left untouched.

code-reviewgitworkflowprocess

manual rule request (2026-07-10): pull branch + master locally before every review

Jul 10, 2026git

css ruleP2

Use the repeat() notation for repeated grid tracks

Define repeated CSS grid tracks with the repeat() function instead of writing the same track value several times in a row, for example `repeat(3, 1fr)` rather than `1fr 1fr 1fr`. It states the repetition once and is easier to change.

cssgriddryreadabilitygrid-template-columns

FCK-3172 updates bors page (silvenon review)

Jul 6, 2026css

css ruleP2

Group selectors or use a custom property for a shared CSS value

When the same value (height, color, size) is set on an element and a descendant, or repeated across rules, group the selectors with a comma (e.g. `&, .child { height: X }`) or extract a custom property, instead of writing the declaration twice.

cssdryreadabilitycustom-properties

FCK-3172 updates bors page (silvenon review)

Jul 6, 2026css

css ruleP2

Do not comment idiomatic CSS like minmax(0, 1fr)

Skip explanatory comments for well-known, idiomatic CSS. minmax(0, 1fr) is standard grid track sizing that any CSS Grid user recognizes, not an obscure hack, so it does not need a comment explaining what it does. If a CSS comment is genuinely kept, use precise layout terminology (say the grid would 'overflow', not 'stretch').

csscommentsgridreadability

FCK-3172 updates bors page (silvenon review)

Jul 6, 2026css

correctness ruleP2

Don't add a null check for a case an existing success flag already rules out

Before adding an extra `=== undefined` guard alongside a `.success`/discriminant check, verify whether the failure branch already covers that case — a redundant condition just adds noise without changing behavior.

typescriptredundancyreadability

startsiden/hegnar-forum-web#1873

Jul 6, 2026TypeScript

correctness ruleP2

Keep the null vs undefined convention consistent across sibling optional properties

Pick one absent-value convention (null or undefined) for a group of related optional properties and apply it uniformly, rather than mixing null for some and undefined for others in the same interface.

typescriptnull-safetyconsistency

startsiden/hegnar-components#331

Jul 6, 2026TypeScript

readability ruleP2

Don't introduce a new synonym for a concept that already has an established name

When adding a new type/field, reuse the codebase's existing name for the concept (e.g. "article") instead of a new synonym (e.g. "story") — two names for the same thing invites confusion about whether they're actually different.

namingconsistencyreadability

startsiden/hegnar-web#4554

Jul 6, 2026TypeScript

readability ruleP2

Don't reuse a library's internal type-naming convention as your own domain vocabulary

When a dependency uses an implementation-detail suffix in its type names (e.g. schema-dts's `*Leaf`), don't adopt that word in your own comments/prose as if it were a shared domain term — it confuses readers unfamiliar with the library's internals.

namingdocumentationreadability

startsiden/hegnar-web#4551

Jul 6, 2026TypeScript

readability ruleP2

Give similarly-named sibling parameters distinct, purpose-revealing names

When two options serve genuinely different roles but share a generic name pattern (e.g. homeName vs pageName), name them so the distinction is obvious, or add a one-line comment — don't leave a reviewer wondering if they can be merged.

namingapi-designreadability

startsiden/hegnar-web#4551

Jul 6, 2026TypeScript

correctness ruleP2

Extract one validity predicate when the same rule applies to two input paths

When a calendar/picker enforces the same validity rules through two separate entry points (click vs typed text), centralize the check into a single function reused by both — divergence between paths causes inconsistent UI behavior.

dryvalidationreactcorrectness

startsiden/hegnar-components#331

Jul 6, 2026React / TypeScript

frontend ruleP2

Let web-component boolean attributes be explicitly set to false

When validating a web component's attribute values, don't treat the literal string 'false' as an invalid/absent value — that makes it impossible to explicitly opt out if the attribute's default behavior ever flips.

web-componentsapi-designattributes

startsiden/hegnar-components#331

Jul 6, 2026Web Components

testing ruleP2

Verify a test assertion can actually fail before relying on it

Before adding an assertion meant to catch a specific bug, check that a broken implementation would actually make it fail — an assertion that's structurally always true tests nothing.

testingcorrectnessassertions

startsiden/hegnar-bellsheep-web#394

Jul 6, 2026TypeScript / Vitest

workflow ruleP2

Locally build and run a Docker image before merging Dockerfile changes

After changing a Dockerfile, build and run the image locally before merging — don't rely solely on CI to catch build breakage.

dockerciprocess

startsiden/hegnar-bellsheep-web#394

Jul 6, 2026Docker

workflow ruleP2

Copy config files only into the Docker build stages that need them

In multi-stage Dockerfiles, COPY a file (e.g. a workspace manifest) only into the stages that actually consume it, not into every stage.

dockerbuildmonorepo

startsiden/hegnar-bellsheep-web#394

Jul 6, 2026Node / Docker

testing ruleP2

Add test-only formatting in the test file, not the shared serializer

When a security-sensitive serialization function's output is hard to read in snapshots, add a pretty-printing wrapper in the test file — don't change the shared function's behavior between test and production.

testingsnapshotssecurityserialization

startsiden/hegnar-web#4547

Jul 6, 2026TypeScript / Vitest

backend ruleP2

Check an identity provider's secondary fields, not just the primary identifier

When resolving a user's email from an external IdP, fall back to the attributes bag — some users have a different primary identifier (e.g. phone) with email only present as a secondary attribute.

identityauthenticationexternal-apicorrectness

startsiden/hegnar-user-ws#208

Jul 6, 2026TypeScript / Node.js

backend ruleP2

Track backfill/batch job progress with an explicit processed flag

Mark each row processed after an attempt (success or empty result), don't infer completion from whether the target field ended up populated.

backfillbatch-jobsidempotencycorrectness

startsiden/hegnar-user-ws#208

Jul 6, 2026TypeScript / Node.js

mobile ruleP2

Pass one listener interface when a view needs several callbacks

When an adapter/view needs multiple click callbacks, define a single interface with those methods and pass one instance, instead of several separate lambdas.

androidadapterinterfacecallbacks

mobile-mining-2026-06

Jul 5, 2026android

mobile ruleP2

Implement the Android splash via a launcher theme, not a SplashActivity

Use android:windowBackground on the launch theme (or the SplashScreen API) instead of a dedicated SplashActivity that adds a redundant screen and delay.

androidsplashstartuptheme

mobile-mining-2026-06

Jul 5, 2026android

mobile ruleP1

Localize every user-facing string

Run visible text through the localization system (.localize()/NSLocalizedString/strings resources), never hardcode display copy in the view.

mobilei18nlocalization

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP2

Don't use trailing-closure syntax when passing more than one closure

With multiple closure arguments, label them all explicitly instead of trailing the last one, so it's clear which closure is which.

swiftclosuresreadabilityswiftlint

mobile-mining-2026-06

Jul 5, 2026swift

mobile ruleP2

Use .absolute over .estimated for fixed-size collection layout items

When an item's height is fixed (e.g. single-line label), use NSCollectionLayoutDimension.absolute instead of .estimated to skip self-sizing recalculation and scroll more smoothly.

ioscollectionviewperformancelayout

mobile-mining-2026-06

Jul 5, 2026ios

mobile ruleP1

Handle unknown/unmapped backend enum values gracefully

When decoding a string into an enum, account for values the app doesn't know (new server states) with a default/unknown case instead of crashing or misbehaving.

mobileenumdecodingrobustness

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP2

Iterate an enum with CaseIterable.allCases, not a hardcoded list

When an enum is CaseIterable, use allCases (and rawValue) instead of manually listing cases, so adding a case doesn't require editing every list.

swiftenumcaseiterabledry

mobile-mining-2026-06

Jul 5, 2026swift

mobile ruleP2

Map snake_case JSON to camelCase with CodingKeys

Keep Swift properties camelCase and map wire names via CodingKeys (or a keyDecodingStrategy) instead of naming properties snake_case.

swiftcodablejsonnaming

mobile-mining-2026-06

Jul 5, 2026swift

mobile ruleP2

Guard debug/preview-only code with #if DEBUG

Nice-to-have logging, preview seams and test hooks should be compiled out of release builds with #if DEBUG / #if DEV.

swiftdebugbuildspreview

mobile-mining-2026-06

Jul 5, 2026swift

mobile ruleP1

Execute completion callbacks before dismissing/deallocating a view

If you dismiss (or pop) a view before its selected-action callback runs, deallocation can cancel the remaining code; run the callback first or from the dismiss completion.

ioslifecyclecallbacksbug

mobile-mining-2026-06

Jul 5, 2026ios

mobile ruleP1

Percent-encode dynamic values before putting them in a URL

Interpolating user/search text straight into a URL breaks on spaces and special characters; percent-encode the query component.

mobileurlencodingnetworking

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP1

Never put a live MapView inside a reusable cell

Embedding MKMapView/MapView in a recycled list cell spikes memory and stutters; render a cached static map image (with annotation) instead.

mobileperformancemapscellsmemory

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP1

Reuse a shared DateFormatter, don't create one per call

DateFormatter is expensive to allocate; create it once (static/shared util) and reuse it rather than instantiating per format call.

mobileperformancedateformatterdry

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP2

Put derived model values in computed properties/extensions

Compute display/derived values (formatted price, vintage, full name) in a computed property or model extension instead of unwrapping inline at each call site.

swiftmodelextensiondry

mobile-mining-2026-06

Jul 5, 2026swift

mobile ruleP1

Make model fields optional when the backend may omit them

If the API can return null/absent for a field, decode it as optional so decoding doesn't fail; keep only truly-guaranteed fields (like id) non-optional.

mobilecodablejsonnull-safety

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP2

Configure UIKit subviews in a property closure, not in setup code

Declare and configure a subview in a lazy/immediately-invoked property closure so its config lives with its declaration instead of scattered in setupUI.

iosuikitreadability

mobile-mining-2026-06

Jul 5, 2026ios

mobile ruleP2

Give custom views/cells a consistent init + setup structure

Custom UIView/UITableViewCell subclasses should share one init pattern (commonInit → setupUI → setupConstraints) instead of ad-hoc per-cell setup.

iosuikitview-setupconsistency

mobile-mining-2026-06

Jul 5, 2026ios

mobile ruleP1

Access UserDefaults/SharedPreferences through one settings service

Don't read/write UserDefaults or SharedPreferences directly from view controllers; centralise them behind a settings service.

mobilepersistenceuserdefaultsarchitecture

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP1

Put environment-specific values in build config, not hardcoded

Base URLs and per-environment values belong in Gradle BuildConfigField / an .xcconfig keyed to build type, not hardcoded in source.

mobileconfiggradleenvironments

mobile-mining-2026-06

Jul 5, 2026mobile

mobile ruleP1

Keep mobile tests deterministic — mock the network and clock

Tests that hit the real network or wall clock are flaky; inject and mock network, time and randomness.

mobiletestingflakymocking

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Unit-test business logic in view models/use-cases

Put logic in testable, UI-free types (view models, use cases) and unit-test them; don't hide logic in view controllers/activities.

mobiletestingarchitecture

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Cancel in-flight requests/tasks when the screen goes away

Requests tied to a screen must be cancelled on teardown so callbacks don't fire into a dead view or waste bandwidth.

mobilelifecyclecancellationmemory

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Downsample large images to the display size

Loading full-resolution images into small views wastes memory and can OOM; downsample/resize to the target size (or use an image lib).

mobileperformanceimagesmemory

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Access data through a repository, not directly from the UI

Route network/DB access through a repository so caching, offline and error handling live in one place and the UI stays thin.

mobilearchitecturerepository

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Decode JSON with typed models and handle decode failures

Use Codable / kotlinx.serialization / Moshi with explicit types and handle the failure path instead of assuming the shape.

mobilejsondecodingerror-handling

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Map network DTOs to domain models at the boundary

Don't pass raw API response types through the app; decode into DTOs and map to domain models so the UI doesn't depend on wire shape.

mobilearchitecturedtomapping

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Run side effects in Compose effect handlers, not in composition

Launching work or mutating external state directly in a composable body runs on every recomposition; use LaunchedEffect/DisposableEffect.

androidcomposeside-effectslaunchedeffect

mobile-canon-2026-06

Jul 5, 2026android

mobile ruleP1

Provide stable keys in LazyColumn/LazyRow items

Without a stable key, Compose can't track item identity across changes, hurting state retention and animations.

androidcomposelazy-listkeys

mobile-canon-2026-06

Jul 5, 2026android

mobile ruleP1

Hoist state out of composables; keep them stateless

A reusable composable should take state + callbacks as parameters, not own mutable state, so it stays testable and reusable.

androidcomposestate-hoisting

mobile-canon-2026-06

Jul 5, 2026android

mobile ruleP0

Don't hold Activity/Context references in long-lived objects

Static or long-lived references to an Activity/Context leak the whole view tree; use applicationContext or weak refs.

androidmemorycontext-leak

mobile-canon-2026-06

Jul 5, 2026android

mobile ruleP1

Keep UI state in a ViewModel that survives config changes

State stored in the Activity/Fragment is lost on rotation; hoist it into a ViewModel so it survives configuration changes.

androidviewmodellifecyclestate

mobile-canon-2026-06

Jul 5, 2026android

mobile ruleP1

Run blocking work on Dispatchers.IO, not the main dispatcher

Network/disk work must run off the main dispatcher; wrap it in withContext(Dispatchers.IO) so the UI stays responsive.

kotlincoroutinesdispatchersthreading

mobile-canon-2026-06

Jul 5, 2026kotlin

mobile ruleP0

Launch coroutines in a lifecycle scope, never GlobalScope

GlobalScope coroutines outlive the screen and leak; use viewModelScope/lifecycleScope so work is cancelled with the owner.

kotlincoroutineslifecycleleak

mobile-canon-2026-06

Jul 5, 2026kotlin

mobile ruleP1

Model finite UI/result states with a sealed class

Represent loading/success/error as a sealed hierarchy so the compiler enforces handling every state in when.

kotlinsealed-classstateexhaustiveness

mobile-canon-2026-06

Jul 5, 2026kotlin

mobile ruleP2

Prefer val over var; make state immutable by default

Declare with val unless reassignment is genuinely required; immutability prevents accidental mutation bugs.

kotlinimmutabilityval

mobile-canon-2026-06

Jul 5, 2026kotlin

mobile ruleP0

Avoid the !! not-null assertion in Kotlin

!! throws NPE when the value is null; use safe calls (?.), the Elvis operator (?:), or restructure so nullability is handled.

kotlinnull-safetycrash

mobile-canon-2026-06

Jul 5, 2026kotlin

mobile ruleP0

Store credentials in Keychain/Keystore, not UserDefaults/SharedPreferences

UserDefaults/SharedPreferences are plaintext and backed up; put tokens and passwords in the platform secure store.

mobilesecuritykeychainstorage

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP0

Never hardcode secrets/API keys in the app binary

Anything compiled into a mobile app can be extracted; keep secrets server-side and store tokens in the Keychain/Keystore.

mobilesecuritysecretskeychain

mobile-canon-2026-06

Jul 5, 2026mobile

mobile ruleP1

Fully configure reused cells (reset every mutable field)

Dequeued cells retain old state; set every visible property (including the empty case) or stale content leaks across rows.

iosuikittableviewreusebug

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP2

Prefer async/await over nested completion handlers

Deeply nested callbacks are hard to read and easy to get wrong on error paths; use async/await for sequential async work.

swiftconcurrencyasync-awaitreadability

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP0

Never do blocking I/O or heavy work on the main thread

Synchronous network/disk/CPU work on the main thread freezes the UI; move it to a background queue or async/await.

iosthreadingperformancemain-thread

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP1

Own SwiftUI state with the right property wrapper

Use @State for view-local state, @StateObject to create an observable, @ObservedObject/@Binding to receive it — don't recreate a @StateObject-worthy object with @ObservedObject.

iosswiftuistate

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP1

Keep view controllers thin; extract logic out of the VC

Move networking, formatting and business logic out of UIViewController into view models/services so the VC only wires views.

iosarchitecturemvvmseparation-of-concerns

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP1

Switch enums exhaustively instead of a catch-all default

Handle each enum case explicitly (no default) so adding a case forces a compile error where it must be handled.

swiftenumswitchexhaustiveness

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP2

Mark declarations private/fileprivate unless they need to be exposed

Default to the most restrictive access level; expose only the intended API surface.

swiftaccess-controlencapsulation

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP1

Surface failures with throws or Result, not optional-nil

Returning nil on failure loses the reason; model recoverable failure with throws or Result so callers get the error.

swifterror-handlingresult

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP2

Name methods for clarity at the call site (Swift API Design Guidelines)

Choose names that read as a phrase at the call site and omit needless words already implied by types.

swiftnamingapi-design

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP1

Model data with structs (value types) by default

Prefer struct over class for data models to get value semantics and avoid shared-mutable-state bugs; use classes only when identity/reference is needed.

swiftvalue-typesstructimmutability

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP2

Use guard for preconditions and early exit

guard keeps the happy path un-indented and makes the unwrapped value available after the check, unlike nested if let.

swiftguardreadabilitycontrol-flow

mobile-canon-2026-06

Jul 5, 2026swift

mobile ruleP1

Declare delegate properties as weak

A strong delegate reference back to its owner creates a retain cycle; delegates should be weak var.

iosmemorydelegateretain-cycle

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP0

Perform all UI updates on the main thread

UIKit/SwiftUI are not thread-safe; hop back to the main thread (DispatchQueue.main / @MainActor) before touching UI.

iosthreadinguimain-thread

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP0

Capture self weakly in escaping closures to avoid retain cycles

Strongly capturing self in a stored/escaping closure creates a retain cycle and leaks; use [weak self] and guard it.

iosmemoryretain-cycleclosures

mobile-canon-2026-06

Jul 5, 2026ios

mobile ruleP0

Never force-unwrap optionals with ! outside tests

Force-unwrapping an optional crashes when it's nil; bind with if let / guard let or coalesce with ?? instead.

swiftoptionalscrashnull-safety

mobile-canon-2026-06

Jul 5, 2026swift

workflow ruleP2

Draft a what-and-why PR description before every PR, tracker or not

Whenever an implementation is finished and about to become a pull request — whether or not there is a linked Jira/tracker ticket — draft a short plain-English PR description ready to paste into the PR body, alongside the usual 2-3 commit-message options. But hold these back until the pre-PR review has run: the developer runs the `pre-pr-review` command after every coding session, so do not volunteer the commit messages or PR description at the moment coding finishes — wait until that review is done and its findings are addressed, then produce them together. The description should be a few sentences covering: what changed at a user- or system-visible level, why (the motivation, and the ticket key if one exists), and any notable caveats, follow-ups, or testing notes. Never write it as a dry restatement of the diff or a bullet list of touched files (updated X.ts, modified Y.tsx) — that tells a reviewer nothing they cannot already see in the file list. Only draft the description; never post it, comment on the PR, or open/merge it yourself — the developer pastes it in when they create the PR.

prgitworkflowdescriptioncommit-message

manual-rule-request

Jul 3, 2026git

workflow ruleP2

Use acli to read Jira tasks and create branches (read-only)

When given a Jira work-item key (e.g. FCK-1234, FABS-1234): resolve the target repo (use the current git repo if inside one, else infer from the project prefix/summary and confirm with git, asking only if unsure), read the task with `acli jira workitem view <KEY>` (add --json to parse issuetype and summary), then create a branch named `<type>/<KEY>-<slug>` where <type> is a git-flow prefix (bugfix/ for Bug, feat/ for Story/Task/new feature, fix/ for small fixes/chores) and <slug> is a kebab-case slug of the summary. After branching, propose an implementation plan and wait for confirmation before writing code. After implementing, STOP: do NOT offer commit messages or a PR description yet — the pre-PR review is a mandatory gate. Wait until the developer has run the `pre-pr-review` command and addressed its findings, and only then suggest 2-3 commit-message options prefixed with the task key in the form `<KEY>: <concise imperative summary>`, plus a short plain-English PR description (a couple of sentences on what and why) ready to paste into the pull request. Read the work item only; never commit or push.

jiragitaclibranchingworkflow

Jul 2, 2026git

communication ruleP1

Write like a human, avoid AI-tell punctuation and phrasing

Never use the em-dash (—) or other AI-signature symbols and phrasings in any written output: code comments, commit messages, PR and issue descriptions, docs, READMEs. Use plain human punctuation instead (hyphens, commas, colons, parentheses, or separate sentences) and avoid formulaic AI flourishes so the text reads as if a person wrote it.

writingdocumentationpr-descriptioncommit-messagecommentstone

manual: humanlike writing (no AI tells)

Jul 1, 2026any

documentation ruleP2

Don't write comments that restate the code

Avoid comments that merely narrate what the adjacent code already says — e.g. listing the CSS/Tailwind classes or property values an element applies, or paraphrasing an obvious statement. Comments should capture intent, constraints, or the non-obvious 'why'; descriptions of literal values add no information and silently drift out of sync when the code changes.

commentsreadabilityself-documenting-codedocumentation

FCK-3194 Fix MyFA widget border

Jun 29, 2026general

architecture ruleP2

Reference repeated graph entities by id, not duplicate nodes

In a structured-data graph (JSON-LD / schema.org), define a shared entity such as the Organization once and reference further occurrences by @id, instead of inlining a duplicate node each time. Derive the @id from one helper so the reference can never drift from the node it points at.

json-ldschema-orgseodedup

startsiden/hegnar-web#4546

Jun 29, 2026typescript

accessibility ruleP2

Pair hidden scrollbars with an overflow affordance

If you hide the scrollbar on a scrollable container, provide another cue that more content exists: a partially cut-off next item, a gradient/fade, or an arrow. A hidden scrollbar with no affordance removes the only signal that the region scrolls.

uxscrolldiscoverability

startsiden/hegnar-web#4529

Jun 29, 2026css

readability ruleP2

Annotate the map type argument, not the result array

Type a transform via the .map<T>() type argument rather than annotating the destination variable. The type argument constrains the callback's return so a mismatch is reported on the offending field inside the callback, not as a vague whole-array assignment error.

typesgenericsmap

startsiden/hegnar-web#4546

Jun 29, 2026typescript

correctness ruleP2

Guard optional numbers with typeof, not !== undefined

When conditionally including an optional numeric field, guard with typeof x === 'number' instead of x !== undefined. The undefined check lets null (and NaN-via-coercion surprises) through; the typeof check admits only real numbers.

null-safetytypesnarrowing

startsiden/hegnar-web#4546

Jun 29, 2026typescript

testing ruleP1

Keep security-sensitive code identical across test and prod

Do not branch a security-sensitive serializer/escaper for test vs production. Keep the shared filter byte-for-byte identical in both, and apply any test-only readability transform (e.g. pretty-printing) in the test layer so what you assert on is the same code that ships.

securitytestingsnapshots

startsiden/hegnar-web#4547

Jun 29, 2026typescript

maintainability ruleP2

Import ambient global types explicitly

Add an explicit import for a type even when it already resolves through a `declare global {}` ambient block. Relying on ambient resolution hides the dependency, so refactoring the global block to a named export breaks consumers with no missing-import to point at.

typesimportsglobal

startsiden/hegnar-web#4547

Jun 29, 2026typescript

correctness ruleP1

Handle empty base explicitly when resolving URLs

When building an absolute URL with new URL(path, base), handle a missing or empty base explicitly with a ternary or a real fallback origin; do not paper over it with a trailing-slash hack, because new URL('/x', '/') throws.

urledge-casesjavascript

startsiden/hegnar-web#4547

Jun 29, 2026typescript

readability ruleP2

Prefer URL.href over URL.toString()

Read the serialized string from a URL object via .href instead of calling .toString(); it is shorter and reads as a property, not a conversion.

urlnitpickjavascript

startsiden/hegnar-web#4547

Jun 29, 2026typescript

frontend ruleP2

Use browser logging in client components, not the server logger

In code that runs in the browser, log via console rather than a server-side logger utility that may not behave correctly client-side.

loggingclient-serverreact

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Force a full page load for links when SSR-injected widgets must re-initialize

When third-party or server-injected components (headers, footers, paywall widgets) only mount on a full document load, use a real navigation/full reload instead of client-side routing for those links.

routingssrnavigationthird-party-widgets

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Don't re-wrap an object you return as a JSON response

When the value is already an object, pass it directly to res.json(value) instead of wrapping it in another object literal.

apiresponse-shapecleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

fullstack ruleP2

Compare against stable identifiers, not display names

Branch on a stable id/key rather than a human-readable name, which can change or be localized and is fragile to match on.

correctnessidentifierscomparison

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Use a date library for date arithmetic instead of manual mutation

Compute relative dates with a helper like subDays rather than subtracting from getDate(), which is error-prone around month/year boundaries.

datesdate-fnscorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

fullstack ruleP2

Use unknown[] rather than never[] for an untyped empty array

Reserve never for values that can't exist (functions that always throw); type a placeholder array as unknown[] instead.

typescripttypesneverunknown

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Set the correct request headers for what the call does

Don't send Content-Type on a request that has no body; use Accept to declare the response format you want to receive.

httpfetchheaders

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP2

Use shared HTTP status constants instead of magic numbers

Reference a shared status constant (e.g. HTTP_STATUS.UNAUTHORIZED) rather than hard-coding numeric status codes in handlers.

httpconstantsreadabilityapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Use a named options object instead of a bare positional boolean flag

Replace a trailing positional boolean argument with an options object so the call site documents intent (resetTicker: true) instead of an opaque true.

function-signaturereadabilityboolean-trap

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Default an options parameter to an empty object instead of optional chaining everywhere

Give a trailing options bag a default of {} so call sites read options.x rather than peppering options?.x throughout the function.

function-signaturedefault-paramsreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Don't reach for context when state is only passed a couple levels down

Use React context only when state must travel three or more levels or to many consumers; for shallow passing keep it as local state and props.

state-managementcontextprop-drillingreact

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use a reducer to simplify a context with many related state setters

When a context manages several interrelated pieces of state with multiple setters, model it with useReducer and typed actions to reduce boilerplate.

reactcontextreducerstate

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Structure event payloads as an action with a nested data object

Group event payload fields under a typed data object alongside the action discriminator instead of a flat, loosely structured bag.

eventspayloadstructuretypes

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Read standard status info from the response instead of a redundant interface

When error messages mirror standard HTTP status text, use response.status/statusText rather than declaring an interface that re-describes them.

httpinterfacesdryapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Trim strings before checking them for emptiness

A whitespace-only string is truthy, so trim before treating it as present, e.g. reject sessions/tokens that are blank after trimming.

stringsvalidationwhitespaceauth

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Name legacy or transitional functions so their nature is obvious

Prefix functions wrapping legacy or soon-to-be-replaced backends with a clear marker (e.g. Legacy) so callers understand what they're using.

naminglegacyapiclarity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Remove leftover test and debug data before merging

Strip hard-coded test data, console logs, and debug scaffolding from code before it is merged.

cleanupdebuggingreview

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Type the detail payload of dispatched custom events

Give CustomEvent detail payloads an explicit type rather than leaving them untyped or Record<string, unknown> when the shape is known.

eventstypescripttypesdom

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Parse HTML with a DOM parser instead of regular expressions

Use DOMParser or the browser DOM to parse stringified HTML rather than hand-written regex, which is fragile and error-prone.

htmlparsingdomregex

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Do not duplicate the HTTP status in the JSON response body

Set the status code on the response itself; don't also include a status field in the body since the client can read it from the response.

apihttpresponse-shaperest

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP1

Validate request input with a schema library instead of hand-rolled validators

Use an established schema-validation library (e.g. Zod or Valibot) rather than building and maintaining a custom type-checking utility.

validationapizodschema

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Set the Allow header when rejecting a disallowed HTTP method

When returning 405 Method Not Allowed, set the Allow response header listing the accepted methods.

httpapirestheaders

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Use descriptive, intention-revealing test ids

Name test ids after the element's role (e.g. meatballs-button) so tests read clearly and target the right node.

testingtest-idsnaming

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use a component library's size prop instead of hardcoding dimensions

When a UI library component exposes a size prop, prefer it over manually overriding width/height in CSS so you stay aligned with the design system.

muistylingdesign-systemprops

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Define a handler where its dependencies live, then pass it down

If a handler depends only on values available in the parent, define it there and pass it as a prop instead of passing all the dependencies down to a child.

reactpropscohesionhandlers

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP1

Don't duplicate backend business-rule validation in the API gateway layer

Avoid an extra fetch from your BFF/Next API just to validate a rule the downstream backend will validate anyway; let the backend return the proper error code instead.

architecturevalidationlatencyapiseparation-of-concerns

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Mark loading skeletons with aria-busy for screen readers

Add aria-busy="true" to a skeleton/placeholder container so assistive tech announces that content is loading.

accessibilityarialoadingskeleton

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Compute list keys into a variable when the inline expression trips lint

Pull a templated React key into a named variable so the key is stable/clear and you avoid the lint warning about inline keys.

reactkeyslintlists

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use CSS shorthand for symmetric box values

Collapse separate padding/margin declarations into shorthand when the values are symmetric or zero on a side.

cssshorthandreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Don't set a style in CSS that you already pass via a component prop

If a value (e.g. color) is supplied through a component prop, don't also hardcode it in the CSS module — the duplicate can drift.

scssduplicationstylingprops

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Use kebab-case for custom DOM event names

Name custom browser events in kebab-case (e.g. 'reply-discard') to follow the platform convention for event types.

eventsnamingdomconvention

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Cast to boolean consistently across the codebase

Pick one boolean-coercion idiom (e.g. Boolean(x)) and use it everywhere instead of mixing Boolean() and !! for the same purpose.

consistencybooleanstyle

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP1

Return descriptive error bodies, not null, from API routes

On a 4xx error respond with a JSON object describing what went wrong instead of an empty/null body, so API consumers can react.

apierror-handlinghttp

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

fullstack ruleP0

Default to the least-privileged user state, not the most permissive, and handle failures

When deriving auth/user status, default to the safest state (e.g. anonymous) and distinguish genuine failures from a known unauthenticated response instead of treating any error as logged-out.

authsecurityerror-handlingdefaults

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Be careful that a generically placed helper is actually generic

A helper in a generic location will be reused broadly; ensure its logic is truly generic (e.g. doesn't misclassify banned/admin users as 'active') or scope it to its specific use case.

correctnessabstractionplacementedge-cases

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Don't unit-test styles that come from external CSS modules

Avoid asserting computed CSS from SCSS/CSS modules in jsdom/happy-dom unit tests, since those styles aren't applied; test inline/prop-driven values or use a tool that renders real CSS.

testingcss-modulesjsdomvitest

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Keep unrelated changes out of the current PR

Don't include changes that belong to another PR/task; keep each PR scoped to its own concern so reviewers aren't re-reviewing work from elsewhere.

pr-hygienescopereview

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

backend ruleP1

Reject unsupported multi-item requests with a clear error status

When an endpoint supports only a single item (e.g. one image), validate and reject extra items with a custom error status and message instead of silently processing only the first.

apivalidationerror-handlinguploads

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Name components by their role, not their implementation detail

Name a component after what it represents (ThreadReply) rather than how it's built internally (ThreadReplyGrid); the layout technique is an implementation detail.

namingcomponentsabstraction

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Don't import styles in index files

Keep style imports inside the component they belong to; importing stylesheets directly in index/barrel files is an anti-pattern.

cssimportsstructureanti-pattern

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Keep components that depend on window/breakpoints as client components

A component using browser-only APIs (window size, breakpoints) must run on the client and cannot be a server component.

reactnextjsrscssr

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Conditionally render instead of hiding with display:none

When an element should not appear under a condition (e.g. mobile), skip rendering it rather than mounting it and hiding it with display:none, unless a library requires the node to stay mounted.

reactconditional-renderingcssperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Don't fire a handler with empty arguments when there is no data

If an action only makes sense with data, don't invoke its handler with null/undefined placeholders; gate the call so it only runs when the data exists.

reacteventsguard-clauses

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Don't re-specify props you already spread

If you spread an object's properties onto a component, don't also pass the same properties explicitly.

reactpropsredundancyjsx

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Make a component's context dependency obvious to consumers

A reusable component that consumes a context should either take the data via props or wrap itself with the required provider, so callers aren't surprised by a hidden dependency.

reactcontextcomponent-designcoupling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Log, don't throw, when a context is missing

On a missing context provider, console.error and return gracefully so one component fails rather than crashing the whole app.

reactcontexterror-handlingresilience

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Make components customizable via a classes prop, not single-purpose boolean flags

Let callers override styling through a classes object prop instead of adding one-off boolean props like isForum.

reactcomponent-designreusabilitystyling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP1

Return the proxy route's own status, not the upstream service's

A BFF/proxy route should respond with a status reflecting its own success/failure, not blindly forward the upstream's status to the client.

apistatus-codesbfferror-handling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP2

Name the new implementation cleanly and mark the old one deprecated

When replacing a method/route, give the new one the canonical name and rename+deprecate the legacy one rather than suffixing the new code.

namingdeprecationapimigration

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

backend ruleP2

Prefer Node built-in modules over browser polyfill packages in server code

In server-only code, use node: built-ins (e.g. node:assert) instead of installing browser-targeted polyfill packages.

nodedependenciescleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

fullstack ruleP1

Default pagination to page 1, not page 0

When defaulting a page number, use 1 — page 0 typically renders nothing.

paginationdefaultscorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Append the query separator only when query params exist

Don't hard-code a trailing '?' on a URL; add it only when there are params so empty-param URLs stay clean.

urlquery-paramsapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Name variables after the domain concept, not the UI widget

Name a value for what it represents in the domain (e.g. activeSort/sort) rather than the component that displays it (e.g. threadButton).

namingreadabilityreact

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Destructure context directly when the provider is guaranteed present

Inside a known provider tree, destructure context values directly; rely on the hook's dev-time error for misuse rather than defensive checks.

reactcontextredundancy

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use a modern TypeScript target and bundler-friendly compiler options

Set target/lib to a recent ES version and use react-jsx so you don't import React in every file or carry legacy interop flags.

typescripttsconfigconfiguration

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Let each component own its own error state instead of gating from a parent

Don't short-circuit rendering in a parent when children already render their own error/empty states, or you hide the correct UI.

reacterror-handlingcomponent-design

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Set the html lang attribute to the page's actual language

The root html lang attribute must reflect the real content language for accessibility and SEO.

accessibilityseoi18nhtml

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP1

Handle nullable inputs consistently across sibling functions

When two functions do the same mapping job, give them the same nullable signature and default so they behave identically on null.

typescriptconsistencynull-handlingapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Keep user-agent based device detection on the server to avoid hydration re-renders

Detect device type from the user agent server-side so server and client render the same markup and you avoid an extra re-render.

ssrhydrationresponsivereact

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Preload heavy editor resources only when the user is about to need them

Defer loading of large optional dependencies (e.g. a rich text editor) until interaction is imminent rather than on initial page load.

performancelazy-loadingpreload

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Access store state through the documented selector pattern

Read and update global store state via the established selector hook usage rather than an alternate access path with different semantics.

state-managementzustandstore

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Keep route data-loading logic readable and colocated

Avoid hiding getServerSideProps in a separate file when it forces reviewers to open multiple files to understand a route's params and fetches.

next.jsssrreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Match naming conventions of sibling components

Name a new component to mirror its siblings (e.g. singular like CategoryCTA) so related components stay consistent.

namingconsistencycomponents

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Compute a hook's inputs outside it and pass them as dependencies

Resolve values like ids outside a custom hook and pass them in as dependencies rather than fetching them inside the hook.

reacthooksdependencies

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Gitignore generated build artifacts and untrack committed ones

Add generated files like *.tsbuildinfo to .gitignore, and git rm --cached anything already committed.

gitbuildtooling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Round pixel values and avoid decimals in CSS

Use whole-number pixel dimensions instead of stray decimals to keep sizing consistent across the codebase.

cssconsistencysizing

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Drive repeated UI from a config array instead of duplicated JSX

Define lists of similar elements as data in a config file and map over them rather than hand-writing each repeated block.

reactdryconfig

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP1

Validate resource existence early and return 404 for missing routes

Check whether a requested resource exists in getServerSideProps/handler before running component logic, and return a real 404 instead of 200 with a null body.

next.jsssrerror-handlingcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Avoid redundant state updates in error handlers

Reset error/flag state with a single direct set instead of redundant conditional or wrapping logic.

reactstatereadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Hide scrollbars with cross-browser CSS

When hiding a scrollbar, include the Firefox-specific declaration (or a shared mixin) so it works in every browser.

csscross-browserscrollbar

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Place feature-specific files in feature-scoped subfolders

Group a feature's hooks, interfaces, and utilities under a feature-named subfolder rather than dumping them in the generic root of each directory.

organizationfile-structure

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Set fallback values to the documented default rather than undefined

When a value has a defined default (e.g. null), assign that default in just-in-case branches instead of leaking undefined.

defaultsnull-handlingconsistency

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Use a falsy check for empty strings instead of explicit comparison

An empty string is already falsy, so guard with the value directly rather than comparing against ''.

readabilityconditionalsshorthand

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP1

Guard server-only service methods against client-side execution

Methods that use server secrets (API keys) should detect a browser environment and refuse to run, signalling the misuse clearly.

securityssrapi-key

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

fullstack ruleP2

Name a boolean argument with a constant instead of passing a bare true

A bare true/false at a call site hides the parameter's meaning; assign it to a self-describing constant first.

readabilityboolean-parameterclarity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Follow one function-declaration style consistently across similar exports

Match the established declaration style (e.g. arrow functions for all SVG/component exports) so similar modules look uniform.

consistencystyleconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Fire analytics events at the point the action is committed

Decide whether you are tracking a click or a saved/submitted change, and place the analytics call accordingly (in the submit handler for persisted changes).

analyticseventsuxcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP1

Base Cache-Control on the backend's actual caching, not copy-paste

When adding cache headers to an endpoint, verify how long the upstream/backend caches that resource (or ask the PM) instead of copying values from an unrelated endpoint.

cachinghttpapicorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

fullstack ruleP1

Do not silently transform values the backend owns

Do not coerce backend data (e.g. forcing a negative number positive) without an agreed contract; the backend owns data validity, so confirm before altering it.

data-integritybackend-contractcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Name icons and symbols after the design source of truth

Name icon components and assets exactly as they appear in the design system (e.g. Figma) so they map predictably.

namingiconsdesign-systemconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

backend ruleP2

Retry a flaky operation once before treating it as a real error

For operations that intermittently fail on the first attempt, retry once and only surface an error if the retry also fails.

resilienceretryerror-handling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP1

Separate the auth/session token from other request params

Handle the authorization token (e.g. session cookie) distinctly from generic query/body params rather than bundling it in.

authsecurityapiparams

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP2

Use import.meta.dirname instead of recomputing the directory in ESM

In ESM, get the current directory via import.meta.dirname rather than deriving it from import.meta.url manually.

nodeesmpaths

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP1

Cascade env-file lookup or fail loudly with an explanatory error

When loading env config, try a sensible cascade of files and, if a required one is missing, throw a clear error explaining what is expected.

nodeenvconfigerror-handlingdx

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Compute paired conditional values once via array destructuring

When two related values switch together on one condition, derive them in a single ternary with array destructuring instead of repeating the condition.

readabilitydrydestructuring

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Import shared constants directly rather than passing them as props

When a value is a static importable constant, import it where it is used instead of threading it through props.

reactpropsconstantsreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Give every component a typed props interface and index barrel

Each component should declare a typed props interface (no implicit any), use it on React.FC, and ship an index.ts barrel where the project convention requires it.

reacttypescriptcomponentsconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Keep a component's prop interface aligned with its actual props

Ensure the declared props interface matches the props the component actually destructures and uses.

typescriptpropsreactcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Use the ch unit for character-based width limits

Cap text width by character count with the CSS ch unit instead of approximating with pixels.

cssunitstypographytruncation

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Set colors via color props and a colors token object, not CSS classes

Apply text and stroke colors through the component's color prop using values from the shared colors object rather than ad hoc classNames or literals.

stylingdesign-tokenscolorsmui

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Reserve switch for enums or typed unions, not arbitrary strings

Use switch on enums or string-literal unions; for an open-ended string with one dominant default, prefer simpler branching.

switchenumstypesreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Use switch fall-through for cases sharing identical logic

Group switch cases that produce the same result via fall-through instead of duplicating the body.

switchdryreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Use 401 for authentication/authorization failures

Return 401 when a request fails because the user is not authenticated, not a generic error status.

httpauthstatus-codes

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Branch create vs edit modes explicitly instead of patching props

When a dialog serves both create and edit, pass different inputs per mode (e.g. no existing items for create) rather than working around shared props.

propsmodesclarityforms

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Centralize fetch-and-reset logic in a context to avoid refetch-on-open

Move data fetching and state into a context so opening/closing UI reads existing state instead of refetching and resetting on every open.

contextstate-managementfetchingarchitecture

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use kebab-case for HTML element ids

Follow the kebab-case convention for DOM element id attributes.

naminghtmlconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Use null for 'not yet loaded' and empty array for 'loaded but empty'

Reset collection state to null to mean not-yet-fetched and reserve [] for a fetched-but-empty result, so loading and empty UI states can be told apart.

stateloading-statenull-vs-emptyux

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP1

Model mutually-exclusive states as an enum, not parallel booleans

When a value can be one of several exclusive states, expose a single enum so consumers don't recombine booleans into logic; keep enums logic-free.

enumsmodelingbooleansreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Comment out code you'll soon need rather than deleting it

If a feature (e.g. a time filter) is temporarily out of MVP scope but planned, comment it out with a note instead of removing it so it isn't lost.

scopemaintainabilityfeature-flags

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Abstract IntersectionObserver logic into a reusable visibility hook

Extract element-in-view detection into a hook like useElementIsVisible that returns a boolean, instead of repeating IntersectionObserver wiring inside feature hooks.

reacthooksintersection-observerreuse

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP1

Model overlapping roles as separate flags, not one mutually-exclusive level

When a higher role implies a lower one (admin is also registered), branching with else-if on a single access level hides the overlap; track independent flags (isAdmin, isRegistered) so checks for the base role still pass.

authorizationmodelingstatecorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Make optional callbacks safe with a default or optional call

When a callback prop is optional, either default it to a no-op or invoke it with optional chaining (callback?.()) so callers aren't forced to pass an empty function.

callbacksdefensiveapi-design

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Return early in a guard branch instead of falling through to a reset

When a condition short-circuits the work, return inside that branch so trailing reset logic (e.g. setting a flag false) doesn't run unintentionally.

control-flowguard-clausecorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

fullstack ruleP2

Make the PR template descriptive with a pre-merge checklist

Replace one-word headings with explicit questions (what/why/how/testing) and add a 'remember to check' list (tests pass, description written, shared functions tested) so reviewers can reject incomplete PRs fast.

processpull-requestdocumentationreview

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

fullstack ruleP2

Create a dedicated type for an endpoint-specific response

Rather than reusing a broad domain type full of optional fields, define a focused interface (e.g. TopCategoriesResponse) for a response that has its own shape.

typescripttypesapimodeling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Place reusable components in the shared folder, page-specific ones in views

Only put a component in the shared components/ directory if it is used in several places; components used by a single page belong under that page's views folder.

project-structurecomponentsorganization

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Group a long destructured list by purpose for readability

When pulling many values out of a context or object, group them (state vs setters, or by feature) instead of one undifferentiated wall of names.

readabilitydestructuringorganization

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP1

Don't call setState in an effect cleanup function

Setting state in a useEffect cleanup causes redundant re-renders or infinite loops; remove the cleanup if there is nothing to actually clean up (or handle an abort signal instead).

reactuseEffectcleanupbug

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Depend on the specific field an effect reads, not the whole object

If an effect only uses query.threadId, put query.threadId in the dependency array, not the entire query object, so unrelated query changes don't re-fire it.

reactuseEffectdependenciescorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Name functions, hooks, and types by what they actually do

Pick names that describe behaviour (e.g. useFrontpageData, fetchParameters) rather than vague or misleading words; keep casing of a concept consistent across the codebase.

namingreadabilityconsistency

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP1

Keep fetch helpers pure and move state setters into the calling hook

A reusable fetch function should return data (or null on error) rather than reaching into context and calling setState; let the hook/component that calls it own the state and error handling.

reactseparation-of-concernshookspurity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Drop mobile/desktop styles from a component that only renders at one breakpoint

When a separate component already handles the other breakpoint, remove the unused isMobile branches and breakpoint media queries from this one instead of leaving dead responsive code.

responsivedead-codescsscleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

fullstack ruleP2

Do related cleanup in the same PR that touches the code

When you've already modified a method or area, fold the small follow-up/cleanup into the same change instead of deferring it to a separate task.

processcleanupscope

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

fullstack ruleP2

Don't include mock properties the code under test never reads

Only set fields in a test mock that the tested code actually uses; extra properties (e.g. a `status` no branch depends on) mislead readers into thinking they matter.

testingmockingclarity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Don't spread an array into a new one when you can return it unchanged

If you aren't mutating the array, return it directly instead of creating a needless `[...arr]` copy (and if you do copy, comment why).

readabilityperformancearrays

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

fullstack ruleP2

Use Math.min/Math.max to clamp values instead of a ternary

Replace `x > limit ? limit : x` style clamping with `Math.min(limit, x)` (or `Math.max`) for clarity.

readabilitymathsimplification

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Update only the changed item instead of recomputing the whole collection

When changing one element of an array in a state update, copy and splice that single index rather than mapping every item and computing values you only need for one.

reactstateperformancereadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Collapse mutually exclusive className conditions into one expression

For a binary either/or class choice, use a single ternary instead of two separate object-syntax `cx` conditions.

reactclassnamesreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Don't use a mixin that injects styles you don't want

Prefer plain declarations over a convenience mixin when the mixin sets extra properties (e.g. align-items/justify-content) the element doesn't need.

cssmixinsscsscleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

backend ruleP1

Guard JSON.parse of request bodies against missing or malformed input

Don't assume `req.body` exists and is valid JSON; validate it (and the types of extracted fields) before parsing and passing values downstream.

validationerror-handlingapi-routesrobustness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP1

Match interface field types to the actual API payload

Confirm the runtime type a third-party API returns (e.g. an id may arrive as a string, not a number) before declaring the field, and convert explicitly when you need a different type.

typesapi-integrationcorrectnessvalidation

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Don't type a request as having a field that isn't populated yet

Typing a handler's `req` as carrying an enriched field (e.g. `userId`) before any middleware has set it lies about the runtime shape; only widen the type after the value is actually attached.

typesmiddlewarecorrectnessapi-routes

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Enforce types in the signature, don't rely on callers' good will

An implementation should not depend on a caller always passing a string/number; type the parameter precisely so TypeScript guarantees it rather than assuming runtime values.

typesdefensive-codingcontractscorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP2

Keep each test mock narrow and single-purpose

Avoid one mega-mock with many flags handling unrelated scenarios; split it into focused mocks and only require the inputs each test actually uses.

testingmockingreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Don't create a wrapper function that only forwards to another

A function that just calls another with the same arguments and no extra logic adds indirection without value; call the underlying method directly.

abstractiondead-codereadabilityindirection

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Keep an exported symbol's name consistent with its module name

When a module is named after one concept (e.g. `checkUserId`) but exports a differently-named member (e.g. `getUserId`), rename one so the file and its export agree.

namingmodulesconsistency

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Name a scaling factor for the value, not the operation applied to it

A variable used as a divisor should be named for what it represents (scaleValue), not after the operation, to avoid reading like 'dividing by divide'.

namingreadabilitymath

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Use the same construct (enum vs const map) consistently for related sets

When similar fixed sets elsewhere are enums, prefer an enum here too rather than mixing loose constants, unless you genuinely need keyed lookup by value.

typescriptconsistencyenumsnaming

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Guard percentage/ratio math against tiny or zero denominators

Dividing by a value close to zero produces absurd results; decide and document the fallback (null, capped value) instead of returning huge numbers.

correctnessmathedge-cases

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP1

Format numbers and dates with a locale matching the actual audience

Choose a locale (or explicit formatting) that reflects your users' conventions rather than borrowing an unrelated locale that happens to look similar.

i18nlocalizationformattingcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Trust response.ok instead of re-checking the HTTP status range

response.ok already covers the 2xx range, so a redundant numeric status check after it is unnecessary unless the payload carries its own status field.

fetchhttpredundancy

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Do not set the default 200 status explicitly

When a successful JSON response uses the default 200 status, return the json directly rather than calling status(200) to reduce noise.

apihttp-statusreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

backend ruleP2

Consolidate API routes that do essentially the same work

When two endpoints differ only in where a parameter comes from or a minor branch, merge them into one route that handles the variation instead of maintaining duplicates.

dryapirouting

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Name React components as nouns, not actions

A component that renders UI should be named like a thing (SaveEstimateButton), not like an action or hook.

namingreactcomponents

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use rem helpers and shared variables instead of hardcoded px and hex values

Replace magic pixel values and raw hex colors in stylesheets with the project's rem-calc helper and named color/spacing variables.

stylingscssdesign-tokensmaintainability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

backend ruleP2

Remove duplicate guard/logging blocks within one function

When the same guard (e.g. an if (!response.ok) log) appears twice in one function, keep a single check to avoid duplicate logging and dead branches.

dryerror-handlingloggingcode-hygiene

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Prefer a virtualized list over combining infinite scroll with pagination

When the goal is rendering a large list performantly, use list virtualization rather than wiring infinite-scroll fetching alongside pagination.

reactperformancevirtualizationlists

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Base conditional logic on the meaningful attribute, not array position

When a rule depends on what an item is (its name/type), key the condition on that attribute; only use index when the rule genuinely depends on position.

readabilityconditionalsmaintainabilityclarity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Set loading state after early-return guards, not before

Place setIsLoading(true) after any guard clauses that may bail out early, so you don't flip loading on for a request you never make.

reactloading-stateguard-clausescorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP1

Use git mv for case-only file or folder renames

On case-insensitive filesystems a case-only rename isn't tracked and breaks on case-sensitive deploy targets; use git mv so the change is recorded.

gitfilesystemcase-sensitivitydeployment

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Extract repeated SCSS declarations into a parameterized mixin

Replace blocks of the same property set repeated across rules (e.g. flex centering) with a reusable mixin that accepts parameters with sensible defaults.

scssdrymixinsmaintainability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Derive values during render instead of storing redundant state

If a value can be computed from existing state/props, compute it inline rather than holding it in its own useState and syncing it.

reactstate-managementderived-statesimplicity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Keep style modules out of the routing pages directory

Place component styles with the component, not under the framework's pages/routing folder where they may not resolve and clutter routes.

nextjsproject-structurescssrouting

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Do not add a redundant hover rule when cursor: pointer already implies it

Avoid duplicating hover affordance styling that is already conveyed; remove redundant hover blocks.

cssscssredundancyclean-code

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Reset numeric CSS properties to 0, not unset

For numeric properties like margin/padding, prefer an explicit 0 over unset for clarity and predictability.

cssscssreadabilityreset

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Re-export through an index barrel to keep imports clean

Provide an index barrel that re-exports default and named members so consumers import once from the directory.

importsbarrelproject-structurereadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Use location.href for in-page navigation rather than window.open(_self)

For navigating the current tab, assign window.location.href instead of window.open with _self.

browser-apinavigationclean-code

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Type event-name parameters with keyof WindowEventMap

Constrain event-name arguments to keyof WindowEventMap (optionally unioned with known custom keys) instead of plain string.

typescripteventstype-safetydom

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Pass auth tokens via a custom header, not a cookie, when there is no reason to use a cookie

Send service tokens through a dedicated request header rather than overloading the cookie header without a specific reason.

httpauthheadersapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Keep a custom hook's state inside the hook

A custom hook should own and return derived state from inputs, not push state ownership back onto every caller.

reacthooksencapsulationapi-design

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Use a named helper for string casing instead of inline char surgery

Replace ad-hoc inline string slicing/casing with a clearly named utility (or lodash) so intent is obvious.

readabilitystringsclean-codeutilities

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

fullstack ruleP1

Guard dynamic map lookups with optional chaining and a fallback

When indexing a record by a runtime value, use optional chaining and provide a fallback so a missing key does not throw.

typescriptnull-safetycorrectnessmaps

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Return 404 instead of a redirect for embedded/web-view routes

For routes loaded in a native app web view, return notFound rather than a redirect so the app can react instead of rendering a full redirected page.

nextjswebviewhttprouting

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Prefer config-level redirects over redirect-only page components

Implement pure URL redirects in the framework's config redirects instead of creating a page whose only job is to redirect.

nextjsroutingredirects

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Expose client env variables via the framework prefix, not a custom context

Use NEXT_PUBLIC_ (framework-provided client env prefix) to expose values to the browser instead of building a bespoke env-passing mechanism.

nextjsenv-varsconfiguration

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Call the backend that owns the data directly instead of proxying through extra hops

Avoid routing a request web -> ws -> backend when the client can call the owning service directly, or fold extra data into an existing response.

architectureapiperformancenetwork

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Render SVGs as components instead of CSS background-image where possible

Inline SVGs as React components rather than CSS background-image so the framework can optimize and control them; CSS backgrounds are acceptable only for tiny static cases.

reactsvgassetsperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Encapsulate context state inside a provider component

Wrap context value/state in a dedicated provider component co-located with the context, instead of wiring state and value inside an unrelated consumer component.

reactcontextproviderencapsulation

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Signal cross-page events with a flag, not a full message in the URL

To notify another page of an event, pass a boolean/flag query param and resolve the user-facing copy at the destination instead of encoding the whole message in the URL.

url-statequery-paramsmessagingdesign

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP1

Use full, valid absolute URLs for external links

External link hrefs must include the protocol (https://) and the correct destination, not a bare domain or placeholder.

linksurlscorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026html

frontend ruleP2

Do not add a class selector alongside a unique id selector

When selecting by a unique id you don't also need a class qualifier; the id already uniquely identifies the element.

cssselectorsspecificitycleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Make one configurable SVG component instead of near-duplicate icons

Render a single SVG React component whose fill/stroke and rotation are driven by props/CSS instead of creating separate icons for each state.

reactsvgiconsdry

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Reuse a single lookup result instead of searching repeatedly

Find an item once and derive all needed fields from that result rather than calling find multiple times for the same element.

performancedryreadabilityarrays

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Move mock and static data into config files

Keep mock datasets, placeholder images, and static lists in dedicated config/.mock files rather than embedding them in components or interface files.

organizationmock-dataconfigconstants

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Use the project's standard component type annotation

Annotate components the same way across the codebase (e.g. React.FC) instead of mixing styles, and don't double-annotate destructured props.

reacttypescriptconsistencyconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Extract single-use JSX branches into a dedicated component

When a large conditional branch is only used by one page/route, move it into its own component near that view.

reactcomponent-extractionorganization

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Do not render the same component twice unintentionally

Avoid leaving a duplicate render of the same component (e.g. a dialog) both inside and outside a conditional block.

reactjsxcorrectnessduplication

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Remove tests only when the behavior they cover is gone

Deleting a test is acceptable when the element/behavior it asserts has itself been removed; otherwise keep the coverage.

testingmaintenancecoverage

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP2

Add unit tests for pure utility functions

Pure, deterministic helper functions are good candidates for unit tests; add coverage for them.

testingunit-testsutilities

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Keep service config inside the class, not at module scope

Store a service's configuration (such as its base API URL) as a private property of the class rather than instantiating it at module level.

service-designencapsulationconfig

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Render rich HTML content via the proper mechanism, not manual tag stripping

To display server HTML content, use the framework's HTML-rendering API rather than hand-written regex to strip tags.

reacthtmldangerouslySetInnerHTMLrendering

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Define CSS classes in the module of the component that uses them

Keep a style class in the stylesheet of the component that consumes it rather than passing class strings down from a parent, which lets the prop become a clean boolean.

css-modulesencapsulationpropscoupling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Forward refs with forwardRef, not a custom ref prop

Pass refs into a component using React.forwardRef rather than smuggling a ref through a normal prop.

reactrefsforwardRefpatterns

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Name component style-override slots by their standard slot names

When overriding a UI library's style slots, name your class for the standard slot (e.g. `root`) rather than a custom redundant name.

muinamingstyling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Use SCSS variables consistently rather than ad-hoc CSS custom properties

When the codebase standardizes on SCSS variables, keep using them instead of introducing one-off CSS custom properties with hardcoded fallbacks.

scssvariablesconsistencytheming

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Separate CSS selectors with a blank line

Add an empty line between adjacent CSS/SCSS selectors and rule blocks for readability.

cssscssformattingreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Stop event propagation on inner clickable handlers

Call event.stopPropagation() in handlers nested inside a clickable parent so the inner action does not also trigger the parent's click.

reacteventsclick-handling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use explicit default values instead of empty strings for style props

When conditionally setting a style prop, pass the real default value rather than an empty string so the prop is meaningful.

stylingdefaultsreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Mark layout-grid children as items

Direct children of a layout grid container should set the item flag so spacing and sizing props apply correctly and reduce extra CSS.

muigridlayout

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use layout components only for actual layout

Reserve flex/grid layout components for flexible containers; for a plain non-layout wrapper use a basic element instead.

muilayoutsemanticscomponent-usage

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Check the fields you care about, not just the wrapping object

When validating presence, test the specific nested values rather than the container object, which can be truthy while its fields are null.

null-safetyvalidationcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

backend ruleP2

Cast strings to numbers with Number() rather than unary plus

Use the explicit Number(value) cast instead of the terse `+value` so the intent of converting a string param to a number is clear.

readabilitytype-coercionnumbers

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Do not return null from functions typed to return void

When a function's declared return type is void, drop the explicit `return null` since it contradicts the signature.

typescriptreturn-typevoidcleanup

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Don't ship incorrect accessibility labels

An aria-label that is wrong is worse than none; either set it correctly to describe the element or remove it.

accessibilityariacorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Call hooks directly where their value is consumed

Invoke a hook (e.g. useRouter) inside the component that needs it instead of threading its value down through props.

reacthooksprop-drillingsimplification

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Prefix related type names by domain for discoverability

Name variant types with the shared domain prefix (e.g. ThreadDeleted, not DeletedThread) so editor autocomplete groups them together.

typescriptnamingintellisenseconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Keep style properties in a consistent (alphabetical) order

Order CSS declarations consistently (e.g. alphabetically) to reduce churn and ease scanning.

scssorderingconsistencylint

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Toggle component states via props, not duplicated CSS classes

Use a component's built-in state props (e.g. disabled) so its theme styling applies, instead of replicating the state with a custom CSS class that can fight the theme.

muipropscsstheming

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use a component's icon props instead of hand-rolled markup

When a UI component exposes startIcon/endIcon (or similar) props, use them to render icons rather than reproducing icon-and-label layout manually.

muicomponentsiconsreuse

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Always set an explicit typography variant

Specify the design-system typography variant on text components instead of relying on defaults or ad-hoc font styling.

muitypographydesign-systemconsistency

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Don't override fontSize when a typography variant already sets it

When a typography variant defines its font size, don't also pass an explicit fontSize; pick the right variant or add a need-based custom variant.

muitypographyredundancystyling

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Define types for third-party API responses

Write explicit types for external/provider API responses (per their docs) instead of leaving them untyped.

typescriptapitypesintegration

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Omit type annotations the compiler already infers

Don't restate a function's return type or a variable type when TypeScript infers it correctly from arguments or initializer.

typescriptinferenceredundancy

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

List only real dependencies in memoization hooks

Include in a useMemo/useCallback dependency array only the values the computation truly depends on, so it doesn't recompute on every unrelated change.

reacthooksmemoizationperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use the full webkit line-clamp block for multiline ellipsis

To truncate text across multiple lines you need the complete -webkit-box clamp set, not just text-overflow: ellipsis.

csstruncationtextui

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP1

Use the Sass ampersand correctly for compound and nested selectors

Nest related classes properly and use & only when classes truly co-occur on the same element; a bare nested class targets a descendant, not the same node.

scssselectorsnestingcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

frontend ruleP2

Use the semantic element prop instead of forcing display: block in CSS

When a UI library exposes a component/as prop to render a block element, use it rather than overriding display: block in the stylesheet.

muisemanticscsscomponents

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Prefer dedicated handlers over data-attribute action dispatch

Instead of encoding an action in a data attribute and branching with if/else, write one explicit handler per action.

reacteventsreadabilityhandlers

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Model mutually exclusive states with a single value, not multiple booleans

When only one of several states can be active at a time (e.g. upvote/downvote/none), represent it as one tri-state value rather than independent booleans that can contradict.

statecorrectnessdata-modelingreact

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Name event handlers handleX and their props onX

Prefix internal event handlers with handle and the props that receive them with on, so naming is consistent across the codebase.

namingreacteventsprops

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use template literals for strings containing special characters

Wrap strings that contain Unicode or special characters in backticks rather than plain quotes to avoid escaping and encoding issues.

stringsunicodereadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP1

Skip the initial client fetch when data already came from SSR

When server-side rendering already provided the data, do not refetch it on mount; use an update-only effect so the first render uses the SSR payload.

reactssrperformancehooks

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

fullstack ruleP2

Name raw backend payload types with a Response suffix

Keep two types per fetch function: one suffixed Response for the raw web-service payload and one without the suffix for the resolved domain value.

namingtypescriptapiconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP2

Put illustrative example values in .env.example

The example env file should contain representative placeholder values, not be left blank, so others know the expected format.

configenvdocumentationdx

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Coerce a value to string with a template literal instead of an extra cast

Prefer a concise template-literal coercion over declaring an intermediate arrow/cast when you just need a string.

clean-codecoercionstringsreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

frontend ruleP0

Avoid effect setups that re-trigger themselves into an infinite loop

Be careful that a useEffect does not update state that is in its own dependency chain in a way that re-runs forever.

reactuseEffectinfinite-loopcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Use PascalCase for type and interface names and drop the I prefix

Types and interfaces should start with an uppercase letter (PascalCase) and not use a Hungarian I prefix.

typescriptnamingtypesconventions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP1

Make prop types match the values actually passed

If null can be passed, the prop type must allow null (or guard the call); mismatches would surface as errors under strict null checks.

typescriptpropsnull-safetystrict-null-checks

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

List props explicitly instead of spreading an object into a component

Pass named props so a component's interface is visible at the call site, rather than spreading an opaque object that hides what it receives.

reactpropsreadabilityexplicitness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP1

Search for existing utilities and types before adding duplicates

Before creating a type, helper, or block, check whether it already exists; duplicating logic in a third place is a signal to extract and reuse.

dryreuseduplicationmaintainability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026universal

frontend ruleP2

Keep page files thin: compose sections, no inline styling or markup blocks

A page should mostly assemble section/feature components; move styling and reusable markup into dedicated components instead of living in the page.

nextjsarchitecturecomponentsseparation-of-concerns

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Avoid inline arrows in list rendering; carry data via data attributes

In mapped lists, do not create a new arrow per item to pass row data; use a single handler that reads a data attribute, and always set a stable key.

reactlistskeysperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Nest SCSS selectors to follow the component's markup hierarchy

Keep the top-level container as the root selector and nest child selectors inside it to mirror the DOM structure of the component.

cssscssnestingstructure

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026css

fullstack ruleP1

Model types after the documented API schema

Derive request/response types from the API contract (Swagger/OpenAPI) instead of inventing fields, and drop fields the API does not return.

typescriptapitypescontracts

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Pass the setter directly when a wrapper handler only forwards its argument

If a handler does nothing but call a state setter with the same value, pass the setter itself instead of wrapping it.

clean-codereacthandlersredundancy

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Type form context with the form-values generic for autocomplete

Pass your form-values interface as the generic to the form hook so getValues and friends are typed and autocompleted.

react-hook-formtypescriptgenericsdx

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Set repeated component defaults centrally in the theme, not per usage

Configure default props (placement, variant) for a UI-library component once in the theme rather than repeating the same prop at every call site.

muithemedefaultsdry

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Do not reset state on mount when the keyed prop never changes

Avoid an effect that resets state on a prop that only sets once; it just causes an extra render on mount.

reacthooksuseeffectperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Name configuration maps for their role, not generically

Give lookup maps and config objects descriptive names (e.g. ApiBaseUrlMap) rather than ambiguous ones like Api.

namingconfigreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP2

Do not put page data-fetching functions in API routes

Server data-fetching functions only run for rendered pages; they have no effect when placed in an API route handler.

nextjsapi-routesdata-fetchingcorrectness

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP1

Verify you are calling third-party APIs as documented

When using a library's validation/config API, follow its documented shape (e.g. an object/array of callbacks) rather than guessing a signature that silently no-ops.

correctnessvalidationthird-partyforms

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Name a mount-only flag isFirstRender

Use a clear name like isFirstRender for a one-time mount guard rather than an initial-prefixed name implying repetition.

reactnaminghooksreadability

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

frontend ruleP2

Consolidate tightly-coupled state into a single variable

When two state values always change together (e.g. snackbar message and open flag), model them as one piece of state derived appropriately.

reactstatesimplicityderived-state

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Drop redundant intermediate response types

Don't define a wrapper interface that is only used to unwrap a response; type the parsed JSON inline and return the inner data directly.

typescripttypesservice-layersimplicity

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP2

Omit the error binding in catch when unused

Use an optional catch binding (catch { }) when the error object is not used, instead of declaring an unused parameter.

error-handlingcleanupstyle

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026javascript

fullstack ruleP1

Keep a single point of contact with the backend API

Route API calls through one layer (services or API routes), not both, so request/response logic is not duplicated.

architectureservice-layerdryapi

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026node

frontend ruleP2

Name and type props for what they accept

If a prop will not always be a specific format (e.g. an HTML string), name it generically (htmlContent), make it optional, and fall back to children.

reactpropsnamingflexibility

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP1

Return an empty collection rather than null for list-returning functions

Prefer returning an empty array over null from functions whose callers expect a list, so consumers do not need null checks.

typescriptnull-safetyapiservice-layer

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

fullstack ruleP1

Fetch initial page data on the server, not on mount

Load a page's initial data in the server-side data function and pass it as props instead of fetching in a client useEffect on mount.

nextjsssrdata-fetchingperformance

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026react

backend ruleP2

Prefer a single explicit method over a function that returns a function

Avoid curried/partial-application service methods when one method with clear parameters is simpler to read and call.

service-layerapireadabilityfunctions

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

frontend ruleP2

Select behavior by variant with a lookup map

When a component must choose between known implementations, drive the choice with a variant prop mapped through a record rather than branching logic.

reactdesignlookup-mapvariants

hegnar-forum-web · org-mining-hist-2026-06

Jun 20, 2026typescript

backend ruleP1

Use the branch context variable that matches the workflow trigger

In GitHub Actions, github.event.ref is null for pull_request; use github.head_ref (or a fallback) for branch names on PR triggers.

github-actionscicorrectnessworkflow

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026yaml

frontend ruleP1

Generate unique ids for SVG defs that may render multiple times

Hard-coded clipPath/gradient ids collide when several icons render together; make them unique per instance.

svgidsreactcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Give boolean ARIA attributes explicit true/false values

Write aria-hidden={true} (or "true") rather than a valueless aria-hidden so the attribute is unambiguous.

accessibilityariareactjsx

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP2

Use find() instead of filter()[0] for the first match

When you want the first matching element, use find() rather than filter(...)[0]: it is clearer and stops at the first hit.

arraysreadabilityperformance

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP0

Do not use `value || true` as a default — it is always true

An `x || true` expression collapses to true regardless of x; use the correct default (often `x ?? false`) and match it to the backing source.

correctnessbooleandefaultsbug

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Name variables by their meaning and reflect their type in hasX booleans

A hasX name implies a boolean; do not assign it a string, and avoid names that suggest the wrong domain concept.

namingreadabilitybooleanstypes

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP2

Compare against string literals so TypeScript narrows the value

Direct === comparisons against literal values let TypeScript narrow the type, unlike a Set.has() check which leaves it as string.

typescripttype-narrowingcontrol-flow

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP1

Use satisfies to validate a literal's shape instead of as

Annotate object literals with satisfies SomeType to type-check them while keeping inference; as coerces and can hide mismatches.

typescriptsatisfiestype-safety

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Use the Mock type from vitest instead of ReturnType<typeof vi.fn>

Type mock functions with import type { Mock } from 'vitest' rather than the verbose ReturnType<typeof vi.fn>.

testingvitesttypescripttypes

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP1

Test Express endpoints through supertest rather than hand-built req/res casts

Exercise route handlers via supertest over the real app instead of casting partial objects to Request/Response, which breaks as soon as the handler touches more of req/res/next.

testingexpresssupertestintegration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Define variables used inside vi.mock factories with vi.hoisted

Because vi.mock is hoisted above imports, reference outside variables through vi.hoisted instead of bare module-scope consts.

testingvitestmockinghoisting

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Mock modules using a dynamic import() reference for path resilience and type safety

Pass import('module') to vi.mock so the mock path follows refactors and you get type safety on the factory.

testingvitestmockingtypescript

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Make the whole handler async rather than wrapping its body in an async IIFE

If a handler needs await, declare the handler async instead of wrapping the body in a void async IIFE.

asyncreadabilitypromises

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP1

Decode HTML entities comprehensively or document the limited scope

Hand-rolled entity handling that covers only one entity is a trap; use a real decoder or comment why only specific entities are handled.

htmlencodingcorrectnessstring

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP1

Store an API response and reuse it instead of calling the endpoint twice

When a status code is checked and the call is repeated for the non-error path, capture the response once and branch on the stored value.

httpperformanceredundancyapi

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Place page-specific markup only on the pages that need it, not a shared template

Adding a feature placeholder to a shared template leaks it onto every page that template renders; scope it to the intended page instead.

templatesscopeshared-layout

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP1

Check the HTTP status the upstream API actually returns on success

Validate responses against the status code the upstream service truly returns (for example 201 on create), not an assumed one, to avoid false negatives.

httpapicorrectnessstatus-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Do not add .ts extensions to TypeScript import paths

Import TypeScript modules without the .ts extension so the path stays consistent with the rest of the codebase and bundler resolution.

typescriptimportsconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Prefer explicit, self-documenting code over a clever one-liner

Choose a clear, obvious implementation over a terse helper (e.g. lodash xor) when the helper's behaviour is not self-evident at the call site.

readabilitylodashclarity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Compare unordered id collections by size then membership, not by JSON.stringify

To detect whether a set of ids changed, compare size and membership instead of relying on JSON.stringify, which is order-sensitive and slower.

correctnesssetcomparisonperformance

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Do not pin a dependency to an exact version without a documented reason

Keep the caret range unless there is a real reason to lock an exact version; an accidental drop of the caret is a bug.

package-jsonversioningdependencies

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Do not add scripts whose only purpose is catching another developer's tooling mistake

Avoid install/preinstall guard scripts that exist only to catch a wrong-package-manager mistake; the cost outweighs the rare one-time error.

toolingpackage-jsonoverheadyagni

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Skip routes that only return the same fallback the default handler already provides

Do not register explicit routes whose only job is to return the same 404/fallback that a catch-all handler already produces.

expressroutingdead-coderedundancy

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Account for spacing variants when running automated find-and-replace

A codemod or search-replace keyed on exact tokens (e.g. '1rem') will miss spaced variants ('1 rem'); broaden the match or do a manual sweep.

codemodrefactoringsearch-replace

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP2

Use enough decimal precision when rescaling values in a codemod

When a migration multiplies values by a non-terminating factor, keep enough decimal places (verify, don't assume three is enough) to avoid rounding drift.

codemodprecisionroundingmigration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Remove data attributes for analytics tools no longer in use

Strip leftover tracking data attributes (e.g. GA hooks) once the analytics tool they served has been retired.

dead-codeanalyticscleanup

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP1

Type each route's req/res with the exact extended shape it needs

Extend Request/Response per route with the specific query, params and locals used, instead of one global type carrying many optional properties.

expresstypescripttype-safetyrouting

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Standardize on one package manager and drop unnecessary script arg separators

Use a single package manager consistently (search and replace stray references) and avoid the extra -- separator pnpm doesn't require for passing flags.

package-jsontoolingscriptsconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Use named wildcards in modern router path patterns

With routers built on newer path-to-regexp, use named wildcard syntax (e.g. /*splat) instead of bare /* or embedded regex.

expressroutingmigration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Add new files using utility classes to the framework's content config

When introducing a new file that uses Tailwind (or similar JIT utility) classes, add its path to the content/purge config so styles aren't stripped.

tailwindconfigurationbuildcss

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

backend ruleP2

Keep required resource identifiers in the path, not the query string

An identifier that is required to resolve a resource belongs in the URL path, not as an optional-looking query parameter.

apiroutingresturl-design

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Prefix related environment variables with their domain

Group related environment variables under a consistent domain prefix so their purpose and ownership are clear.

envconfigurationnaming

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP1

Include Origin in the Vary header for cached CORS responses

When CORS responses can be cached, add Origin to Vary so a response for one origin isn't served to another.

corscachinghttpvary

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP1

Return CORS headers on both the OPTIONS preflight and the actual request

Apply CORS handling to both the preflight (OPTIONS) and the real GET/POST handler; browsers block the response otherwise.

corsexpresshttpcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP1

Send cookies via credentials: 'include' instead of a manual Cookie header

Use the fetch credentials option for cross-origin authenticated requests rather than manually copying the Cookie header.

fetchcorscookiessecurity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Log the actual endpoint instead of passing the caller's name just to log it

When logging an error from a shared request helper, log the endpoint/URL it called rather than threading a caller method name in as an argument.

loggingapireadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Add a hover state to links even when the design omits one

Provide a hover color for links/buttons as a baseline interaction affordance even if the design spec doesn't specify it.

cssuxlinkshover

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP1

Use event delegation instead of attaching duplicate listeners on the same element

Listen once in a common parent and pass derived data down as props rather than registering N identical listeners on the same element.

reacteventsperformancearchitecture

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP2

Type Express handlers with RequestHandler instead of listing req/res/next individually

Use the framework's RequestHandler type to type middleware rather than annotating Request, Response and NextFunction separately each time.

expresstypescriptmiddlewarereadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Rename a symbol at its definition rather than aliasing at each import

If a component or function has a misleading name, rename it where it is defined instead of aliasing it on every import.

namingimportsmaintainability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP1

Pass Date objects internally and serialize to string only at the boundary

Keep dates as Date objects through the codebase and only convert to strings when serializing for output.

datestypesserialization

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP1

Cache repeated DOM query results in a variable

Store the result of a DOM/selector query in a variable instead of re-querying the same element repeatedly.

performancedomreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Be deliberate about value-copy versus reference semantics

When refactoring, verify whether a value is passed by reference or copied, since that can change behavior such as shared mutations.

referencesmutationcorrectnessgotcha

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Export each symbol one way and match how it is imported

Don't export functions both individually and inside a namespace object if consumers only ever import one form; keep exports consistent with usage.

modulesexportsconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Build an object fully then push it once instead of mutating by index

Construct an object completely and append it to the array in one step rather than repeatedly assigning into array[0].

readabilityarraysdata-modeling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Name boolean flags after what they mean

Choose self-explanatory boolean names (e.g. isClickable) that describe the concept rather than vague terms like isAble.

namingbooleansreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

fullstack ruleP1

Use undefined for missing data instead of sentinel placeholders

Represent absent values as undefined and check optional fields, rather than substituting strings like 'Unknown' or 0.

null-handlingdata-modelingcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Hoist loop-invariant computation out of the loop

Compute values that do not change between iterations once before the loop instead of recomputing them every pass.

performanceloopsoptimization

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Do not sort or mutate data inside the render method

Compute sorted or derived data outside render (memoized or upstream) instead of sorting on every render pass.

reactrenderperformancepurity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Normalize text to lowercase/kebab-case when deriving CSS class names

When turning a label into a class name, normalize it (toLowerCase, ideally kebab-case) so styling can be extended without touching the markup.

cssclass-namesnormalizationkebab-case

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Don't export a symbol that's only used in its own file

Keep components and helpers unexported when nothing outside the file uses them; only export when a real consumer exists (and move shared ones to a partials/shared module).

modulesexportsencapsulationcleanup

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Don't add intermediary wrapper components that add nothing

If a passthrough wrapper component provides no behavior, render its child directly instead of introducing an extra layer.

reactcomponentssimplificationabstraction

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Finish extracting logic instead of leaving it half-inline

When pulling logic out of a map/loop into a helper, extract all of it (often into a named component) rather than leaving part as an inline function, which is messier than before.

reactrefactoringcomponentsreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Lazily initialize a shared global with nullish assignment

Create-or-reuse a shared global instance (like an IntersectionObserver) with ??= so multiple callers share one instance, expressed in a single readable line.

singletonglobalsnullish-coalescingreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Use semantic description lists and microdata for label/value data

Render label/value pairs with <dl>/<dt>/<dd> and add schema.org microdata (itemscope/itemprop) for SEO instead of generic divs.

htmlsemanticsseomicrodataaccessibility

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Don't name things "New"

Avoid "New" (or "Old") in component and symbol names; newness is temporary and conveys nothing about what the thing does.

namingreadabilitycomponents

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP2

Keep network timeouts realistically short

Don't set very long request timeouts; if a response hasn't arrived within a couple of seconds it usually won't, and a long timeout just blocks the caller.

timeoutshttpperformanceresilience

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Register listeners with the event name, not the handler property name

addEventListener takes the bare event name (e.g. 'touchstart'), not the on-prefixed property name ('ontouchstart').

domeventsaddeventlistenercorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Use modulo directly for wrap-around indexing

Modulo already keeps an index in range, so don't guard it with a redundant comparison before applying it.

modulosimplificationmath

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Do not nest anchor elements

Nested <a> tags are invalid HTML and trigger React warnings; ensure an element is wrapped by only one link.

htmlaccessibilityreactsemantics

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Use one markup with CSS/media queries instead of duplicating markup per breakpoint

When mobile and desktop share the same structure, render it once and adapt with media queries rather than maintaining separate mobile and desktop markup.

responsivemedia-queriesdrymarkup

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP2

Pick the simplest API that solves the measurement problem

Don't reach for IntersectionObserver for a one-off measurement that a single getBoundingClientRect would solve.

overengineeringdommeasurementsimplicity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Design UI for all fetch states: success, loading, error, empty

Every data fetch has success, loading, error, and empty states; explicitly design and render each rather than conflating them.

reactdata-fetchinguxerror-handling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

If a global may be absent, type it as optional

When window globals might not exist, reflect that in the type definitions (optional) rather than asserting and guarding ad hoc.

typescriptglobalstypesoptional

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Name .d.ts files after what they declare, not a bare module name

A file like window.d.ts implies `declare module 'window'`; name ambient declaration files to reflect their actual purpose/location.

typescriptdeclaration-filesnaming

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Avoid extending built-in prototypes; export a utility instead

Don't add methods to global built-ins like Date/Number; provide a standalone helper function so it's clear what is built-in vs custom.

javascriptprototypesutilitiesmaintainability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Access DOM elements through the ref object, not a captured variable

Read element.current at use time rather than caching node into a local that can go stale when the ref changes.

reactrefsdomhooks

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Avoid extra state writes that the render already guards

Don't add a class/flag in an effect when the JSX already conditionally applies it; the duplicate write causes extra renders.

reacthooksre-rendersstate

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Use unitless line-height values

Specify line-height as a unitless multiplier so it scales with font size, instead of fixed px.

csstypographyline-height

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP2

Don't console.error an error already surfaced in the UI

Skip logging an error the user already sees rendered; if you log for debugging, gate it to development only.

loggingerror-handlingux

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Don't convert a value's type back and forth across layers

Pick one representation for a value and keep it consistent; avoid serializing number-to-string on the backend then parsing it back on the frontend.

typesconsistencydata-flow

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Factor out repeated URL-building steps

When the same path/query assembly is duplicated across branches, consolidate it into one set of conditional appends.

dryurl-buildingreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Don't include return-object fields that are always set to a constant

Drop properties that are unconditionally zeroed/empty in a returned object unless a downstream consumer truly requires the key.

dead-codeapi-designcleanup

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Use a stable cache key, not a unique-per-request param

Don't bust caching with a fresh value on every request; change the cache-key param only when the underlying inputs actually change.

cachinghttpperformance

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP2

Avoid resize listeners for non-critical layout adjustments

Skip window resize handlers for cosmetic, non-critical layout that would be costly to re-evaluate; let a refresh re-run the measurement.

performanceeventsresizelayout

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Use observer.disconnect() instead of tracking refs to unobserve

When cleaning up an IntersectionObserver/ResizeObserver, call disconnect() rather than holding the element to call unobserve and null-checking refs.

domobserverscleanupreact

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Trim trailing whitespace but keep the final newline

Configure your editor to trim trailing whitespace while preserving the single trailing newline at end of file.

formattingeditor-configwhitespace

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP0

Keep personal auth tokens in the user-level config, not project files

Place personal registry/auth tokens in your global ~/.npmrc (or shell env), never in the project-tracked .npmrc.

secretsnpmsecurityconfiguration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Make the full intended region scrollable, not a partial inner container

Apply horizontal scroll to the whole logical row that reaches the viewport edge so content isn't cut off mid-container.

cssresponsiveoverflowux

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP1

Guard optional meta tags with an existence check on their content

Only emit a meta/SEO tag when the value backing it actually exists, rather than rendering empty tags.

htmlseometa-tagstemplates

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP2

Do not repeat the same guard check in parent and child

If a parent already guards on a condition before rendering a child, the child does not need to re-check the same condition.

reactredundancyconditional-renderingdry

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Add an English comment next to non-English UI strings

When hardcoded copy is in a language not all reviewers read, leave a short translation comment so reviewers can verify it without a translator.

i18ncommentscode-reviewreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP2

Use a consistent import style across similar units

When several similar pieces of code can import a type/util two equivalent ways, pick one style and apply it consistently.

consistencyimportsconventions

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Strip ad/tracking config and meta that the feature doesn't need

Don't carry over ad/tracking meta tags and config objects into a stripped-down view (like a preview) where they serve no purpose.

cleanuphtmlperformance

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Use exclusive routing middleware when a route is scoped to one context

If a route should only exist for one publication/tenant, register it with the exclusive middleware rather than the general resolver that exposes it everywhere.

routingmiddlewarescoping

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Keep emit-related compiler options in the config that actually emits

Settings like noEmit and output paths belong in the tsconfig that performs the build, not in a base config that's only extended.

typescripttsconfigbuildconfiguration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Give a Map's value a named type instead of a bare primitive

Wrap a Map value in a named type or object so Map<number, X> documents what the value means rather than an opaque boolean.

typescripttypesreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Import individual lodash functions rather than the whole library

Import only the lodash functions you use so bundlers can tree-shake instead of pulling in all of lodash.

bundle-sizelodashimportsperformance

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Avoid adding a dependency that overlaps one you already have

Before adding a package, confirm it isn't duplicating functionality of an existing dependency.

dependenciespackage-managementbloat

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP1

Type a field as nullable when the source can return null

If an upstream can return null for a field despite its documented contract, reflect that in the type (string | null) so consumers handle it.

typescripttypesnull-safetyapi

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP1

Don't substitute an empty string for a missing auth token

If a required token is absent, handle that case explicitly rather than sending an empty-string header that silently produces a bad request.

authheaderscorrectnesserror-handling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP2

Use a const-asserted array plus a type guard to narrow a string against allowed values

Array.includes on an `as const` array won't narrow a plain string in TypeScript; add a small type guard so the check both validates and narrows.

typescriptnarrowingtype-guardsvalidation

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Read environment values on the server and pass them to the client as props

Client code can't read server-only env vars; resolve them server-side and pass the value down rather than hardcoding a host.

environmentconfigclient-serverhardcoding

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Model a filter as a query parameter rather than a separate route

Use a query param for a list filter/category instead of minting distinct pages, which avoids ambiguous URLs and duplicated routing.

routingurlsfiltersdesign

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP2

Recover from errors by refetching data, not reloading the whole page

On a failed widget request, prefer re-running the data fetch (or re-issuing the token) over forcing a full page reload.

uxerror-handlingdata-fetching

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Place a component file where its actual parent lives

Keep a component's file inside the folder of the component that actually renders it, not under an unrelated sibling.

reactfile-structureorganization

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Name boolean variables with clear affirmative intent

Prefer a positively phrased, descriptive boolean name (isUserAuthenticated) over vague or negated names.

namingbooleansreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Extract a repeated responsive media-query check into a shared hook

When the same breakpoint media-query check is copied across components, centralize it in a reusable hook like useIsMobile.

reacthooksresponsivedry

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP1

Share one source-of-truth type instead of duplicating type definitions

Derive related types from a single shared type (via Exclude/Extract) so a change in one place forces TypeScript to flag every dependent spot.

typescripttypesdrymaintainability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Build a reusable image-with-fallback component with onError handling

When a fallback image/initial pattern recurs, extract a component that renders a fallback and handles onError for broken sources.

reactcomponentsimagesreuse

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP1

Validate a date string before relying on the parsed Date

TypeScript won't catch an invalid date string passed to new Date(); validate it in the consuming code.

datesvalidationrobustness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Don't return a value that callers always ignore

If a function's return value is never used, either use it or don't return it, so the signature reflects reality.

api-designreadabilitydead-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP2

Don't build a URL via new URL().toString() when a template literal suffices

For straightforward URLs use a plain template string instead of constructing a URL object only to stringify it.

readabilityurlsimplicity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Give env vars descriptive names and document them in the template

Name environment variables clearly and add a comment plus example value in the env template (when not secret).

configenvdocumentation

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Debounce search-as-you-type and reset pagination on new queries

Don't fire a request on every keystroke; debounce input and reset the page to the first when the query changes.

reactperformancesearchux

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Make placeholder and helper text match actual capability

Don't advertise a search field or input as supporting input it can't actually handle.

uxcopycorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP2

Mark methods that aren't always implemented as optional

If an interface method isn't always present, declare it optional (or use an abstract class) rather than forcing every implementer.

typescriptinterfacesdesign

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Avoid a multi-key classes prop; prefer semantic markup with one root class

Instead of exposing a classes object to style internals, use a single root className plus semantic elements you can target in CSS.

reactcssapi-designcomplexity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Store a boolean error flag when you only need to know it failed

If the UI only cares whether an error happened, set a boolean rather than stashing the error object.

reactstateerror-handling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Pass date strings as props and parse at point of use

Prefer passing a date string between components and converting to a Date where you actually need it, validating it in the consumer.

reactpropsdates

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Don't reference process.env in browser-only code

Client code can't access process; use a build-injected value, a passed config, or a relative path instead.

browserenvbundlingcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP1

Do not combine contradictory Cache-Control directives

Directives like max-age and no-store contradict each other; pick the one that matches the caching intent.

httpcachingheaders

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Satisfy consistent-return in effects with explicit returns

useEffect should return a cleanup function or nothing; when other branches return, use return undefined to keep the rule happy.

reacthookseslint

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Collapse redundant chained replaces into a single regex pass

If two sequential replaces achieve one transformation (e.g. whitespace then space-to-dash), combine them into one regex.

regexclean-codesimplificationstring

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Avoid redundant wrapper elements by passing classes to the inner component

Instead of wrapping a component in an extra div just for a class, pass the className to the component directly.

reactjsxclean-codemarkup

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP1

Add tests for boundary values and guarantee no crash on invalid input

Cover edge cases like zero, negatives, and large numbers, and verify that passing invalid input does not throw a 500.

testingedge-casesrobustnessvalidation

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Test functions with inputs that represent their real accepted types

Exercise a function with the kinds of inputs it actually accepts (e.g. a Date for a Moment-input parser), not just the type that happens to be returned, so the test proves real behavior.

testingcoverageedge-casescorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Name test cases by the function under test, not by the exact expected value

Keep test names focused on the behavior/function being tested rather than embedding the specific literal value asserted.

testingnamingreadabilityclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Compare values of the same type rather than relying on loose equality

When comparing two values, cast both to the same type (string or number) so a strict comparison is meaningful.

correctnessequalitytypesclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Remove the else branch after an early return

When an if branch returns, drop the else and let the following code run at the top level for flatter, clearer flow.

control-flowclean-codereadabilityguard-clause

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Drop get/render prefixes from identifiers that are no longer functions

When a getter is refactored into a plain value, rename it to drop the verb prefix so the name reflects what it is.

namingclean-coderefactoringreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP0

Do not use dangerouslySetInnerHTML when rendering plain children works

Render text/content as normal JSX children instead of dangerouslySetInnerHTML, which opens an XSS hole and is unnecessary for non-HTML strings.

reactsecurityxssjsx

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP1

Use a 301 status for permanent redirects

When a URL has permanently moved (e.g. canonicalizing a profile/author URL), redirect with status 301 instead of the default temporary redirect.

httpredirectseoexpress

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Type function components by usage rather than forcing React.FC

You don't need to annotate a function component with React.FC just to validate its return; TypeScript flags an invalid React node where it's rendered, so add the annotation only when authoring shared/library components.

reacttypescriptreact-fctypes

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Only coerce with !! when the target value is actually a boolean

!! converts a value to a boolean, which is fine for boolean props/conditions, but don't apply it when the API expects a non-boolean value (it would discard the real value).

coercionbooleantypescriptcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Favor named components over deeply inline div markup in render

Extract chunks of JSX (especially conditional div soup) into named components whose name says what they are and whose props say what they need; it reads far better than raw nested tags.

reactcomponentsreadabilityjsx

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP1

Don't import server-only types or modules into client code

Keep server and client boundaries clean: importing server-only types/modules into a client bundle drags in server dependencies and breaks the build; define shared types in a neutral location.

module-boundariesclient-serverimportsbundling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Enable the strict umbrella flag rather than individual strict sub-flags

Turning on strict in tsconfig already enables all its constituent strict checks, so set strict instead of listing them individually; also consider forceConsistentCasingInFileNames.

typescripttsconfigstrictconfiguration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP2

Don't put NODE_ENV in .env; set it explicitly per script

NODE_ENV is conventionally set per-command (or overridden manually), not stored in .env, because a forgotten committed value can cause confusing, hard-to-diagnose behavior.

nodeenvnode-envconfiguration

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Keep one component per file and define non-reusable JSX outside the render body

Favor one component per file; small non-reusable JSX may stay in the same file but should be defined outside the component body (ideally as a pure function) so it isn't recreated each render and can be extracted later.

reactfile-organizationrenderpurity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Define functions and methods before they are used in a file

Order declarations so a function appears before the code that calls it; reading top-to-bottom is easier than jumping around for definitions.

readabilityfile-organizationorderingclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

fullstack ruleP2

Name methods descriptively; reserve generic get for accessor semantics

Avoid a bare get() for methods that compute/derive data; a name like getArticleRenderData communicates intent, and get() conventionally implies a keyed/array/singleton accessor.

namingmethodsreadabilityclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP2

Implement stateless service/provider classes as singletons or static, consistently

When a service or provider class is never meant to have multiple instances, make it a singleton or a static class, and apply the same pattern across all such classes.

architecturesingletonservicesconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Use reduce only when aggregating into a single value

Prefer map/filter/loops for transforming arrays; reserve reduce for genuinely collapsing many items into one value, since complex reduces are hard to read later.

array-methodsreducereadabilityclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Use test.each for tables of similar test cases

When several tests differ only by input/expected values, drive them with test.each instead of copy-pasting near-identical test bodies.

testingvitestjestdry

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Don't add optional chaining in tests; mock dependencies and assert on known shapes

Tests should control their inputs and outcomes, so avoid defensive optional chaining; mock third-party calls and assert against the expected, deterministic shape.

testingmockingassertionsdeterminism

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Avoid single-letter type names outside of generics

Give types descriptive names (e.g. SomethingProps); reserve single letters for generic type parameters only.

typescriptnamingtypesreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Write sort comparators that return 0 for equal items

A sort comparator should return a negative, zero, or positive number; use subtraction so equal keys yield 0 rather than an arbitrary nonzero value.

sortingcomparatorarraycorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Pass serializable literal props and never mutate props

With server-side rendering, non-literal prop values (like URL objects) get coerced to strings, so prefer serializable literals; and never reassign properties of props — copy into a local variable instead.

reactssrpropsimmutability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Use a ref to access React-managed DOM nodes instead of querying the document

When an element is rendered and managed by React, reach it via useRef rather than document.querySelector so you target that exact node and stay within React's model.

reactuseRefdombest-practice

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Narrow DOM types with instanceof instead of as assertions

Avoid `as` type assertions on DOM lookups; use `instanceof` checks (or the already-correct return type) so TypeScript actually verifies the type at runtime.

typescripttype-assertionsdomtype-safety

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP1

Use + not * when at least one character is required, and name validators to match their semantics

A trailing * quantifier matches the empty string, so it validates as true for empty input; use + when one or more characters are required, and name the validator to reflect whether empty is allowed.

regexvalidationnamingcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Reuse the project's asset loader mixin instead of inlining assets

Use the established mixin/helper for loading icons or assets rather than hand-rolling the same inclusion.

mixinsreusedryassets

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP1

Handle the fallthrough state so a render branch can't crash

Make sure an else/fallback branch can't be reached with data it isn't prepared to render, or guard it explicitly.

conditional-renderingdefensivecorrectnessnull-safety

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Put reusable content transforms in a shared util, not in components

Place HTML/data transformation logic in the shared utility/processing layer rather than inline in a component.

separation-of-concernsutilscomponentsstructure

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP1

Verify the `this` binding passed into callbacks

Confirm what `this` refers to when handing it to another function; an unintended binding silently breaks behavior.

thisbindingcallbackscorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Attach event handlers by reference, not via wrapper closures

Subscribe handlers directly (player.on('play', trackPlay)) instead of wrapping them in extra anonymous functions.

event-handlersclosuresreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Drop the aggregate wrapper when there is only one validator

Call a single validator directly instead of wrapping it in an all/compose aggregator that adds no value.

validationsimplificationredundancy

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Prefer a server redirect over client-side click hacks

Return a real HTTP redirect from the server when possible, rather than rendering a page that fakes a click to navigate.

redirecthttpserversimplicity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP1

Register new client components in the shared component index

Add a newly created client-hydrated component to the central component registry so it actually mounts.

registrationhydrationcomponentswiring

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP1

Set private:true on packages that should never be published

Mark internal/app package.json files with private:true so package managers refuse an accidental npm publish.

npmpackage-jsonpublishingsecurity

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP1

Don't hardcode a single unit when formatting relative time

Use a relative-time formatter that picks the right unit (m/h/d) instead of fixing the label to minutes.

dateformattingrelative-timei18n

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

An intentional no-op catch needs an empty function body

To truly swallow a rejection, attach .catch(() => {}); an empty .catch() with no handler still rejects.

promisescatcherror-handlingcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Don't rely on useEffect in server-only rendered components

useEffect never runs during server rendering, so don't place behavior in it for components that render only on the server.

useeffectssrserver-renderinghooks

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Use consistent verb prefixes for similar functions

Pick one verb (get vs fetch) and apply it consistently across functions that do the same kind of thing.

namingconsistencyconventions

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Don't add an empty .then() just to silence floating-promise lint

If you don't need the result and don't need to await, omit the promise chain (or void it) rather than tacking on an empty .then().

promiseslintasyncnoise

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP2

Don't add defaults that a later guard already handles

Skip a fallback default when a subsequent check already filters out the falsy case, to avoid redundant code.

defaultsredundancyguards

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Don't leak raw HTTP responses out of service functions

Have a service interpret the HTTP response internally and return a clean success/failure or domain value, not the raw response.

abstractionapiencapsulationservice-layer

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP2

Compute environment-derived config once, not on every request

Resolve values that come from environment/config at startup, not recomputed inside per-request handlers.

configperformanceenvironmentrequest-handlers

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP1

Don't derive feature config from NODE_ENV; use dedicated env vars

Use purpose-specific environment variables for external integrations rather than coupling them to NODE_ENV.

environmentconfigcouplingnode-env

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

frontend ruleP2

Don't put never-changing values in component state

Keep constant configuration as plain consts/props, not state, when nothing ever updates them.

usestatestate-managementconstantshooks

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Match useState setter name to its value

Name the useState pair consistently as [value, setValue] so the setter clearly maps to its state.

usestatenaminghooksconventions

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Configure linter rules for formatting concerns rather than fixing them by hand

Encode recurring formatting/style preferences (object spacing, arrow parens, quote style, blank lines) as lint rules so they are enforced and auto-fixed.

lintingformattingtoolingconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Keep indentation consistent with the surrounding file

Match the file's existing indentation width instead of mixing 2- and 4-space indentation.

formattingindentationconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

backend ruleP2

Use an established library for common tasks instead of hand-rolling

Reach for a well-known library (e.g. for query-string building) for common, error-prone tasks rather than reimplementing the logic by hand.

librariesreusemaintainability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Guard a map with a presence check instead of an extra index variable

Render a list with value && value.map(...) to avoid an extra variable or branch when the source may be empty/absent.

reactrenderingarraysconciseness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP2

Import related modules through one consistent mechanism

Don't mix a barrel/aggregated import with a one-off direct import of the same kind of module; pick one approach and apply it consistently.

importsconsistencyorganization

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

backend ruleP2

Don't create enums that just duplicate config data

Instead of an enum that mirrors a config file and re-exposes its values, add the needed property to the config and expose it through the owning service.

configurationencapsulationdryenums

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Split long optional-chaining expressions into readable steps

Break a heavily optional-chained expression into separate guarded statements, since chained ?. operators can go unnoticed and reduce readability.

readabilityoptional-chainingcontrol-flow

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Use Object.entries to iterate keys and values together

When you need both the key and value of an object, iterate with Object.entries instead of looking up the value by key inside the loop.

javascriptobjectsiterationreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Name props by what they mean, not by incidental placement

Choose a prop name describing the concept (e.g. variant) rather than an incidental detail like where it appears, and rename boolean props to read naturally.

reactnamingpropsreadability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Don't read state right after calling its setter

State updates are not applied synchronously, so don't rely on the new value in the same function right after calling setState.

reactstatesetstatecorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Don't combine assignment and a conditional check in one confusing expression

Split a statement that both performs a check and calls a function into clearer, separate steps so the control flow is obvious.

readabilitycontrol-flowclean-code

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

backend ruleP2

Invert guard clauses to return early and reduce nesting

Return early on the failure condition instead of wrapping the happy path in a large if block, to keep indentation flat.

control-flowearly-returnreadabilityguard-clause

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP1

Include every referenced value in the useEffect dependency array

List all reactive values the effect reads in its dependency array, even if you believe they never change, to follow the rules of hooks.

reacthooksuseeffectdependencies

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP1

Type DOM refs as nullable so null access is caught at compile time

Declare element refs as useRef<HTMLElement | null>(null) and guard .current before use, since the ref can be null before mount.

reactrefsnull-safetytypescript

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP2

Remove default cases and fallback values that cannot occur

Drop a switch default or fallback that returns meaningless placeholder values when the input is guaranteed valid, since it allows nonsensical return shapes.

control-flowdefaultscorrectnessswitch

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP2

Do not add default values for parameters that always receive one

Drop default parameter/prop values when every call site already supplies a value, since the default is misleading and never used.

defaultspropsreadabilityapi-design

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

frontend ruleP1

Use shared theming/skins for variations across products

Express brand or product styling differences through a shared theming mechanism instead of duplicating component logic per product.

themingcssdrymulti-brand

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP1

Use window.innerWidth for responsive checks, not screen.width

screen.width reports the physical device size; use window.innerWidth to react to the actual viewport.

responsivebrowser-apicorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Remove element id attributes that are not used

Drop id attributes added to markup when nothing references them for styling, scripting, or hydration.

htmlcleanupattributesnitpick

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026html

fullstack ruleP1

Guard against missing or empty data before using it

Handle the cases where fetched data is absent or empty so the UI degrades gracefully instead of throwing.

defensive-programmingerror-handlingcorrectness

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Control SVG size and color via CSS, not inline in the asset

Style width, height, and color of inline SVGs through CSS classes rather than editing attributes in the SVG file.

csssvgstylingmaintainability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026css

frontend ruleP2

Don't destructure props when the component uses none

Drop the props parameter and destructuring entirely if a component reads no props.

reactpropscleanupnitpick

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Do not return the result of a void state setter

Returning a setState call returns undefined and signals confusion; call the setter on its own statement.

reacthooksreadabilitynitpick

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

fullstack ruleP2

Resolve TODOs rather than leaving them in merged code

Make a decision and implement it instead of committing TODO placeholders.

todocleanupdecisionsnitpick

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

frontend ruleP1

Do not repurpose React's reserved key prop as a data field

key is reserved by React for reconciliation; store domain data under a differently named property.

reactkeysreserved-propsdata-modeling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

frontend ruleP2

Pass a boolean JSX prop by presence instead of ={true}

Writing a boolean prop bare is equivalent to setting it to true, so drop the explicit value.

jsxpropsbooleansnitpick

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026react

backend ruleP1

Type a list field as an array of the element shape, not a single-element tuple

Model collections as ElementType[] rather than a one-element array literal of an inline object.

typescriptinterfacestypesdata-modeling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

backend ruleP1

Use the same environment variable name across all environments

Don't set NODE_ENV locally when CI uses APP_ENV; align variable names so behavior matches everywhere.

envconfigciconsistency

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP2

Keep only the build/run scripts that are actually used

Remove duplicate or dead package scripts so the only supported way to build/run is unambiguous.

buildscriptsdead-codetooling

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP2

Separate distinct blocks of logic with blank lines

Add vertical whitespace between logically distinct sections so dense code is easier to scan.

formattingreadabilitywhitespacestyle

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026universal

backend ruleP1

Wrap independent async calls in separate try/catch blocks

Give each independent request its own try/catch so you can tell which one failed and handle them distinctly.

error-handlingasynctry-catchobservability

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026node

fullstack ruleP1

Use parentheses to make operator precedence explicit in conditions

Group comparisons and logical operators with parentheses so precedence (&&, !==) reads as intended.

operatorsprecedenceconditionsbug

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Always pass a radix to parseInt and provide a fallback

Call parseInt with an explicit base 10 and a default to avoid NaN and ambiguous parsing.

parsingnumbersparseintbug

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Define interfaces for config and repeated object shapes

Give recurring object shapes (config sections, error messages, props) named interfaces and reuse them.

typescriptinterfacesdrytypes

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026typescript

fullstack ruleP2

Start line comments with a space after the marker

Put a single space between the comment marker and the text for consistent, lint-clean comments.

commentsformattinglintstyle

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

fullstack ruleP1

Iterate arrays with array methods, not for...in

Use forEach/for...of for arrays; reserve for...in for enumerating object properties.

javascriptiterationarraysobjectsbug

hegnar-web · org-mining-hist-2026-06

Jun 19, 2026javascript

frontend ruleP2

Type custom-element props with the minimal shape you actually use

When declaring props for a custom element, use the raw object shape of the attributes you need rather than pulling in broad helpers like DetailedHTMLProps/HTMLAttributes.

typescripttypesweb-componentsclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Ship custom-element type definitions inside the package that provides them

Consumers should not have to redeclare a web component's JSX types; the type definitions belong in the package exporting the component so all consumers get them automatically.

typescripttypespackagesweb-components

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Beat CSS specificity with a selector trick, not an extra wrapper div

To override a higher-specificity rule from a shared component, repeat a class in the selector (.modal.modal) rather than adding a wrapper element solely to win specificity.

cssspecificityscssclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026SCSS

frontend ruleP2

Reuse a component's CSS module classes instead of wrapping in a new component

To apply existing typography/styles to a plain tag, import and apply the relevant CSS module classes directly rather than introducing an extra wrapper component that changes the tag.

reactcss-modulesreuseclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Preserve the original semantic tag when changing typography variants

Switching a Typography variant should not silently change the rendered HTML tag; pass component="h2" (or the original tag) to keep semantics and avoid layout/a11y regressions.

accessibilitysemanticstypographyreact

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Match the formatter; don't fight tooling over self-closing void tags

Browsers handle void elements like <meta> regardless of a trailing slash, so accept whatever the formatter (Prettier) produces instead of fighting it.

htmlformattingtoolingclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML

frontend ruleP1

Mirror changes between paired desktop and mobile config files

When constants or config are split into desktop and mobile variants, any change to one must be reflected in the other to avoid divergence bugs.

consistencyconfigurationmaintainabilityduplication

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Exclude test files from Tailwind content scanning

Add a negated test-file glob to Tailwind's content config so class names appearing only in tests are not scanned into the build.

tailwindbuildconfigurationtests

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind

frontend ruleP2

Do not create a shared file re-exporting Tailwind base directives

Avoid a single use-tailwind file that re-applies @tailwind base/components/utilities for reuse; repeat the directives per entry as Tailwind recommends.

tailwindcssbuildconventions

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind

frontend ruleP2

Use consistent empty/initial values for related pieces of state

Two related state values representing 'no selection' should use the same empty representation (both null or both '') so downstream checks behave uniformly.

reactstateconsistencyclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Do not use a functional state update to set a constant value

setState(prev => true) and setState(prev => false) are just setState(true)/setState(false); use the constant form when the new value does not depend on the previous one.

reactstateclean-coderedundancy

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Apply a style only at the breakpoints where it has an effect

Scope properties like z-index or positioning to the breakpoint where they actually matter, instead of applying them globally and breaking smaller viewports.

cssresponsivebreakpointscorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS

frontend ruleP2

Import static assets from source so they get content-hashed

Place images and similar assets in src and import their URL so the bundler adds a content hash; reserve the public folder for files that must keep a fixed path (favicon, robots.txt).

assetscachingbundlerperformance

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Vite

frontend ruleP2

Reference globals with their full path to show where the value comes from

Prefer window.product over a bare product reference so it is immediately clear the value is a browser global, not a local variable.

readabilityglobalsclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP2

Reuse the existing form input component with built-in states

Use the shared FormInput (or equivalent) that already handles error styling instead of re-styling a raw input per feature.

reactformsreusedry

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Treat an oversized component stylesheet as a signal to split or reuse

A very large single component stylesheet usually means the component should be broken into children or that shared/global styles are missing; reconsider the structure.

cssscsscomponent-designmaintainability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026SCSS

frontend ruleP1

Do not reference functions that are not defined in scope

Calling a function that has no definition in the component (relying on an external runtime injection) is fragile; define it, type it, or guard its existence explicitly.

correctnessreactglobalstype-safety

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Type boolean-like props as booleans and name initial-state props clearly

A toggle's value prop should be a boolean named for its meaning (checked), and the local initial-state prop should read as initial (initialChecked) rather than a stringly-typed defaultChecked.

reactpropsnamingtypes

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Write code identifiers in English even when copy is localized

Keep variable, prop, and key names in English for a consistent codebase, while user-facing text stays in the product's language.

namingi18nconventionsreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Break long copy into meaningful translation keys instead of one sentence-as-key

Prefer short semantic keys mapping to message fragments (ACCOUNT_SUSPENDED, CONTACT_ADMIN_MESSAGE) over using whole sentences as the key.

i18ntranslationsnamingmaintainability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Pass class overrides through a typed classes object, not a loose className

When a component supports overriding the styles of several internal parts, accept a classes={{ part: ... }} object rather than a single ambiguous className string.

reactstylingapi-designconventions

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Carry related data through the mapper instead of re-indexing the raw array

When mapped items need a property from the raw item, attach it during mapping rather than re-looking up the original by index, which breaks if mapping or order changes.

reactdata-mappingcorrectnessclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Prefer HTML preload links over a JS hook for images

Preload images with <link rel=preload> in HTML rather than a custom hook; scope them with media queries so only viewport-relevant images load.

performancepreloadimageshtml

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML

backend ruleP2

Pin the CI Node version from .nvmrc instead of hardcoding it

Use setup-node's node-version-file pointing at .nvmrc so the CI Node version stays in sync with the repo's declared version automatically.

cinodeconfigurationdry

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026GitHub Actions

backend ruleP2

Set the npm auth token env var once for the whole workflow instead of per step

npm reads NPM_AUTH_TOKEN from the environment, so define it once at workflow/top level rather than amending .npmrc before every install.

cinpmconfigurationdry

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026GitHub Actions

backend ruleP2

Do not expose two methods that are never used apart from each other

If two public methods are always called together, collapse them into one method that does the combined work, keeping the intermediate logic encapsulated.

api-designencapsulationclean-codecohesion

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Name service methods so the verb and noun match what is returned

A method named getX should return an X; if you are already inside a named journey/context, drop the redundant qualifier and ensure the returned value matches the noun in the name.

namingservicesclean-codereadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Detect outside clicks with a document listener and a ref, not an extra wrapper element

To close on outside click, attach a listener to document and check whether event.target is inside the ref, instead of adding a wrapping div whose only purpose is catching clicks.

reacteventsdomperformance

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP1

Name a method for what it actually does, including side effects

A method named as a pure query (e.g. evaluate/get) must not also mutate state; either split read and write or rename it to reflect the mutation.

namingside-effectssingle-responsibilityclean-code

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Don't forget the decorator needed to inject request-derived params

Parameters sourced from the request (language, user, etc.) must carry their injection decorator (e.g. @Req / a custom param decorator); a bare parameter will be undefined at runtime.

nestjsdecoratorsrequestcorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP2

Remove join conditions already implied by another condition

Drop extra ON conditions that are logically guaranteed by an existing one; they add noise without changing results.

sqljoinsredundancyclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP1

Build unique constraints on columns guaranteed to be present

Base a unique constraint on fields that are actually required/non-null (e.g. email + tenant id) rather than on optional fields that may be empty.

databaseconstraintsdata-integrityuniqueness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP2

Prefer JOIN with GROUP BY over correlated subqueries for aggregation

Rewrite count/aggregate correlated subqueries as a JOIN with GROUP BY where it yields the same result, for clearer and often faster queries.

sqlperformancequery-optimizationjoins

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP1

Wrap nullable SQL aggregates/expressions in COALESCE

When an aggregate or arithmetic on possibly-null columns can yield NULL, wrap it in COALESCE so the query returns a sensible default rather than null.

sqlnull-handlingaggregatescorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP2

Use mockRejectedValue / Promise.reject for rejecting mocks in tests

Stub a rejecting async function with mockRejectedValueOnce or a Promise.reject factory instead of a verbose mockImplementation that throws, for clearer test intent.

testingmocksjestreadability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Jest

backend ruleP2

Don't initialize a variable you immediately overwrite in every branch

If every branch assigns a variable, declare it with a type and no initial value rather than giving it a throwaway default that is always overwritten.

clean-codevariablesreadabilityredundancy

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Avoid exposing a column under a name that conflicts with another field

Don't alias a database column to a DTO property name that collides with the real meaning of another column; it confuses consumers and blocks exposing the original column later.

dtonamingmappingclarity

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Filter out falsy entries before mapping to extract ids

When extracting a list of ids from records that may lack one, filter for the presence of the field first, then map, so the resulting array has no undefined entries.

arraysclean-codemap-filtercorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Reuse shared currency/exchange-rate utilities instead of ad-hoc conversion

Use the project's existing exchange-rate or currency library for conversions rather than re-implementing rate logic inline, to keep behavior consistent.

reusedrycurrencyconsistency

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Node.js

backend ruleP1

Wrap scheduled jobs in error handling

Cron/scheduler-triggered tasks should catch and log their own errors so an unhandled rejection doesn't crash the process or fail silently.

error-handlingschedulercronresilience

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Node.js

backend ruleP2

Use consistent date types across DTOs and tests

Represent the same conceptual field with a consistent type everywhere (always Date or always ISO string); mixing them within the same codebase causes confusion and serialization bugs.

consistencydatestypesdto

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Mark nullable model columns with the allow-null decorator

If a database column can hold null, annotate the ORM model accordingly so the type and the schema agree and consumers handle null correctly.

databasemodelnull-safetyorm

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize / TypeScript

backend ruleP2

Avoid generic folder and module names

Name folders and modules after their role (e.g. helpers, services) rather than vague labels like "class" or "admin-tool"; generic names hide what lives inside.

namingproject-structureconventionsreadability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Inline single-use interfaces instead of declaring a separate type

If an interface is used in exactly one place, consider inlining the shape to keep the code compact rather than creating a dedicated declaration file.

typescriptclean-codeinterfacesyagni

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Use independent if blocks instead of if/else-if when conditions are not mutually exclusive

When multiple conditions can each apply independently, write separate if statements rather than chaining them with else-if which implies exclusivity.

control-flowreadabilityconditionalsclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Use named bind parameters in SQL instead of positional arrays

Bind SQL replacements by name (:key) with an object rather than a positional array, so parameters are self-documenting and order-independent.

sqlreadabilityquerymaintainability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL / Sequelize

backend ruleP2

Log error.message directly instead of wrapping a single value in a template literal

When a string already holds the full message, pass it as-is rather than embedding it in a redundant template literal.

clean-codeloggingreadabilitynitpick

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Derive ENUM column definitions from the enum's values

Define a database ENUM column from the TypeScript enum's values instead of hardcoding the option list, so the column and enum cannot drift apart.

databaseenumdrysingle-source-of-truth

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript / Sequelize

backend ruleP1

Add NOT NULL columns in stages: add nullable, backfill, then add constraint

Adding a NOT NULL column to a populated table fails without a default; add the column nullable, fill it with data, then apply the not-null constraint.

databasemigrationnot-nulldata-integrity

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL / Sequelize migrations

backend ruleP1

Backfill existing rows in the migration when changing a column default

Changing a column's default only affects new rows; if existing rows should use the new value, update them within the same migration.

databasemigrationdata-integritydefaults

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL / Sequelize migrations

backend ruleP1

Validate a real DTO instance, not a plain object

class-validator only validates class instances; pass a DTO instance (e.g. via plainToInstance) rather than a plain object literal, or validation silently passes.

validationclass-validatorcorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP2

Add conditions so update queries touch only the rows that need it

Include extra where conditions (e.g. is_available = false, bottle_id IS NOT NULL) to skip rows that don't require updating, making queries faster and safer.

databaseperformancequery-building

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP1

Use the known primary key as the update where-condition

When you already have an entity's id, filter updates/lookups by that id rather than by other (possibly non-unique) fields.

databasecorrectnessquery-building

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

fullstack ruleP2

Collapse duplicate branches into a single computation

If two variables or branches end up computing the same thing, use one; only keep the split if it adds genuine semantic clarity.

dryclean-codereadability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Wrap the whole loop iteration in try/catch, not just the tail

When iterating and you want per-item resilience, the try/catch should cover the full iteration body so an early failure doesn't skip later steps or break the loop.

error-handlingloopsresilience

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Place decorators in the correct order and omit redundant ones

Decorator order matters (they apply bottom-to-top); place each where it takes effect and drop decorators that only restate the framework default.

decoratorsclean-codeclass-validator

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP1

Provide the generic type on raw/select query calls

Pass the expected row shape as a generic to raw query/select methods so the result is typed instead of any/unknown.

typesdatabasegenerics

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP2

Use a pick helper to map a subset of identical properties

When a mapper copies several same-named properties, use a pick utility (e.g. lodash pick) instead of listing each assignment manually.

mappingdryclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Add explicit access modifiers to class members

Declare public/private/readonly explicitly and consistently on class properties and methods rather than relying on the implicit default.

access-modifiersconsistencyclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Return only the data the caller needs from helpers

If callers only consume ids, have the helper return an array of ids rather than full DTOs, reducing coupling and payload.

api-designclean-codeperformance

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Keep functions to a single responsibility

A function named for a query/check (e.g. isRegionOnly) should not also perform an unrelated mutation like a DB update; split the concerns.

single-responsibilityside-effectsclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Specify an explicit sort direction

Always state ASC or DESC in ORDER BY / order options rather than relying on the implicit default, so the intent is clear and stable.

sqlsortingclarity

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP2

Capitalize SQL keywords

Write SQL keywords in uppercase (SELECT, ORDER BY, WHERE) so queries read consistently and keywords stand out from identifiers.

sqlstylereadability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

fullstack ruleP1

Set the flag in both branches of an if/else

When a boolean outcome depends on a condition, set it explicitly in both the if and else branches rather than leaving the else case to a stale or default value.

control-flowcorrectnessconditionals

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Define unique constraints on the minimal correct column set

A composite unique constraint should cover exactly the columns that must be unique together; adding columns already implied by a narrower constraint is redundant or wrong.

databaseconstraintsmigrationscorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP2

Return the update result when the caller needs the updated record

If callers need the updated entity, return the ORM update result (with returning option) instead of discarding it.

databasereturn-valuesapi-design

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP1

Skip to the next iteration when there is nothing to process

Inside a loop, after logging/handling a missing or filtered-out case, use continue so you don't fall through to processing empty data.

loopscontrol-flowcorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP1

Don't rely on an array being falsy; check its length

An empty array is truthy, so `if (arr)` is always true; test arr.length (or compare values) to detect emptiness.

truthinessarrayscorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026JavaScript

backend ruleP2

Order query-builder options consistently

Within a query, keep options in a predictable order (where, include, pagination, then order) so queries are easy to scan and compare.

readabilityquery-buildingconventions

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP2

Use an interface, not a validated DTO, for internal-only argument shapes

When a type is only used to pass arguments to an internal function (no request validation), declare it as an interface rather than a class DTO with decorators.

dtointerfacesclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP1

Include the entity id in read DTOs

Read/response DTOs should expose the resource id so clients can reference the entity; omitting it is usually a mistake.

dtoapi-designcorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

fullstack ruleP2

Omit redundant explicit types where inference is clear

Don't annotate a type that the initializer already makes obvious (e.g. a number initialized to 0); let inference handle it.

typesclean-codeinference

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Alias aggregate/computed columns in SQL results

Give aggregate expressions a clear alias (COUNT(...) AS total) so the result property name is meaningful instead of the raw expression text.

sqlreadabilityquery-building

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026SQL

backend ruleP2

Validate enum values dynamically with @IsIn(Object.values(Enum))

Validate that a field is a member of an enum using @IsIn(Object.values(MyEnum)) instead of hardcoding the allowed list, so it stays in sync with the enum.

validationenumsclass-validatordry

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP2

Use raw:true when you only need plain data

If you don't need model instances/methods, set raw:true on the query to skip instance building and return plain objects.

databasesequelizeperformance

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP1

Don't set include required:true when a where clause already forces it

In Sequelize, defining a where on an include makes it required automatically; an explicit required:true can wrongly exclude rows (e.g. users with zero relations).

databasesequelizecorrectness

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

backend ruleP1

Use @ValidateNested with @Type for nested DTOs and arrays

Nested objects and arrays of DTOs are not validated unless annotated with @ValidateNested() and @Type(); without them class-validator silently skips them.

validationclass-validatordto

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP1

Return bulk results aligned with the input so callers know what failed

For bulk-create style operations, return an array the same length as the input (with null for skipped/failed items) so the caller can map results back by index.

api-designbulk-operationserror-reporting

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Define a shared mock return once instead of per test case

When every test stubs the same return value, set it directly on the mock declaration rather than repeating the stub inside each it block.

testingmocksdry

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Jest

backend ruleP2

Use the simplest mock form in tests

Prefer mockReturnValue over mockImplementation when you only return a value, and drop unnecessary Promise.resolve wrappers and redundant mockClear calls.

testingmocksclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Jest

backend ruleP2

Use a plain loop unless you actually await inside it

Only use for-await / sequential awaiting when the loop body genuinely awaits; otherwise a regular for loop (or Promise.all) is clearer and correct.

asyncloopsreadability

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Match validation decorators to the actual property type

Use type-appropriate validators (@IsNumber for numbers, @IsString for strings); a decorator that contradicts the declared type (e.g. @IsString on a number) is a bug.

validationtypesclass-validator

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP2

Normalize a parameter's type rather than branching on it at runtime

If a function accepts string | string[], normalize to one shape (e.g. always an array via rest/flat) so the body doesn't need union-handling branches.

typesapi-designclean-code

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP0

Check required account state before issuing an auth token

Confirm preconditions like verified/active status before signing and returning an access token, so unverified accounts cannot authenticate.

securityauthenticationauthorization

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026NestJS

backend ruleP1

Only add truthy filters to a database query

Build where-clauses by conditionally including parameters; do not forward undefined/empty values into the query so the function stays correct and standalone regardless of upstream validation.

databasequery-buildingdefensive

vinify-backend · org-mining-hist-2026-06

Jun 19, 2026Sequelize

fullstack ruleP0

Don't drop validation that filters out no-op requests

Removing a filter that excludes empty/zero-amount entries can send no-op requests to the backend (wasteful calls, possible errors, misleading success messages). Keep the guard or validate server-side.

validationcorrectnessapiregression

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP2

Adopt Conventional Commits for commit messages

Format commit messages as type(scope): description (e.g. feat(docs): update template), optionally referencing a ticket, so history is structured and tooling-friendly.

gitcommitsconventionsprocess

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Git

frontend ruleP2

Consolidate repeated render conditions into one block

When several adjacent JSX elements all gate on the same variant/condition, wrap them in a single conditional block instead of repeating the check on each line.

reactreadabilityconditionalsdry

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Name or comment special-case enum members precisely

If an enum member only applies to a specific case (one vendor, one mode), make the name reflect that or add a comment, so future readers don't assume broader applicability.

enumsnamingclaritytypescript

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP1

Don't drop data needed by downstream flows

Before removing the propagation of a value (token, credential, query param), verify nothing downstream depends on it; silently dropping it can break later steps.

correctnessdata-flowauthregression

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript / TypeScript

frontend ruleP2

Prefer switch/case over long if-else chains on one variable

When branching on the discrete values of a single variable, a switch/case reads more clearly than a chain of if/else-if comparisons.

readabilitycontrol-flowswitch

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript / TypeScript

frontend ruleP2

Use a styled confirmation dialog instead of window.confirm

Replace native window.confirm/alert with the app's styled dialog component for a consistent UX and to avoid the no-alert lint suppression.

uxdialogreactno-alert

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Don't ship asset variants you don't actually use

Before adding font/image/asset variants (e.g. italic, extra weights), confirm they're actually needed; unused variants bloat the bundle.

assetsfontsbundle-sizeyagni

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Web assets

frontend ruleP1

Guard derived calculations against undefined async state

When deriving values from state that starts null/undefined before an async fetch resolves, guard against the nullish case instead of computing directly on possibly-undefined fields.

reactnull-safetyasyncstate

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Keep SCSS class names short and nesting shallow

Avoid deeply nested SCSS selectors with long descriptive class names; flatten the structure and use concise, scoped class names.

scsscssnamingreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS / CSS Modules

frontend ruleP2

Don't repeat an identical attribute on every item

If the same prop/value is set identically on every iteration or option, lift it out instead of writing it manually on each one.

reactdryjsx

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Keep type and variable singular/plural naming aligned

Don't pair a plural type name with a singular variable (or vice versa); name both consistently and generically (PdfFontConfig, not CurrentPdfFonts for one value).

typescriptnamingconsistency

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP1

Make a function async when it performs asynchronous work

If a function awaits or returns a promise-based operation, declare it async (and return the promise) instead of leaving it synchronous.

asynccorrectness

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

fullstack ruleP2

Don't send undefined values in request bodies; omit the key

Conditionally include a field in a request body only when it has a value, rather than sending undefined; build the payload from defined values.

apirequestsdata-shaping

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

fullstack ruleP2

Use reduce to build an aggregate instead of manual accumulation

When building a single accumulated value or object from an array, prefer reduce over a manual loop pushing into an external variable.

arraysreducefunctionalreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Use the shared toast utility for success and error feedback

Surface success/error messages through the app's Toast helper instead of ad-hoc UI, and only show a success toast when the design calls for it.

reactuxnotificationsconsistency

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use InputAdornment for input affixes instead of fragments

Render leading/trailing icons or text inside form fields with the library's InputAdornment component rather than stitching empty fragments around the input.

muiformsadornment

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Material-UI

frontend ruleP2

Use short modifier class names nested under their parent

Inside a parent selector, name modifier classes by the modifier alone (&.modifier) instead of repeating the parent name (&.parentClassModifier).

scssnamingbemcss-modules

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS

fullstack ruleP2

Give module-level constants descriptive SCREAMING_SNAKE_CASE names

Name reusable constant values descriptively in SCREAMING_SNAKE_CASE (e.g. EMPTY_PRICE_RANGE) and place them at an appropriate scope.

namingconstantsconventions

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

backend ruleP2

Type the API route response object

Annotate the response (e.g. NextApiResponse<ResponseType>) so the handler's payload shape is type-checked.

nextjsapitypescripttypes

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Next.js

frontend ruleP1

Split a hook that takes too many parameters

A hook accepting a long parameter list becomes tightly coupled and hard to maintain; split it into smaller hooks or move some logic to the parent.

reacthookscouplingmaintainability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Group a hook's return value into data and actions

For hooks returning many values, group them under data and actions keys for readability, and drop redundant suffixes like 'data' from individual names.

reacthooksapi-designreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP1

Type async functions as returning a Promise

An async function always returns a Promise, so its annotated return type must be Promise<T>, not T.

typescriptasynctypescorrectness

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Keep provider and context names aligned

Name a context provider consistently with its context so consumers can tell what it provides.

reactcontextnaming

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Copy an array before sorting to avoid mutating shared state

Array.sort mutates in place; clone the array first (e.g. [...arr]) when the source could be a prop or state, since mutating state directly is unsafe.

reactimmutabilityarraysstate

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use a plain variable instead of a function that takes no input

If a helper takes no arguments and just computes a value, declare it as a variable rather than wrapping it in a function.

readabilitysimplificationfunctions

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Name event-handler props with an on-prefix and drop redundant context

Name callback props onClick/onSelect/onChange; omit context the component name already implies (e.g. onSelect rather than onLocationSelected inside a LocationCard).

reactnamingpropsconventions

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Lift shared state up or into context instead of duplicating it

Two components that need the same state should share a single source (lifted state or context); giving each its own state instance leads to divergence.

reactstate-managementcontextsingle-source-of-truth

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use the .tsx extension only for files containing JSX

Name pure TypeScript helper files .ts; reserve the .tsx extension for files that actually contain JSX.

typescriptfile-namingconventions

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Keep a consistent casing convention for enum and union members

Pick one casing style for enum/union string values and apply it consistently across the codebase rather than mixing camelCase and kebab-case.

typescriptconsistencynamingenums

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Either use a declared value or delete it

Don't leave declared-but-unused variables, imports, or assignments; remove them or wire them up.

dead-codeclean-codelint

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP1

Omit props from a spread type that would override explicit handlers

When spreading a props type that includes onClick (or similar) onto an element that already wires that handler, Omit it from the spread type to prevent silent overrides.

typescriptreactpropscorrectness

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Avoid double-negation when a clearer check exists

Replace !!value coercion with a more explicit check like value.length or Boolean(value) when it reads more clearly.

clean-codebooleansreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP2

Don't annotate components with redundant JSX.Element return types

The JSX.Element return type on a component is inferred; adding it explicitly is noise unless it serves a specific purpose.

typescriptreactclean-code

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Rename local components to avoid clashing with library names

Don't name a local component the same as a widely-used library export (e.g. FormControl); pick a distinct name to prevent import confusion.

reactnamingimportsclarity

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Pass meaningful values to callbacks instead of raw events

A parent usually wants the new value and identifiers, not the DOM event; design callbacks like onChange(value, rowId, cellId) rather than onChange(event).

reactcallbacksapi-design

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use a boolean prop when only two states exist

When a prop really represents a yes/no condition (selected or not), model it as a boolean like isSelected rather than a string variant or single-value enum.

reactpropsmodelingnaming

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Extract inline style objects into a dedicated styles file

Move large inline StyleSheet/style objects (e.g. for PDF rendering) into a ComponentName.styles file to keep the component readable.

reactstylingstructure

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use a ternary for mutually exclusive loading states

Render loading vs content with a single ternary instead of two separate truthy/falsy checks on the same flag.

reactrenderingreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Merge branches that produce the same result

If two condition branches return or set the same thing, collapse them into a single branch or a shared else.

clean-codecontrol-flowsimplicity

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript

fullstack ruleP2

Extract repeated logic into a single reusable function

When the same block appears in multiple places, pull it into one function and call it where needed instead of duplicating.

dryrefactoringreuse

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP1

Don't reassign shared singletons on every render

Assigning a value into a shared/static object during render runs on every render and is a code smell; resolve the dependency where it actually belongs.

reactside-effectsanti-pattern

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use one consistent naming case for SCSS variables

Pick a single casing convention for SCSS variable names and apply it everywhere; mixing kebab-case and camelCase is inconsistent.

scssnamingconsistency

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS

frontend ruleP2

Use early-exit rendering instead of mapping that returns null

When iterating a heterogeneous list, return early for the irrelevant branches up front so the render path reads clearly.

reactearly-returnreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

backend ruleP2

Name service methods to match the endpoint they call

A service method should be named after the route or resource it hits (getHomepageFeed for /homepage-feed) so the mapping is obvious.

namingservicesapireadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP1

Use the correct logical operator in null-guard conditions

Watch out for && vs || in guard clauses: combining two negated checks with && can make the condition unreachable, so confirm the intended logic.

correctnesslogicbugs

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP1

Conditionally render a link instead of passing a possibly-null href

When a URL may be unavailable, track that with a flag and only wrap content in a link when a valid href exists, rather than passing null to href.

reactcorrectnesslinksaccessibility

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Place API-related helpers in the api folder

Utilities whose job is server/API data fetching belong with the other API code, not in a generic utils root, so related code stays discoverable.

organizationstructureapi

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Next.js

backend ruleP2

Skip the method switch when an API route handles one verb

A handler that supports a single HTTP method doesn't need a switch on req.method; handle the verb directly (and reject others) to cut boilerplate.

nextjsapisimplicitybackend

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Next.js

frontend ruleP2

Avoid calling multiple handlers when one would do

If a UI action triggers several handlers in sequence, consider whether they can be merged into a single handler to reduce coupling and surprises.

reacthandlerssimplicity

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Use includes() to test membership instead of comparing to a literal array

Comparing a value to a literal array with === always fails; use Array.includes (or compare the single element) to express membership.

javascriptcorrectnessarrays

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP2

Name a component's props interface after the component

A component's props interface should be named ComponentNameProps, not a different or unrelated name, so the relationship is obvious.

typescriptreactnamingconventions

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Don't set href on non-anchor components or use component='a' without href

Don't pass href to a component that renders a non-anchor (e.g. a div), and if you render an anchor (component='a') make sure it has an href.

reactsemantic-htmlanchorsprops

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Verify color values copied from design tools are valid

Check hex/color values pasted from design tools (Figma, etc.); an invalid value (e.g. too many characters) silently fails to apply.

csscolorsvalidationnitpick

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS/CSS

frontend ruleP2

Prefer overflow: auto over overflow: scroll

Use overflow: auto so scrollbars only appear when needed; overflow: scroll has caused issues (e.g. trackpad/mouse connect-disconnect) and shows scrollbars unconditionally.

cssoverflowscrollux

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS/CSS

frontend ruleP1

Don't perform navigation from inside state/redux actions

Leave routing to the framework's router/components; pushing routes from inside a redux action or reducer interferes with framework-managed navigation.

reduxroutingnextjsseparation-of-concerns

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026Next.js/Redux

frontend ruleP2

Reuse an existing prop to drive behavior instead of adding a new flag

Before adding a new boolean/prop, check whether existing inputs (e.g. the value of an option) can express the variation; avoid redundant props.

reactpropsapi-designsimplicity

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Add a blank line before the return statement

Separate the final return from the preceding logic with a blank line for readability; apply consistently across functions/components.

formattingreadabilitywhitespacereturn

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript/React

frontend ruleP2

Avoid selectors that match all descendants of an element

Don't use broad child/descendant selectors (e.g. `.parent *`) that style everything inside; target specific classes to keep styles predictable.

cssselectorsspecificitymaintainability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS/CSS

frontend ruleP2

Prefer margins over CSS gap where broad browser support is required

When older-browser compatibility matters, lay out spacing with margins instead of the fl/grid `gap` property, which isn't supported everywhere.

cssbrowser-compatlayoutflexbox

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026SCSS/CSS

frontend ruleP2

Use Array.isArray() to test whether a value is an array

Check for arrays with Array.isArray(value) rather than truthiness or length tricks; it is explicit and self-documenting.

arraystype-checkreadability

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Assign a conditionally-chosen component to a capitalized const before rendering

When the component to render depends on a condition, pick it into a PascalCase const and render <Component /> once, instead of branching the JSX.

reactjsxreadabilitydry

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use UPPER_SNAKE_CASE for enum member names

Name enum members in UPPER_SNAKE_CASE for visual consistency and to distinguish them from regular variables.

enumsnamingtypescript

vinify-frontend · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP2

Keep version numbers consistent within a single doc example

When a how-to walks through one example version, use the same version string throughout; don't let a copy-paste leave a mismatched number in a later step.

documentationconsistencycopy-pastereview

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026documentation

fullstack ruleP2

Use git switch -c to create branches in docs and scripts

Prefer the modern `git switch -c <branch>` over `git checkout -b` in documentation and tooling for clearer intent.

gitdocumentationcliconventions

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026git

frontend ruleP2

Don't set both async and defer on a script element

`async` and `defer` have conflicting semantics; pick the one that matches your need (usually `async` for independent scripts) rather than setting both.

htmlscriptsloadingcorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML / JavaScript

fullstack ruleP1

Test units through their real integration point, not their internals

Don't write tests that hard-code a unit's internal structure or hand-mock data the framework should provide; drive the unit through its actual host (e.g. run a real build for a build plugin) so the test catches what the real graph would.

testingintegrationmockingtest-design

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Vitest / build tooling

frontend ruleP2

Omit the default type="text/javascript" on script elements

`text/javascript` is the default script type; setting it explicitly is redundant.

htmlredundancyscriptscleanup

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML / JavaScript

frontend ruleP1

Load non-critical third-party scripts asynchronously

Scripts like reCAPTCHA that aren't needed until a later user action should be injected/loaded async rather than render-blocking; check the vendor's loading guide.

performancethird-party-scriptsasyncpage-load

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML / JavaScript

frontend ruleP2

Keep conditional code near its test fixtures for easy toggling

Place code that you flip on/off during testing right below the commented-out test data so a reviewer can switch states by editing one block.

testingreadabilitycode-organizationdeveloper-experience

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026any

frontend ruleP2

Skip browser feature-checks where compilation or context guarantees support

Don't hand-write defensive guards (or avoid syntax) for a feature when your build target/runtime guarantees it; conversely, don't rely on un-compiled syntax in raw inline scripts whose support is borderline.

browser-supportinline-scriptsoptional-chainingtranspilation

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

backend ruleP2

Print diagnostics to the console rather than writing throwaway files

A quick-lookup dev tool should log to the console instead of writing result files to disk; for analysis-only builds you can even skip writing the bundle via build.write=false.

toolingloggingside-effectsbuild

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Vite / Node

backend ruleP2

Use the plugin's apply predicate instead of a separate enabled flag

For Vite/Rollup plugins, decide whether to run inside the `apply` function from env/command rather than gating each hook on a hand-rolled `enabled` boolean.

vitepluginsbuildidiomatic

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Vite / Rollup

backend ruleP1

Prefer async child_process over the sync variants

Use promisified `exec`/`execFile` instead of `execSync` so the call doesn't block the event loop, especially in build plugins and tooling.

nodejsperformanceasyncchild-process

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Node.js

backend ruleP2

Scope dev/build tooling to committed state, not work-in-progress

A diff/trace dev tool that also reads unstaged and staged changes mixes WIP with committed work and can mislead; compare against committed history only.

toolinggitbuildscoping

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Node / build tooling

frontend ruleP2

Use relative links instead of unnecessarily prefixing a base URL

If a same-origin link can be a plain relative href, don't pull in a base-URL helper just to prepend the origin.

linkssimplicityurlsredundancy

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Follow the repository's established conventions for file placement

Put new files where the repo's existing structure dictates; question placement that diverges from the prevailing convention even if it technically works.

project-structureconventionsorganizationconsistency

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026any

frontend ruleP2

Insert new design-token variants in their natural scale order

When adding a new shade/size token to an enum or union, position it within the existing ordered scale rather than appending it at the end.

design-tokensorderingreadabilityunion-types

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Prefer inline utility mapping over naming every Tailwind class

Extracting each Tailwind combination into a named constant defeats Tailwind's locality benefit; map variant-to-classes at the point of use instead.

tailwindnamingreadabilityutility-first

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind CSS / React

frontend ruleP2

Configure Tailwind class sorting for custom class-holding attributes

When Tailwind classes move out of `className` into custom props/variables, Prettier no longer sorts them; configure `tailwindAttributes`/regex so sorting keeps working.

tailwindprettiertoolingformatting

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind CSS / Prettier

frontend ruleP2

Spread a known collection to clear all related classes instead of per-class toggles

When swapping mutually-exclusive classes, remove the whole set with a spread (filtered) and add the active one, rather than enumerating each class with toggle calls.

domdryclasslistreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

fullstack ruleP1

Preserve comments that explain why code exists before deleting them

Comments documenting non-obvious reasoning (why a hook stays, why an order matters) are guards against accidental regressions; don't strip them during a refactor.

commentsrefactoringmaintainabilityintent

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026any

frontend ruleP1

Encapsulate environment and window checks inside the resolver function

Don't make every caller perform the same defensive window/global checks before calling a helper; push those checks into the helper so callers stay clean and logic isn't duplicated.

dryabstractionssrencapsulation

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript / React

frontend ruleP2

Configure revalidation mode instead of clearing errors manually on change

Control when validation re-runs (onChange/onSubmit) via the form's revalidation setting rather than wiring custom onChange handlers to clear errors.

formsreact-hook-formvalidationux

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

frontend ruleP1

Ensure every controlled form field has a name to register it

A controlled field must be given a name prop so the form library can register and track it; a missing name silently breaks validation and submission.

formsreact-hook-formcorrectnessvalidation

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

fullstack ruleP2

Define a constant value as a value, not a method

If a computed result never changes, compute it once as a constant instead of a function/method that recomputes it on every call.

performanceconstantsreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Don't wrap a view in a modal component when the parent already is the modal

A view rendered inside a modal shouldn't itself render the modal wrapper; let the parent own the modal so styling and behavior aren't doubled.

reactmodalscompositionduplication

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Do not render two labels for a single input

If a field component already renders a label, don't add a second label element for the same input; reuse the existing one or restructure.

accessibilityformsduplicationlabels

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, accessibility

frontend ruleP1

Render form fields inside the form provider, not a sibling

Components that consume form context must be rendered within the provider; structure as Form > FormContent so hooks like useFormContext work.

reactformscontextreact-hook-form

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

frontend ruleP2

Prefer the form library's reset over manual state clearing

To clear a form, use the library's reset function rather than manually setting dirty flags or hand-clearing fields.

formsreact-hook-formstate

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

frontend ruleP2

Name state enum members by their meaning

Choose enum member names that describe the state (idle, success, rejection) rather than an incidental detail; success/confirmed is clearer than reusing 'error' as feedback.

namingenumsstate-machinereadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Render text through the shared typography component

User-facing text should go through the design-system typography component rather than a bare element, for consistent styling.

design-systemtypographyconsistency

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Remove redundant React fragments

Drop a fragment wrapper when it surrounds a single child or is otherwise unnecessary.

reactjsxcleanup

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Write conditionals so a missing value falls back to the default branch

Express product/variant checks as 'is one of the special cases' so an unset value defaults to the intended fallback, rather than 'equals the default'.

conditionalsdefaultsrobustness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Use flex-direction: row-reverse instead of order on items

To reverse the visual order of flex children, flip the container direction rather than setting order on individual items.

cssflexboxreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS/SCSS

frontend ruleP2

Do not mix a utility-CSS framework and SCSS in the same component

Style a component with either utility classes or SCSS, not both; mixing them makes precedence unclear and migration ambiguous.

csstailwindconsistencymaintainability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS/SCSS, Tailwind

frontend ruleP2

Reset a cleared optional selection to null, not a stale value

When the user deselects an optional field, set the form value to null so the cleared state is represented accurately.

formsstatecorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript, React

frontend ruleP1

Model domain data with explicit types, not loose strings

Type fields with their real shape (object or id) instead of a generic string when the value represents a structured entity.

typescripttype-safetymodeling

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Put type aliases in the types location, not the interfaces one

Declarations using `type` (unions, aliases) belong in the types directory; reserve the interfaces directory for actual interfaces.

typescriptorganizationtypes

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP1

Use relative URLs for same-origin API requests

When the API lives on the same origin as the app, fetch with a relative path so it works across environments without configuration.

fetchurlsconfigenvironments

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP1

Validate input at the point of entry, not after the side effect

Check constraints (e.g. file size) when the user provides the input so the action can be blocked, rather than validating only at final submit after the upload already happened.

validationuxuploadscorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP1

Await customElements.whenDefined instead of polling with timeouts

To act on a web component once it is ready, await customElements.whenDefined rather than retry loops or setTimeout guesses.

web-componentsasyncdomreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript, Web Components

frontend ruleP1

Prefer a library's native events over DOM observers

When an editor or widget exposes an update/change event, subscribe to it instead of polling or watching the DOM with a MutationObserver.

eventsdomperformancethird-party

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript

frontend ruleP2

Type unsupported props as never to forbid them

When a component must not receive a prop (e.g. data-testid it ignores), declare it as `never` so passing it is a compile error.

typescriptpropstype-safety

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript, React

frontend ruleP1

Encode mutually-required props in the type, not at runtime

Use discriminated unions so invalid prop combinations (e.g. a close button without an onClose handler) fail to compile rather than being allowed and checked at runtime.

typescriptpropstype-safetyapi-design

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript, React

frontend ruleP2

Name state as a noun and handlers/actions as verbs

A boolean state should read like a description (isDiscardModalOpened), while a function should read like an action (openDiscardModal); mismatched naming misleads readers.

namingreadabilitystatehandlers

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript/TypeScript, React

frontend ruleP1

Set server errors through the submit handler's form methods

Use the form library's setError from the submit callback (often provided as a second argument) instead of separate component state for server-side errors.

reactformsreact-hook-formvalidationerror-handling

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

frontend ruleP1

Use the form library's built-in error state instead of custom state

Rely on the form library's error/validation state rather than maintaining parallel useState flags for the same concern.

reactformsreact-hook-formstateduplication

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React, react-hook-form

frontend ruleP2

Allow abstraction-level names to differ from underlying design tokens

A prop's value set (e.g. Button color names) is an abstraction over the palette and need not exactly mirror token names.

namingabstractiondesign-system

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Reconcile divergent UI patterns with the designer rather than stacking them

When a new pattern differs sharply from existing ones, decide with the designer to update old, revert new, or intentionally keep both — don't default to keeping both blindly.

uxconsistencyprocess

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026General

frontend ruleP2

Provide alt text in the product's language

Write image alt text in the same language as the UI so screen-reader users get localized descriptions.

accessibilityi18nimages

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

backend ruleP1

Use valid npm command syntax in scripts and CI

Invoke scripts correctly (npm test or npm run test), not invalid forms like 'npm test run'.

npmciscripts

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026npm

backend ruleP2

Don't read fields off an object only to pass them straight back in

If a found object can act on itself, call its method directly instead of extracting its props and feeding them back to it.

simplicityapi-designcohesion

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Disambiguate bulk operations from single-item ones in the name

When a deleteX exists, name the bulk variant clearly (deleteAllX / clearAllX) to avoid confusion.

namingapi-designclarity

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP1

Account for the cleared/null case when validating selections

When a selection can be unselected (set to null), validation/error clearing must handle that case, not just the selected case.

validationnull-handlingcorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Trim redundant SVG attributes carried over from export tools

Vector tools often emit fill-rule/clip-rule defensively; for simple shapes they're unneeded and can be removed (verify the icon still renders).

svgcleanupassets

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

backend ruleP2

Name interfaces and files after the domain they represent

Relate a response interface to its source service by interface or file name so its origin is obvious.

naminginterfacesclarity

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Merge paired conditional classes into a single expression

Combine two clsx branches that key off the same condition into one branch with both classes.

tailwindclsxreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind

frontend ruleP2

Use the color/opacity shorthand instead of separate opacity utilities

Combine color and opacity into one utility (text-white/50) rather than text-white plus text-opacity-50.

tailwindcssshorthand

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind

frontend ruleP2

Use the size-* shorthand for equal width and height

Replace paired h-N w-N utilities with the size-N shorthand.

tailwindcssshorthand

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Tailwind

frontend ruleP2

Color icons via a fill prop instead of CSS path targeting

Prefer passing fill/color to an icon component over writing CSS that reaches into its internal <path> elements.

csssvgcomponentsencapsulation

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS

frontend ruleP2

Write identifiers in English

Keep variable, function, and constant names in English even when the displayed UI text is in another language.

namingi18nreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Derive iteration count from the data, not a duplicated magic number

Map over the actual array instead of Array.from({length: N}) indexing into it, so the two can't drift out of sync.

dryrenderingkeys

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP0

Render a context via its Provider with a value prop

A context object is not itself a component; wrap children in Context.Provider and pass value.

reactcontextcorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Prefer stable APIs over experimental ones for compatibility

Use the established hook (e.g. useContext) instead of an experimental API (e.g. React's use) unless the experimental behavior is genuinely required.

reactstabilityhooks

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

backend ruleP2

Use plain functions instead of a class with only static members

A class whose members are all static adds no value; export named functions or a module object instead.

typescriptmodulessimplicity

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP2

Keep word order consistent between related class and method names

Method names should follow the same ordering of domain terms as their class to avoid confusion.

namingconsistency

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

fullstack ruleP2

Name methods after what they actually return

A method's name should reflect its return value; getX should return an X, not some unrelated shape.

namingclarityapi-design

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Skip attaching listeners when their feature flag is off

Conditionally attaching an event listener (not a hook) inside useEffect avoids needless work when the behavior is disabled.

eventsperformanceuseEffect

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Cover both touch and pointer devices when listening for outside taps

Use touchstart for touch devices and mousedown for pointer devices (selected via a coarse-pointer media query) so dismiss-on-outside works everywhere without firing twice.

eventstouchaccessibilityux

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP2

Use mousedown rather than click for outside-click detection

For dismiss-on-outside-click behavior, listen for mousedown to avoid the delay click incurs while waiting to disambiguate from dblclick.

eventsuxdom

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP2

Do not declare a runtime constant when only its type is used

If a value's literal is never read at runtime and only its type is referenced, define a type instead of exporting a constant.

typescriptdead-codetypes

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Omit CSS properties that already match their defaults

Drop declarations that just restate the default (e.g. flex-direction: row, transparent backgrounds, full-width on block elements) to reduce noise.

csscleanupdefaultsreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS

fullstack ruleP2

Transform data with map and spread, not by cloning and mutating

Avoid deep-cloning (e.g. JSON.parse(JSON.stringify(arr))) just to mutate; use .map() returning new objects with spread to derive changed copies without touching the original.

immutabilitymaparraysfunctional

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP2

Set inherited text color on the element that sets the background

Put text color on the container that defines the background (since links/children inherit color) rather than repeating it on each child or relying on hover overrides.

csscolorinheritancetheming

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS

frontend ruleP2

Use semantic HTML elements instead of styled divs

Reach for the semantic element (e.g. <hr> for a thematic divider) rather than a div styled to look like one.

htmlsemanticsaccessibility

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026HTML

fullstack ruleP2

Name and locate tests after the unit under test

Put a test next to the file it covers and name it after that unit, rather than under an unrelated entry/feature name.

testingfile-structurenamingcolocation

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

fullstack ruleP1

Catch errors as unknown and narrow before using them

Type catch clause errors as unknown (or leave untyped) and narrow with instanceof Error, instead of typing them as any, since anything can be thrown.

typescripterror-handlingtype-safetycatch

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

backend ruleP1

Await response.json() before returning the parsed body

response.json() returns a promise; await it before assigning/returning so callers get data, not a pending promise.

fetchasyncpromisescorrectness

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

fullstack ruleP1

Don't write logically redundant or impossible condition combinations

Review combined conditions for contradictions (e.g. value === 'null' && value.length < 1) and simplify to what you actually mean.

correctnessconditionalslogicreadability

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

fullstack ruleP1

Use lowercase primitive types, not wrapper-object constructors, for type annotations

Annotate values with primitive types (string, number, boolean) rather than the boxed constructors (String, Number, Boolean) to avoid subtle type mismatches and confusion.

typescripttypesprimitives

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026TypeScript

frontend ruleP2

Always provide a generic font-family fallback

End every font-family stack with a generic fallback (e.g. sans-serif) so text renders sensibly before the custom font loads or if it fails.

cssfontsfallbacktypography

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026CSS

fullstack ruleP2

Log errors with console.error, not console.log

Use console.error (or console.warn) for failure paths so errors surface correctly in tooling, instead of console.log.

loggingerror-handlingconsole

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026JavaScript

frontend ruleP1

Pass an empty dependency array for effects that should run once on mount

An effect meant to run only on mount (e.g. adding a one-time listener) must declare an empty deps array, otherwise it re-runs on every render.

reacthooksuseeffectdependenciesperformance

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Remove dependencies you no longer use

Delete packages added for experiments or removed features from the manifest so the dependency tree stays lean and accurate.

dependenciescleanuppackage-json

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026Node

frontend ruleP1

Expose composition props instead of baking variant-specific markup into a component

For reusable components, accept slot/adornment props (e.g. startAdornment/endAdornment) so parents control variant-specific UI, rather than hard-coding it inside.

reactcomponent-designcompositionreusabilityapi-design

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

frontend ruleP1

Register event listeners in useEffect and return a cleanup function

Attach global/window event listeners inside useEffect and remove them in the returned cleanup to avoid leaks and duplicate handlers.

reacthooksevent-listenerscleanupmemory-leak

hegnar-zephr-components · org-mining-hist-2026-06

Jun 19, 2026React

fullstack ruleP2

Override recommended lint rules deliberately, not by disabling wholesale

When a recommended lint rule conflicts with a valid pattern, scope the override narrowly (or downgrade to warn) rather than turning it fully off and losing all coverage.

lintingeslintconfigurationcode-quality

abcn-web · org-mining-hist-2026-06

Jun 18, 2026ESLint / linting

backend ruleP2

Over-fetch when later filtering may reduce the result set below the target

If you fetch N items and then filter some out (e.g. dedup against another section), request more than N so the visible count still meets the requirement.

data-fetchingpaginationfilteringedge-cases

abcn-web · org-mining-hist-2026-06

Jun 18, 2026data fetching / APIs

frontend ruleP2

Use one sufficient mechanism instead of stacking redundant ones

Don't add a second overlapping implementation (e.g. a scroll listener alongside an IntersectionObserver) when one already covers the use case; the extra mechanism is overkill and adds complexity.

simplicityperformanceintersection-observerredundancy

abcn-web · org-mining-hist-2026-06

Jun 18, 2026Web APIs / React

frontend ruleP1

Remove stray semicolons inside JSX

A semicolon after an expression in JSX renders as a literal character on the page; remove it.

jsxcorrectnessrenderingsyntax

abcn-web · org-mining-hist-2026-06

Jun 18, 2026React / JSX

frontend ruleP1

Extract repeated cross-component logic into context and helper functions

When the same stateful logic appears in multiple components, lift it into a shared context plus a wrapper helper instead of re-implementing it each place.

reactcontextdryreusestate-management

abcn-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Write valid, well-formed markup in embedded HTML strings

When embedding HTML in content/strings, quote attributes and close tags correctly; malformed anchors and unquoted attributes break rendering.

htmlcorrectnessmarkup

abcn-web · org-mining-hist-2026-06

Jun 18, 2026HTML

frontend ruleP2

Let reusable item components span full width and size them in the parent

Keep single-item components layout-neutral (full width) and apply grid/width sizing in the parent that maps over them, so the item stays reusable in different layouts.

component-designreuselayoutseparation-of-concerns

abcn-web · org-mining-hist-2026-06

Jun 18, 2026React / CSS layout

fullstack ruleP2

Name config keys after their specific scope, not a generic label

Give configuration keys descriptive, scope-qualified names so multiple consumers don't collide on an ambiguous generic key.

configurationnamingclarity

abcn-web · org-mining-hist-2026-06

Jun 18, 2026configuration

fullstack ruleP1

Don't overwrite a shared default to serve one specific case

Leave generic/default values (titles, metadata, configs) intact since they apply to many consumers; pass case-specific overrides at the point of use instead of mutating the default.

defaultsconfigurationreusemetadata

abcn-web · org-mining-hist-2026-06

Jun 18, 2026any

frontend ruleP1

Use one handler with graceful fallback instead of duplicating UI per device

When a native capability may be unavailable (e.g. navigator.share), call it and fall back to a custom UI on failure rather than branching into duplicated components and handlers per viewport.

progressive-enhancementdryweb-apiux

abcn-web · org-mining-hist-2026-06

Jun 18, 2026Web APIs / React

fullstack ruleP2

Skip stale tests explicitly rather than deleting or commenting them

When a test is temporarily out of date, mark it with it.skip (and a note) so it stays visible and is restored later, instead of removing or commenting it out.

testingmaintenancevisibility

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026Jest / Vitest

backend ruleP1

Exclude empty-string and null sentinel keys when joining

When a join key column allows '' or NULL as 'unknown', exclude those values in the ON clause so unknown rows don't all match each other and corrupt results.

sqljoinscorrectnessdata-integrity

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026SQL

backend ruleP1

Use the HTTP exception that matches the failure semantics

A duplicate-resource error should be a 409 Conflict, not a generic 400 Bad Request; pick the status code that reflects what actually went wrong.

httperror-handlingstatus-codessemantics

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026NestJS / HTTP

backend ruleP2

Prefer purpose-built methods over generic configurable parameters

Rather than adding a flexible searchBy/columns parameter for a single current need, expose a focused method (e.g. searchInstrument) and add another when a genuinely different need appears — YAGNI.

yagniapi-designsimplicityabstraction

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Do not wrap LIKE in LOWER() when the collation is already case-insensitive

MySQL's LIKE is case-insensitive by default under typical collations; wrapping both sides in LOWER() adds complexity and can defeat indexes for no benefit.

sqlmysqlperformancesimplicity

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026MySQL / SQL

backend ruleP2

Simplify chunking loops by stepping the index by chunk size

Instead of computing iteration counts with Number.isInteger/Math.ceil and index math, map to the needed values up front and step a for-loop by the chunk size with slice.

clean-codereadabilityarrayschunking

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Do not cache error responses such as 404s

Set caching headers only on successful responses; error responses (e.g. 404) should not be cached so transient or recoverable failures aren't served from cache.

httpcachingcorrectnessheaders

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026HTTP / any

backend ruleP2

Run raw queries through a shared database/data service

Centralize raw SQL execution behind a database service rather than scattering direct dataSource/repository.query calls, so query handling stays consistent.

architecturedatabaseconsistencyabstraction

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeORM / TypeScript

backend ruleP1

Do not access another module's repository directly; go through its service

Injecting another module's repository couples modules to each other's data layer; call that module's service instead to preserve encapsulation.

architectureencapsulationmodulesseparation-of-concerns

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026NestJS / TypeScript

backend ruleP1

Write data migrations against deterministic business keys, not auto-increment ids

Migrations that hardcode auto-increment ids break on reseed; look the rows up by a stable business key (e.g. isin) and update via that instead.

databasemigrationscorrectnessreproducibility

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeORM / SQL

backend ruleP1

Generate a migration whenever entity schema changes

Renaming or altering entity columns requires a corresponding generated migration so the database stays in sync with the model definitions.

databasemigrationsschemaorm

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeORM / SQL

fullstack ruleP2

Define path aliases without redundant repeated segments

Set up TS/bundler path aliases so imports read cleanly (e.g. @libs/s3) rather than producing repetitive paths like s3/s3.

configimportsreadabilitytsconfig

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Document error responses and add examples in API schemas

Endpoints should declare their error responses (e.g. ApiNotFoundResponse) with a description and example payload, not only the success case.

api-docsswaggererror-handlingdocumentation

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026NestJS / Swagger

backend ruleP2

Mark optional query params as optional in API docs

When a request parameter is optional in validation, reflect that in the OpenAPI/Swagger schema (e.g. ApiPropertyOptional) so generated docs match actual behavior.

api-docsswaggerconsistencyvalidation

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026NestJS / Swagger

backend ruleP2

Decouple resource-link building behind a dedicated service method

Instead of inlining URL/key construction at each call site, expose a method on the owning service (e.g. createLink) so the logic lives in one place and can change later.

abstractiondrydecouplingmaintainability

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Add a deterministic tiebreaker column to paginated ORDER BY

Sorting only by a non-unique column makes pagination non-deterministic across pages; append a unique column (e.g. id) as a fallback sort key.

sqlpaginationcorrectnessordering

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026SQL

backend ruleP1

Throttle large batches of concurrent promises with a pool

When fanning out many async operations, cap concurrency with a promise pool instead of an unbounded Promise.all that can overwhelm the downstream system.

performanceconcurrencyasyncrate-limiting

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Inject collaborators as services instead of instantiating them inline

External clients (HTTP, DB, queues) should be provided through dependency injection rather than created directly inside a class, so they can be swapped and mocked.

dependency-injectiontestabilityarchitecturenestjs

hegnar-shareholders-ws · org-mining-hist-2026-06

Jun 18, 2026NestJS / TypeScript

backend ruleP2

Put type-only packages in devDependencies

@types/* and other build/test-only packages belong under devDependencies, not dependencies, since they are not needed at runtime.

dependenciespackage-jsontooling

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026Node.js / npm

backend ruleP2

Use a standard auth header format consistently across services

Avoid inventing per-service token header names; align on a standard like `Authorization: Bearer <token>` so auth handling is uniform and predictable across apps.

httpauthenticationconsistencyheaders

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026HTTP

backend ruleP2

Type guaranteed config values as non-optional to avoid undefined leaks

When an env/config value is enforced at startup, type the config accessor so it returns a definite string, instead of letting `get<string>()` return string|undefined and propagating undefined through the code.

configtypesnull-handling

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / NestJS

backend ruleP2

Return the best available data instead of null when you can

When a derived value cannot be fully computed, prefer returning a sensible fallback (e.g. lastUpdated or now) over null, so consumers still get useful information.

api-designnull-handlinggraceful-degradation

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Omit initializers for ordered numeric enums

TypeScript numeric enums auto-increment from 0, so explicit sequential values (0,1,2,...) are noise. Leave them off unless the values are meaningful.

typescriptenumsclean-coderedundancy

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Follow the established pattern already used elsewhere in the codebase

When the project consistently uses a pattern (e.g. the repository pattern for data access), new code should follow it rather than introducing a one-off divergent approach.

consistencyarchitecturepatterns

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Name routes and endpoints after what they do

Endpoint paths should describe the resource/action (e.g. /user/live-data-optin), not internal implementation names. Clear, purpose-driven route names aid discoverability.

api-designnamingrest

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026REST / NestJS

backend ruleP2

Use jest.fn() for plain mocks and spyOn only when observing or restoring

If a test only needs to stub a return value, jest.fn() is enough. Reach for jest.spyOn when you also need to assert how the original was called or restore it afterward.

testingmockingjest

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Jest

backend ruleP2

Keep API response decorators in sync with the statuses actually returned

OpenAPI response decorators are documentation; if the handler throws 502/500/404 the decorators must declare those, not a stale 400. Mismatched docs mislead consumers.

swaggeropenapidocumentationhttp

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / NestJS

backend ruleP1

Do not reuse a source field name when you change its meaning

If you remap an upstream value into a field that no longer means what the upstream name implies, define your own DTO with a clearly named field. Reusing the original name hides the transformation and misleads debugging.

api-designnamingdata-mappingmaintainability

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP1

Build a lookup map instead of calling find inside a loop

When you join two collections by key, convert one to a Map once (O(n)) instead of calling Array.find for each item (O(n*m)).

performancealgorithmsdata-structures

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

backend ruleP2

Use a class, not an interface, for DTOs picked up by Swagger

OpenAPI/Swagger metadata is emitted from classes, not interfaces. Define DTOs as classes so the schema is generated.

swaggerdtoopenapitypes

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / NestJS

fullstack ruleP2

Use a type guard instead of any or a cast for runtime discrimination

When you branch on the shape of a value at runtime, write a `data is T` type guard so the type narrows safely, instead of casting or typing as any. If it is broadly useful, lift it to a shared utility.

typestype-guardclean-code

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Drop redundant return await on a returned promise

When you immediately return a promise, `return await` adds an extra microtask and no value (outside try/catch). Just return the promise.

asyncclean-coderedundancy

hegnar-user-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

fullstack ruleP2

Don't flag pre-existing behavior unrelated to the PR's change

If something worked a certain way before the PR and isn't touched by it, raising it in review is out of scope — the author may not own that decision.

code-reviewscopeetiquette

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

fullstack ruleP2

Don't map(String) before join; join already stringifies

Array.prototype.join converts elements to strings, so an extra .map(String) before it is redundant.

arraysredundancyidioms

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP2

Match image intrinsic width/height to its rendered size

An img with intrinsic dimensions far larger than the CSS-rendered size causes layout shift and scaling; align them or rely on CSS sizing.

imagesperformancelayout-shiftcls

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026HTML/CSS

frontend ruleP1

Mock remote assets with local files, never hit real URLs in tests

Don't passthrough to real remote assets in tests — it incurs cost and flakiness; serve small local test images instead.

testingmocksassetsreliability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Testing

frontend ruleP2

Enable test-only setup only in files that actually use it

Don't turn on middleware/config in a test file that doesn't exercise it; enable it only where the feature is used (e.g. inside renderRoute).

testingsetupscopecleanup

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Testing

frontend ruleP1

Avoid a fresh default array/object in a hook dependency

Defaulting to [] or {} inside render creates a new reference each render, defeating memoization. Use optional chaining with ?? in the body instead.

reacthooksmemoizationreferential-equality

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Observe element size with ResizeObserver, not the window resize event

ResizeObserver fires only when the observed element actually changes size, which is more precise and efficient than a window resize listener.

domresizeobserverperformanceweb-api

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP2

Nest media queries inside the selector to avoid repeating it

Modern CSS allows nested @media; place the query inside the rule so you don't restate the selector.

cssmedia-queriesdry

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP1

Give SVG icons an accessible name with title or aria-label

Decorative-by-default SVGs that convey meaning need a <title> (preferred) or aria-label so assistive tech can announce them.

accessibilitysvga11yicons

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026SVG/Accessibility

frontend ruleP2

Use distinct sprite icons with titles over rotating one icon

For directional icons, prefer separate sprite symbols each with a <title> for accessibility rather than CSS-rotating a single icon.

svgaccessibilityicons

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026SVG/Accessibility

fullstack ruleP2

Throw redirects in loaders for cleaner data typing

In data-loader frameworks, throwing a redirect (vs returning it) keeps the loader's success return type clean for useLoaderData<typeof loader>.

remixreact-routerloaderstypes

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React Router/Remix

fullstack ruleP2

Document vendored/copied code with a comment and its source

If you must inline third-party or generated code (like a polyfill), add a header comment explaining what it is and where it came from.

documentationvendoringmaintainability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP2

For an SPA, client-only bundled deps are devDependencies

In a single-page app everything bundled to the client is a build-time concern; only packages needed to serve belong in production dependencies.

dependenciesspapackaging

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026npm/package.json

frontend ruleP1

Keep content available to screen readers with sr-only

When hiding text visually on some breakpoints, use sr-only / not-sr-only so the label stays announced rather than removed.

accessibilitya11ytailwind

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Tailwind/Accessibility

fullstack ruleP2

Remove redundant return statements

A return at the end of a void function, or returning a value only to return it again, is noise; drop it.

cleanupcontrol-flowreadability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP2

Return an empty response when the body is irrelevant in a test mock

When mocking a request whose body you don't care about, return an empty HttpResponse rather than fabricating JSON of the wrong content type.

testingmocksmsw

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026MSW/Testing

fullstack ruleP2

Prefer template literals over string concatenation

Use template literals for readability when assembling strings with variables.

readabilitystringsidioms

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP1

Augment a shared global (like dataLayer) instead of overwriting it

Push onto an existing global array and guard its existence rather than reassigning it, which would clobber data other code set.

globalsanalyticscorrectness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript

backend ruleP2

Extract request setup into small named Express middleware

Move per-request setup (e.g. populating res.locals) into focused, documented middleware functions composed in the route chain rather than inline blocks.

expressmiddlewareorganization

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node/Express

backend ruleP2

Use a comment as a placeholder for a block you replace at build/serve time

When server-side string replacement swaps in markup, mark the spot with an HTML comment rather than a fake/typo'd meta tag.

templatingssrclarity

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node/Express

frontend ruleP2

Remove static head meta when it is set dynamically

If title/description are injected per-route at runtime, leaving generic static ones in the HTML shell can override or confuse crawlers; drop them.

seometahtml

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP2

Know that a function returning void can fill an undefined slot

TypeScript treats a void return as compatible with undefined; you can return undefined from helpers without an extra ?? undefined coercion.

typescripttypesvoid

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP1

Clear only the params you own, not the entire param set

Resetting to an empty object/params erases unrelated query params; delete the specific keys you manage instead.

url-statecorrectnessquery-params

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP1

Don't mutate the previous value inside a state updater; return a new one

Mutating prev (e.g. URLSearchParams) in a setState callback can cause stale state and missed re-renders. Copy it, then mutate the copy.

reactstateimmutabilitycorrectness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Display values from the API rather than recomputing them client-side

If the backend already returns a computed figure, render it directly instead of redoing the math, which risks unit/scale bugs.

correctnessdataui

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP2

Let a component own its own conditional rendering of internal pieces

If a child can decide whether to show a fallback (e.g. an avatar with/without an image), pass it the data and let it branch, instead of a ternary at every call site.

reactcomponentsencapsulationdry

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP1

Choose every vs some to match the intended presence semantics

A 'has any data' check should use .some(), not .every(); confusing the two flips behavior, e.g. returning true when all values are absent.

correctnessarrayslogic

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP0

When you invert a boolean's name, flip every use of it

Renaming hasNoX to hasX changes its meaning; you must also remove/add the negation at all call sites or the logic inverts silently.

namingbooleanscorrectnessrefactoring

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP2

Narrow a filter with an intersection type instead of restating the whole shape

In a type predicate, intersect the original type with the narrowed field so you don't have to re-list every property.

typescripttype-guardsfilter

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP1

Handle problematic data in code, don't strip it from test fixtures

If the backend can return a value (e.g. null), keep it in the mock and handle it in the component; removing it from fixtures just hides the bug.

testingmockscorrectnessnull-handling

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP1

Put statements before break in a default case, or drop the redundant break

In a switch default, code after break never runs. Place logic before break, or remove break since it is the last case.

control-flowswitchcorrectness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP1

Collapse repeated conditional branches into a helper plus a switch

When many if-blocks repeat the same shape with different values, extract the shared work into one function and drive it with a switch.

dryrefactoringcontrol-flow

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Name component variants after their context, not their styling

Variant names should describe where/how the component is used (page, table) rather than visual adjectives, so call sites read clearly.

namingcomponentsvariants

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React/TypeScript

fullstack ruleP2

Don't restate a name that's already provided elsewhere

Avoid setting a step/job name that merely duplicates a name the action and job already carry; redundant labels add nothing.

ciredundancyconfigcleanliness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026GitHub Actions

fullstack ruleP2

Expand acronyms and document non-obvious config

Spell out acronyms (e.g. GCR = Google Container Registry) and add brief comments for non-obvious config like an empty workflow_dispatch, so readers don't have to guess.

documentationclarityconfigcomments

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Don't quote YAML scalar values unless required

YAML often doesn't need quotes around simple scalars (branch names, etc.). Drop unnecessary quotes for cleaner config; quote only when the value would otherwise be misparsed.

yamlstyleconfigcleanliness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026YAML

fullstack ruleP2

Namespace shared config/asset paths to avoid future clashes

When a path could collide with a framework convention later (e.g. .github/actions), use a namespaced folder name so adding the convention later won't conflict.

organizationnamingciconventions

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Pin CI to the latest stable major versions of actions

In CI workflows, use the current major version of shared actions (e.g. actions/checkout@v4) rather than trailing older ones, unless a runner constraint specifically blocks it.

cigithub-actionsmaintenanceversions

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026GitHub Actions

frontend ruleP2

Use a wrapper component to share JSX between content and Suspense fallback

Extract the shared header/skeleton into small components and a wrapper so the same markup feeds both the rendered content and the Suspense fallback, shrinking the diff and matching UX.

reusesuspensecomponentsdry

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Provide a meaningful, context-appropriate fallback error screen

Don't reuse a data-heavy component (e.g. a profile with tables) as an error fallback. Render a generic error screen that still signals context, and don't rely solely on per-section error handling.

error-handlinguxfallbackresilience

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Match border-radius across visually related blocks

Keep corner rounding consistent between elements meant to read as one group (e.g. table heading, body, and pagination), so the composite looks cohesive.

cssconsistencydesignvisual

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Don't render controls (e.g. buttons) that do nothing

Remove placeholder buttons/controls with no behavior; they confuse users. Add them back when they actually do something.

uxdead-codecomponentscleanup

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Show scroll affordances only when content actually overflows

Don't leave a permanent border/shadow indicating scroll. Detect overflow (scroll event + state, or CSS) and show the shadow/border only while the content overflows.

uxoverflowscrollresponsive

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS / React

frontend ruleP2

Use a prettier-ignore comment to protect intentionally-formatted blocks

When Prettier reformats markup you deliberately kept on one line (e.g. grouped selectors), restore it and add a prettier-ignore comment instead of accepting the churn.

prettierformattingtoolingdiff-hygiene

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Prettier

fullstack ruleP2

Pass the expected response type to typed fetch helpers

When a fetch wrapper accepts a generic for the response shape, supply it so the resolved data is typed instead of any.

typescriptfetchtypestype-safety

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Make param-driven UI tolerant of unknown/missing values

When matching against query-param values, fall back gracefully for unknown or missing values (e.g. treat absent from/to as 'all') instead of breaking the UI.

robustnessquery-paramsdefensiveux

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Add inherent spacing around content so it never hits container edges

Give content (images, error states) some padding/margin so on short or narrow viewports it doesn't touch the borders. Match spacing patterns already used elsewhere for consistency.

cssspacingresponsiveux

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Avoid large indentation-only changes that bloat diffs and cause conflicts

Wrapping content in a new container reindents everything and creates conflict-prone diffs. Introduce a small wrapper component that takes children so the existing indentation stays intact.

diff-hygienegitreadabilitycomponents

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Don't pass empty strings to clsx/className helpers

An empty-string argument to clsx() (or an empty className) is noise. Omit it.

cleanupclassnamesclsxtidiness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Tailwind / React

frontend ruleP2

Use forwardRef only on components that actually need a ref

Don't blanket-apply forwardRef to every component. Keep it on the one component that needs a forwarded ref and simplify the rest.

reactforwardrefsimplicitycomponents

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Trim vendored template components to what you actually use

Templates like shadcn/ui are starting points: delete unused parts (e.g. TableFooter), drop forwardRef/displayName where not needed, and simplify pass-through components to the underlying element.

dead-codetemplatessimplicitycomponents

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Put shared styles inside the reusable component, not at each call site

If two usages of a component repeat the same classes, move those common styles into the component itself so call sites only specify what differs.

drycomponentsstylesreuse

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React / CSS

frontend ruleP2

Add flex-shrink-0 to icons/avatars so flex doesn't squish them

Fixed-size icons and avatars inside a flex row can get compressed. Apply flex-shrink-0 (shrink-0) so they keep their dimensions.

cssflexboxiconslayout

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS / Tailwind

frontend ruleP2

Keep z-index values low and lean on DOM order for stacking

Don't escalate z-index (9999) to win stacking battles. Among equal z-index, later DOM elements stack on top, so reorder markup or use small values; keep a handful of defined layers.

cssz-indexstackinglayering

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP1

Read identifiers from route params, not by parsing the path client-side

Define dynamic route segments (e.g. /person/:id/:name) and read them with the router's params hook instead of slicing window.location, which is brittle and client-dependent.

routingparamscorrectnessrobustness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React Router / Next.js

frontend ruleP2

Set shared variables in a switch, then call setters once afterward

When each switch branch repeats the same setState/setX calls, instead assign local variables in the branches and perform the setter calls once after the switch.

readabilitydrycontrol-flowrefactor

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript / React

frontend ruleP2

Don't name a plain helper with a set* prefix reserved for state setters

Reserve set* naming for actual state setters. A helper that builds search params should be named for what it does (e.g. buildDateRangeParams), not setDateRange which implies React state.

namingconventionsreactclarity

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Use a lazy initializer for state whose initial value is expensive

Pass a function to useState when computing the initial value is costly (e.g. reading window.innerWidth), so it runs once instead of on every render.

reactperformanceuseStateinitialization

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP1

Use the right existence check: `in` for optional keys, null check for nullable values

The `in` operator tests key presence, not value. For a property that's always present but may be null, compare the value; reserve `in` for genuinely optional keys.

typescriptnarrowingcorrectnessoperators

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

fullstack ruleP2

Name boolean-returning helpers as predicates

A function that returns a boolean should read like a question/assertion (hasX, isX, canX) rather than implying a value or action.

namingbooleanspredicatesreadability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Prefer findBy queries; use waitFor only for non-appearance conditions

Most async waits are covered by findBy queries. Reach for waitFor when you need to await a condition findBy can't express (e.g. element count reaching N), not as a default.

testingasynctesting-library

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Testing Library

fullstack ruleP2

Avoid index-based lookups in test assertions

Asserting against element/array indexes is brittle — a small change shifts everything. Find rows by id/role/text or use inline snapshots for deterministic, intent-revealing assertions.

testingbrittlenessassertionsmaintainability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Testing Library

fullstack ruleP2

Use toBe for primitive equality and it.each for table-driven cases

Reserve toEqual for deep object/array equality; use toBe for primitives like strings and numbers. Collapse repetitive same-shape assertions with it.each.

testingassertionsvitestreadability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Vitest / Jest

frontend ruleP2

Use mouseenter/mouseleave instead of mouseover for hover behavior

mouseover/mouseout bubble and fire for descendant elements; mouseenter/mouseleave fire once for the element itself, which is what hover logic usually wants as the DOM grows.

eventsdomhovercorrectness

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026DOM / JavaScript

backend ruleP2

Let the proxy/infra layer own concerns like trailing-slash redirects

Don't hand-roll per-route redirect logic in app code for things the reverse proxy (nginx) should handle globally; otherwise you must repeat it for every future route.

infrastructureredirectsseparation-of-concernsproxy

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node / nginx

frontend ruleP2

Read env vars via import.meta.env in Vite and declare their types

In Vite projects access environment variables through import.meta.env to match how Vite exposes them, and add the typings to vite-env.d.ts for type safety.

viteenvconfigurationtypes

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Vite

frontend ruleP2

Prefer string interpolation over fragmented inline expressions for text

Build a sentence with a template string rather than many separate JSX expressions with {' '} spacers; it reads more clearly and avoids stray whitespace tokens.

readabilitystringsjsx

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React / JavaScript

frontend ruleP2

Don't normalize case when both sides already match

Avoid sprinkling .toLowerCase() in comparisons when the API data and the values you compare against are already the same case. Remove the redundant transformation everywhere.

redundancycomparisonsimplicitystrings

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP2

Reserve space for dynamic UI to prevent layout jump

When a count or badge appears/disappears, the surrounding layout shouldn't jump. Reserve consistent space so toggling content doesn't shift neighbours.

csslayout-shiftuxstability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP1

Store filter/pagination state in URL query params, not browser storage

Keep filters, sorting, and pagination in the URL so the view survives refresh and is linkable/shareable. Avoid localStorage/sessionStorage for state that should be reproducible from a URL.

url-statequery-paramsuxshareability

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React / Next.js

frontend ruleP2

Name props after what they represent, not a borrowed/inaccurate term

A prop holding a dropdown button's visible name is a label, not a placeholder. Name props to describe their actual role so the API reads clearly.

namingpropsclarityapi-design

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Don't keep an artificial split between vendored and own components without a reason

When you copy in template components (e.g. shadcn/ui) they become yours; avoid maintaining a separate folder split unless it earns its keep, and merge thin wrappers into one component until a reason to separate appears.

organizationcomponentssimplicityyagni

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Name files so they don't falsely imply framework-reserved behavior

Avoid filenames that look like framework conventions (e.g. page.helpers.tsx next to page.tsx). Use a neutral name like consts.ts so it's clear the file isn't tapping into a framework feature.

namingconventionsclaritynextjs

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Next.js

fullstack ruleP2

Avoid renaming files for trivial reasons so git keeps the history

Renaming a file (e.g. just because it grew) makes git see a new file and lose blame/history. Keep the name and configure tooling to use it unless a rename is truly warranted.

githistoryrenamestooling

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026git

backend ruleP1

Don't hardcode host and port; resolve them in a deployment-stable way

A handler that fetches http://localhost:3000 only works locally. Determine host/port from the framework/runtime so it works in every environment.

configurationenvironmentsportabilityhttp

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node / Next.js

backend ruleP2

Verify a new endpoint by actually hitting it before assuming it works

After adding a route/handler, make a real request to it (browser console, curl) and inspect the response to confirm the implementation, rather than assuming correctness.

verificationendpointstestinghttp

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Next.js / HTTP

frontend ruleP1

Use the framework's Link component for internal navigation

Use next/link or React Router's Link for in-app navigation instead of a raw <a>, to get client-side routing, base-path handling, and no hardcoded origins.

routinglinksnavigationspa

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Next.js / React Router

backend ruleP1

Modules should only export; never run side-effecting work at import time

Route/module files should declare and export. Side effects (fetches, IO) at the top level run on import, which is unexpected — only scripts invoked directly should execute work.

side-effectsmodulesimportsarchitecture

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node / Next.js

fullstack ruleP2

Install dependencies in the branch/feature that actually uses them

Don't add a dependency in an unrelated PR. Install it in the branch that consumes it, and commit the lockfile change alongside it.

dependencieslockfilescopegit

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Node / package managers

frontend ruleP1

Keep route folder names and the links pointing to them in sync

When you rename a route, update both the directory name and every link/href that targets it so navigation does not 404.

routingnextjsconsistencylinks

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Next.js

frontend ruleP1

Wrap context providers at the lowest common ancestor, not the root layout

Adding a client-side provider and 'use client' to the root layout opts the entire app out of server rendering. Wrap providers around only the subtree that needs them.

nextjsrsccontextproviders

hegnar-bellsheep-web · org-mining-hist-2026-06

Jun 18, 2026Next.js App Router / React

frontend ruleP1

Clear a previous error state when an operation succeeds on retry

If an action sets an error on failure, a later successful attempt must reset that error, otherwise stale error UI lingers after recovery.

reacterror-handlingstateux

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP1

Validate the shape of an external response before trusting it

A 200 status does not guarantee the payload matches your interface. A type guard at the boundary stops a malformed upstream response from crashing the frontend; weigh this against consistency in your codebase.

validationtype-guardsdefensive-programmingapi

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Prefer simple positioning over creating extra GPU composition layers

Centering with inset:0 + margin:auto is cheaper than translate-based centering, which forces a new composition layer / GPU acceleration. Reach for the lighter approach by default.

cssperformancelayoutcompositing

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Use RefObject for object refs; reserve React.Ref for callback-ref flexibility

React.Ref allows both object and callback refs, forcing you to check the type before reading .current. Use React.RefObject<T | null> unless you actually need to accept callback refs.

reactrefstypescripttypes

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Use CSS custom properties for values shared between CSS and JS

SCSS variables are build-time macros and cannot be read at runtime. For a value needed in CSS and also via the JS style prop, define a CSS custom property (var) so there is one source of truth.

csscustom-propertiesscsstheming

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Inline single-use JSX and only PascalCase real components

Don't hoist a chunk of JSX into a variable that's used once; inline it. And a value that is not a React component should be camelCase, since PascalCase implies a component.

reactnamingreadabilityjsx

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Rotate icons with a CSS class on the parent, not an SVG transform prop

Safari mishandles transform applied directly to an <svg> (especially via a prop). Toggle a class and rotate the element in CSS for cross-browser correctness.

csssvgsafaricross-browsertransform

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP1

Mount a portal target outside the React root element

A portal whose container lives inside the same React root defeats the purpose and can malfunction. Create a sibling element for portals (and if it is already inside the root, you do not need a portal at all).

reactportaldomarchitecture

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Use defaultOpen for an initially-open dialog, open only when controlling state

Radix Dialog's open prop is for controlled state and must be paired with onOpenChange. To simply start open, use defaultOpen.

radixdialogcontrolled-componentsreact

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Group @include mixins at the top of a rule, before plain declarations

Listing all @include lines first, then property declarations, makes rule blocks easier to scan.

scssreadabilityorderingstyle

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026SCSS

fullstack ruleP2

Use an as const object instead of an enum for value-only constants

When a set of constants is used only as values (never as a type), a frozen object literal with as const is lighter and more idiomatic than a TS enum.

typescriptenumconst-assertionidioms

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP1

Prefer unknown over any for untyped values

any disables type checking entirely. Use unknown so the value must be narrowed before use.

typescripttypestype-safety

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Order status checks loading, error, empty to avoid repeated negations

Guard render branches in the order loading -> error -> empty so each later check no longer has to re-test !isLoading.

reactreadabilitycontrol-flowearly-return

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Debounce search input around 150-300ms, not a full second

A one-second debounce on a search field feels broken to users. Target 150-300ms so results feel responsive while still throttling requests.

debouncesearchuxperformance

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Pass handler references to event props, do not invoke them during render

Wiring a function that runs immediately (returning its call result) into onClick executes it on every render. Pass a reference or wrap in an arrow.

reactevent-handlersrenderingperformance

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Document public component props/APIs with JSDoc

Add JSDoc to exported component props and public functions so editors surface inline docs at the call site.

documentationjsdoctypescriptdx

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Narrow config globs to the file types you actually use

Scope glob patterns (e.g. Storybook story globs) to the extensions actually in use instead of a broad catch-all, to keep config intentional.

configtoolingclean-codesimplicity

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026tooling/config

frontend ruleP2

Use a large/infinite border-radius for pill shapes

To make a pill regardless of dimensions, use `border-radius: calc(infinity * 1px)` (or a very large value) instead of guessing an arbitrary radius.

cssshapesclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Avoid layout shift when adding a focus border

Adding a border only on focus shifts surrounding content; use outline, a transparent reserved border, or box-shadow so the focus indicator doesn't change layout.

cssaccessibilityfocuslayout

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Prefer display:block; width:100% over flexbox for single inputs

For laying out a lone input, `display: block; width: 100%;` is simpler than wrapping it in flex; reach for the simplest layout that works.

csslayoutsimplicityforms

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Filter pointer events by pointerType instead of capability checks

To handle mouse-only interactions, check `event.pointerType === 'mouse'` inside pointerenter/leave rather than maintaining a separate hasHoverSupport flag.

eventspointer-eventsjavascriptclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP2

Extract validation rules into a small helper/config

Centralize allowed-type validation (e.g. accepted image MIME types) in a helper or config constant so it's easy to find and change, rather than inlining conditions.

validationconfigclean-codemaintainability

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP2

Use the hidden attribute instead of inline display:none

To hide an element entirely, prefer the native `hidden` attribute over inline style display:none.

htmlreactclean-codeaccessibility

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026HTML/React

frontend ruleP2

Avoid setTimeout in effects unless genuinely required

Don't wrap effect logic in setTimeout(0) by default; only use it when a real timing/focus issue requires deferring to the next tick, and document why.

reacthookstimingclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Cover all browsers (and verify) when applying font smoothing

Font-smoothing properties are vendor/browser specific; include the relevant properties and verify the result in Firefox/Safari, not just Chrome.

csscross-browserfontsverification

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Size elements with padding/font-size before reaching for fixed dimensions

Prefer intrinsic sizing (padding + font-size) over hardcoded width/height where it gives the right result, falling back to fixed dimensions only when needed for stability across zoom/browsers.

csslayoutsizingclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Don't set both a fixed width and a max-width that conflicts

A fixed `width` plus a smaller `max-width` is redundant/confusing; use `width: 100%` with `max-width` for a responsive cap, or just one of them.

csslayoutclean-coderedundancy

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Agree on one conditional className convention and keep it consistent

Standardize how conditional classes are applied (e.g. `&&` for a single class, object notation via clsx for multiple) and apply it consistently across components.

consistencyreactstylingclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP2

Don't add a per-item config flag for a single special case

If only one item needs a flag, identify it by a stable property (name/id) instead of attaching a flag to every item in config; add the flag per-item only when many items use it and it changes often.

configdata-modelingclean-codeyagni

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026language-agnostic

frontend ruleP2

Give custom events specific, namespaced names

Name dispatched CustomEvents to reflect both their source and the specific action (e.g. domain:component.action) so listeners are unambiguous.

eventsnamingclean-codeweb-components

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP2

Split into separate components when breakpoints diverge in behavior

When mobile and desktop need meaningfully different markup/JS (e.g. drawer vs dropdown), render distinct components based on an isMobile check rather than morphing one with CSS.

reactresponsivecomponentsarchitecture

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Use a toggle hook for simple boolean state

For on/off UI state, reach for an existing useToggle/useToggleState hook instead of a raw useState boolean with manual setters.

reacthooksreuseclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP2

Don't sacrifice readable multi-line objects to formatter one-lining

Keep object/type definitions multi-line when single-lining hurts readability; configure the formatter rather than letting it cram everything onto one line.

readabilityformattingclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026language-agnostic

fullstack ruleP2

Use one consistent file-naming case across a module

Don't mix camelCase and kebab-case filenames for sibling utilities; pick one convention. Also merge tiny related utility files into a cohesive module.

namingconsistencyproject-structureclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026language-agnostic

fullstack ruleP1

Don't overload one flag to control unrelated behavior

A flag with an established meaning (e.g. disablePeriodicFetch to turn off polling) shouldn't be repurposed to also gate a different feature (push/SSE); use a dedicated condition.

correctnessapi-designflagsclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026language-agnostic

frontend ruleP2

Trim derived/redundant values from effect dependency arrays

Remove dependencies that are derived from other listed dependencies to avoid a bloated array and surprising re-runs.

reacthooksdependenciesclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Use the native placeholder attribute instead of faking it with content

For inputs/textareas, use the placeholder attribute rather than rendering placeholder text as real content, which gets laid out and can cause odd resize behavior.

htmlformscssplaceholder

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026HTML/CSS

frontend ruleP2

Reuse an existing component before building a new one

Before implementing UI from scratch, check whether the codebase already has a component for it (e.g. an existing Tooltip) and reuse it.

reusedrycomponentsdiscoverability

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP1

Type a lookup that can miss as `T | undefined`

A find/lookup function that may not match should return `T | undefined` (not `T`), forcing callers to handle the miss.

typescripttypescorrectnessnull-handling

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Type string-keyed object maps with Record

Prefer `Record<string, T>` over a hand-written index signature interface for plain key/value maps.

typescripttypesclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Use a HEAD request to check resource existence

To verify a URL exists without downloading its body (and to avoid fetching an image twice), issue a HEAD request — or better, handle image fallback declaratively via onError.

httpperformancenetworkingimages

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript/HTTP

frontend ruleP1

Make displayed content configurable via props, not hardcoded

Reusable components shouldn't bake in titles, names, image URLs or other content; accept them as props so the component can be reused.

reactreusabilitypropscomponents

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Derive computed values from the real data, not a duplicated copy

When a calculation depends on a value that's also rendered, pass the actual value in rather than hardcoding a duplicate literal that can drift.

drycorrectnessreactclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Prefer CSS pseudo-classes over JS state for visual UI states

Use :focus-within, :hover, :focus, etc. for purely visual states instead of tracking them in React state and re-rendering.

cssreactperformancesimplicity

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS/React

frontend ruleP2

Subtract 1px from the breakpoint when using max-width

A breakpoint at 768px means max-width queries should target 767px; using max-width: 768px inadvertently creates a new 769px breakpoint.

cssresponsivebreakpointscorrectness

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS/SCSS

frontend ruleP2

Prefer 100dvh over 100vh for full-viewport heights

Use dynamic viewport units (dvh) with a @supports fallback so layouts account for mobile browser UI that shows/hides.

cssmobileviewportresponsive

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS/SCSS

frontend ruleP1

Always set an explicit type on <button>

A button without a type defaults to submit and can unexpectedly submit a surrounding form. Set type="button" (or submit/reset) explicitly.

htmlaccessibilityformscorrectness

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026HTML/React

frontend ruleP1

Restore shared environment state after a story/test changes it

When a story or test mutates shared state (e.g. the viewport, globals), reset it on teardown so later stories/tests aren't affected by leaked state.

testingstorybookisolationcleanup

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026Storybook/testing

frontend ruleP1

Share a single stylesheet across many web-component instances

Injecting a <style> per component instance multiplies identical style nodes in the DOM. Create one shared stylesheet (e.g. a constructable/adopted stylesheet) reused by all instances.

web-componentsperformancedomstyles

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026Web Components

frontend ruleP1

Call a data-fetching hook once high up and pass results down

Avoid calling the same non-cached fetching hook in both parent and child; call it once at the top level and pass the data as props to reduce duplicate requests and re-renders.

reacthooksperformancedata-fetchingarchitecture

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Make timeouts abortable via an AbortSignal

Wire timeouts to an AbortSignal so a single controller.abort() can cancel multiple pending timers at once.

javascripttimersabort-controllercleanup

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP2

Don't re-check the first element after verifying length

If you already confirmed an array is non-empty, accessing the first element doesn't need a separate optional/guard check.

clean-codearraysredundancy

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP2

Avoid misleading qualifiers in names (mock, visible, ...)

Drop name qualifiers that no longer hold: don't call permanent data `*.mock`, and only call a subset `visibleX`/`filteredX` if a hidden/full set actually exists.

namingreadabilityclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026language-agnostic

frontend ruleP2

Prefer optional props over an explicit `| undefined` union

Mark props that may be absent as optional (`name?: T`) instead of typing them `name: T | undefined`, so callers can simply omit them.

typescriptpropsapi-designclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Let test runners auto-detect CI single-run mode instead of forcing flags

Modern runners like Vitest switch to a single, compact run when CI=true; set that env var rather than fighting npm arg-passing with --run.

testingcitoolingvitest

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026Node

fullstack ruleP1

Run a single validate gate (lint, format, types, tests) before publishing

Add one validate task that lints, checks formatting, typechecks, and runs tests, and wire it into prepublishOnly so bad releases can't be published.

citoolingpublishingquality-gate

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026Node

frontend ruleP2

Don't disguise a plain function as a hook

A function that doesn't use React state/effects isn't a hook; don't prefix it with use or keep it under hooks/. Name it for what it does (isMobile/checkIfMobile).

reacthooksnamingconventions

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Prefer a modern lightweight date library over heavy legacy ones

Avoid large legacy date libraries like moment for new code; choose a small modern alternative (e.g. dayjs/date-fns) to keep bundles lean.

dependenciesbundle-sizedatesmodernization

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP1

Pass runtime config to shared components as props, not build-time env vars

A reusable/published package can't bake environment URLs at its own build time; expose them as props/attributes so each consuming app supplies its own values.

configurationlibraryenvcomponent-design

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026any

frontend ruleP1

Externalize framework deps when bundling a library

A shared component library must externalize react/react-dom and their subpaths (react-dom/client, react/jsx-runtime) so the host app provides a single instance, not a bundled duplicate.

buildlibrarybundlingpeer-dependencies

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026Vite

fullstack ruleP1

Don't issue a request you know will fail without auth

If a call requires a session that is absent, short-circuit with a clear error rather than firing a request that returns nothing and surfaces a confusing empty state.

autherror-handlingguard-clauseux

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP2

Prefer Sass @use over the deprecated @import

Sass @import is deprecated in favor of the module system @use; migrate to @use (on dart-sass/sass-embedded) to avoid global namespace leakage and future removal.

scsssassmodulesdeprecation

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026SCSS

frontend ruleP2

Lift duplicated styles into one shared class and override per variant

When two selectors repeat the same declarations, define a common class at a higher level and only add variant-specific overrides.

cssscssdrymaintainability

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026CSS

frontend ruleP2

Name singular vs plural related props distinctly to avoid confusion

Props like category and categories sitting side by side are confusing; rename the singular to activeCategory/currentCategory to signal its role.

reactnamingpropsreadability

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Only fetch data when the feature that needs it is shown

Don't eagerly fetch supporting data (e.g. categories) on mount if it's only used by an optional tab/view; guard the fetch behind the condition.

performancefetchreactconditional

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

fullstack ruleP2

Keep ID-like values as strings unless you do arithmetic on them

IDs that look numeric but are only compared and passed through should stay strings; converting introduces NaN risks and you just convert back later anyway.

typesidsdata-modelingcorrectness

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Avoid deeply nested destructuring; destructure one level directly

Triple-nested destructuring forces the reader to parse in reverse; pull the value with a short direct path instead.

readabilitydestructuringclean-code

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP1

Reusable components must not mutate the page URL or global history

A component meant to be dropped onto arbitrary pages should keep its state internal; pushing to window.history on interaction leaks side effects onto the host page.

reactside-effectsurlcomponent-design

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Treat boolean HTML attributes by presence, following native conventions

Detect boolean attributes via hasAttribute (allowing valueless usage) and name them like native ones (disabled, not is-disabled); `=== 'true' || false` is redundant.

web-componentshtmlattributesconventions

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026JavaScript

frontend ruleP1

Don't reach for newer framework APIs that break supported versions

If a library must support an older major (e.g. React 17), avoid version-gated APIs like createRoot directly; feature-detect with a dynamic import fallback so older consumers still work.

reactcompatibilitylibraryversioning

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Put the anchor inside the list item, not wrapping it

<a> is not permitted as a direct child of <ul>/<ol>; nest the <a> inside each <li>. Also drop the key from inner elements - it belongs only on the outermost mapped element.

htmlsemanticsreactlistskeys

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP1

Don't mix a real href with a JS-navigation onClick on the same anchor

An anchor that both has an href and an onClick that opens/navigates does the work twice; either use a button with the click handler or a plain link with no handler.

reactanchornavigationsemantics

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Drive a presentational component's variants from a state enum, not loose strings

Instead of passing several free-form text/url props, expose a state enum and let the component resolve its own copy and links per state.

reactcomponent-designenumsingle-responsibility

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

frontend ruleP2

Use a named type guard for discriminating union responses

When a function returns one of several shapes, narrow with a documented type-guard function rather than scattering inline `'key' in obj` checks at every call site.

typescripttype-guarddiscriminated-unionreadability

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Prefer a plain boolean over boolean | null for loading flags

A loading flag that can be true/false/null forces awkward `!== null` guards downstream; default it to false unless you genuinely need to model 'never loaded' as a distinct state.

reactstatereadabilitytypescript

hegnar-components · org-mining-hist-2026-06

Jun 18, 2026React

backend ruleP2

Extract distinct loop bodies into named functions for testability

A long function that builds several independent collections in successive loops is easier to read and test when each loop becomes its own named function returning its slice of work.

refactoringtestabilityseparation-of-concerns

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP1

Mock dependencies in unit tests instead of exercising nested implementations

A unit test should mock the collaborators a function calls and assert on its own contract, not invoke and depend on the behavior of methods-within-methods.

testingmockingunit-tests

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP2

Validate input before calling, and avoid needlessly wrapping a single arg in an object

Return the error response as soon as a required input is missing instead of delegating that check, and pass a lone value directly rather than wrapping it in a one-key object.

input-validationapi-designsimplicity

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Node/HTTP

backend ruleP0

Do not embed credentials in a connection URL string

Pass username/password via dedicated client options instead of interpolating them into a connection URL, which can leak into logs and error messages.

securitysecretslogging

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Node

backend ruleP1

Order numeric threshold branches so every range is reachable

Sort range/threshold conditions monotonically and make boundaries contiguous so no branch is unreachable and no input falls through to an unintended default.

control-flowcorrectnessreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP2

Do not reimplement behavior the base class already provides

Before adding manual logic (deduping, normalization, etc.) check whether the inherited/base implementation already does it; duplicating it is redundant and risks divergence.

dryinheritancereuse

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP1

Do not use the unfiltered internal data source unless explicitly required

An 'internal' query mode that returns unpublished or otherwise hidden records must not be used by default, only when the use case explicitly demands it.

data-accesscorrectnesssecurity

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP1

Pass the caller's own identifier to tracing/diagnostic parameters

When a method accepts an 'invokedBy'/origin parameter for tracing, pass the actual current call site rather than a copied-from-elsewhere or unrelated value.

observabilitycopy-pastecorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

backend ruleP2

Extract inline workarounds into a reusable, parameterized utility

Inline quick-fix logic (like splitting a payload into fixed chunks) should be pulled into a named utility with parameterized sizes instead of being hardcoded at the call site.

refactoringdrymaintainability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026general

frontend ruleP0

Guard the container before indexing an optionally-chained value

Optional chaining stops at the first nullish link; indexing the result of a possibly-undefined access still throws.

typescriptoptional-chainingnull-safety

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Return a consistent DTO shape across all sources implementing the same contract

When multiple entities implement a shared DTO method, ensure every one returns the same fields (use a shared/extended interface or always-present values) so consumers get a uniform shape.

consistencyapi-designpolymorphism

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Group related routes into their own router instead of cluttering a shared one

When two or more similar endpoints accumulate in a catch-all router, move them into a dedicated sub-router to keep the routing table readable.

organizationapireadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Express

fullstack ruleP2

Deduplicate a collection before mapping, not after

Remove duplicates on the raw list before transforming it; deduping post-map often forces you to carry extra fields just to identify duplicates.

data-processingsimplicityperformance

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Expose a focused getter/method rather than handing out the whole entity

To let callers read one derived value, expose a getter or method for it; don't leak the underlying entity object so the deriving logic stays inside the owning class.

encapsulationoopapi-design

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Keep image scaling/CDN-wrapping transforms in one consistent layer

Apply imaginary/resize/CDN-wrap transforms in a single, predictable place (e.g. the repository) rather than sometimes returning raw full-resolution URLs and transforming elsewhere.

consistencyarchitectureimages

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Tag deferred fixes with a TODO and a tracking ticket, don't fix tech debt mid-PR

Avoid expanding a task's scope for tech-debt cleanup; mark the spot with a TODO referencing a ticket so it's tracked and the current PR stays focused.

processtech-debtscopecomments

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

End every file with a trailing newline

Files should end with a single newline; this is standard, keeps diffs clean, and satisfies common linters.

styleformattinglint

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Delete methods superseded by an existing equivalent

Before adding a new helper, check whether one already exists; if you later find your new method duplicates an existing one, delete the duplicate rather than leaving both.

dead-codedrycleanup

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Handle non-200 success statuses, not just status !== 200 as failure

Treating any status other than 200 as an error breaks legitimate responses like 304 Not Modified; check for the actual failure range or handle 304 explicitly.

httpcorrectnesserror-handling

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Make environment-dependent values config-driven, not hardcoded to prod

URLs, IDs, and namespaces that differ per environment should come from config keyed by the current environment instead of a hardcoded production string.

configurationenvironmentsmaintainability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Pass a couple of related primitives as parameters, not wrapped in a throwaway object

If a method takes two scalar values that are immediately destructured, accept them as plain parameters instead of wrapping them in an object only to unwrap it inside.

api-designsimplicityreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Use the library's data accessors instead of manual attribute strings

With cheerio/jQuery-style APIs, prefer element.data('id') / element.data('id', v) over manually reading and writing data-* attributes; it's cleaner and less error-prone.

readabilitylibrary-usagedom

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / cheerio

fullstack ruleP2

Discriminate union members with type guards consistently

If you have a type guard for one variant of a union (isTvArticle), add guards for the other variants too rather than checking shapes ad hoc.

typescripttype-guardsconsistency

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Collapse a trivial arrow-function block to a single expression

A callback that only returns an object can drop the block and explicit return in favor of an implicit-return object literal.

readabilityconcisenessstyle

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Use a Set for membership/lookup collections, not an array

When a static collection exists only to answer 'does it contain X', a Set communicates intent and gives O(1) lookups versus an array's linear scan.

data-structuresperformancereadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Instantiate a dependency where it's used rather than threading it through

If a provider/helper is only needed inside one method, create it there instead of building it in the caller and passing it down through several layers.

simplicitycouplingreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Prefer the simpler query method when you don't need its heavier variant

Use the lightweight query call (asArray) over the iterating/paginating one (all) when limits make the difference moot; the iterating variant adds unnecessary count checks and extra round-trips.

performancesimplicityqueries

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Use the cache wrap/memoize helper instead of manual get/set

Prefer a `cache.wrap(key, producer, opts)` helper that returns cached value or computes-and-stores, over hand-written get-check-set-return blocks.

cachingdryreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Don't throw an error only to catch it yourself one line later

If you handle a failure in the same function, log and return/produce the fallback directly instead of throwing into your own try/catch.

error-handlingcontrol-flowreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Centralize cache-key computation and TTL constants in one place

Let the caching layer compute the key (so the hashing strategy lives in one spot) and define TTLs as named, semantic constants rather than scattering raw numbers across call sites.

cachingdrymagic-numbersmaintainability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Make methods static when they don't depend on instance state

If a method or field reads nothing from `this`, mark it static; it documents that the logic is instance-independent and avoids needless instantiation.

oopstaticreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

For singletons, export the instance rather than the class

Export `SomeClass.Instance` as the module default so callers don't repeat `.Instance` everywhere and cannot accidentally `new` the class.

singletonoopapi-design

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Pick interface vs type by convention and apply it uniformly

Decide a project convention for when to use interface vs type alias (and the I/T prefix), then apply it consistently; don't let an auto-fixer flip type to interface while leaving a T-prefixed name.

typescriptconsistencynamingconventions

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Keep null out of a named type alias; add it at the point of optionality

Define a type alias as the non-null shape and apply `| null` where the value is actually optional, instead of baking null into the alias itself.

typescripttypesreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Reserve underscore-prefixed names for private members only

Don't prefix a public getter/method with an underscore; the underscore convention signals 'private/internal', so either drop it or make the member actually private.

namingconventionsreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Don't expose an internal constant as a parameter when the method name already implies it

If a method's name fixes the data set (e.g. agendaIrWidgetArticles), don't take the defining id/tag as a caller parameter; keep it internal so callers can't pass a contradictory value.

api-designnamingencapsulation

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP1

When a function signature returns T | null, actually return null for the empty case

If you declared a return type of `T | null` to signal 'nothing here', return null in that case instead of an object full of null/empty fields that the caller must re-check.

correctnessnull-handlingapi-design

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Don't reach for generics when each concrete case maps differently

A generic type parameter only pays off when implementations are identical except for T. If each variant hardcodes its own mapping, a plain shared interface with a differing field is simpler.

typescriptgenericssimplicityyagni

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Factor near-identical type guards into one generic validator

When several `isValidX` guards share the same body except the lookup set, extract a single generic helper and define each guard as a thin call to it.

drytypescriptgenericstype-guards

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Parse query params with a uniform typed-destructure pattern across handlers

Use the same typed query-param destructuring style (typed object + defaults via destructuring) across route handlers instead of one-off casts, for a consistent, predictable codebase.

consistencyapireadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Express

backend ruleP2

Return the final shape from its source rather than re-mapping downstream

If a repository/data method is the sole producer of a shape and nothing else consumes its raw form, have it return the final interface directly instead of mapping it again in the caller.

architecturedrylayering

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Do not expose pagination params an endpoint cannot honor

Accepting an offset that has no effect (because the upstream cannot paginate) misleads callers; omit the param or document the limitation.

api-designpaginationquery-paramsclarity

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Express / Node.js

backend ruleP1

Set a derived validity flag before the code path that reads it

A flag initialized true and only flipped false by getters invoked later is read stale; compute validity (e.g. via setters in the constructor) before it's consumed.

statecorrectnessinitializationordering

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Beware switch values that can be undefined

If the switched expression can be undefined, the switch still runs and may match an unintended case; guard for undefined before switching.

control-flownull-handlingcorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

backend ruleP2

Place routes in the namespace that matches their purpose

Use action/api namespaces for interactions and read namespaces for simple static reads; putting a read under an action path (or vice versa) misleads.

routingapi-designconventions

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Express / Node.js

fullstack ruleP2

Keep generated URL paths consistently absolute with a leading slash

Generated link paths should start with '/' to match sibling fields and avoid relative-path bugs.

urlsconsistencycorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

fullstack ruleP2

Include a stable id in list items so clients can key them

API list items consumed by a UI should carry a stable identifier so the frontend can use it as a render key.

api-designreactkeysfrontend

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / React

fullstack ruleP2

Run the formatter before pushing so style is consistent

Inconsistent formatting (missing semicolons, spacing) should be auto-fixed by running the project formatter/prettier before review.

formattingprettiertoolingclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

backend ruleP1

Do not overload a single field to mean two different concepts

Conflating distinct concepts (e.g. article source vs article type) into one parameter breeds confusion; model them as separate fields/enums.

modelingapi-designenumsclarity

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Implement an interface fully rather than stubbing methods that throw

Extending a base/interface but stubbing required methods with 'throw new Error(not implemented)' signals the wrong abstraction; implement them or pick a better base.

interfacesabstractionooparchitecture

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Accept the simplest type a function actually needs

If a method only ever uses url.toString(), accept a string rather than a URL object so the signature reflects the real dependency.

api-designtypesclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Keep fetch error handling inside the method that owns the fetch

Push the try/catch around a network call down into the fetch method so the higher-level method stays focused on its logic.

error-handlingseparation-of-concernsclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Node.js

backend ruleP2

Set cache TTL to match how often the data actually changes

A very short TTL on rarely-changing data (e.g. logos) causes needless refetches; size the TTL to the data's real volatility.

cachingperformancettl

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Node.js

fullstack ruleP2

Return a Map keyed by id when callers do repeated lookups

If consumers repeatedly look items up by id, return a Map/keyed object instead of an array so lookups are O(1) and call-site code is simpler.

data-structuresperformanceapi-design

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

backend ruleP1

Parse boolean query params explicitly, not via truthiness

Query params arrive as strings, so '?flag=false' is the truthy string 'false'. Compare against 'true' explicitly.

query-paramsbooleansvalidationcorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026Express / Node.js

backend ruleP1

Do not reference repositories from inside domain entities

Entities depending on repositories creates tangled coupling; keep data access in the repository/service layer and pass data into entities.

architecturecouplingseparation-of-concernsdomain-model

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP2

Do not couple a generic interface to a more specific one

Picking fields from a narrower interface to define a broader/more generic one inverts the dependency direction; define the shared shape independently.

typescouplingarchitecture

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Avoid else-if that implies a nonexistent third case

When an enum has exactly two values, an else-if chain misleads readers into thinking a third branch exists; prefer a clearer two-way form or default.

clean-codecontrol-flowreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

fullstack ruleP2

Remove conditional defaulting that produces the same value either way

A guard like 'if x>0 use x else 0' on a non-negative value is a no-op; drop it. Push defaults into getters instead of building parallel objects.

clean-coderedundancysimplification

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

backend ruleP2

Do not JSON.stringify a value that is already a string

Calling JSON.stringify on a plain string adds quotes and serves no purpose when feeding a hash or update call; pass the string as-is.

clean-codestringsredundancy

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript / TypeScript

frontend ruleP1

Use nullish coalescing so a value matches its declared null type

If a getter is typed string | null, optional chaining alone can yield undefined; add ?? null so the runtime value matches the type.

type-safetynull-handlingcorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

frontend ruleP2

Use the API's boolean helper instead of counting elements

When a library exposes a boolean check (e.g. hasClass), use it rather than selecting elements and inspecting their count.

clean-codedomreadability

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript / cheerio / DOM

fullstack ruleP2

Use find (not filter + loop) when you expect a single match

If at most one element matches, filter followed by a forEach that overwrites is wasteful and bug-prone; use find and handle the single result.

arraysclean-codecorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / JavaScript

backend ruleP1

Confine a cross-cutting dependency to the layer that owns it

A dependency like a cache model should live in the base/dedicated class that uses it, not be threaded through unrelated subclasses and their constructors.

architecturedependency-injectionseparation-of-concerns

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript

backend ruleP1

Paginate at the data source, not by slicing in memory

Pass limit/offset down to the query layer instead of fetching everything and slicing afterward; in-memory slicing wastes fetch bandwidth and breaks at scale.

performancepaginationdatabase

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Node.js

backend ruleP1

Distinguish failures from empty results in API responses

On a genuine fetch/processing failure return an error payload, not an empty array, so callers can tell 'nothing found' apart from 'something broke'.

error-handlingapi-designsemantics

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026TypeScript / Node.js

backend ruleP2

Make error log messages reflect the actual failure source

A catch that can fire for multiple reasons shouldn't hardcode one cause in its message; describe accurately or distinguish.

loggingerror-handlingobservabilitycorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Use object rest destructuring to omit properties concisely

To strip a field from each object in a list, destructure with rest instead of manual reconstruction.

destructuringclean-codeobjectsshorthand

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP2

Place code in the module that matches its responsibility

Generic, reusable code (e.g. a serializer) doesn't belong in a feature-specific file; move it to a fitting location.

organizationcohesionclean-codemodularity

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Store data pre-sorted rather than reordering on every use

If a list is needed in a fixed order repeatedly, sort it once at the source instead of re-sorting at each call site.

performanceclean-codedataefficiency

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Use padStart for zero-padding numbers consistently

Apply leading-zero formatting uniformly (e.g. to both day and month) using String.padStart instead of ad-hoc checks.

formattingstringsdatesclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP2

Avoid while(true) loops with internal breaks

Express the loop's exit condition in the while clause rather than relying on a break inside an infinite loop.

control-flowreadabilityloopsclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

backend ruleP1

Return 400 for missing required request parameters

When a required query/body param is absent, respond with 400 Bad Request rather than returning empty data or proceeding.

httpvalidationerror-handlingapi-design

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

backend ruleP0

Fail fast when required environment variables are missing

Validate mandatory env vars at startup and throw, instead of silently defaulting to an empty/placeholder value.

configurationfail-fastsecuritycorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Only mark a function async when it actually awaits

Don't add async to a function with no await inside; it adds an unnecessary promise wrapper and obscures intent.

asyncclean-codecorrectnesspromises

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

fullstack ruleP2

Place the default case last in a switch statement

The default branch represents 'no other case matched', so conventionally it belongs at the bottom for readability.

switchreadabilityconventionclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP2

Keep naming consistent with existing conventions

Match the established naming pattern (interface prefixes, casing, abbreviations) used elsewhere in the codebase.

namingconsistencyclean-code

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026any

fullstack ruleP1

Use the global regex flag when replacing all occurrences in a string

String.replace with a plain string argument only replaces the first match; use a /g regex to replace all.

javascriptstringsregexcorrectness

hegnar-ws · org-mining-hist-2026-06

Jun 18, 2026JavaScript/TypeScript

frontend ruleP1

Trigger user-data side effects on the correct lifecycle event

Choose the hook/callback that fires for every relevant scenario. For example, sending user data on page visit vs. only on login changes who it covers; verify both the already-logged-in and just-logged-in paths fire the intended code.

lifecycleside-effectsauthcorrectness