TypeScript Workflows for AI Coding Agents

Best for: Broad TypeScript project assessment and maintainability work

typescript-expert is the broad project-health workflow in this catalog. Use it when an agent needs to understand the existing TypeScript conventions, find weak boundaries, and make improvements that remain coherent across the codebase.

Choose it for a project-level pass before narrowing into one type model, API contract, runtime boundary, compiler diagnostic, or documentation task. It keeps the surrounding TypeScript practices aligned while the other workflows handle their specific jobs.

• TypeScript project assessment
• Maintainable codebase conventions
• Clear type and module boundaries
• Health-focused implementation guidance

Best for: Generics, conditional types, mapped types, and type-level relationships

typescript-advanced-types is the type-model workflow for expressing relationships that ordinary annotations cannot capture. Use it when a model needs reusable constraints, derived shapes, or precise relationships between inputs and outputs.

Apply it while designing the type layer, before duplicating assertions or loosening the model. The goal is a type that communicates the allowed values and relationships directly to the rest of the project.

• Advanced type relationships
• Reusable generic models
• Derived and mapped shapes
• Constraints expressed in types

Best for: Designing typed functions, modules, and public interfaces

typescript-pro is the type-first API workflow. Use it when a function, module, or exported surface should be designed from a clear contract instead of being typed after the implementation has already taken shape.

It is especially useful for choosing parameters and return types, preserving inference, and keeping consumers aligned with the intended behavior. The result is an API whose types guide both implementation and use.

• Contract-first API design
• Typed inputs and outputs
• Consumer-friendly inference
• Stable exported surfaces

Best for: Validating external data and avoiding false static assumptions

typescript-best-practices is the runtime-data workflow for the point where typed code meets values that were not checked by the compiler. Use it to make boundary assumptions explicit and to keep uncertain data from silently becoming trusted data.

Choose it when parsing, transforming, or accepting dynamic input. Runtime checks and disciplined narrowing belong at that boundary; downstream code can then rely on the validated model rather than repeating guesses.

• Runtime boundary discipline
• External-data validation
• Safer unknown values
• Evidence before typed use

Best for: Investigating compiler errors without hiding the underlying problem

typescript-magician is the compiler-repair workflow. Use it when diagnostics resist a superficial fix and the agent needs to trace the error back through inference, assignability, generics, or the surrounding declaration.

The repair should resolve the cause rather than silence the checker with an unnecessary assertion or broad type. This keeps compiler feedback useful after the immediate error is gone.

• Compiler diagnostic analysis
• Inference and assignability repair
• Type-safe error resolution
• Root-cause fixes over suppression

Best for: Documenting exported APIs, types, and usage expectations

typescript-docs is the documentation workflow for TypeScript contracts. Use it when an exported function, type, or module needs an explanation that its signature alone cannot provide.

Document the behavior, inputs, outputs, constraints, and examples that consumers need at the point where the API is defined. Clear docs preserve the intent behind a type-first design as the code evolves.

• Exported API documentation
• Complex type explanations
• Usage and behavior examples
• Intent preserved beside declarations

Best for: Making consistent implementation choices in TypeScript and TSX files

typescript is a code-style workflow for the everyday decisions that shape a TypeScript codebase: when inference is enough, how type-only imports should work, and how to avoid weakening a useful contract with broad casts.

Use it after the project-level conventions are known and before a local implementation drifts into ad hoc patterns. It covers code-level discipline rather than a broad project assessment or one advanced type model.

• Inference-first annotations
• Type-only import discipline
• Async I/O conventions
• Safe extension patterns

Best for: Jest test structure, dependency mocking, and async TypeScript behavior

javascript-typescript-jest is the TypeScript unit-testing workflow. Use it when a change needs focused behavioral coverage, a dependency must be isolated, or an asynchronous result needs a clear assertion.

It keeps tests specific to JavaScript and TypeScript implementation concerns without replacing the broader test-strategy guide. The job here is writing the Jest unit test well once the behavior to protect is known.

• Focused Jest test structure
• Module and function mocks
• Async assertion patterns
• Careful snapshot review

Best for: Creating typed API clients from OpenAPI schemas, paths, and responses

openapi-to-typescript is the contract-generation workflow for teams that already have an OpenAPI 3.0 file. It validates the specification, maps its schemas and endpoints into TypeScript, and keeps generated code labeled as generated.

Choose it after the API contract is settled. Unlike type-first API design, this workflow derives the client-side surface from an external specification instead of designing a new public TypeScript API by hand.

• OpenAPI 3.0 validation
• Schema-to-interface generation
• Typed request and response contracts
• Generated runtime guards