ts-implement

Enforce TypeScript implementation best practices and coding standards.

1|1|Updated Nov 1, 2015
One-click install
npx skills add https://github.com/s4kr4/dotfiles --skill ts-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ts-implement
Source: https://github.com/s4kr4/dotfiles/tree/main/.claude/skills/ts-implement
Command: npx skills add https://github.com/s4kr4/dotfiles --skill ts-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, guideline-driven approach to implementing TypeScript code with strong type safety, consistent style, and maintainable patterns, reducing runtime errors and improving collaboration.

Core Features & Use Cases

  • Explicit typing: Enforces explicit parameter and return types, avoiding any.
  • Pattern guidance: Covers interfaces, generics, utility types, error handling, and async patterns.
  • Quality focus: Emphasizes SRP, modular organization, and modern JavaScript features for maintainable code.
  • Use Case: A team standardizes new TS modules so developers can quickly scaffold robust components with minimal boilerplate.

Quick Start

Generate a small TypeScript module that follows the guidelines described in this skill.

Frequently Asked Questions about ts-implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce explicit typing and avoid the any type in TypeScript?

Explicit typing in TypeScript means declaring parameter and return types for all functions and variables. This Skill automates enforcement of strict typing rules, eliminating any and catching type mismatches at compile time rather than runtime, improving code reliability and IDE support.

What TypeScript patterns should I follow for error handling and async/await?

TypeScript best practices for error handling include typed try-catch blocks, discriminated unions for error states, and proper async/await patterns with return type annotations. This Skill provides concrete pattern examples and guides async code that maintains type safety throughout the promise chain.

How can I standardize TypeScript code across my team with consistent patterns?

Standardizing TypeScript involves establishing guidelines for interfaces, generics, utility types, and modular organization that all developers follow. This Skill automates adherence to these standards, enabling teams to scaffold new modules quickly while maintaining consistent style and reducing code review friction.

Why should I use generics and utility types instead of loose typing?

Generics and utility types provide reusable, type-safe abstractions that scale across components without sacrificing specificity. This Skill emphasizes these features to reduce boilerplate, improve maintainability, and catch bugs early by encoding business logic into the type system itself.

Can I apply these TypeScript best practices to existing projects?

Yes. This Skill applies to TypeScript modules, type definitions, and patterns within existing projects. You can adopt its guidelines incrementally—starting with new components or during refactoring—without requiring a complete rewrite of your codebase.

What's the difference between this structured approach and writing TypeScript without formal patterns?

Unstructured TypeScript often leads to inconsistent typing, runtime errors, and maintenance overhead. This Skill's guideline-driven approach enforces single responsibility, modular organization, and explicit typing, reducing bugs and making code easier for teams to understand and extend.