typescript-strict
Strict TypeScript rules. Use when writing ANY TypeScript.
Best use case
typescript-strict is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. Strict TypeScript rules. Use when writing ANY TypeScript.
Strict TypeScript rules. Use when writing ANY TypeScript.
Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.
Practical example
Example input
Use the "typescript-strict" skill to help with this workflow task. Context: Strict TypeScript rules. Use when writing ANY TypeScript.
Example output
A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.
When to use this skill
- Use this skill when you want a reusable workflow rather than writing the same prompt again and again.
When not to use this skill
- Do not use this when you only need a one-off answer and do not need a reusable workflow.
- Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/typescript-strict/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How typescript-strict Compares
| Feature / Agent | typescript-strict | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Strict TypeScript rules. Use when writing ANY TypeScript.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Strict TypeScript Standards
## Rules
### 1. NO `any`
```typescript
// NEVER
function process(data: any) {}
// CORRECT
function process(data: unknown) {
if (isValidData(data)) { /* use data */ }
}
```
### 2. Explicit Returns
```typescript
// NEVER
function getUser(id: string) { return db.find(id); }
// CORRECT
function getUser(id: string): Promise<User | null> { return db.find(id); }
```
### 3. Typed Errors
```typescript
// NEVER
catch (e) { console.log(e.message); }
// CORRECT
catch (error: unknown) {
if (error instanceof AppError) { logger.error(error.message); }
else if (error instanceof Error) { logger.error(error.message); }
else { logger.error('Unknown error', { error }); }
}
```
### 4. No Unexplained Assertions
```typescript
// NEVER
const user = users.find(u => u.id === id)!;
// CORRECT
const user = users.find(u => u.id === id);
if (!user) throw new NotFoundError(`User ${id} not found`);
```
### 5. Prefer Type Inference Where Obvious
```typescript
// Unnecessary - type is inferred
const count: number = 5;
// Good - type is inferred
const count = 5;
// Good - explicit for function signatures
function add(a: number, b: number): number {
return a + b;
}
```
### 6. Use Discriminated Unions
```typescript
// CORRECT
type Result<T> =
| { success: true; data: T }
| { success: false; error: string };
function handle(result: Result<User>) {
if (result.success) {
// TypeScript knows result.data exists
console.log(result.data.name);
} else {
// TypeScript knows result.error exists
console.log(result.error);
}
}
```
## Quick Reference
| Pattern | Status |
|---------|--------|
| `any` | NEVER |
| Implicit return | NEVER |
| `!` without comment | NEVER |
| `// @ts-ignore` | NEVER |
| `as` casting | MINIMIZE |
| `unknown` + guards | PREFERRED |Related Skills
openapi-to-typescript
Converts OpenAPI 3.0 JSON/YAML to TypeScript interfaces and type guards. This skill should be used when the user asks to generate types from OpenAPI, convert schema to TS, create API interfaces, or generate TypeScript types from an API specification.
typescript-pro
Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns. Use PROACTIVELY for TypeScript architecture, type inference optimization, or advanced typing patterns.
typescript-expert
TypeScript and JavaScript expert with deep knowledge of type-level programming, performance optimization, monorepo management, migration strategies, and modern tooling. Use PROACTIVELY for any TypeScript/JavaScript issues including complex type gymnastics, build performance, debugging, and architectural decisions. If a specialized expert is a better fit, I will recommend switching and stop.
typescript-advanced-types
Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.
javascript-typescript-typescript-scaffold
You are a TypeScript project architecture expert specializing in scaffolding production-ready Node.js and frontend applications. Generate complete project structures with modern tooling (pnpm, Vite, N
dbos-typescript
DBOS TypeScript SDK for building reliable, fault-tolerant applications with durable workflows. Use this skill when writing TypeScript code with DBOS, creating workflows and steps, using queues, using DBOSClient from external applications, or building applications that need to be resilient to failures.
typescript-write
Write TypeScript and JavaScript code following Metabase coding standards and best practices. Use when developing or refactoring TypeScript/JavaScript code.
typescript-review
Review TypeScript and JavaScript code changes for compliance with Metabase coding standards, style violations, and code quality issues. Use when reviewing pull requests or diffs containing TypeScript/JavaScript code.
tdd-vitest-typescript
Test-Driven Development (TDD) using Vitest and TypeScript. Use when the user requests help with TDD, writing tests before code, test-first development, Vitest test setup, TypeScript testing patterns, unit testing, integration testing, or following the Red-Green-Refactor cycle with Vitest.
typescript-node-expert
Expert TypeScript/Node.js developer for building high-quality, performant, and maintainable CLI tools and libraries. Enforces best practices, strict typing, and modern patterns.
typescript-dev
TypeScript development best practices, code quality tools, and documentation templates. Activated when working with .ts, .tsx files or TypeScript projects.
typescript-strict-guard
Use when writing or reviewing TypeScript code. Enforces strict mode standards, explicit typing, and best practices. Prevents 'any' types, @ts-ignore comments, and non-null assertions. This is a COMPREHENSIVE skill - consult the detailed guides before writing any TypeScript code.