CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

typescript-advanced-utility-types

TypeScript's built-in utility types and how to build custom ones — Partial/Required, Pick/Omit, Readonly/Record, Extract/Exclude, NonNullable/Awaited, ReturnType/Parameters/ConstructorParameters/InstanceType, key remapping with `as` in mapped types, and hand-rolled custom mapped types. Use when picking the right built-in utility type instead of hand-writing one, extracting a function's parameter or return type, filtering a union with Extract/Exclude, or remapping object keys.

Quality

83%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

71%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A well-structured reference skill: the body stays an overview, defers mechanics to sibling skills, routes all detail to 8 real, one-level-deep reference files, and enforces its guidance with concrete BAD/GOOD anti-patterns. Its main costs are duplicated trigger sections (When to Apply / Use When / When NOT to Use overlap) and the lack of any inline example for key remapping or custom mapped types, plus a validation command not yet tied into a sequence.

Suggestions

Merge the 'When to Apply' bullet list and 'Use When' quote list into one section (the bullets and quotes restate the same triggers), and fold 'When NOT to Use' into 'Out of Scope' instead of repeating the deep-readonly handoff twice.

Add one short inline example each for key remapping (`as` clause) and a custom mapped type, since these are the two tasks where users cannot yet judge from the body alone what the skill will produce.

Turn 'Quick Commands' into a step: 'after applying a transform, verify with `npx tsc --noEmit`' so the type-check acts as an explicit validation checkpoint in the workflow.

DimensionReasoningScore

Conciseness

The body avoids explaining concepts Claude already knows (it defers mapped-type mechanics to a sibling skill) and its code examples are tight, but the triggers are restated three times — "When to Apply" (8 bullets), "Use When" (4 quotes), plus the description — and "Out of Scope" repeats verbatim in "When NOT to Use" (deep-readonly named twice). This is the 3 anchor ("mostly efficient but includes some unnecessary explanation or could be tightened") rather than 2, since nothing is conceptually padded — the redundancy is structural duplication that could be merged.

3 / 5

Actionability

The three anti-patterns give executable BAD/GOOD TypeScript pairs (e.g., `type UserUpdate = Partial<User>` vs a hand-written interface), and the References table maps each need to a concrete file, but the body itself gives no inline example of the two tasks users most need shown — key remapping and custom mapped types are only pointed at. This fits the 4 anchor ("mostly executable guidance; concrete code or commands with minor gaps") rather than 5, since the common cases rely on navigation rather than inline copy-paste coverage.

4 / 5

Workflow Clarity

The decision path is clear: Mindset establishes built-in-first, combine-don't-invent rules; When to Apply lists triggers; and the References table routes each need to its file, with `npx tsc --noEmit` offered as verification. It sits at the 4 anchor rather than 5 because the validation command is presented as a loose "Quick Commands" item rather than an integrated step (e.g., "apply the transform, then type-check"), leaving a minor checkpoint gap; no destructive/batch cap applies since this is a non-destructive selection skill.

4 / 5

Progressive Disclosure

The body is a genuine overview: mindset, triggers, scope boundaries, anti-patterns, and a References table routing to all 8 bundle files — each of which exists in `references/` exactly as listed, is one level deep, and is labeled with what it covers. This matches the 5 anchor (clear overview with well-signaled one-level-deep references, content appropriately split, easy navigation).

5 / 5

Total

16

/

20

Passed

Description

88%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong description: it explicitly states both what it covers (an exhaustive enumeration of TypeScript's built-in utility types plus custom mapped types) and when to use it, in third person, with natural trigger phrasing and no padding. The only weaknesses are minor: a few common user phrasings (e.g., "make properties optional") are missing from the triggers, and the key-remapping clause slightly overlaps a sibling mapped-types skill without an explicit boundary in the description itself.

DimensionReasoningScore

Specificity

The description enumerates concrete, specific content exhaustively — "Partial/Required, Pick/Omit, Readonly/Record, Extract/Exclude, NonNullable/Awaited, ReturnType/Parameters/ConstructorParameters/InstanceType, key remapping with `as` in mapped types, and hand-rolled custom mapped types" — covering the full built-in utility surface plus custom construction. This is comprehensive coverage of multiple specific concrete items, matching the 5 anchor rather than the 4 anchor ("several specific actions; minor gaps"), since no built-in utility family is omitted.

5 / 5

Completeness

Both questions are explicitly and concretely answered: what — "TypeScript's built-in utility types and how to build custom ones" with a full enumeration — and when — "Use when picking the right built-in utility type..., extracting a function's parameter or return type, filtering a union with Extract/Exclude, or remapping object keys". This matches the 5 anchor (clear what AND when with concrete trigger phrases), not the 4 anchor where "when" could be more explicit.

5 / 5

Trigger Term Quality

The "Use when" clause gives natural trigger phrasings — "picking the right built-in utility type instead of hand-writing one, extracting a function's parameter or return type, filtering a union with Extract/Exclude, or remapping object keys" — and the what-clause names the exact type names users would mention. It falls just short of the 5 anchor (comprehensive synonyms/extensions) because common user phrasings like "make all properties optional", "read-only", or "subset of a type" are absent, but it clearly exceeds the 3 anchor ("some relevant keywords, missing common variations") since the utility names themselves are the natural vocabulary.

4 / 5

Distinctiveness Conflict Risk

The niche is clear (TypeScript's ready-made utility types) with distinctive triggers around Extract/Exclude and ReturnType/Parameters, but the clause "key remapping with `as` in mapped types" overlaps with a sibling type-system skill's mapped-type territory — the description itself does not demarcate that boundary (the body does). This fits the 4 anchor ("mostly distinct; minor overlap risk with closely related skills") rather than 5 ("minimal conflict risk"), while clearly exceeding the 3 anchor's broader overlap.

4 / 5

Total

18

/

20

Passed

Validation

93%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

CriteriaDescriptionResult

allowed_tools_field

'allowed-tools' contains unusual tool name(s)

Warning

Total

15

/

16

Passed

Repository

pantheon-org/tekhne

Path

skills/development/typescript-advanced/utility-types/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.