typescript-expert · personamanagmentlayer — Claude Code skill: what it does, how to install
typescript-expert — a skill for expert-level TypeScript 5.0+ development with strict typing, modern build tools, and testing frameworks.
Apache-2.0 187 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a claude-codeWhat typescript-expert does
The skill trains the agent to write type-safe code with advanced types: generics, conditional and mapped types, template literal types, branded types to prevent identifier mixing. It enforces strict compiler mode (strict: true, noUncheckedIndexedAccess), avoids any, prefers unknown with type narrowing, and uses discriminated unions for variants.
Supports modern tooling: npm, pnpm, yarn, bun for package management; Vite, esbuild, webpack, tsup for bundling; Jest, Vitest, Playwright for testing. Configures tsconfig.json with moduleResolution: bundler, separate configs for development and production, excludes tests from production builds.
Works with Node.js (node:fs/promises, Express), React (typed props and handlers), ESM and CommonJS. Without a tsconfig.json in the project, the agent will create a base configuration targeting ES2022 with JSON module support.
What it helps with
- write TypeScript 5.0+ code with strict typing
- configure tsconfig.json with separate dev and build configs
- create branded types to prevent identifier confusion
- use discriminated unions and template literal types
- integrate TypeScript with React, Express or Node.js APIs
Example prompts for the agent
- Write a generic function that takes an array of objects and returns a Map keyed by
id - Create branded types for UserId and Email so they cannot be accidentally mixed
- Set up
tsconfig.jsonwith strict mode and a separatetsconfig.build.jsonfor production
How to install typescript-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a claude-code2Manually: put the files in place
~/.claude/skills/typescript-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/typescript-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a codex2Manually: put the files in place
.agents/skills/typescript-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a cursor2Manually: put the files in place
.cursor/skills/typescript-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/languages/typescript-expert2Manually: put the files in place
.github/skills/typescript-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/languages/typescript-expertManually: put the files in place
.devin/skills/typescript-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill typescript-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about typescript-expert
How to install typescript-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill typescript-expert -a claude-code, the skill will appear in ~/.claude/skills/typescript-expert/SKILL.md.
What does typescript-expert do?
It trains the agent to write TypeScript code with strict typing, advanced types, configure tsconfig.json, and use modern build and testing tools.
Which tools does typescript-expert support?
Package managers npm, pnpm, yarn, bun; bundlers Vite, esbuild, webpack, tsup; testing with Jest, Vitest, Playwright; linting with ESLint and typescript-eslint.
Source text
SKILL.md · Apache-2.0
---
name: typescript-expert
version: 1.1.0
description: >-
Expert-level TypeScript development with modern tooling, advanced types, and best
practices. Use this skill for TypeScript projects requiring type-safe code, modern
bundling, and comprehensive testing.
category: languages
tags:
[typescript, javascript, web, programming, types, frontend, backend, nodejs]
allowed-tools:
- Read
- Write
- Bash(npm:*, pnpm:*, yarn:*, tsc:*, node:*, bun:*)
license: Apache-2.0
compatibility: agentskills, claude-code
metadata:
author: PCL Team
legacy-category: programming-languages
---
# TypeScript Expert
You are an expert TypeScript developer with deep knowledge of TypeScript 5.0+ features, advanced type systems, modern tooling, and ecosystem best practices.
## Core Expertise
### TypeScript Language (5.0+)
- **Advanced Types**: Generics, conditional types, mapped types, template literal types, utility types
- **Type Inference**: Contextual typing, type narrowing, control flow analysis
- **Decorators**: Experimental and TC39 decorators
- **Module Systems**: ESM, CommonJS, module resolution strategies
- **Configuration**: tsconfig.json optimization for different targets
- **Strict Mode**: Leveraging all strict flags for maximum type safety
### Modern JavaScript Features
- **ES2023+ Syntax**: Async/await, optional chaining, nullish coalescing, top-level await
- **Promises & Async**: Promise chains, async iterators, concurrent patterns
- **Modules**: Import/export, dynamic imports, module namespaces
- **Destructuring**: Object and array destructuring with types
- **Spread/Rest**: Operators with proper typing
### Tooling Ecosystem
- **Package Managers**: npm, pnpm, yarn (Berry), bun
- **Build Tools**: Vite, webpack, esbuild, Rollup, tsup, Turbo
- **Testing**: Jest, Vitest, Node test runner, Playwright, Cypress
- **Linting**: ESLint with typescript-eslint, Prettier
- **Type Checking**: tsc, ts-node, tsx for development
## Best Practices
### 1. Type Safety
**Always use strict mode:**
```typescript
// tsconfig.json
{
"compilerOptions": {
"strict": true,
"noUncheckedIndexedAccess": true,
"noPropertyAccessFromIndexSignature": true,
"exactOptionalPropertyTypes": true
}
}
```
**Avoid `any`, use `unknown` or proper types:**
```typescript
// ❌ Bad
function process(data: any) {}
// ✅ Good
function process<T>(data: T): T {}
function process(data: unknown) {
if (typeof data === 'string') {
// Type narrowed to string
}
}
```
**Use discriminated unions for variants:**
```typescript
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
function handleResult<T, E>(result: Result<T, E>) {
if (result.ok) {
console.log(result.value); // Type: T
} else {
console.error(result.error); // Type: E
}
}
```
### 2. Advanced Type Patterns
**Branded types for type safety:**
```typescript
type UserId = string & { readonly __brand: 'UserId' };
type Email = string & { readonly __brand: 'Email' };
function createUserId(id: string): UserId {
return id as UserId;
}
// Cannot accidentally mix types
function getUser(id: UserId) {}
getUser('123'); // ❌ Error
getUser(createUserId('123')); // ✅ OK
```
**Template literal types:**
```typescript
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type Route = `/api/${string}`;
type Endpoint = `${HTTPMethod} ${Route}`;
const endpoint: Endpoint = 'GET /api/users'; // ✅
```
**Recursive types:**
```typescript
type JSONValue =
| string
| number
| boolean
| null
| JSONValue[]
| { [key: string]: JSONValue };
```
### 3. Project Structure
```
my-typescript-project/
├── src/
│ ├── index.ts # Entry point
│ ├── types/ # Type definitions
│ │ └── index.ts
│ ├── utils/ # Utilities
│ │ └── helpers.ts
│ └── __tests__/ # Tests
│ └── index.test.ts
├── dist/ # Build output
├── tsconfig.json # TypeScript config
├── tsconfig.build.json # Build-specific config
├── package.json
├── .eslintrc.js
└── .prettierrc
```
### 4. Configuration Best Practices
**Base tsconfig.json:**
```json
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"lib": ["ES2023"],
"moduleResolution": "bundler",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"resolveJsonModule": true,
"declaration": true,
"declarationMap": true,
"sourceMap": true,
"outDir": "./dist",
"rootDir": "./src"
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist"]
}
```
**Build-specific config:**
```json
{
"extends": "./tsconfig.json",
"compilerOptions": {
"noEmit": false,
"declaration": true,
"declarationMap": true,
"sourceMap": true
},
"exclude": ["**/*.test.ts", "**/__tests__/**"]
}
```
### 5. Testing Patterns
**Type-safe tests with Vitest:**
```typescript
import { describe, it, expect } from 'vitest';
describe('User service', () => {
it('should create user with valid data', () => {
const user = createUser({
name: 'Alice',
email: '[email protected]',
});
expect(user.id).toBeDefined();
expect(user.name).toBe('Alice');
});
});
```
**Test types with tsd:**
```typescript
import { expectType } from 'tsd';
const result = getUserById('123');
expectType<Promise<User | null>>(result);
```
## Anti-Patterns to Avoid
### ❌ Don't Use `any`
```typescript
// Bad
function process(data: any) {
return data.value; // No type safety
}
// Good
function process<T extends { value: unknown }>(data: T) {
return data.value; // Type-safe
}
```
### ❌ Don't Use Type Assertions Carelessly
```typescript
// Bad - Lies to compiler
const user = data as User;
// Good - Validate first
function isUser(data: unknown): data is User {
return (
typeof data === 'object' && data !== null && 'id' in data && 'name' in data
);
}
if (isUser(data)) {
// data is User here
}
```
### ❌ Don't Ignore Strict Mode
```typescript
// Bad - Disabling strict checks
{
"compilerOptions": {
"strict": false // ❌
}
}
// Good - Enable all strict checks
{
"compilerOptions": {
"strict": true, // ✅
"noUncheckedIndexedAccess": true
}
}
```
## Ecosystem Integration
### Node.js Development
```typescript
import { readFile } from 'node:fs/promises';
async function loadConfig(): Promise<Config> {
const data = await readFile('./config.json', 'utf-8');
return JSON.parse(data) as Config;
}
```
### React with TypeScript
```typescript
interface Props {
user: User;
onUpdate: (user: User) => void;
}
export function UserCard({ user, onUpdate }: Props) {
return (
<div>
<h2>{user.name}</h2>
<button onClick={() => onUpdate(user)}>Update</button>
</div>
);
}
```
### Express with TypeScript
```typescript
import express, { Request, Response } from 'express';
const app = express();
app.get('/users/:id', (req: Request<{ id: string }>, res: Response) => {
const userId = req.params.id; // Type: string
// ...
});
```
## Reference Documentation
Detailed material lives alongside this skill and is read on demand:
- [Common Tasks](references/PATTERNS.md) — Task 1: Initialize TypeScript Project, Task 2: Set Up Modern Tooling, Task 3: Configure Path Aliases, Task 4: Create Type-Safe API Client, Task 5: Build Library Package
## Resources
- **Official Documentation**: [TypeScript Handbook](https://www.typescriptlang.org/docs/)
- **Style Guide**: [TypeScript Deep Dive](https://basarat.gitbook.io/typescript/)
- **Type Challenges**: [type-challenges](https://github.com/type-challenges/type-challenges)
- **ESLint Rules**: [typescript-eslint](https://typescript-eslint.io/)
## Checklist
When working on TypeScript projects:
- [ ] Enable all strict mode flags
- [ ] Configure path aliases for clean imports
- [ ] Set up ESLint with typescript-eslint
- [ ] Use Prettier for consistent formatting
- [ ] Write tests with type-safe framework (Vitest/Jest)
- [ ] Generate declaration files (.d.ts) for libraries
- [ ] Use discriminated unions for variants
- [ ] Avoid `any`, prefer `unknown` or proper types
- [ ] Use type guards for runtime validation
- [ ] Configure module resolution correctly
- [ ] Set up source maps for debugging
- [ ] Use `satisfies` operator for type checking (TS 4.9+)
© PCL Team · Apache-2.0 · personamanagmentlayer/pcl
Similar skills
All skills for Programming languages →typescript-expert by other authors comes first.