Install
Terminal · npx$
npx skills add https://github.com/jeffallan/claude-skills --skill typescript-proWorks with Paperclip
How Typescript Pro fits into a Paperclip company.
Typescript Pro drops into any Paperclip agent that handles this kind of work. Assign it to a specialist inside a pre-configured PaperclipOrg company and the skill becomes available on every heartbeat — no prompt engineering, no tool wiring.
S
SaaS FactoryPaired
Pre-configured AI company — 18 agents, 18 skills, one-time purchase.
$27$59
Explore packSource file
SKILL.md145 linesExpandCollapse
---name: typescript-prodescription: Implements advanced TypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building TypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC.license: MITmetadata: author: https://github.com/Jeffallan version: "1.1.0" domain: language triggers: TypeScript, generics, type safety, conditional types, mapped types, tRPC, tsconfig, type guards, discriminated unions role: specialist scope: implementation output-format: code related-skills: fullstack-guardian, api-designer--- # TypeScript Pro ## Core Workflow 1. **Analyze type architecture** - Review tsconfig, type coverage, build performance2. **Design type-first APIs** - Create branded types, generics, utility types3. **Implement with type safety** - Write type guards, discriminated unions, conditional types; run `tsc --noEmit` to catch type errors before proceeding4. **Optimize build** - Configure project references, incremental compilation, tree shaking; re-run `tsc --noEmit` to confirm zero errors after changes5. **Test types** - Confirm type coverage with a tool like `type-coverage`; validate that all public APIs have explicit return types; iterate on steps 3–4 until all checks pass ## Reference Guide Load detailed guidance based on context: | Topic | Reference | Load When ||-------|-----------|-----------|| Advanced Types | `references/advanced-types.md` | Generics, conditional types, mapped types, template literals || Type Guards | `references/type-guards.md` | Type narrowing, discriminated unions, assertion functions || Utility Types | `references/utility-types.md` | Partial, Pick, Omit, Record, custom utilities || Configuration | `references/configuration.md` | tsconfig options, strict mode, project references || Patterns | `references/patterns.md` | Builder pattern, factory pattern, type-safe APIs | ## Code Examples ### Branded Types```typescript// Branded type for domain modelingtype Brand<T, B extends string> = T & { readonly __brand: B };type UserId = Brand<string, "UserId">;type OrderId = Brand<number, "OrderId">; const toUserId = (id: string): UserId => id as UserId;const toOrderId = (id: number): OrderId => id as OrderId; // Usage — prevents accidental id mix-ups at compile timefunction getOrder(userId: UserId, orderId: OrderId) { /* ... */ }``` ### Discriminated Unions & Type Guards```typescripttype LoadingState = { status: "loading" };type SuccessState = { status: "success"; data: string[] };type ErrorState = { status: "error"; error: Error };type RequestState = LoadingState | SuccessState | ErrorState; // Type predicate guardfunction isSuccess(state: RequestState): state is SuccessState { return state.status === "success";} // Exhaustive switch with discriminated unionfunction renderState(state: RequestState): string { switch (state.status) { case "loading": return "Loading…"; case "success": return state.data.join(", "); case "error": return state.error.message; default: { const _exhaustive: never = state; throw new Error(`Unhandled state: ${_exhaustive}`); } }}``` ### Custom Utility Types```typescript// Deep readonly — immutable nested objectstype DeepReadonly<T> = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];}; // Require exactly one of a set of keystype RequireExactlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, never>> }[Keys];``` ### Recommended tsconfig.json```json{ "compilerOptions": { "target": "ES2022", "module": "NodeNext", "moduleResolution": "NodeNext", "strict": true, "noUncheckedIndexedAccess": true, "noImplicitOverride": true, "exactOptionalPropertyTypes": true, "isolatedModules": true, "declaration": true, "declarationMap": true, "incremental": true, "skipLibCheck": false }}``` ## Constraints ### MUST DO- Enable strict mode with all compiler flags- Use type-first API design- Implement branded types for domain modeling- Use `satisfies` operator for type validation- Create discriminated unions for state machines- Use `Annotated` pattern with type predicates- Generate declaration files for libraries- Optimize for type inference ### MUST NOT DO- Use explicit `any` without justification- Skip type coverage for public APIs- Mix type-only and value imports- Disable strict null checks- Use `as` assertions without necessity- Ignore compiler performance warnings- Skip declaration file generation- Use enums (prefer const objects with `as const`) ## Output Templates When implementing TypeScript features, provide:1. Type definitions (interfaces, types, generics)2. Implementation with type guards3. tsconfig configuration if needed4. Brief explanation of type design decisions ## Knowledge Reference TypeScript 5.0+, generics, conditional types, mapped types, template literal types, discriminated unions, type guards, branded types, tRPC, project references, incremental compilation, declaration files, const assertions, satisfies operator