Exécutez n'importe quel Skill dans Manus
en un clic

Exécutez n'importe quel Skill dans Manus en un clic

writing-idiomatic-typescript

Étoiles1

Forks0

Mis à jour12 juin 2026 à 20:28

Use when writing or reviewing TypeScript — getting value from the type system (unknown over any, discriminated unions, narrowing, satisfies, readonly) and avoiding the escape hatches (any, unchecked as casts, non-null !) that silently defeat it.

Installation

Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.

Exécuter dans Manus

Source

meaganewaller

meaganewaller/rosetta

Ouvrir le dépôt GitHub Voir les dépôts du créateur

Téléchargement

Exécuter dans Manus

Métiers associésSOC

Basé sur la classification professionnelle SOC

Développeurs de logicielsProfessions informatiques et mathématiques·SOC 15-1252

SKILL.md

readonly

name	writing-idiomatic-typescript
description	Use when writing or reviewing TypeScript — getting value from the type system (unknown over any, discriminated unions, narrowing, satisfies, readonly) and avoiding the escape hatches (any, unchecked as casts, non-null !) that silently defeat it.

Writing idiomatic TypeScript

The point of TypeScript is to make illegal states unrepresentable and let the compiler catch mistakes. Idiomatic TS works with the type system instead of around it. Assume strict: true.

Model the domain in types

Discriminated unions for "one of N shapes" ({ kind: "ok"; value } | { kind: "err"; error }), then switch on the tag — the compiler checks exhaustiveness.
type aliases for unions/functions/mapped types; interface for object shapes that may be extended or merged. Be consistent.
Prefer union string literals (type Mode = "r" | "w") over enum.
Mark data readonly where it shouldn't mutate; use as const for literal tuples/objects.
Reach for utility types (Pick, Omit, Partial, Record, ReturnType) before restating shapes.

Stay sound

unknown, not any, at boundaries (JSON, catch) — then narrow with type guards.
Avoid as casts; when unavoidable, cast to the narrowest type and comment why. Never double-cast through unknown to silence an error.
Avoid the non-null assertion !; narrow instead (if (x == null) return).
Use satisfies to check a value against a type without widening it.
Type guards (x is T) and in/typeof/instanceof narrowing over manual casts.

Functions & async

Let inference do the work for locals; annotate parameters and public return types.
async/await over raw .then chains; never leave a promise unawaited (handle or void it).
Prefer immutable transforms (map/filter/reduce) over mutation when it reads clearly.

Anti-patterns to flag

any (especially implicit), unchecked as, !, @ts-ignore without a justification.
enum where a string-literal union would do; Function/Object/{} as types.
Optional-everything interfaces that don't reflect real invariants.

American English in identifiers and comments.

Plus depuis ce dépôt

même dépôt

agent-memory-patterns

meaganewaller/rosetta

Use when designing memory or persistent context for an agent — deciding what to persist vs. recompute, how to retrieve only what's relevant, and how to summarize/compact history to fit the context window. Use when an agent forgets, bloats its context, or repeats work.

2026-06-171

configure-rosetta

meaganewaller/rosetta

Interactive installer for Rosetta. Guides users through selecting and installing skills and language-specific rules at user-level or project-level, verifies paths, and optionally optimizes installed files.

2026-06-171

continuous-learning

meaganewaller/rosetta

Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills, commands, and agents.

2026-06-171

designing-llm-evals

meaganewaller/rosetta

Use when building or reviewing an evaluation for an LLM feature — assembling a representative test set, choosing pass criteria (exact match, programmatic checks, rubric, or LLM-as-judge), and catching regressions. Use when asking "how do I know this prompt or model change is better?"

2026-06-171

effective-prompting

meaganewaller/rosetta

Use when writing or reviewing a prompt for an LLM — making it specific, structured, and testable (clear task, role/context, examples, an explicit output contract, decomposition, room to reason) and avoiding the anti-patterns that make prompts brittle. Provider-agnostic.

2026-06-171

iterative-retrieval

meaganewaller/rosetta

Pattern for progressively refining context retrieval to solve the subagent context problem.

2026-06-171

name	writing-idiomatic-typescript
description	Use when writing or reviewing TypeScript — getting value from the type system (unknown over any, discriminated unions, narrowing, satisfies, readonly) and avoiding the escape hatches (any, unchecked as casts, non-null !) that silently defeat it.

Writing idiomatic TypeScript

The point of TypeScript is to make illegal states unrepresentable and let the compiler catch mistakes. Idiomatic TS works with the type system instead of around it. Assume strict: true.

Model the domain in types

Discriminated unions for "one of N shapes" ({ kind: "ok"; value } | { kind: "err"; error }), then switch on the tag — the compiler checks exhaustiveness.
type aliases for unions/functions/mapped types; interface for object shapes that may be extended or merged. Be consistent.
Prefer union string literals (type Mode = "r" | "w") over enum.
Mark data readonly where it shouldn't mutate; use as const for literal tuples/objects.
Reach for utility types (Pick, Omit, Partial, Record, ReturnType) before restating shapes.

Stay sound

unknown, not any, at boundaries (JSON, catch) — then narrow with type guards.
Avoid as casts; when unavoidable, cast to the narrowest type and comment why. Never double-cast through unknown to silence an error.
Avoid the non-null assertion !; narrow instead (if (x == null) return).
Use satisfies to check a value against a type without widening it.
Type guards (x is T) and in/typeof/instanceof narrowing over manual casts.

Functions & async

Let inference do the work for locals; annotate parameters and public return types.
async/await over raw .then chains; never leave a promise unawaited (handle or void it).
Prefer immutable transforms (map/filter/reduce) over mutation when it reads clearly.

Anti-patterns to flag

any (especially implicit), unchecked as, !, @ts-ignore without a justification.
enum where a string-literal union would do; Function/Object/{} as types.
Optional-everything interfaces that don't reflect real invariants.

American English in identifiers and comments.