typescript-best-practices
Write idiomatic TypeScript patterns for clean, maintainable code. Use when writing or refactoring TypeScript classes, functions, modules, or async logic.
73
68%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./.github/skills/typescript/typescript-best-practices/SKILL.mdQuality
Discovery
67%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description has good structural completeness with an explicit 'Use when...' clause and clearly identifies the TypeScript domain. However, it lacks specificity in the concrete actions it performs (what specific patterns or transformations?) and could include more natural trigger terms that users would use when seeking TypeScript help. The description is functional but could be more distinctive and detailed.
Suggestions
Add specific concrete actions like 'implement type-safe interfaces, use generics, apply discriminated unions, structure error handling with Result types' to improve specificity.
Expand trigger terms to include common variations like 'types', 'interfaces', 'generics', 'type safety', '.ts files', 'TS', 'type annotations', 'type guards'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (TypeScript) and mentions some actions ('writing or refactoring'), but 'idiomatic patterns for clean, maintainable code' is somewhat vague. It doesn't list specific concrete actions like 'create type-safe interfaces, implement generics, configure strict compiler options'. | 2 / 3 |
Completeness | Clearly answers both 'what' (write idiomatic TypeScript patterns for clean, maintainable code) and 'when' (Use when writing or refactoring TypeScript classes, functions, modules, or async logic) with an explicit 'Use when...' clause. | 3 / 3 |
Trigger Term Quality | Includes relevant keywords like 'TypeScript', 'classes', 'functions', 'modules', 'async logic', 'refactoring', which users might naturally say. However, it misses common variations like 'types', 'interfaces', 'generics', 'type safety', '.ts files', or 'TS'. | 2 / 3 |
Distinctiveness Conflict Risk | The TypeScript focus provides some distinctiveness, but 'writing or refactoring classes, functions, modules' is broad enough to overlap with general coding skills or JavaScript-specific skills. The 'idiomatic patterns' framing helps somewhat but could still conflict with general code quality or style guide skills. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
70%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured TypeScript conventions skill that is concise and well-organized with appropriate progressive disclosure to a references file. Its main weakness is the lack of any inline code examples—for a skill about TypeScript patterns, at least a few small executable snippets (e.g., exhaustiveness check with `never`, proper async/await error handling) would make the guidance significantly more actionable. The anti-patterns section is effective as a quick-reference checklist.
Suggestions
Add 2-3 small, executable TypeScript code snippets for the most important patterns (e.g., exhaustiveness checking with `never`, async/await error handling with `unknown` narrowing, dependency injection with constructor injection).
Remove minor explanatory phrases that Claude already knows (e.g., 'to enable better refactoring/auto-imports', 'for testability') to improve conciseness.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Mostly efficient but the excessive bold formatting and some explanatory phrases like 'to enable better refactoring/auto-imports' and 'for testability' add minor verbosity. The content could be tightened, but it doesn't over-explain concepts Claude already knows. | 2 / 3 |
Actionability | Provides specific, concrete guidance (naming conventions, specific tools like Zod, specific patterns like constructor injection) but lacks any executable code examples. For a TypeScript patterns skill, at least one or two concrete code snippets showing the preferred patterns would significantly improve actionability. | 2 / 3 |
Workflow Clarity | This is a single-purpose reference skill for coding conventions, not a multi-step workflow. The guidelines and anti-patterns are clearly organized and unambiguous, making the single task (writing idiomatic TypeScript) clear. | 3 / 3 |
Progressive Disclosure | The skill provides a concise overview with a clear, well-signaled one-level-deep reference to examples.md for detailed patterns like DI, exhaustiveness checking, and assertion functions. Content is appropriately split between overview and detailed examples. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_version | 'metadata.version' is missing | Warning |
metadata_field | 'metadata' should map string keys to string values | Warning |
Total | 9 / 11 Passed | |
- Repository
- HoangNguyen0403/agent-skills-standard
- Commit
4c72e76
- 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.