TypeScript Strict Mode

Enable and satisfy strict TypeScript checks including strictNullChecks and exactOptionalPropertyTypes

When to Use

• Starting a new TypeScript project (always enable strict mode from day one)
• Migrating an existing project to stricter type checking
• Debugging type errors caused by strict flags
• Deciding which individual strict flags to enable during incremental adoption

Instructions

1. Enable

   strict: true

   in

   tsconfig.json

   — this activates all strict flags at once:

{
  "compilerOptions": {
    "strict": true
  }
}

2. What

   strict: true

   enables:

   • strictNullChecks

     —

     null

     and

     undefined

     are not assignable to other types

   • strictFunctionTypes

     — function parameter types are checked contravariantly

   • strictBindCallApply

     —

     bind

     ,

     call

     ,

     apply

     are fully typed

   • strictPropertyInitialization

     — class properties must be initialized

   • noImplicitAny

     — untyped variables/parameters are errors, not

     any

   • noImplicitThis

     —

     this

     must have a type in function bodies

   • alwaysStrict

     — emits

     "use strict"

     in every file

   • useUnknownInCatchVariables

     — catch variables are

     unknown

     , not

     any

3. Handle

   strictNullChecks

   — the most impactful flag. Check for null before accessing:

function getUser(id: string): User | null {
  /* ... */
}

const user = getUser('123');
// user.name; // Error: Object is possibly 'null'
if (user) {
  user.name; // OK — narrowed to User
}

4. Handle

   noImplicitAny

   — add explicit types where inference fails:

// Error: Parameter 'item' implicitly has an 'any' type
function process(item) {
  /* ... */
}

// Fixed
function process(item: unknown) {
  /* ... */
}

5. Handle

   strictPropertyInitialization

   — initialize class properties:

class Service {
  // Error: Property 'db' has no initializer
  private db: Database;

  // Fix 1: Initialize in constructor
  constructor(db: Database) {
    this.db = db;
  }

  // Fix 2: Definite assignment assertion (use sparingly)
  private db!: Database;
}

6. Handle

   useUnknownInCatchVariables

   :

try {
  await fetchData();
} catch (error) {
  // error is 'unknown', not 'any'
  if (error instanceof Error) {
    console.log(error.message);
  }
}

7. Additional strict flags beyond

   strict: true

   :

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

8. noUncheckedIndexedAccess

   — index signatures include

   undefined

   :

const map: Record<string, string> = { a: 'hello' };
// Without flag: map['b'] is string
// With flag: map['b'] is string | undefined

9. Incremental strict adoption — enable flags one at a time:

{
  "compilerOptions": {
    "strict": false,
    "strictNullChecks": true,
    "noImplicitAny": true
  }
}

Fix errors per flag before enabling the next.

Details

Strict mode catches entire categories of bugs at compile time: null dereferences, implicit

any

types, uninitialized properties, and unsafe function calls. The upfront cost of fixing strict errors pays back quickly in reduced runtime bugs.

noUncheckedIndexedAccess

is not included in

strict: true

but is one of the most valuable additional flags. It forces you to handle the case where an array index or object key might not exist, preventing

undefined is not a function

errors.

exactOptionalPropertyTypes

distinguishes between "property is missing" and "property is

undefined

". With this flag,

{ name?: string }

means the property may be absent, but if present it must be a

string

(not

undefined

).

Strict migration strategy:

1. Enable

   strict: true

   and count the errors
2. If manageable (<100), fix them all at once
3. If large (>100), disable

   strict

   and enable flags individually:

   noImplicitAny

   first (most errors), then

   strictNullChecks

   , then the rest
4. Use

   // @ts-expect-error

   temporarily for errors you cannot fix immediately — track them with a lint rule

Trade-offs:

• Strict mode increases type annotation verbosity — but reduces debugging time

• strictNullChecks

  causes the most migration pain — but prevents the most common runtime error (null dereference)

• noUncheckedIndexedAccess

  adds

  | undefined

  to every index access — use non-null assertion (

  !

  ) or destructuring with defaults for known-safe accesses
• Third-party libraries with loose types can produce cascading strict errors — use declaration merging to fix them locally

Source

https://typescriptlang.org/tsconfig#strict

Process

1. Read the instructions and examples in this document.
2. Apply the patterns to your implementation, adapting to your specific context.
3. Verify your implementation against the details and edge cases listed above.

Harness Integration

• Type: knowledge — this skill is a reference document, not a procedural workflow.
• No tools or state — consumed as context by other skills and agents.

Success Criteria

• The patterns described in this document are applied correctly in the implementation.
• Edge cases and anti-patterns listed in this document are avoided.