typescript-best-practices
Write idiomatic TypeScript patterns for clean, maintainable code. Use when writing or refactoring TypeScript classes, functions, modules, or async logic. (triggers: **/*.ts, **/*.tsx, class, function, module, import, export, async, promise)
80
76%
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 ./.agent/skills/typescript/typescript-best-practices/SKILL.mdQuality
Discovery
82%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a reasonably well-structured skill description with clear 'what' and 'when' clauses and good trigger term coverage for TypeScript files. Its main weakness is that the capability description is somewhat vague—'idiomatic TypeScript patterns' doesn't enumerate specific concrete actions—and the broad triggers like 'function' and 'class' could cause conflicts with other language skills.
Suggestions
Add more specific concrete actions, e.g., 'Define interfaces and type guards, use generics, structure modules with proper exports, handle async/await error patterns.'
Narrow generic triggers like 'function' and 'class' to reduce conflict risk with other language skills, or add qualifying context such as 'TypeScript class' or 'TypeScript function.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (TypeScript) and mentions 'idiomatic patterns' and 'clean, maintainable code,' but doesn't list specific concrete actions like 'create interfaces, define generics, implement type guards.' The actions are somewhat vague—'write idiomatic TypeScript patterns' is more of a general goal than a concrete capability list. | 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 explicit trigger terms listed. | 3 / 3 |
Trigger Term Quality | Includes a good set of natural trigger terms that users would actually use: file extensions (*.ts, *.tsx), and common TypeScript concepts (class, function, module, import, export, async, promise). These cover many natural ways a user might invoke TypeScript-related work. | 3 / 3 |
Distinctiveness Conflict Risk | While it targets TypeScript specifically, the broad scope of 'classes, functions, modules, async logic' could overlap with general coding skills, JavaScript skills, or framework-specific skills. The triggers like 'function', 'class', 'import', 'export' are very generic and could easily conflict with other language-specific skills. | 2 / 3 |
Total | 10 / 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.
The skill is well-structured and concise as a TypeScript conventions reference, with good progressive disclosure to a separate examples file. Its main weakness is the lack of inline code examples for the patterns it prescribes—the anti-patterns and guidelines are specific but would be much more actionable with even brief code snippets demonstrating the preferred approach vs. the anti-pattern.
Suggestions
Add 2-3 brief inline code examples for the most important patterns (e.g., exhaustiveness checking with `never`, async/await error handling with `unknown` narrowing, dependency injection via constructor)
Reduce excessive bold/backtick formatting which adds visual noise without improving clarity (e.g., '**`arrow functions`**' could just be 'arrow functions')
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Mostly efficient but the excessive bold formatting and some explanatory phrases ('to enable better refactoring/auto-imports', 'for testability') add minor verbosity. The content could be tighter, but it doesn't over-explain concepts Claude already knows. | 2 / 3 |
Actionability | Provides specific guidance (naming conventions, patterns to use/avoid) but lacks any executable code examples. For a TypeScript patterns skill, concrete code snippets showing the preferred patterns (e.g., exhaustiveness check with `never`, proper async/await error handling, DI pattern) would significantly improve actionability. | 2 / 3 |
Workflow Clarity | This is a style/convention skill rather than a multi-step workflow skill. The guidelines and anti-patterns are clearly organized and unambiguous as a single-purpose reference for writing TypeScript code. No destructive or batch operations require validation checkpoints. | 3 / 3 |
Progressive Disclosure | Clean structure with a concise overview in the main file and a single, clearly signaled reference to examples.md for detailed patterns (Immutable Interfaces, Exhaustiveness Checking, DI Patterns, etc.). One level deep, well-organized. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- HoangNguyen0403/agent-skills-standard
- Commit
19a1140
- 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.