CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

typescript-advanced-practices

Type-first TypeScript coding practices — designing types before implementation, making illegal states unrepresentable with discriminated unions, runtime validation with Zod at system boundaries, and module organization (single-function modules, barrel files, encapsulation). Use when starting a new feature by asking what the types should look like first, spotting an interface with too many optional fields that let impossible combinations compile, or deciding how to validate data coming from outside the type system (an API response, form input, environment variables).

Quality

89%

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

80%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.

The body is a well-structured overview with highly actionable BAD/GOOD code examples and correctly wired one-level-deep references. Its weaknesses are redundant trigger sections (When to Apply vs Use When) and the absence of an explicit sequenced workflow with validation checkpoints — the design-first order and tsc --noEmit check exist but are never assembled into a numbered process.

Suggestions

Merge "When to Apply" and "Use When" into a single section — the two lists duplicate each other and the frontmatter description, costing tokens without adding information.

Add a short numbered workflow in the body (e.g., 1. draft the types, 2. model mutually exclusive states as a discriminated union, 3. validate at the boundary with Zod, 4. run `npx tsc --noEmit` before proceeding) so the practice order and its validation checkpoint are explicit rather than implied across sections.

Trim the Mindset paragraph's rationale sentences (e.g., "a type is a specification the compiler checks on every subsequent change") to one or two lines, keeping only the guidance Claude cannot infer on its own.

DimensionReasoningScore

Conciseness

The anti-pattern sections are tight (one-line WHYs, lean BAD/GOOD code) and nothing explains TypeScript basics, but "When to Apply" and "Use When" largely duplicate each other and the frontmatter description, and the Mindset paragraph re-explains design rationale ("a type is a specification the compiler checks") that could be trimmed. Efficient overall with minor instances of over-explanation — the 4 anchor.

4 / 5

Actionability

Three complete, executable BAD/GOOD TypeScript pairs cover the common cases (FetchState discriminated union, Zod `UserSchema.parse(await res.json())`, module encapsulation with `getConnection()`), plus copy-paste commands (`npx tsc --noEmit`, `npm install zod`). Fully executable, copy-paste-ready guidance — the 5 anchor.

5 / 5

Workflow Clarity

The type-first order is implied in Mindset ("Design the types before writing the implementation", "validate once there") and `npx tsc --noEmit` provides a validation checkpoint, but the body never sequences these into an explicit workflow with checkpoints — the actual workflow lives in references/type-first.md. This fits "sequence present but checkpoints missing or implicit" at 3; not 4 because no ordered steps with validation gates appear in the body itself.

3 / 5

Progressive Disclosure

The body is a well-organized overview (mindset, scope, anti-patterns, commands) with a References table mapping each topic to a real one-level-deep file (all four referenced files exist in references/), plus two well-chosen external links. Content is appropriately split between inline overview examples and detail files — the 5 anchor.

5 / 5

Total

17

/

20

Passed

Description

96%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: concrete actions covering all sub-topics, explicit 'Use when' triggers phrased as natural user scenarios, and third-person voice. The only weakness is that its breadth across four practices creates minor overlap risk with sibling TypeScript and general validation/organization skills.

DimensionReasoningScore

Specificity

The description lists multiple concrete actions covering the skill's full surface: "designing types before implementation, making illegal states unrepresentable with discriminated unions, runtime validation with Zod at system boundaries, and module organization (single-function modules, barrel files, encapsulation)". Each action is specific and concrete, matching the comprehensive-coverage anchor rather than the minor-gaps anchor at 4.

5 / 5

Completeness

Both what and when are explicit: the opening sentence enumerates what the skill does, and "Use when starting a new feature by asking what the types should look like first, spotting an interface with too many optional fields..., or deciding how to validate data coming from outside the type system" gives concrete trigger phrases — the exact pattern of the 5 anchor.

5 / 5

Trigger Term Quality

Triggers are natural phrases users would actually say: "starting a new feature", "asking what the types should look like first", "interface with too many optional fields", "an API response, form input, environment variables", plus concrete technical terms (Zod, discriminated unions, barrel files). Scenario-based phrasing covers the variations users would naturally express, fitting the comprehensive anchor.

5 / 5

Distinctiveness Conflict Risk

The type-first design niche has distinct scenario triggers, but the description spans four sub-topics (discriminated unions, Zod validation, module organization) that carry minor overlap risk with closely related skills — e.g., a general validation/schema skill or a general module-organization skill. It fits the "mostly distinct; minor overlap risk with closely related skills" anchor better than the minimal-conflict anchor at 5.

4 / 5

Total

19

/

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/practices/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.