Best Claude Code Skills for TypeScript [2026]

We installed 12 TypeScript skills from the SkillSafe registry, read every file, and scored each out of 50. Five made the list: typescript-magician (45), openapi-to-typescript (41), typescript-advanced-types (40), tsdown (39) and deno-typescript (33). Seven were cut, including one with 5,500 installs and seven critical reverse-shell findings.

Updated September 2026: scores and archive contents are unchanged since the April review, and the guidance still holds. The reason one skill with 5,500 installs was excluded — seven critical reverse-shell findings — is also the argument for scanning before install rather than trusting an install count.

Most of the 12 were disappointing. Two “TypeScript expert” skills turned out to describe stock ticker data pipelines. Matt Pocock’s skill was a generic refactoring planner with no TypeScript-specific content at all. What survived: two deep type-system references, a spec-to-types workflow tool, a library bundler and a Deno guide.

The Five Skills, Scored

Skill	Score	Key Feature	Libraries / Tools	Installs
@mcollina/typescript-magician	45/50	14 dedicated rule files	TypeScript, Node.js, tsc, strict mode	7,221
@softaworks/openapi-to-typescript	41/50	Spec-to-types workflow	OpenAPI 3.0, Zod, type guards	8,883
@wshobson/typescript-advanced-types	40/50	6 advanced patterns with full implementations	TypeScript generics, Zod, builder pattern	1,367
@antfu/tsdown	39/50	42-file reference archive	tsdown, Rolldown, DTS, monorepo tooling	3,936
@mindrally/deno-typescript	33/50	Deno-native TypeScript guide	Deno, Fresh, Oak, Deno KV	7,380

Figure: the five TypeScript skills that made the list, out of 12 installed and read in full.

Browse the full TypeScript catalog: /tags/typescript/

How We Scored

Each skill was scored out of 50 across five dimensions:

Dimension	Max	What we looked at
Relevance	10	Does it specifically address TypeScript concerns (types, generics, DX patterns)?
Depth	10	How much actual content? Specific patterns, type examples, not vague directives.
Actionability	10	Can a developer follow the guidance and improve their TypeScript code?
Structure	10	Is the skill well-organized with clear file layout and workflows?
Adoption	10	Install count and stars as a proxy for real-world validation.

Skills that were generic coding advice rebranded as “TypeScript” scored low on Relevance. Skills with critical security findings were excluded entirely, regardless of content quality — one of them had 5,500 installs and promising documentation, and still earned an F grade from the SkillSafe scanner for seven critical reverse-shell patterns in its shell scripts.

Figure: install count is not a quality signal. The skill excluded on security had 5,500 installs — more than two of the five we recommend.

1. @mcollina/typescript-magician — 45/50

Score: 45/50 | Relevance: 10 · Depth: 9 · Actionability: 9 · Structure: 10 · Adoption: 7

This is the best TypeScript type system skill in the registry. The archive ships 16 files totaling 4,304 lines: a hub SKILL.md (117 lines) plus 14 dedicated rule files in a rules/ directory. Each rule is a self-contained deep dive into one TypeScript type pattern, averaging 280 lines per file with before/after code examples, comparison tables, and “common pitfalls” sections.

Archive structure:

SKILL.md                            <- hub file with workflow + quick examples
rules/
  array-index-access.md    (164 lines)
  as-const-typeof.md       (174 lines)
  builder-pattern.md       (349 lines)
  conditional-types.md     (292 lines)
  deep-inference.md        (320 lines)
  error-diagnosis.md       (339 lines)
  function-overloads.md    (290 lines)
  generics-basics.md       (279 lines)
  infer-keyword.md         (288 lines)
  mapped-types.md          (398 lines)
  opaque-types.md          (272 lines)
  template-literal-types.md (304 lines)
  type-narrowing.md        (429 lines)
  utility-types.md         (289 lines)

The hub file defines a clear workflow: run tsc --noEmit first, identify the root cause, craft a fix, then verify with a second tsc --noEmit pass. The quick examples show concrete before/after transformations — replacing any with generics, narrowing unknown API responses with type guards. The rule files then go deep. The opaque-types.md file, for instance, doesn’t just explain branded types — it covers type predicates vs. assertion functions (including the gotcha that assertion functions must use the function keyword, not arrow syntax), factory functions for validated construction, and the unique symbol branding alternative. The error-diagnosis.md file teaches strategies for reading complex TypeScript error messages, which is exactly the kind of thing an AI agent needs to handle well.

The rule files map closely onto the TypeScript handbook’s own chapter structure — mapped types, narrowing, conditional types — but each one adds the part the handbook deliberately leaves out: when an agent should reach for the pattern and what it should write instead when the pattern is wrong.

What makes this skill stand out is the modular structure. An agent can load mapped-types.md when it encounters a mapped type problem and builder-pattern.md when it’s implementing a fluent API. It doesn’t have to parse 700 lines of monolith to find the relevant section.

npx skills add https://api.skillsafe.ai/mcollina/typescript-magician

2. @softaworks/openapi-to-typescript — 41/50

Score: 41/50 | Relevance: 8 · Depth: 8 · Actionability: 9 · Structure: 8 · Adoption: 8

This is a workflow skill, not a reference skill. It teaches an AI agent to convert OpenAPI 3.0 specifications into TypeScript interfaces and type guards, step by step. The archive has two files: a SKILL.md (344 lines) and a README.md. The SKILL.md is the entire skill — it’s a complete code generation specification.

The workflow is explicit: (1) read the OpenAPI file, (2) validate it’s 3.0.x, (3) extract schemas from components/schemas, (4) extract endpoints from paths, (5) generate TypeScript with interfaces and type guards, (6) write the output file. The skill includes a complete type mapping table (OpenAPI primitives to TypeScript types, format modifiers like uuid/date-time to annotated strings), rules for handling $ref resolution, oneOf unions, allOf intersections, and enum string literals.

The strongest part is the type guard generation spec. For each interface, the skill instructs the agent to generate a runtime type guard function that checks typeof value === 'object' && value !== null, then verifies each required field with 'field' in value and type checks with typeof. It even handles arrays (Array.isArray()) and enums (.includes()). The output follows a consistent section structure: file header with generation timestamp, interfaces, request/response types, type guards, and an ApiError type that’s always included.

Hand-written guards are the right default here, but they are not the only option: Zod infers the static type from a runtime schema, which collapses the two artifacts into one. The skill does not cover that trade-off, which is the main thing a reviewer should add when the agent finishes.

The naming convention is well-defined: {Method}{Path}Request for params/body, {Method}{Path}Response for responses. The skill also specifies a complete input-to-output example (a User schema with roles enum producing a full TypeScript file), which gives agents something concrete to pattern-match against. At 8,883 installs, this is one of the most-installed TypeScript-specific skills in the registry.

npx skills add https://api.skillsafe.ai/softaworks/openapi-to-typescript

3. @wshobson/typescript-advanced-types — 40/50

Score: 40/50 | Relevance: 10 · Depth: 9 · Actionability: 9 · Structure: 7 · Adoption: 5

This is the single-file counterpart to typescript-magician. At 717 lines in one SKILL.md, it covers every major TypeScript type system feature: generics (with constraints and multiple type parameters), conditional types (distributive, nested, with infer), mapped types (key remapping, property filtering), template literal types (with path building), utility types, type guards, assertion functions, and type testing patterns. It then provides six complete advanced pattern implementations.

Conditional types are the engine under most of those patterns, and the handbook’s own definition is worth keeping in view while reading the skill:

Conditional types help describe the relation between the types of inputs and outputs. […] Conditional types provide us with a way to infer from types we compare against in the true branch using the infer keyword.

— TypeScript handbook, Conditional Types

The patterns are what set this skill apart from documentation restatements. Pattern 2, the type-safe API client, builds a complete generic APIClient<Config> class where the type system enforces that request("/users", "POST", { body: ... }) requires a body matching the EndpointConfig definition, while request("/users", "GET") requires no options at all. The conditional rest parameter trick using ExtractParams and ExtractBody is advanced enough that most AI agents would not generate it unprompted. Pattern 3 implements a builder where build() is only callable when all required fields have been set — using IsComplete<T, S> to conditionally type this as never when fields are missing.

The skill also covers type testing (AssertEqual<T, U> using bidirectional extends checks) and closes with seven common pitfalls and performance considerations for recursive types. The main weakness is structure: 717 lines in a single file means an agent has to process everything at once. At 1,367 installs and 9 stars, adoption is lower than the other top picks, but the star-to-install ratio is actually the highest in this roundup, suggesting that people who use it actively endorse it.

npx skills add https://api.skillsafe.ai/wshobson/typescript-advanced-types

4. @antfu/tsdown — 39/50

Score: 39/50 | Relevance: 5 · Depth: 9 · Actionability: 8 · Structure: 10 · Adoption: 7

This is not a TypeScript language skill — it’s a TypeScript library bundling skill, and it’s the most thoroughly documented tool skill in the registry. The archive ships 42 files totaling over 400 lines in the hub SKILL.md alone, with 36 reference files in a references/ directory covering every configuration option, framework recipe, and advanced feature of the tsdown bundler (powered by Rolldown and Oxc).

Archive structure:

SKILL.md                              <- hub with quick start, option tables, common patterns
references/
  guide-getting-started.md
  guide-introduction.md
  guide-migrate-from-tsup.md
  option-cjs-default.md
  option-cleaning.md
  option-config-file.md
  option-css.md
  option-dependencies.md
  option-dts.md                        <- DTS generation details
  option-entry.md
  option-output-format.md
  option-package-exports.md
  option-platform.md
  option-sourcemap.md
  option-target.md
  option-tree-shaking.md
  option-unbundle.md
  recipe-react.md
  recipe-vue.md
  recipe-solid.md
  recipe-svelte.md
  recipe-wasm.md
  reference-cli.md
  ... (36 files total)

The hub file is organized into four table sections: Core References, Build Options, Dependency Handling, and Output Enhancement. Each links to a dedicated reference file. The common patterns section covers eight real configurations: basic library bundle, multiple entry points, browser library (IIFE/UMD), React component library with externalized React, preserved directory structure (unbundle mode), CI-aware builds with publint/attw validation, WASM support, and standalone executables. The dependency handling section is particularly useful — it explains the neverBundle, alwaysBundle, onlyBundle, and skipNodeModulesBundle options that trip up most library authors.

If you ship TypeScript packages to npm, this skill fills a gap that no type-system skill covers. It scores lower on Relevance because it’s about tooling rather than the TypeScript language itself, but for library authors, it’s indispensable. Note: the security scanner flagged one critical finding in references/advanced-plugins.md (a netcat pattern in an example), giving it a C security grade. The content itself is a documentation reference, not executable code — which is exactly the case where a human reads the finding and decides, rather than the registry deciding for them.

npx skills add https://api.skillsafe.ai/antfu/tsdown

5. @mindrally/deno-typescript — 33/50

Score: 33/50 | Relevance: 6 · Depth: 6 · Actionability: 7 · Structure: 7 · Adoption: 7

This is the best Deno-specific TypeScript skill in the registry, and it earns its spot for developers working outside the Node.js ecosystem. The archive is a single SKILL.md (335 lines) covering TypeScript guidelines, Deno-specific conventions, the security model, HTTP server patterns, Fresh framework integration, Deno KV, built-in testing, and deno.json configuration.

The TypeScript guidelines section is concise but correct: prefer interface for object shapes, avoid enums in favor of as const, use Zod for runtime validation with inferred types, use readonly for immutable properties. The naming conventions section specifies PascalCase for types, camelCase for variables, kebab-case for files, and descriptive boolean names (isLoading, hasError). These are standard recommendations, but having them explicitly stated means an AI agent generating Deno code will follow a consistent style.

The Deno-specific sections are where this skill adds value that agents wouldn’t have on their own. The permission model is the one an agent gets wrong most often, and Deno’s own documentation states the rule the skill encodes:

Deno is secure by default. Unless you specifically enable it, a program run with Deno has no access to sensitive APIs, such as file system access, network connectivity, or environment access.

— Deno docs, Security and permissions

The skill lists the exact flags (--allow-net=example.com, --allow-read=./path) and shows programmatic permission requests, which matters because the scoped form is what keeps a generated script from asking for blanket access. The project structure section defines a convention (src/routes/{resource}/, src/middleware/, src/services/, deps.ts). The testing section uses Deno’s built-in BDD runner with describe/it from std/testing/bdd.ts, which is different from the Jest/Vitest patterns most agents default to.

The main weakness is depth. At 335 lines in a single file, it covers a lot of surface area without going deep on any topic. There are no advanced type patterns, no discussion of Deno-specific type quirks, and no error handling for complex async scenarios. The 7,380 install count reflects broad appeal from the mindrally “240+ skills” collection rather than targeted TypeScript adoption.

npx skills add https://api.skillsafe.ai/mindrally/deno-typescript

Frequently Asked Questions

What makes a good AI TypeScript skill?

Specificity. The best skills teach AI agents things they wouldn’t know from their training data: exact type patterns with before/after examples, workflow steps for code generation, and rules that prevent common mistakes. A skill that says “use generics for type safety” is useless. A skill that shows how to constrain a builder pattern so build() only compiles when all required fields are set — as @wshobson/typescript-advanced-types does with IsComplete<T, S> — is genuinely useful.

Which TypeScript skill should I install first?

@mcollina/typescript-magician, at 45/50. Its 14 rule files cover the type-system territory an agent gets wrong most often — mapped types, narrowing, infer, opaque types — and the modular layout means the agent loads one 280-line file rather than a 700-line monolith. Add @softaworks/openapi-to-typescript if you consume OpenAPI specs, and @antfu/tsdown only if you publish packages to npm.

Can an AI skill be a security risk?

Yes, and one of the 12 we screened was. A skill is loaded into an agent that can read files, run shell commands and reach the network, so a skill’s instructions inherit those capabilities. The skill we excluded had 5,500 installs and seven critical reverse-shell findings in its bundled scripts. Run a repository through the SkillSafe scanner before you install it, and prefer skills with a stored tree hash so tampering is detectable.

Do these skills work with Claude Code, Cursor, and Windsurf?

Yes. All five install with the npx skills add command and create symlinks for both Claude Code (.claude/skills/) and Cursor (.cursor/skills/). Windsurf supports the same Markdown skill format. The skills are plain Markdown files with no tool-specific dependencies.

How were these skills scored?

We installed each skill, read every file in the archive, counted lines, examined directory structure, and evaluated the content against five dimensions: Relevance (TypeScript-specific vs. generic), Depth (specificity of patterns and examples), Actionability (can you follow the guidance), Structure (file organization and navigability), and Adoption (installs and stars). Maximum score is 50. Skills with critical security findings were excluded regardless of content quality.

Conclusion

For pure TypeScript type system work, install @mcollina/typescript-magician. Its 14-file rule library is the most comprehensive type reference in the registry, and the modular structure means your AI agent loads only the pattern it needs.

npx skills add https://api.skillsafe.ai/mcollina/typescript-magician
npx skills add https://api.skillsafe.ai/softaworks/openapi-to-typescript
npx skills add https://api.skillsafe.ai/wshobson/typescript-advanced-types

If you build TypeScript libraries for npm, add @antfu/tsdown for bundling configuration. If you’re working in Deno, add @mindrally/deno-typescript. And if you work with OpenAPI specs, @softaworks/openapi-to-typescript will save you from writing type guards by hand.

Scan anything before you install it — the SkillSafe scanner takes a repository URL and returns a severity-rated report, and dual-side verification re-checks the archive on download. For the framework layer these pair with, see the React roundup; for the review step, the code review roundup.

Related roundups: Browse all Best Of roundups