TypeScript strict mode enabled

Without TypeScript strict mode, the compiler silently allows implicit any types, skips null-safety checks, and misses a family of type errors that only surface at runtime. ISO 25010:2011 §6.5.4 classifies these as reliability defects. A single null dereference in an authentication path or payment flow can take down production. Strict mode is the umbrella flag — disabling it means noImplicitAny, strictNullChecks, and strictFunctionTypes are all off simultaneously.

Enable strict mode in tsconfig.json. Do not compensate by disabling individual sub-flags — that defeats the flag's purpose. To migrate an existing codebase without a full-stop build failure, temporarily set "noEmitOnError": false while you work through the errors one file at a time.

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true
  }
}

Use // @ts-expect-error (with a comment) to suppress individual stubborn errors during migration — never // @ts-ignore without context.

• ID: code-quality-essentials.type-safety.strict-mode

• Severity: critical

• What to look for: Open tsconfig.json and read compilerOptions. Look for "strict": true. The strict flag is a convenience flag that enables a family of strict type checking options simultaneously: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, and alwaysStrict. If strict is absent or false, check whether these sub-flags are individually enabled (partial credit scenario: note which are missing). A strict: true setting that is then partially overridden by explicit "noImplicitAny": false still fails this check.

• Detector snippet (shell-capable tools only): If jq is available, read the explicit compilerOptions.strict value. Output "true" means pass. Output "false" or "null", or exit >=2 (file not found / malformed JSON), means the snippet is inconclusive — fall back to the prose reasoning below and walk any extends: chain manually.

  jq -r '.compilerOptions.strict // "null"' tsconfig.json
  

• Pass criteria: Quote the actual strict value from tsconfig.json. On pass, report the count of strict-related compiler options enabled. Count all tsconfig.json files. compilerOptions.strict is true and is not overridden by explicit disabling of individual sub-flags with at least 1 verified location.

• Fail criteria: strict is false, missing, or strict: true is paired with explicit false overrides on sub-flags. A project that relies only on individual strict flags without the umbrella strict: true does not count as pass.

• Skip (N/A) when: Project has no TypeScript files — all source files are .js or .jsx with no tsconfig.json.

• Detail on fail: "tsconfig.json has strict: false (or missing); noImplicitAny and strictNullChecks are not enforced" (max 500 chars)

• Cross-reference: Compare with code-quality-essentials.type-safety.strict-null-checks — strict mode enables strictNullChecks, but this check verifies the umbrella flag.

• Remediation: Enable strict mode in tsconfig.json. If the project has existing code that does not compile under strict mode, enable it progressively using // @ts-expect-error on specific lines while you fix each class of issue. Never disable a sub-flag to silence the migration — that defeats the purpose.

  {
    "compilerOptions": {
      "strict": true,
      "noUncheckedIndexedAccess": true
    }
  }
  

  To see what errors strict mode surfaces without failing your build, temporarily add "noEmitOnError": false during migration.