AgentStack
SKILL verified MIT Self-run

Typescript Performance

skill-caraya-agent-skills-typescript-performance · by caraya

TypeScript performance skill for profiling, bundle size optimization, type-checking overhead, and runtime efficiency. Trigger phrases: TypeScript performance, bundle size, sourcemap impact, type checking speed, memory leak, CPU profile.

No reviews yet
0 installs
3 views
0.0% view→install

Install

$ agentstack add skill-caraya-agent-skills-typescript-performance

✓ scanned · ✓ verified — works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

Are you the author of Typescript Performance? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

TypeScript Performance

Use When

  • Profiling TypeScript applications for CPU, memory, or bundle size issues.
  • Analyzing type-checking and build time performance.
  • Optimizing bundle size and startup time.

Profiling Tools

  1. Node.js profiling
  • CPU: node --prof app.js then node --prof-process to analyze.
  • Memory: Use Chrome DevTools heap snapshots or --inspect.
  • Flame graphs: Use 0x package or native --prof + tools.
  1. Build and bundle analysis
  • Type-checking: tsc --diagnostics or tsc --listFiles to trace performance.
  • Bundle: Use webpack-bundle-analyzer, rollup-plugin-visualizer, or esbuild --metafile.
  • Sourcemap impact: Check .map file sizes; consider source-map-loader overhead.
  1. Type-checking overhead
  • Profile tsc compilation: time tsc --noEmit.
  • Check for expensive patterns: deeply nested generics, complex type unions, circular type references.

Checklist

  1. Type-checking and build performance
  • Are expensive type operations (deep generics, complex unions) unavoidable, or can they be simplified?
  • Is type-checking parallelizable? Use project references for large monorepos.
  • Are sourcemaps necessary for production? Remove them for speed/size.
  1. Runtime performance
  • Identify hot paths with CPU profiling; focus optimization there.
  • Check for unnecessary object allocations in loops.
  • Verify async operations are not blocking the event loop.
  1. Bundle and startup
  • Analyze bundle composition: what is the largest and most-imported module?
  • Check for dead code; use tree-shaking rules in tsconfig and bundler.
  • Consider code splitting and lazy loading for large features.
  1. Memory efficiency
  • Look for large object retention or circular references in heap dumps.
  • Check for memory leaks from event listeners or timers not cleaned up.

Output Requirements

For each finding provide:

  • Measurement (current baseline, profiling evidence).
  • Root cause and impact.
  • Optimization strategy with expected improvement.
  • Effort and risk assessment.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet — be the first.

Versions

  • v0.1.0 Imported from the upstream source.