caching_skill

Overview

This skill guides implementing caching responsibly in TypeScript services. It emphasizes performance gains while enforcing a mandatory invalidation strategy to avoid stale data and memory issues. Use it to add caches that are predictable, bounded, and maintainable.

How this skill works

The skill inspects caching patterns and enforces the rule: never introduce a cache without a defined invalidation strategy. It shows concrete patterns (TTL, write-through, event-based, cache-aside) and code examples for in-memory and Redis caches. It also highlights anti-patterns, detection heuristics, and concrete responses to common stakeholder pushback.

When to use it

• When the same data is fetched repeatedly
• When database queries or computations are expensive
• When external API rate limits or latency matter
• When asked to "just add caching" without a plan
• For read-heavy endpoints tolerant of controlled staleness

Best practices

• Always define an invalidation strategy before adding a cache (TTL, write-through, or event-based).
• Use TTL plus explicit invalidation on writes; combine strategies for distributed systems.
• Set memory/size limits and eviction policies to avoid leaks in long-running processes.
• Prefer event-based invalidation or pub/sub in distributed deployments.
• Avoid caching rapidly changing or security-sensitive data (sessions, payment status).

Example use cases

• Cache product catalog responses with short TTL and write-through on updates.
• Cache user profiles with cache-aside plus invalidate on profile updates via event bus.
• Cache expensive computed aggregates with TTL and periodic recompute jobs.
• Use Redis for cross-instance caches and keys with setex TTL and pattern invalidation.
• Wrap database reads in a cache-aside layer for read-heavy APIs to reduce DB load.