How do I install the Typescript Best Practices skill?

Run npx skillmds@latest add aliceisjustplaying/typescript-best-practices in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Typescript Best Practices skill do?

TypeScript best practices. Use when reading or editing any .ts or .tsx file. It is listed under Coding & Dev Tools on SkillMD.

Is Typescript Best Practices safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Typescript Best Practices?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Typescript Best Practices free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Typescript Best Practices?

aliceisjustplaying (@aliceisjustplaying) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Typescript Best Practices by aliceisjustplaying

Name: Typescript Best Practices
Author: aliceisjustplaying

File contents

TypeScript best practices

Apply the type-system-discipline principle skill first; this skill grounds it in TypeScript syntax.

Rule	Summary
Discriminated unions	Model variants with a `kind` literal discriminant so impossible states can't be represented. No optional-field bags.
Branded types	Brand primitives with `& { readonly __brand: "X" }` so they can't be mixed up. Validate once at creation.
Constructive modeling	Build the shape so the illegal value can't be constructed. `[T, ...T[]]` for non-empty, `[T, T][]` for even length, `start` plus `duration` for a range. Not a runtime guard, not a wish for refinement types.
Simplest total type	Keep `T[]` while every operation on it stays total. Strengthen to `NonEmpty<T>` only where the loose type forces `!`, a cast, or a "should never happen" throw.
`unknown` over `any`	External data is `unknown`. `any` disables type checking everywhere it touches.
No `as` casts	Every `as` is a runtime crash waiting. Cast only after validation.
Narrowing hierarchy	Discriminant switch > `in` operator > `typeof`/`instanceof` > user-defined type guard > `as`.
Type guards	Must verify the claim. A lying guard is worse than `as` because the bug hides behind a name that says it's safe. Name them `isX` or `hasX`.
Exhaustiveness	Inline `const _exhaustive: never = x;` in default arms so the compiler errors when a new variant is added.
`satisfies` over `as`	Validates the value without widening literal types.
Boundary validation	Parse where data crosses in, into a named domain type. `Record<string, unknown>` (however spelled) stops at that parse. Trust types inside. See the boundary-discipline principle skill.
Schema-derived types	Reach for `Pick`/`Omit`/`Parameters`/`ReturnType`/`Awaited`/`typeof` before declaring a new interface.
Object args	Pass objects, not positional, so argument order is self-documenting. Skip on hot paths (per-frame render, tokenizers, parsers).
Real tests	Don't mock what you can run. Prefer the framework's real test primitives with leak/disposable checks, and verify UI in a running build. Mock only what you can't run locally.
Structured telemetry	Prefer structured logger diagnostics with enough context to debug from an id. No `console.log` in shipped code.

Examples: references/patterns.md.

---name: typescript-best-practicesdescription: TypeScript best practices. Use when reading or editing any .ts or .tsx file.---# TypeScript best practicesApply the **type-system-discipline** principle skill first; this skill grounds it in TypeScript syntax.| Rule | Summary ||------|---------|| Discriminated unions | Model variants with a `kind` literal discriminant so impossible states can't be represented. No optional-field bags. || Branded types | Brand primitives with `& { readonly __brand: "X" }` so they can't be mixed up. Validate once at creation. || Constructive modeling | Build the shape so the illegal value can't be constructed. `[T, ...T[]]` for non-empty, `[T, T][]` for even length, `start` plus `duration` for a range. Not a runtime guard, not a wish for refinement types. || Simplest total type | Keep `T[]` while every operation on it stays total. Strengthen to `NonEmpty<T>` only where the loose type forces `!`, a cast, or a "should never happen" throw. || `unknown` over `any` | External data is `unknown`. `any` disables type checking everywhere it touches. || No `as` casts | Every `as` is a runtime crash waiting. Cast only after validation. || Narrowing hierarchy | Discriminant switch > `in` operator > `typeof`/`instanceof` > user-defined type guard > `as`. || Type guards | Must verify the claim. A lying guard is worse than `as` because the bug hides behind a name that says it's safe. Name them `isX` or `hasX`. || Exhaustiveness | Inline `const _exhaustive: never = x;` in default arms so the compiler errors when a new variant is added. || `satisfies` over `as` | Validates the value without widening literal types. || Boundary validation | Parse where data crosses in, into a named domain type. `Record<string, unknown>` (however spelled) stops at that parse. Trust types inside. See the **boundary-discipline** principle skill. || Schema-derived types | Reach for `Pick`/`Omit`/`Parameters`/`ReturnType`/`Awaited`/`typeof` before declaring a new interface. || Object args | Pass objects, not positional, so argument order is self-documenting. Skip on hot paths (per-frame render, tokenizers, parsers). || Real tests | Don't mock what you can run. Prefer the framework's real test primitives with leak/disposable checks, and verify UI in a running build. Mock only what you can't run locally. || Structured telemetry | Prefer structured logger diagnostics with enough context to debug from an id. No `console.log` in shipped code. |Examples: `references/patterns.md`.

Frequently asked questions

Typescript Best Practices