Claude writes TypeScript. TypeScript Patterns Enforcer checks every edit.

See it work

Claude writes it. The hook flags it. Claude fixes it.

Toggle the same function before and after the hook runs. Each file below is one of the failing and passing fixtures from engine/test/fixtures/.

export function describeStatus(status: string): string {  return status === "active" ? "Active" : status === "paused" ? "Paused" : "Unknown";}

const STATUS_LABELS: Record<string, string> = { active: "Active", paused: "Paused" };export function describeStatus(status: string): string {  return STATUS_LABELS[status] ?? "Unknown";}

ts-patterns: 1 mechanical violation(s) in describeStatus.ts:
  L2:10  no-nested-ternary  nested ternary — flatten, or convert to a Record/.find() lookup (see SKILL.md Data Over Logic).  → SKILL.md Data Over Logic — flatten or convert nested ternaries to a Record/.find() lookup
Fix these to satisfy the TypeScript patterns before continuing.

exit code 2  (stderr goes back to Claude)

clean  no output

exit code 0

export function describeRole(role: string): string {  switch (role) {    case "admin":      return "Admin";    default:      return "Guest";  }}

const ROLE_LABELS: Record<string, string> = { admin: "Admin" };export function describeRole(role: string): string {  return ROLE_LABELS[role] ?? "Guest";}

ts-patterns: 1 mechanical violation(s) in describeRole.ts:
  L2:3  no-switch-statement  switch statement — convert to a Record dispatch table (see SKILL.md Data Over Logic).  → SKILL.md Data Over Logic — convert to a Record dispatch table
Fix these to satisfy the TypeScript patterns before continuing.

exit code 2  (stderr goes back to Claude)

clean  no output

exit code 0

export function identify(value: any): void {  console.log(value);}

export function identify(value: unknown): void {  console.log(value);}

ts-patterns: 1 mechanical violation(s) in identify.ts:
  L1:33  no-explicit-any  Unexpected any. Specify a different type.  → SKILL.md Core Rule 1 — use unknown + narrow, or a precise type
Fix these to satisfy the TypeScript patterns before continuing.

exit code 2  (stderr goes back to Claude)

clean  no output

exit code 0

export function loadUser(id: string): Promise<string> {  return fetch(id).then((response) => response.text());}

export async function loadUser(id: string): Promise<string> {  const response = await fetch(id);  return response.text();}

ts-patterns: 1 mechanical violation(s) in loadUser.ts:
  L2:20  prefer-await-to-then  Prefer await to then()/catch()/finally().  → SKILL.md Core Rule 5 — use async/await, not .then()
Fix these to satisfy the TypeScript patterns before continuing.

exit code 2  (stderr goes back to Claude)

clean  no output

exit code 0

Automatic

Runs after every edit.

The hook reads the file Claude just edited. If a check fails, the message goes to Claude and Claude fixes the file before moving on. Clean files produce no output.

• TriggerOne PostToolUse hook, in hooks/hooks.json. It runs node engine/dist/check.js.
• ScopeOnly .ts and .tsx files.
• OutputViolations go to stderr with exit code 2, which sends them back to Claude.
• Side effectsNone: the engine's own code writes nothing to disk, makes no network calls, and starts no other process.
• No NodeIf Node is missing or the check cannot run, the hook exits with no output. The skill's written rules then remain the only enforcement.

What you get

Three parts, one standard.

The core rules

Eleven rules for the skill to enforce.

The skill also covers data over logic, validation at the boundary, and comment discipline. A hook tag marks a rule the hook also checks mechanically.

1. No anyhookUse unknown and narrow, or write a precise type.
2. Explicit return typesAnnotate public functions.
3. interface vs typeinterface for extendable shapes. type for unions, intersections, and mapped types.
4. readonly by defaultMutable only when mutation is required.
5. async/await onlyhookNo .then() chains. Return Promise<T> explicitly.
6. Typed errorsCustom error classes or discriminated-union results.
7. Constrained generics<TEntity extends BaseEntity>, not <T>.
8. Composition over inheritancePlain functions and utility types first.
9. No magic valueshook: numbersName repeated or meaningful literals in comparisons or branching.
10. Coerce over compareif (!items.length), not items.length === 0.
11. Every regex carries an examplehookA comment directly above it: plain words, a quoted match and reject, and a pre-filled regex101 link.

The ten mechanical checks

The checks find the pattern. Rewriting it well stays with Claude and the skill, because a linter can ban a switch but cannot rewrite one.

Evidence

Tested before it ships.