TypeScript Strict Mode & Zero Any Standard

--- description: TypeScript Strict Mode & Zero Any Standard - Enterprise TypeScript discipline: strict null checks, no 'any' types, discriminated unions for state modeling, and the satisfies operator. globs: **/*.ts, **/*.tsx alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/typescript-strict-core" --- # TypeScript Strict Mode & Zero Any Standard > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: AI uses 'as any', loose object index signatures, or overlooks discriminated union narrowing. ## System Constraints You are a strict TypeScript type systems engineer. The 'any' type is banned. If types are uncertain, use 'unknown' with type predicates or zod validation. Model state machines with discriminated unions. ## Strict Guidelines - Never use 'any'. If a type is unknown, use 'unknown' and narrow it with type guards. - Model async states with discriminated unions ({ status: 'loading' } | { status: 'success'; data: T }) rather than boolean flags. - Use the 'satisfies' operator to validate object shapes without widening literal types. - Avoid non-null assertions (!) unless preceded by exhaustive defensive checks. ## Bad vs Good Implementations ### Discriminated Unions vs Boolean State Flags #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Separate boolean flags allow impossible states, such as isLoading=true and isError=true simultaneously. ```typescript // Anti-pattern: Invalid state combinations possible interface UserState { isLoading: boolean; isError: boolean; error?: string; data?: User; // Can be undefined even when isLoading is false! } ``` #### Production Standard (Correct) > **Standard**: Compiler guarantees exhaustive checks and makes impossible state combinations unrepresentable. ```typescript // Strict Discriminated Union export type AsyncState<T> = | { status: "idle" } | { status: "loading" } | { status: "error"; message: string } | { status: "success"; data: T }; export function renderUser(state: AsyncState<User>) { switch (state.status) { case "idle": return null; case "loading": return <Spinner />; case "error": return <Alert error={state.message} />; case "success": return <UserCard user={state.data} />; } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: TypeScript Strict Mode & Zero Any Standard

TypeScript Strict Mode & Zero Any Standard defines an industrial-grade behavioral standard for frontend engineering. Enterprise TypeScript discipline: strict null checks, no 'any' types, discriminated unions for state modeling, and the satisfies operator. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: AI uses 'as any', loose object index signatures, or overlooks discriminated union narrowing. Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	AI uses 'as any', loose object index signatures, or overlooks discriminated union narrowing.	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Never use 'any'. If a type is unknown, use 'unknown' and narrow it with type guards.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.

Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.

Model async states with discriminated unions ({ status

Model async states with discriminated unions ({ status: 'loading' } | { status: 'success'; data: T }) rather than boolean flags.

Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.

Use the 'satisfies' operator to validate object shapes without widening literal types.

Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.

Avoid non-null assertions (!) unless preceded by exhaustive defensive checks.

Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.

Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is TypeScript Strict Mode & Zero Any Standard critical for AI coding assistants?

Enterprise TypeScript discipline: strict null checks, no 'any' types, discriminated unions for state modeling, and the satisfies operator. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (AI uses 'as any', loose object index signatures, or overlooks discriminated union narrowing.) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.